@mailwoman/resolver-wof-sqlite 8.0.0 → 8.2.0

package/out/lookup.d.ts

@@ -13,6 +13,7 @@ import { DatabaseSync } from "node:sqlite";
 import { type Ancestor, type CoincidentLocality } from "@mailwoman/resolver";
 import { type Convention, type ConventionSource } from "./convention.ts";
 import type { WOFPostalCityAliasLookup } from "./postal-city-alias-lookup.ts";
+import { type RankingWeights } from "./ranking-weights.ts";
 import { type ShardConfig } from "./sharding.ts";
 import type { FindPlaceQuery, PlaceCandidate, PlaceLookup } from "./types.ts";
 export interface WOFSqlitePlaceLookupOpts {
@@ -61,103 +62,6 @@ export interface WOFSqlitePlaceLookupOpts {
      */
     postalCityAliases?: WOFPostalCityAliasLookup;
 }
-/**
- * Ranking weights for `findPlace`. Tweakable per-instance but defaults match the values declared in the Phase 4.2 plan
- * doc.
- */
-export interface RankingWeights {
-    /** Boost when the candidate's placetype matches an explicit `placetype` filter. */
-    placetypeMatchBoost: number;
-    /** Boost when the candidate is a locality and no explicit placetype was requested. */
-    localityImplicitBoost: number;
-    /** Boost when the candidate's country matches an explicit `country` filter. */
-    countryMatchBoost: number;
-    /** Boost when the candidate is a direct child of the requested `parentID`. */
-    directChildBoost: number;
-    /** Boost when the candidate is a transitive descendant of the requested `parentID`. */
-    descendantBoost: number;
-    /** Multiplier on the length-penalty term (penalizes much-longer-than-query names). */
-    lengthPenaltyWeight: number;
-    /**
-     * Magnitude of the proximity boost when the query carries `near`. The contribution is `proximityBoost / (1 +
-     * distanceKm / proximityScaleKm)` — at distance 0 the boost is full magnitude, at `proximityScaleKm` it's half,
-     * decaying further with distance. Default tuned so proximity can overcome a typical FTS rank tie but not dominate a
-     * strong text match.
-     */
-    proximityBoost: number;
-    /**
-     * Magnitude of the bias-hint term inside the exact-tier PROMINENCE sort (the `bias`/viewport path). Deliberately
-     * population-scale (default = populationBoost) so a candidate near the map view / the user beats a distant-but-bigger
-     * namesake — "the map view wins" is the feature; same-region ties (all candidates far from every hint) still fall to
-     * population.
-     */
-    biasBoost: number;
-    /** Distance (km) at which the proximity boost halves. Tune to the typical query radius. */
-    proximityScaleKm: number;
-    /**
-     * Magnitude of the population boost when the candidate has a known `wof:population`. The contribution is
-     * `populationBoost * log10(1 + population) / populationScaleLog10`, capped at `populationBoost`. WOF only carries
-     * population for ~15% of localities (mostly larger ones); places without it get +0 (never a penalty). Default tuned
-     * so the famous Springfield, IL (pop ~112k) gets ~0.42 boost — enough to nudge past tiny same-name peers.
-     */
-    populationBoost: number;
-    /**
-     * Population (in log10) at which the boost reaches its full magnitude. Default 6 — i.e. a population of 1,000,000
-     * gives `populationBoost` exactly. Larger populations cap at the same value (no compounding effect for megacities).
-     */
-    populationScaleLog10: number;
-    /**
-     * Tier candidates with an EXACT name/alias match above candidates that only match partially, BEFORE the weighted-sum
-     * score is consulted. Default true.
-     *
-     * Why this is needed (and why it ALIGNS with — rather than overrides — the population/importance signal): the
-     * weighted sum adds population as a large additive boost (`populationBoost`, up to +4) so that famous places surface
-     * for unambiguous full-name queries. But population is a _prominence prior_ — its job is to break ties among
-     * candidates that match the query EQUALLY WELL (e.g. "Springfield" → Springfield IL over Springfield MA, both exact
-     * name matches). It was never meant to promote a place that matches the query WORSE. For a 2-letter region
-     * abbreviation that backfires: querying "ME" returns Maine (which has the exact alias `ME`) AND Missouri/
-     * Michigan/etc. (which do not), and Missouri's larger population (+4) overcomes Maine's bm25 edge — so "Portland, ME"
-     * resolves its region to Missouri and the locality then cascades to the wrong state. Tiering restores the intended
-     * ordering: **match quality is the primary key, prominence (population) the secondary key WITHIN a tier.**
-     * Springfield-IL-over-MA still works (both exact → same tier → population decides); ME→Maine now works (only Maine is
-     * exact → higher tier → population never gets to override it). See
-     * docs/articles/evals/resolver-geo/2026-05-30-resolver-exact-match.md.
-     *
-     * Note: tiering re-ranks within the over-fetched candidate window (`limit * 4`); a pathological exact match that
-     * falls outside that window is not rescued. For the region-abbrev case the window is comfortably sufficient (a
-     * handful of states match a 2-letter query).
-     */
-    exactMatchTiering: boolean;
-    /**
-     * #936 option 3 — official-language names ARE names. When true, a candidate holding the query as an OFFICIAL name
-     * (`names.official = 1`: a preferred-form name in an official language of its country, stamped at ingest) joins the
-     * NAME-exact sub-tier rather than the alias-exact one, provided its population clears {@link officialNameExactFloor}.
-     * Fixes unscoped "Åbo" → Turku (its official Swedish name) over a hamlet literally named Åbo; population still orders
-     * within the sub-tier, so Paris → Paris FR is untouched.
-     *
-     * Default true (operator-promoted 2026-07-03 after the pre-registered gate battery: four intended exonym flips —
-     * Berne→Bern, Bruges→Brugge, Roma→Rome, Åbo→Turku — with the namesake/abbreviation rows and the US/FI panels
-     * byte-identical). Requires a gazetteer carrying the #940 ingest bit — on older DBs without the `official` column the
-     * probe fails soft and behavior is identical to the flag being off.
-     */
-    officialNameExact: boolean;
-    /**
-     * Minimum population for a candidate's official names to join the name-exact sub-tier. The #936 review's no-floor
-     * census measured the boundary: ≥100k holders are the famous-exonym class (757 flips, intent-correct; 7 collisions,
-     * none harmful) while 10k–100k holders are junk-dominated (3,481 flips led by short-form mis-tags — Villeneuve-Loubet
-     * carrying "villeneuve" would bury five real villages of that name). Rank-time knob: tunable without re-ingest;
-     * below-floor official names simply stay alias-tier (today's behavior).
-     */
-    officialNameExactFloor: number;
-}
-/** Padded character-trigram set (a leading/trailing space pads short tokens). */
-export declare function trigrams(s: string): Set<string>;
-/**
- * Character-trigram Jaccard ∈ [0,1] — tolerant of the swallowed-leading-char fragments ("auen" vs "plauen") and minor
- * misspellings without a heavyweight edit-distance pass. Shared with the candidate backend's FTS5-trigram fuzzy
- * fallback so both lookups rank typos identically.
- */
-export declare function trigramJaccard(a: string, b: string): number;
 export declare class WOFSqlitePlaceLookup implements PlaceLookup, Disposable {
     #private;
     constructor(opts: WOFSqlitePlaceLookupOpts, weights?: Partial<RankingWeights>);
@@ -182,4 +86,6 @@ export declare class WOFSqlitePlaceLookup implements PlaceLookup, Disposable {
     close(): void;
     [Symbol.dispose](): void;
 }
+export { trigramJaccard, trigrams } from "./name-score.ts";
+export type { RankingWeights } from "./ranking-weights.ts";
 //# sourceMappingURL=lookup.d.ts.map

package/out/lookup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lookup.d.ts","sourceRoot":"","sources":["../lookup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,YAAY,EAAsB,MAAM,aAAa,CAAA;AAG9D,OAAO,EAAyB,KAAK,QAAQ,EAAE,KAAK,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAKnG,OAAO,EAIN,KAAK,UAAU,EACf,KAAK,gBAAgB,EAGrB,MAAM,iBAAiB,CAAA;AAWxB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAA;AAE7E,OAAO,EAKN,KAAK,WAAW,EAChB,MAAM,eAAe,CAAA;AAEtB,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,WAAW,EAAgB,MAAM,YAAY,CAAA;AAE3F,MAAM,WAAW,wBAAwB;IACxC;;;;;;;;;;;;;OAaG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC,MAAM,GAAG,WAAW,CAAC,CAAA;IAC3D;;;OAGG;IACH,QAAQ,CAAC,EAAE,YAAY,CAAA;IACvB;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;IAC3D;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,wBAAwB,CAAA;CAC5C;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC9B,mFAAmF;IACnF,mBAAmB,EAAE,MAAM,CAAA;IAC3B,sFAAsF;IACtF,qBAAqB,EAAE,MAAM,CAAA;IAC7B,+EAA+E;IAC/E,iBAAiB,EAAE,MAAM,CAAA;IACzB,8EAA8E;IAC9E,gBAAgB,EAAE,MAAM,CAAA;IACxB,uFAAuF;IACvF,eAAe,EAAE,MAAM,CAAA;IACvB,sFAAsF;IACtF,mBAAmB,EAAE,MAAM,CAAA;IAC3B;;;;;OAKG;IACH,cAAc,EAAE,MAAM,CAAA;IACtB;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAA;IACjB,2FAA2F;IAC3F,gBAAgB,EAAE,MAAM,CAAA;IACxB;;;;;OAKG;IACH,eAAe,EAAE,MAAM,CAAA;IACvB;;;OAGG;IACH,oBAAoB,EAAE,MAAM,CAAA;IAC5B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,iBAAiB,EAAE,OAAO,CAAA;IAC1B;;;;;;;;;;;OAWG;IACH,iBAAiB,EAAE,OAAO,CAAA;IAC1B;;;;;;OAMG;IACH,sBAAsB,EAAE,MAAM,CAAA;CAC9B;AAkGD,iFAAiF;AACjF,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAS/C;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAa3D;AAqBD,qBAAa,oBAAqB,YAAW,WAAW,EAAE,UAAU;;gBAuDvD,IAAI,EAAE,wBAAwB,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC;IAwHvE,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAyDjE;;;;;OAKG;IACH,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,kBAAkB,EAAE;IAyDvE;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,EAAE;IA8vB1C,KAAK,IAAI,IAAI;IAUb,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI;CAgBxB"}
+{"version":3,"file":"lookup.d.ts","sourceRoot":"","sources":["../lookup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,YAAY,EAAsB,MAAM,aAAa,CAAA;AAG9D,OAAO,EAAyB,KAAK,QAAQ,EAAE,KAAK,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAKnG,OAAO,EAIN,KAAK,UAAU,EACf,KAAK,gBAAgB,EAGrB,MAAM,iBAAiB,CAAA;AAaxB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAA;AAC7E,OAAO,EAAmB,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE3E,OAAO,EAKN,KAAK,WAAW,EAChB,MAAM,eAAe,CAAA;AAEtB,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,WAAW,EAAgB,MAAM,YAAY,CAAA;AAS3F,MAAM,WAAW,wBAAwB;IACxC;;;;;;;;;;;;;OAaG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC,MAAM,GAAG,WAAW,CAAC,CAAA;IAC3D;;;OAGG;IACH,QAAQ,CAAC,EAAE,YAAY,CAAA;IACvB;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;IAC3D;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,wBAAwB,CAAA;CAC5C;AAyDD,qBAAa,oBAAqB,YAAW,WAAW,EAAE,UAAU;;gBA6DvD,IAAI,EAAE,wBAAwB,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC;IA8HvE,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IA6DjE;;;;;OAKG;IACH,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,kBAAkB,EAAE;IA2DvE;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,EAAE;IA6xB1C,KAAK,IAAI,IAAI;IAUb,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI;CAkBxB;AAED,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAE1D,YAAY,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA"}

package/out/lookup.js

@@ -16,40 +16,19 @@ import { Kysely } from "kysely";
 import { ancestorLineage } from "./ancestry.js";
 import { COINCIDENT_ROLES_TABLE, coincidentRolesExists } from "./coincident-roles.js";
 import { ADDRESS_CONVENTION_TABLE, resolveConvention, SeedConventionSource, } from "./convention.js";
+import { normalizePlacetypes, sanitizeFTSQuery } from "./fts-query.js";
 import { aliasBagExactMatch, buildPlaceSearchFTS, PLACE_BBOX_TABLE, PLACE_POPULATION_TABLE, placeBboxExists, placePopulationExists, placeSearchFTSExists, } from "./fts.js";
 import { bboxAround, haversineKm } from "./geo.js";
+import { cfNormalize, softNameScore, trigramJaccard } from "./name-score.js";
+import { DEFAULT_WEIGHTS } from "./ranking-weights.js";
 import { pickShardForPlacetype, pickShardsForPlacetype, resolveShards, } from "./sharding.js";
 import { SqliteConventionSource } from "./sqlite-convention-source.js";
-const DEFAULT_WEIGHTS = {
-    placetypeMatchBoost: 0.5,
-    localityImplicitBoost: 0.2,
-    countryMatchBoost: 0.3,
-    directChildBoost: 0.5,
-    descendantBoost: 0.2,
-    lengthPenaltyWeight: 0.1,
-    proximityBoost: 0.8,
-    proximityScaleKm: 100,
-    biasBoost: 4.0,
-    // populationBoost is intentionally large — empirical tuning against real WOF showed BM25 gaps
-    // of 1.5-3.0 between famous places and tiny same-name peers (because the famous ones have
-    // hundreds of alt-name entries that hurt their FTS document score). To consistently surface
-    // "the famous one" for unambiguous queries like "New York" or "Chicago", the population signal
-    // needs to dominate. Callers wanting a more conservative balance can drop this in the
-    // RankingWeights override.
-    //
-    // Note: this resolver uses `place_population` directly. The separate `place_importance` table
-    // (Wikipedia-derived) is consumed by the FST layer, not here. See
-    // docs/articles/concepts/importance-vs-population.md for the two-signal contract.
-    populationBoost: 4.0,
-    populationScaleLog10: 6,
-    // Exact name/alias match outranks partial match before the weighted sum (incl. population) is
-    // consulted — keeps population as an intra-tier prominence tiebreaker, not a cross-tier promoter.
-    // Fixes the 2-letter-region-abbrev bug ("ME" → Maine, not the more-populous Missouri).
-    exactMatchTiering: true,
-    // #936 option 3 — promoted default-ON 2026-07-03 (gate battery PASS; see the RankingWeights docstring).
-    officialNameExact: true,
-    officialNameExactFloor: 100_000,
-};
+/**
+ * Query length at or below which the FTS window is widened. A two- or three-character query is almost always a region
+ * abbreviation, where the exact match can otherwise fall outside the window behind higher-bm25 partial hits — "NY"
+ * losing to "New York".
+ */
+const SHORT_QUERY_MAX_LENGTH = 3;
 /**
  * Over-fetch floor for SHORT (≤3-char) queries — region abbreviations like "NY"/"VT". An exact-abbrev holder's BM25 is
  * poor (long multilingual alt-name document), so the normal `limit * 4` window can drop it before `exactMatchTiering`
@@ -85,57 +64,6 @@ const CF_PC_DECAY_KM = 8;
  */
 const CF_MISMATCH_KM = 50;
 const CF_MISMATCH_DELTA = 0.5;
-/** Case-fold + strip diacritics + collapse punctuation — for the coord-first soft name match. */
-function cfNormalize(s) {
-    return s
-        .toLowerCase()
-        .normalize("NFD")
-        .replace(/[\u0300-\u036f]/g, "") // combining diacritical marks
-        .replace(/[^a-z0-9]+/g, " ")
-        .trim();
-}
-/** Padded character-trigram set (a leading/trailing space pads short tokens). */
-export function trigrams(s) {
-    const t = ` ${s} `;
-    const out = new Set();
-    for (let i = 0; i + 3 <= t.length; i++) {
-        out.add(t.slice(i, i + 3));
-    }
-    return out;
-}
-/**
- * Character-trigram Jaccard ∈ [0,1] — tolerant of the swallowed-leading-char fragments ("auen" vs "plauen") and minor
- * misspellings without a heavyweight edit-distance pass. Shared with the candidate backend's FTS5-trigram fuzzy
- * fallback so both lookups rank typos identically.
- */
-export function trigramJaccard(a, b) {
-    const A = trigrams(a);
-    const B = trigrams(b);
-    if (A.size === 0 || B.size === 0)
-        return 0;
-    let inter = 0;
-    for (const x of A)
-        if (B.has(x)) {
-            inter++;
-        }
-    return inter / (A.size + B.size - inter);
-}
-/** Soft name-match score ∈ [0,1]: exact (normalized) name/alias → 1, else best trigram-Jaccard. */
-function softNameScore(text, name, aliases) {
-    const q = cfNormalize(text);
-    if (!q)
-        return 0;
-    let best = 0;
-    for (const raw of [name, ...aliases]) {
-        const n = cfNormalize(raw);
-        if (!n)
-            continue;
-        if (n === q)
-            return 1;
-        best = Math.max(best, trigramJaccard(q, n));
-    }
-    return best;
-}
 export class WOFSqlitePlaceLookup {
     #db;
     #ownsDB;
@@ -165,7 +93,9 @@ export class WOFSqlitePlaceLookup {
      * override) schema names.
      */
     #shards;
-    /** #920: per-schema probed country sets for country-aware shard routing (non-main shards only). */
+    /**
+     * #920: per-schema probed country sets for country-aware shard routing (non-main shards only).
+     */
     #shardCountries;
     /**
      * The Geographic Rule Engine (Direction E, #289). `#conventionSource` supplies per-WOF-polygon resolution profiles;
@@ -177,13 +107,17 @@ export class WOFSqlitePlaceLookup {
     #conventionSource;
     #strategies;
     #countryWOFIdCache = new Map();
-    /** Strategy names already warned about — so an unknown name surfaces once, not once per query. */
+    /**
+     * Strategy names already warned about — so an unknown name surfaces once, not once per query.
+     */
     #warnedUnknownStrategies = new Set();
     /**
      * Lazily-built `admin_id → coincident localities` map from the #403 relation (null until first use).
      */
     #coincidentRolesCache = null;
-    /** Per-id memoized ancestor lineages (#404) — a hot chain is queried once. */
+    /**
+     * Per-id memoized ancestor lineages (#404) — a hot chain is queried once.
+     */
     #ancestorsCache = new Map();
     /**
      * Opt-in postal-city alias reader (#475). `null` unless `opts.postalCityAliases` was supplied — every alias code path
@@ -216,7 +150,7 @@ export class WOFSqlitePlaceLookup {
             // ATTACH each non-main shard. Schema names were validated by resolveShards, so safe to
             // interpolate directly (SQLite ATTACH doesn't accept parameters for the schema name).
             for (const s of shards.slice(1)) {
-                this.#db.exec(`ATTACH DATABASE '${s.path.replace(/'/g, "''")}' AS ${s.schemaName}`);
+                this.#db.exec(`ATTACH DATABASE '${s.path.replaceAll("'", "''")}' AS ${s.schemaName}`);
             }
         }
         // node:sqlite has no .pragma() helper; pragmas are executed as plain SQL.
@@ -319,7 +253,7 @@ export class WOFSqlitePlaceLookup {
                 break;
             }
         }
-        if (outcome.length > 0)
+        if (outcome.length)
             return outcome;
         // #924: NL postcode retry ladder. The WOF NL postalcode repo stores full codes UNSPACED
         // ('1012LG') plus 4-digit stems ('1012'), while Dutch addresses carry the spaced form
@@ -333,10 +267,10 @@ export class WOFSqlitePlaceLookup {
             (normalizePlacetypes(query.placetype)?.includes("postalcode") ?? false) &&
             /^\d{4}\s?[A-Za-z]{2}$/.test(query.text.trim())) {
             const trimmed = query.text.trim();
-            const joined = trimmed.replace(/\s+/g, "");
+            const joined = trimmed.replaceAll(/\s+/g, "");
             if (joined !== trimmed) {
                 const full = await this.findPlace({ ...query, text: joined });
-                if (full.length > 0)
+                if (full.length)
                     return full;
             }
             const stem = trimmed.slice(0, 4);
@@ -456,7 +390,7 @@ export class WOFSqlitePlaceLookup {
         // (Cross-country abbrev collisions — "VT" is BOTH Vermont and Viterbo — still need a country/
         // postcode signal to disambiguate; this only rescues the window-drop class, not genuine ambiguity.
         // With a `country` hint every abbrev resolves; bare + no-context lifts 7→10/15 US states.)
-        const ftsLimit = query.text.trim().length <= 3 ? Math.max(limit * 4, SHORT_QUERY_OVERFETCH) : limit * 4;
+        const ftsLimit = query.text.trim().length <= SHORT_QUERY_MAX_LENGTH ? Math.max(limit * 4, SHORT_QUERY_OVERFETCH) : limit * 4;
         // Expand the placetype filter through the shared equivalence table (core/resolver): a
         // `locality` query must also reach `borough` / `localadmin` rows — Brooklyn-the-borough
         // (pop 2.5M) is a borough, not a locality, and a strict filter made it unreachable so the
@@ -511,7 +445,7 @@ export class WOFSqlitePlaceLookup {
         // the FROM table — required by FTS5 parser, see sharding.ts header comment.
         const where = ["place_search MATCH ?", "spr.is_current != 0", "spr.is_deprecated = 0"];
         const params = [ftsQuery];
-        if (placetypes && placetypes.length > 0) {
+        if (placetypes && placetypes.length) {
             where.push(`spr.placetype IN (${placetypes.map(() => "?").join(", ")})`);
             params.push(...placetypes);
         }
@@ -532,9 +466,7 @@ export class WOFSqlitePlaceLookup {
         if (useBboxJoin) {
             joinClause += ` JOIN ${sch}.${PLACE_BBOX_TABLE} bbox ON bbox.id = spr.id`;
             // AABB intersection — both bbox sides must overlap. R*Tree handles this in O(log n).
-            const filterBox = query.bbox
-                ? query.bbox
-                : bboxAround(query.near.lat, query.near.lon, query.near.maxDistanceKm);
+            const filterBox = query.bbox || bboxAround(query.near.lat, query.near.lon, query.near.maxDistanceKm);
             where.push("bbox.min_lat <= ? AND bbox.max_lat >= ?", "bbox.min_lon <= ? AND bbox.max_lon >= ?");
             params.push(filterBox.maxLat, filterBox.minLat, filterBox.maxLon, filterBox.minLon);
         }
@@ -616,7 +548,7 @@ export class WOFSqlitePlaceLookup {
 				ORDER BY COALESCE(${PLACE_POPULATION_TABLE}.population, 0) DESC
 				LIMIT ?
 			`);
-            const popParams = params.slice(0, params.length - 3); // drop the two boost params + ftsLimit
+            const popParams = params.slice(0, -3); // drop the two boost params + ftsLimit
             const seen = new Set(rawRows.map((r) => r.id));
             for (const row of popStmt.all(...popParams, POPULATION_FETCH_LIMIT)) {
                 if (!seen.has(row.id)) {
@@ -629,7 +561,7 @@ export class WOFSqlitePlaceLookup {
             // SQLite's bm25() returns a lower-is-better score (negative for matches). Negate so we
             // start from a higher-is-better baseline.
             let score = -row.rank;
-            if (placetypes && placetypes.length > 0 && placetypes.includes(row.placetype)) {
+            if (placetypes && placetypes.length && placetypes.includes(row.placetype)) {
                 score += this.#weights.placetypeMatchBoost;
             }
             if (!placetypes && row.placetype === "locality") {
@@ -639,12 +571,7 @@ export class WOFSqlitePlaceLookup {
                 score += this.#weights.countryMatchBoost;
             }
             if (query.parentID !== undefined) {
-                if (row.parent_id === query.parentID) {
-                    score += this.#weights.directChildBoost;
-                }
-                else {
-                    score += this.#weights.descendantBoost;
-                }
+                score += row.parent_id === query.parentID ? this.#weights.directChildBoost : this.#weights.descendantBoost;
             }
             const extraLen = Math.max(0, row.name.length - queryLen - 3);
             score -= (this.#weights.lengthPenaltyWeight * extraLen) / 10;
@@ -731,7 +658,7 @@ export class WOFSqlitePlaceLookup {
         // Runs even for a SINGLE candidate so `exactMatch` is stamped consistently (parity with the
         // WASM lookup) — a sole alias hit ("New York City" → New York) must still carry the flag the
         // demo cascade / #369 re-rank read.
-        if (this.#weights.exactMatchTiering && candidates.length > 0) {
+        if (this.#weights.exactMatchTiering && candidates.length) {
             const exactIds = this.#exactMatchIds(sch, candidates.map((c) => c.id), query.text);
             // Stamp the tier onto every candidate (not just when the tiering sort fires) so a downstream
             // re-rank — #369's postcode-anchor country pin in `resolveTree` — can keep the country pin from
@@ -739,7 +666,7 @@ export class WOFSqlitePlaceLookup {
             for (const c of candidates) {
                 c.exactMatch = exactIds.has(c.id);
             }
-            if (exactIds.size > 0) {
+            if (exactIds.size) {
                 // #905: WITHIN the exact tier, population is the PRIMARY key and the weighted score
                 // only breaks population ties. Exactness saturates text relevance, and the bm25
                 // residue inside `score` is length-noise (see the fetch-site comment), so letting it
@@ -753,7 +680,7 @@ export class WOFSqlitePlaceLookup {
                 // widen recall, not to tie primaries. ME→Maine is untouched: 'ME' name-exact-matches
                 // nothing, so the alias sub-tier still decides there. Population orders within each
                 // sub-tier as before.
-                const norm = (v) => v.toLowerCase().trim().replace(/\s+/g, " ");
+                const norm = (v) => v.toLowerCase().trim().replaceAll(/\s+/g, " ");
                 const needle = norm(query.text);
                 // #936 option 3: an OFFICIAL name (preferred form in an official language of the place's
                 // country, `names.official = 1`) counts as the place's own name for the sub-tier — "Åbo" is
@@ -789,11 +716,11 @@ export class WOFSqlitePlaceLookup {
                     }
                     return b.score - a.score;
                 });
-                return Promise.resolve(candidates.slice(0, limit));
+                return candidates.slice(0, limit);
             }
         }
         candidates.sort((a, b) => b.score - a.score);
-        return Promise.resolve(candidates.slice(0, limit));
+        return candidates.slice(0, limit);
     }
     #isLocalityQuery(query) {
         const pts = normalizePlacetypes(query.placetype);
@@ -824,7 +751,7 @@ export class WOFSqlitePlaceLookup {
         const cached = this.#countryWOFIdCache.get(code);
         if (cached !== undefined)
             return cached;
-        let id = null;
+        let id;
         try {
             const row = this.#db
                 .prepare(`SELECT id FROM main.spr WHERE placetype = 'country' AND country = ? AND is_current != 0 LIMIT 1`)
@@ -854,7 +781,7 @@ export class WOFSqlitePlaceLookup {
             .prepare(`SELECT locality_id AS id, aliases, distance_km AS dist, is_containing AS containing
 				 FROM ${sch}.${POSTCODE_LOCALITY_TABLE} WHERE ${pcWhere}`)
             .all(...pcParams);
-        if (pcRows.length === 0)
+        if (!pcRows.length)
             return null;
         const limit = query.limit ?? 10;
         // Name-match candidates via the normal FTS path (postcode cleared → no recursion).
@@ -898,7 +825,7 @@ export class WOFSqlitePlaceLookup {
             // (#475). `postalAliasByGeo` is empty unless the opt-in reader was supplied, so when off this
             // reduces to the original `info?.aliases ?? []` and the score is unchanged.
             const wofAliases = info?.aliases ?? [];
-            const aliases = postalAliasByGeo.size > 0
+            const aliases = postalAliasByGeo.size
                 ? [...wofAliases, ...(postalAliasByGeo.get(cfNormalize(cand.name)) ?? [])]
                 : wofAliases;
             const sName = softNameScore(query.text, cand.name, aliases);
@@ -922,12 +849,13 @@ export class WOFSqlitePlaceLookup {
             // every locality polygon still anchor to the closest town.
             const anchorRow = pcRows
                 .filter((r) => merged.has(r.id))
+                // oxlint-disable-next-line unicorn/no-array-sort -- sorts a freshly-built array; toSorted would double-allocate on a hot path
                 .sort((a, b) => b.containing - a.containing || a.dist - b.dist)[0];
             const anchor = anchorRow ? merged.get(anchorRow.id) : undefined;
-            if (anchor && top.id !== anchorRow.id) {
-                if (haversineKm(top.lat, top.lon, anchor.lat, anchor.lon) > CF_MISMATCH_KM) {
-                    top.mismatch = true;
-                }
+            if (anchor &&
+                top.id !== anchorRow.id &&
+                haversineKm(top.lat, top.lon, anchor.lat, anchor.lon) > CF_MISMATCH_KM) {
+                top.mismatch = true;
             }
         }
         return scored.slice(0, limit).map(({ exact, ...c }) => {
@@ -935,9 +863,11 @@ export class WOFSqlitePlaceLookup {
             return c;
         });
     }
-    /** Fetch locality spr rows (from main) for the postcode-injected candidate ids the FTS set missed. */
+    /**
+     * Fetch locality spr rows (from main) for the postcode-injected candidate ids the FTS set missed.
+     */
     #fetchLocalitiesByID(ids) {
-        if (ids.length === 0)
+        if (!ids.length)
             return [];
         const hasPop = this.#hasPopulationIndex.get("main") === true;
         const popSelect = hasPop ? `pp.population AS population` : `NULL AS population`;
@@ -976,7 +906,7 @@ export class WOFSqlitePlaceLookup {
     #exactMatchIds(schemaName, ids, text) {
         const out = new Set();
         const trimmed = text.trim();
-        if (ids.length === 0 || !trimmed)
+        if (!ids.length || !trimmed)
             return out;
         const placeholders = ids.map(() => "?").join(", ");
         try {
@@ -995,7 +925,7 @@ export class WOFSqlitePlaceLookup {
             const rows = this.#db
                 .prepare(`SELECT wof_id AS id, name, alt_names FROM ${schemaName}.place_search WHERE wof_id IN (${placeholders})`)
                 .all(...ids);
-            const norm = (s) => s.toLowerCase().trim().replace(/\s+/g, " ");
+            const norm = (s) => s.toLowerCase().trim().replaceAll(/\s+/g, " ");
             const needle = norm(trimmed);
             for (const r of rows) {
                 if (r.name !== null && norm(r.name) === needle) {
@@ -1029,7 +959,7 @@ export class WOFSqlitePlaceLookup {
     #officialNameIds(schemaName, ids, text) {
         const out = new Set();
         const trimmed = text.trim();
-        if (ids.length === 0 || !trimmed)
+        if (!ids.length || !trimmed)
             return out;
         const placeholders = ids.map(() => "?").join(", ");
         try {
@@ -1056,7 +986,9 @@ export class WOFSqlitePlaceLookup {
     [Symbol.dispose]() {
         this.close();
     }
-    /** Build the FTS5 virtual table from the `names` + `places` tables. */
+    /**
+     * Build the FTS5 virtual table from the `names` + `places` tables.
+     */
     #ensureFTS() {
         buildPlaceSearchFTS(this.#db);
     }
@@ -1066,69 +998,5 @@ export class WOFSqlitePlaceLookup {
         }
     }
 }
-function normalizePlacetypes(p) {
-    if (!p)
-        return null;
-    return Array.isArray(p) ? p : [p];
-}
-/**
- * Make an arbitrary user-typed string safe for FTS5 MATCH.
- *
- * FTS5 has its own query syntax (`"phrase"`, `term1 OR term2`, `prefix*`, NEAR/N, etc.). Letting raw user input through
- * means a user typing `Paris's` or `St. (Petersburg)` causes a syntax error.
- *
- * Per-token rules:
- *
- * - Strip all punctuation except trailing `*` from each whitespace-separated token.
- * - **Trailing `*`** is preserved as FTS5 **prefix syntax** — `627*` becomes the literal `627*` (unquoted). The caller
- *   signaled they want a prefix; respect that.
- * - All other tokens are wrapped in `"..."` as a single-word phrase. Conservative — handles apostrophes, parens, accented
- *   input, etc. safely.
- * - Multiple tokens join with implicit AND.
- *
- * Examples:
- *
- * - `"Paris"` → `"Paris"` (phrase)
- * - `"627*"` → `627*` (prefix)
- * - `"St. (Petersburg)"` → `"St" "Petersburg"` (two phrases, AND-joined)
- * - `"Thiron-Gardais"` → `"Thiron" "Gardais"` (intra-token punctuation SPLITS — #945; fusing to `ThironGardais` matched
- *   nothing because the FTS doc tokenizes the hyphenated name as two terms)
- * - `"110 00"` with `fuseTokens` (postcode-typed) → `"110" "00"` per-token fused — the #920 name law
- * - `"Pari* TX"` → `Pari* "TX"` (mixed prefix + phrase)
- * - `"*"` alone → `""` (no body → drop)
- */
-function sanitizeFTSQuery(text, opts) {
-    const out = [];
-    for (const rawToken of text.normalize("NFKC").split(/\s+/u)) {
-        const trimmed = rawToken.trim();
-        if (!trimmed)
-            continue;
-        const hasPrefixStar = trimmed.endsWith("*");
-        // #920 name law (postcode-typed queries ONLY): delete intra-token punctuation and FUSE the
-        // remainder — postal names are stored in this collapsed shape ("SW1A" stays one term).
-        if (opts?.fuseTokens) {
-            const body = trimmed.replace(/[^\p{L}\p{N}]/gu, "");
-            if (!body)
-                continue;
-            out.push(hasPrefixStar ? `${body}*` : `"${body.replace(/"/g, '""')}"`);
-            continue;
-        }
-        // Everything else SPLITS on intra-token punctuation — the behavior the docstring always
-        // promised ("St. (Petersburg)" → two phrases). The old code DELETED punctuation instead,
-        // fusing "Thiron-Gardais" into the unmatchable single term `ThironGardais` while the FTS
-        // doc holds two terms (#945 — the entire hyphenated-name class missed at the raw lookup;
-        // masked for years because pre-splice tokenizers never emitted hyphen-preserved values).
-        const parts = trimmed.split(/[^\p{L}\p{N}]+/u).filter(Boolean);
-        if (parts.length === 0)
-            continue;
-        for (let i = 0; i < parts.length; i++) {
-            const body = parts[i].replace(/\*/g, "");
-            if (!body)
-                continue;
-            // The caller's trailing `*` applies to the FINAL part ("Thiron-Gard*" → "Thiron" Gard*).
-            out.push(hasPrefixStar && i === parts.length - 1 ? `${body}*` : `"${body.replace(/"/g, '""')}"`);
-        }
-    }
-    return out.join(" ");
-}
+export { trigramJaccard, trigrams } from "./name-score.js";
 //# sourceMappingURL=lookup.js.map