@mailwoman/resolver-wof-sqlite 9.1.0 → 9.3.0

package/out/candidate-lookup.js

@@ -14,7 +14,7 @@
  *   {@link normalizeLocalityForKey} (build- and query-consistent), each row is denormalized (display
  *   `name`, centroid, bbox), and population rank is precomputed into `neg_rank` — so the result is
  *   POPULATION-FIRST and COUNTRY-AGNOSTIC (when no `country` filter is given), exactly like the
- *   demo. That's the deliberate divergence from {@link WOFSqlitePlaceLookup}'s FTS/bm25 ranking: a
+ *   demo. That's the deliberate divergence from {@link WOFSQLitePlaceLookup}'s FTS/bm25 ranking: a
  *   bare "Moscow" resolves to the 10.4 M-pop Russian city, not whichever same-name US township bm25
  *   floats to the top.
  *
@@ -22,91 +22,50 @@
  *   stored bbox and the locality query is point-in-bbox-filtered on the candidate centroid (the
  *   `bbox` field on {@link FindPlaceQuery}).
  */
-import { DatabaseSync } from "node:sqlite";
-import { expandPlacetypeFilter } from "@mailwoman/resolver";
-import { CANDIDATE_FTS_TABLE } from "./candidate-fts.js";
-import { readGazetteerCoverageManifest } from "./coverage-manifest-schema.js";
-import { haversineKm } from "./geo.js";
-import { trigramJaccard } from "./lookup.js";
-import { referentialFromPopulation } from "./place-importance-schema.js";
-import { POSTAL_CITY_CANDIDATE_TABLE } from "./postal-city-candidate-schema.js";
-import { hasColumn, hasTable } from "./sqlite-utils.js";
-import { normalizeLocalityForKey, stripLocalityQualifier } from "./street-normalize.js";
+import { jaroWinkler, levenshteinSimilarity } from "@mailwoman/match/comparators";
+import { expandPlacetypeFilter, partitionByContainment, } from "@mailwoman/resolver";
+import { haversineKm } from "@mailwoman/spatial";
+import { DatabaseClient } from "@mailwoman/sqlite/client";
+import { CANDIDATE_ANCESTOR_TABLE, CANDIDATE_INTERVAL_TABLE, intervalContains, } from "#candidate-ancestors-schema";
+import { CANDIDATE_FTS_TABLE } from "#candidate-fts";
+import { readGazetteerCoverageManifest } from "#coverage-manifest-schema";
+import { referentialFromPopulation } from "#place-importance-schema";
+import { POSTAL_CITY_CANDIDATE_TABLE } from "#postal/city-candidate-schema";
+import { rankByPrimaryPreference, RERANK_FETCH } from "#primary-preference";
+import { applyProximityRerank } from "#proximity-rerank";
+import { REGION_CLASS_PLACETYPES, regionQualifierProbeKeys } from "#region-keys";
+import { allRows, hasColumn, hasTable } from "#sqlite-utils";
+import { normalizeLocalityForKey, stripLocalityQualifier } from "#street/normalize";
+export { rankByPrimaryPreference } from "#primary-preference";
 /**
- * FTS5-trigram over-fetch before the trigram-Jaccard re-rank, and the minimum similarity to count as a fuzzy hit (below
- * it the trigram overlap is noise, e.g. unrelated same-trigram names). Tunable.
+ * FTS5-trigram over-fetch before the WORD-LEVEL re-rank. The trigram index stays the candidate GENERATOR (it is what
+ * the artifact carries); the scoring moved off trigram-Jaccard on 2026-08-12 (#1614), which the aucklnad receipts
+ * falsified as a typo measure: it scored the true transposition correction 'auckland' at 0.333 — below its own 0.34 bar
+ * — while 'auckley' scored 0.375 and the 'gore bay' scrape 0.455, because shared generic suffixes count as trigram
+ * evidence and transpositions count against it.
  */
 const FUZZY_FETCH = 40;
-const FUZZY_MIN = 0.34;
 /**
- * Postcode-containment re-rank gate radius (km) — the SAME value the resolver's country pass measures at
- * (`POSTCODE_COUNTRY_COHERENCE_GATE_KM`, resolver/postcode-country-coherence.ts): a locality within this distance of
- * the postcode's own centroid counts as "containing" it. One number, two passes — a divergence here would make the two
- * mechanisms disagree about what is proximal.
+ * Minimum WORD-LEVEL similarity (max of Jaro-Winkler and normalized edit similarity — the `match/comparators`
+ * primitives, deliberately WITHOUT `nameSimilarity`'s token-subset floor, which is a person-name rule that would hand
+ * 'stanmore bay' to a place named 'Bay') for a fuzzy correction to count. Measured on the #1614 receipts:
+ * 'aucklnad'→'auckland' 0.975 (in), →'auckley' 0.868 (in, but outranked), 'stanmore bay'→'gore bay' ~0.70 (out),
+ * 'sacremento'→'sacramento' ~0.97 (in).
  */
-const POSTCODE_CONTAINMENT_GATE_KM = 25;
+const WORD_FUZZY_MIN = 0.85;
 /**
- * Bounded PRIMARY-NAME preference across a CROSS-COUNTRY name collision (the `is_primary` ranking signal).
- *
- * The raw candidate order is population-first (`neg_rank ASC`) and treats an ALIAS row (a place's alt-name / exonym,
- * `is_primary=0`) and a PRIMARY-name row (`is_primary=1`) on equal footing. So a foreign place whose transliterated
- * exonym coincidentally normalizes to a query — Changchun CN stores the Turkish exonym "Çançun" (`name_key="cancun"`),
- * 4.19 M pop — outranks the PRIMARY-name place the query actually means (Cancún MX, 0.89 M pop). This penalty makes a
- * same-key alias have to clear a population MARGIN over a foreign primary before it wins.
- *
- * It is deliberately NOT a dominant sort key (no `ORDER BY is_primary DESC`, which would make every primary outrank
- * every alias and break the alt-names users depend on — "NYC"→New York, "LA"→Los Angeles, "Frisco"→San Francisco). Two
- * bounds keep it a soft prior:
- *
- * 1. **Cross-country only.** The penalty applies to an alias ONLY when the top-population primary sharing the key is in a
- *    DIFFERENT country. A SAME-country nickname contest (San Francisco's alias "Frisco" vs the primary Frisco, TX —
- *    both US) is left on pure population, so the legitimate alias still wins.
- * 2. **Population-bounded.** The penalty is {@link PRIMARY_PREFERENCE_LOG10} in log10-population units — an alias must be
- *    at least 10x more populous than the foreign primary to still win. So a genuinely dominant alias keeps winning
- *    ("Los Angeles" over La, Ghana — gap 1.6; "Las Vegas" over Vegas, Cuba — gap 2.4) while a near-tie coincidental
- *    collision defers to the primary (Cancún over Changchun — gap 0.7).
- */
-const PRIMARY_PREFERENCE_LOG10 = 1;
-/**
- * Over-fetch cap for {@link rankByPrimaryPreference}: the candidate rows for one `name_key` (all same-name places
- * worldwide) are re-ranked in-process, so the probe fetches this many (population-ordered) before the re-rank rather
- * than the caller's small `limit`, ensuring the intended primary isn't cut below the fold by a cluster of more-populous
- * foreign aliases. Bounded and small — a single contiguous B-tree scan.
+ * The word-level correction similarity — see {@link WORD_FUZZY_MIN}.
  */
-const RERANK_FETCH = 64;
+function wordFuzzySimilarity(a, b) {
+    return Math.max(jaroWinkler(a, b), levenshteinSimilarity(a, b));
+}
 /**
- * Bounded cross-country primary-name preference (see {@link PRIMARY_PREFERENCE_LOG10}). Pure + total-ordered so
- * `candidate-lookup.test.ts` can exercise it on synthetic rows. `rows` arrive population-ordered (`neg_rank ASC`); an
- * alias (`is_primary=0`) is pushed back by `delta` in log10-population units ONLY when the top-population primary
- * sharing the key is in a different country, and is `demoted` out of the exact tier when that penalty leaves it BEHIND
- * the primary. Returns the top `limit` after the re-rank, each annotated.
+ * Postcode-containment re-rank check radius (km) — the SAME value the resolver's country pass measures at
+ * (`POSTCODE_COUNTRY_COHERENCE_THRESHOLD_KM`, resolver/postcode-country-coherence.ts): a locality within this distance
+ * of the postcode's own centroid counts as "containing" it. One number, two passes — a divergence here would make the
+ * two mechanisms disagree about what is proximal.
  */
-export function rankByPrimaryPreference(rows, limit, delta = PRIMARY_PREFERENCE_LOG10) {
-    // The primary the alias actually competes with for the top slot: highest population (min neg_rank). Undefined
-    // when the set has no primary → nothing to prefer, penalty is 0, order stays population-first (today's behavior).
-    let topPrimary;
-    for (const r of rows) {
-        if (r.is_primary === 1 && (topPrimary === undefined || r.neg_rank < topPrimary.neg_rank)) {
-            topPrimary = r;
-        }
-    }
-    const topCountry = topPrimary?.country_id;
-    // A cross-country alias (different country than the top primary) is penalized; it is DEMOTED when even after — i.e.
-    // the penalty leaves its effective rank behind the primary's raw rank (it lost the bounded population contest).
-    const isCrossCountryAlias = (r) => topCountry !== undefined && r.is_primary !== 1 && r.country_id !== topCountry;
-    const annotate = (r) => {
-        const penalized = isCrossCountryAlias(r);
-        const effectiveNegRank = r.neg_rank + (penalized ? delta : 0);
-        return { ...r, effectiveNegRank, demoted: penalized && effectiveNegRank > topPrimary.neg_rank };
-    };
-    return (rows
-        .map((r, i) => ({ row: annotate(r), i }))
-        // Effective rank ASC; ties keep population order, then original index (stable).
-        // oxlint-disable-next-line unicorn/no-array-sort -- sorts a freshly-built array; toSorted would double-allocate on a hot path
-        .sort((a, b) => a.row.effectiveNegRank - b.row.effectiveNegRank || a.row.neg_rank - b.row.neg_rank || a.i - b.i)
-        .slice(0, limit)
-        .map((x) => x.row));
-}
+const POSTCODE_CONTAINMENT_THRESHOLD_KM = 25;
 /**
  * Unpadded character-trigrams of `s`, OR'd into an FTS5 trigram MATCH query (each quoted so FTS treats it as a literal
  * term). Returns "" when `s` is shorter than a trigram or yields no clean grams — the caller then skips the fuzzy
@@ -123,12 +82,16 @@ function ftsTrigramQuery(s) {
     return [...grams].map((g) => `"${g}"`).join(" OR ");
 }
 /**
- * Node {@link PlaceLookup} over `candidate.db`. Drop-in for {@link WOFSqlitePlaceLookup} in `createWOFResolver(backend)`
+ * Node {@link PlaceLookup} over `candidate.db`. Drop-in for {@link WOFSQLitePlaceLookup} in `createWOFResolver(backend)`
  * — same `findPlace` contract, population-first ranking.
  */
 export class WOFCandidateTableLookup {
     #db;
-    #ownsDB;
+    /**
+     * Resources this instance opened. A connection handed in by a caller is NOT in here, so disposal cannot reach it —
+     * ownership is membership rather than a flag a later branch has to check.
+     */
+    #resources = new DisposableStack();
     #countryToID = new Map();
     #idToCountry = new Map();
     #placetypeToID = new Map();
@@ -144,48 +107,86 @@ export class WOFCandidateTableLookup {
      */
     #ftsProbe;
     /**
-     * Prepared UNFILTERED existence probe (`name_key` present anywhere, ignoring country/placetype/bbox). Gates the fuzzy
-     * fallback: fuzzy is a TYPO corrector, so it engages only when the name doesn't exist in the gazetteer at all. A name
-     * that DOES exist but missed under the active filter is a filter miss (e.g. a placer misroute "Vienna, Austria"→IT),
-     * not a spelling miss — fuzzing it would scrape an unrelated same-country place and defeat the cascade's
-     * country-agnostic retry. Prepared only alongside `#ftsProbe`.
+     * Prepared UNFILTERED existence probe (`name_key` present anywhere, ignoring country/placetype/bbox). Checks the
+     * fuzzy fallback: fuzzy is a TYPO corrector, so it engages only when the name doesn't exist in the gazetteer at all.
+     * A name that DOES exist but missed under the active filter is a filter miss (e.g. a placer misroute "Vienna,
+     * Austria"→IT), not a spelling miss — fuzzing it would scrape an unrelated same-country place and defeat the
+     * cascade's country-agnostic retry. Prepared only alongside `#ftsProbe`.
      */
     #nameKeyExistsProbe;
     /**
      * Facts this candidate DB declares about itself — the coverage manifest (`country_coverage` + `country_bbox`) the
      * gazetteer build emits, read once at open. `undefined` when the artifact predates the manifest, so every consumer
-     * (the hard-country coverage gate, guard-B plausibility) falls back to its code constants byte-identically.
+     * (the hard-country coverage check, guard-B plausibility) falls back to its code constants byte-identically.
      */
     artifactCoverage;
     /**
      * `", importance"` when this artifact carries the #28 fame column, `""` when it does not — spliced into the probe's
-     * SELECT list. Existence-gated exactly like `#ftsProbe` and `#postalCityProbe` above, and for the same reason: a
+     * SELECT list. Existence-restricted exactly like `#ftsProbe` and `#postalCityProbe` above, and for the same reason: a
      * candidate.db built before the column is a valid artifact, and naming a column it lacks would turn a stale gazetteer
      * into `no such column` on the first keystroke rather than into "no fame signal", which is what it is.
      */
     #importanceSelect;
+    /**
+     * Whether the artifact carries the #1730 `name_role` column — absent on pre-role builds, where the `excludeNameRoles`
+     * filter degrades to a no-op rather than erroring on a missing column.
+     */
+    #hasNameRole;
+    #variantAliasExemption;
+    /**
+     * `", name_role"` when the artifact carries the column — the probe SELECT rides it so the #1882 exemption can read
+     * the stamp off the row; empty on a pre-role build.
+     */
+    #roleSelect;
+    /**
+     * Prepared chain probe over the `candidate_ancestor` sidecar — `undefined` when the artifact predates it.
+     */
+    #ancestorsProbe;
+    #ancestorsCache = new Map();
+    /**
+     * Prepared interval-label probe over `candidate_interval` — `undefined` when the artifact predates the sidecar, which
+     * is what makes the admin-containment re-rank (#1717 stage 2) capability-restricted: without it,
+     * `FindPlaceQuery.regionQualifier` is ignored, no candidate carries a `containedByQualifier` stamp, and the resolver
+     * walk reports the change `unavailable` instead of silently dead.
+     */
+    #intervalProbe;
+    #intervalCache = new Map();
+    /**
+     * Prepared qualifier probe: the region-band rows (plus `country` — the region SLOT can hold a mislabeled country
+     * name, "Moscow, Russia" parses region="Russia") for one folded qualifier key. `undefined` when the artifact lacks
+     * the sidecar or the placetype dictionary lacks the band entirely.
+     */
+    #qualifierProbe;
+    /**
+     * The ancestor lineage of a resolved place — nearest-first (locality-tier → county → region → … → country), the same
+     * order the FTS backend's `ancestorLineage` serves, read from the `candidate_ancestor` sidecar in one clustered
+     * probe. Backs `ResolveOpts.includeAncestors` (#404) on this backend, which is what puts region-class ancestry in
+     * front of the admin-coherence check (#1717).
+     *
+     * A PROPERTY, not a method, and assigned only when the artifact carries the sidecar: capability probes (`typeof
+     * backend.ancestors === "function"` — the resolver's gap report) then read the ARTIFACT truthfully. A candidate.db
+     * built before the sidecar reports the capability absent instead of presenting a method that answers `[]` for every
+     * place, which would be an absence dressed as a negative answer.
+     */
+    ancestors;
     constructor(opts) {
         if (opts.database) {
             this.#db = opts.database;
-            this.#ownsDB = false;
         }
         else if (opts.databasePath) {
-            this.#db = new DatabaseSync(opts.databasePath, { readOnly: true });
-            this.#ownsDB = true;
+            this.#db = this.#resources.use(new DatabaseClient(opts.databasePath, { readOnly: true }));
         }
         else {
             throw new Error("WOFCandidateTableLookup needs `databasePath` or `database`");
         }
         // The code tables are tiny (country/placetype dictionaries) — load them once at construction so
         // `findPlace` is a single B-tree probe with no dictionary round-trip.
-        for (const r of this.#db.prepare("SELECT id, code FROM country_codes").all()) {
+        for (const r of allRows(this.#db.prepare("SELECT id, code FROM country_codes"))) {
             const code = String(r.code).toUpperCase();
             this.#countryToID.set(code, Number(r.id));
             this.#idToCountry.set(Number(r.id), code);
         }
-        for (const r of this.#db
-            .prepare("SELECT id, placetype FROM placetype_codes")
-            .all()) {
+        for (const r of allRows(this.#db.prepare("SELECT id, placetype FROM placetype_codes"))) {
             this.#placetypeToID.set(String(r.placetype), Number(r.id));
             this.#idToPlacetype.set(Number(r.id), String(r.placetype));
         }
@@ -202,11 +203,192 @@ export class WOFCandidateTableLookup {
         }
         // #28 fame column: probed ONCE here (it runs a PRAGMA, and `findPlace` is per-keystroke hot).
         this.#importanceSelect = hasColumn(this.#db, "candidate", "importance") ? ", importance" : "";
-        // Coverage manifest (survey candidate #2): the artifact's own coverage facts, existence-gated like
+        this.#hasNameRole = hasColumn(this.#db, "candidate", "name_role");
+        this.#variantAliasExemption = opts.variantAliasExemption === true;
+        this.#roleSelect = this.#hasNameRole ? ", name_role" : "";
+        // Ancestors sidecar (#1717): existence-restricted like the probes above, and the CAPABILITY checks with
+        // it — see the `ancestors` property doc for why an older artifact must read as "no ancestors()"
+        // rather than as a method that answers [] everywhere.
+        if (hasTable(this.#db, CANDIDATE_ANCESTOR_TABLE)) {
+            this.#ancestorsProbe = this.#db.prepare(`SELECT parent_spr_id, parent_placetype_id, parent_name FROM ${CANDIDATE_ANCESTOR_TABLE}` +
+                " WHERE spr_id = ? ORDER BY depth ASC");
+            this.ancestors = (id) => this.#ancestorLineage(id);
+        }
+        // Admin-containment re-rank (#1717 stage 2): conditioned on the interval half of the sidecar (built in
+        // the same pass as the closure rows; probed separately so a hand-degraded artifact degrades
+        // truthfully) AND on the placetype dictionary carrying the qualifier band at all.
+        if (this.#ancestorsProbe && hasTable(this.#db, CANDIDATE_INTERVAL_TABLE)) {
+            this.#intervalProbe = this.#db.prepare(`SELECT pre, post FROM ${CANDIDATE_INTERVAL_TABLE} WHERE spr_id = ?`);
+            const bandIDs = [...REGION_CLASS_PLACETYPES, "country"]
+                .map((placetype) => this.#placetypeToID.get(placetype))
+                .filter((id) => id !== undefined);
+            if (bandIDs.length) {
+                this.#qualifierProbe = this.#db.prepare(`SELECT DISTINCT spr_id FROM candidate WHERE name_key = ? AND placetype_id IN (${bandIDs.join(",")}) LIMIT 8`);
+            }
+        }
+        // Coverage manifest (survey candidate #2): the artifact's own coverage facts, existence-restricted like
         // the probes above — a candidate.db built before the manifest reads `undefined` and consumers keep
         // their code-constant fallbacks byte-identically.
         this.artifactCoverage = readGazetteerCoverageManifest(this.#db);
     }
+    /**
+     * The memoized chain read behind {@link ancestors}. Sync raw `.prepare()` on purpose — the backend contract's
+     * `ancestors()` is synchronous (the sync-by-interface resolver-reader rule), and the sidecar row already carries the
+     * parent's name and placetype, so this is one clustered probe with no join.
+     */
+    #ancestorLineage(id) {
+        const pid = typeof id === "number" ? id : Number(id);
+        if (!Number.isFinite(pid) || !this.#ancestorsProbe)
+            return [];
+        const cached = this.#ancestorsCache.get(pid);
+        if (cached)
+            return cached;
+        const rows = allRows(this.#ancestorsProbe, pid);
+        const lineage = rows.map((r) => ({
+            id: Number(r.parent_spr_id),
+            placetype: this.#idToPlacetype.get(Number(r.parent_placetype_id)) ?? "",
+            name: String(r.parent_name ?? ""),
+        }));
+        this.#ancestorsCache.set(pid, lineage);
+        return lineage;
+    }
+    /**
+     * The interval label for one place, memoized. `null` is a real answer — the place has no recorded ancestry in the
+     * source (absence semantics: UNVERIFIABLE, never a containment verdict) — and is cached as such.
+     */
+    #intervalLabel(sprID) {
+        if (!this.#intervalProbe)
+            return null;
+        const cached = this.#intervalCache.get(sprID);
+        if (cached !== undefined)
+            return cached;
+        const row = this.#intervalProbe.get(sprID);
+        const label = row ? { pre: Number(row.pre), post: Number(row.post) } : null;
+        this.#intervalCache.set(sprID, label);
+        return label;
+    }
+    /**
+     * The qualifier's own rows in the candidate table: every region-band (+ country) place whose `name_key` matches one
+     * of the qualifier's {@link regionQualifierProbeKeys} expansions. Alias keys participate — `Thüringen` finds the row
+     * stored as `Thuringia` through the artifact's own alias keying, which is precisely the variant-form bridge the
+     * admin-coherence verdicts' fold-equality bound cannot offer (its stated v1 bound). Empty = the qualifier names
+     * nothing the artifact knows; the caller then stamps `false` everywhere and reorders nothing.
+     */
+    #qualifierRegionIDs(qualifier, country) {
+        const ids = new Set();
+        if (!this.#qualifierProbe)
+            return ids;
+        for (const key of regionQualifierProbeKeys(qualifier, country)) {
+            if (!key)
+                continue;
+            for (const row of allRows(this.#qualifierProbe, key)) {
+                ids.add(Number(row.spr_id));
+            }
+        }
+        return ids;
+    }
+    /**
+     * Is `sprID` contained by ANY of the qualifier's rows? Interval first — {@link intervalContains}, O(1), reflexive —
+     * then the closure rows where intervals abstain: the interval forest encodes only the CANONICAL parent per place, so
+     * a `false` there means "not contained along the canonical hierarchy", and the chain probe (one clustered read of
+     * ≤{@link MAX_ANCESTOR_DEPTH} rows) is the complete record that determines the result.
+     */
+    #containedByQualifier(sprID, qualifierIDs, qualifierLabels) {
+        if (qualifierIDs.has(sprID))
+            return true;
+        const label = this.#intervalLabel(sprID);
+        if (label && qualifierLabels.some((outer) => intervalContains(outer, label)))
+            return true;
+        return this.#ancestorLineage(sprID).some((ancestor) => qualifierIDs.has(Number(ancestor.id)));
+    }
+    /**
+     * The #1717 stage-2 re-rank over one lookup's final row set. Three steps, each additive:
+     *
+     * 1. Resolve the qualifier to its region-band rows ({@link #qualifierRegionIDs}) and stamp every existing row's
+     *    `containedByQualifier` — the stamp is the trace surface, written even when nothing reorders.
+     * 2. INJECT contained same-key candidates the country scope hid: the deciding-site measurement (2026-08-18, the #1729
+     *    lesson re-confirmed) showed `Weimar, Thüringen` under the en-US locale probes `country_id = US`, so the DE row
+     *    is not IN the list and no reorder of the list can reach it. The injection probe runs the same exact fold (and,
+     *    on a contained-miss, the qualifier-strip variant restricted to primary keys — the #1626 alias-scrape guard)
+     *    under the SHAPE conds only, appends contained rows not already present, and never removes anything — recall can
+     *    only widen. The typo-fuzzy tier is deliberately not probed: a qualifier cannot vouch for a name the gazetteer
+     *    does not carry.
+     * 3. Partition contained-first — the SHARED {@link partitionByContainment} (tier-safe, stable; the resolver walk runs
+     *    the same function after its fame re-rank, one function at both deciding sites per the #861 rule) — then
+     *    re-window to `limit`.
+     *
+     * A qualifier that matches nothing stamps `false` everywhere and reorders nothing — byte-identical answers, and the
+     * walk's verdict reads `no_contained_candidate` rather than `unavailable` (the question WAS asked).
+     */
+    #applyAdminContainment(rows, qualifier, country, opts) {
+        const qualifierIDs = this.#qualifierRegionIDs(qualifier, country);
+        if (!qualifierIDs.size) {
+            for (const row of rows) {
+                row.containedByQualifier = false;
+            }
+            return rows;
+        }
+        const qualifierLabels = [...qualifierIDs]
+            .map((id) => this.#intervalLabel(id))
+            .filter((label) => label !== null);
+        const contained = (sprID) => this.#containedByQualifier(sprID, qualifierIDs, qualifierLabels);
+        for (const row of rows) {
+            row.containedByQualifier = contained(Number(row.spr_id));
+        }
+        const present = new Set(rows.map((row) => Number(row.spr_id)));
+        const injected = [];
+        const injectSQL = (primaryOnly) => "SELECT spr_id, name, country_id, placetype_id, latitude, longitude, min_lat, min_lon, max_lat, max_lon, neg_rank, is_primary, population" +
+            `${this.#importanceSelect} FROM candidate WHERE ${["name_key = ?", ...opts.shapeFilters, ...(primaryOnly ? ["is_primary = 1"] : [])].join(" AND ")} ` +
+            "ORDER BY neg_rank ASC LIMIT ?";
+        const injectFrom = (key, primaryOnly) => {
+            const fetched = allRows(this.#db.prepare(injectSQL(primaryOnly)), key, ...opts.shapeParams, RERANK_FETCH);
+            for (const row of fetched) {
+                const sprID = Number(row.spr_id);
+                if (present.has(sprID) || !contained(sprID))
+                    continue;
+                present.add(sprID);
+                injected.push({ ...row, effectiveNegRank: row.neg_rank, demoted: false, containedByQualifier: true });
+            }
+        };
+        injectFrom(opts.nameKey, false);
+        // #1731: the dependent-locality band. A locality query's filter group (locality/borough/localadmin)
+        // cannot reach a neighbourhood-tier namesake, so a CONTAINED one is structurally invisible no matter
+        // how the list reorders — the Astoria class: Queens' Astoria is a WOF neighbourhood, and the walk
+        // answered the Oregon locality under `qualifier="NY"` because nothing in the pool sat under NY. The
+        // widening is injection-only and triple-conditioned: the band is explicit (neighbourhood/macrohood/microhood
+        // — never region or country tiers), admission still requires the sidecar's containment proof, and only
+        // primary-keyed rows enter (an alias-keyed neighbourhood is the #1626 scrape class). Recall can only
+        // widen, and only toward rows the qualifier vouches for. `opts.shapeFilters`' bbox clause is
+        // deliberately not carried: containment is the stronger constraint, and the two co-occurring is not a
+        // measured shape.
+        const bandIDs = ["neighbourhood", "macrohood", "microhood"]
+            .map((placetype) => this.#placetypeToID.get(placetype))
+            .filter((id) => id !== undefined);
+        if (bandIDs.length) {
+            const bandSQL = "SELECT spr_id, name, country_id, placetype_id, latitude, longitude, min_lat, min_lon, max_lat, max_lon, neg_rank, is_primary, population" +
+                `${this.#importanceSelect} FROM candidate WHERE name_key = ? AND placetype_id IN (${bandIDs.map(() => "?").join(",")}) AND is_primary = 1 ` +
+                "ORDER BY neg_rank ASC LIMIT ?";
+            const fetched = allRows(this.#db.prepare(bandSQL), opts.nameKey, ...bandIDs, RERANK_FETCH);
+            for (const row of fetched) {
+                const sprID = Number(row.spr_id);
+                if (present.has(sprID) || !contained(sprID))
+                    continue;
+                present.add(sprID);
+                injected.push({ ...row, effectiveNegRank: row.neg_rank, demoted: false, containedByQualifier: true });
+            }
+        }
+        // The strip variant mirrors the cascade's discipline: tried only when the exact fold vouched for
+        // nothing, and primary-keyed only (a stripped surface never named an alias — #1626).
+        if (!injected.length &&
+            !rows.some((row) => row.containedByQualifier) &&
+            opts.strippedKey &&
+            opts.strippedKey !== opts.nameKey) {
+            injectFrom(opts.strippedKey, true);
+        }
+        if (!injected.length && !rows.some((row) => row.containedByQualifier))
+            return rows;
+        return partitionByContainment([...rows, ...injected], (row) => row.containedByQualifier === true, (row) => !row.demoted && !row.fuzzy).slice(0, opts.limit);
+    }
     /**
      * Does this query want a locality-tier place? Postal-city aliases (#741) are all localities.
      */
@@ -259,7 +441,7 @@ export class WOFCandidateTableLookup {
             return [];
         // #741: postcode-keyed postal-city alias. An exact `(name_key, postcode)` hit resolves a
         // user-typed POSTAL city ("Antioch", 37013) to the geographic locality the postcode sits in
-        // ("Nashville"), bypassing the population/region ranking that can't see the postcode. Gated on
+        // ("Nashville"), bypassing the population/region ranking that can't see the postcode. Conditioned on
         // the side-index being present, a postcode in the query, and a locality-tier request — so the
         // common (no-postcode / non-locality) path is untouched. A hit short-circuits: the postcode is
         // an exact, high-confidence disambiguator, so we return the single geographic locality.
@@ -281,9 +463,15 @@ export class WOFCandidateTableLookup {
             }
         }
         const limit = Math.max(1, query.limit ?? 10);
-        // Filter conds shared by the exact-key + strip-fallback probes (everything but name_key).
+        // Filter conds shared by the exact-key + strip-fallback probes (everything but name_key). The
+        // SHAPE subset (placetype/bbox/primary — everything but the country scope) is kept separately
+        // because the admin-containment injection probe (#1717 stage 2) runs under the shape conds
+        // WITHOUT the country: bypassing a locale-inferred country scope for a qualifier-vouched
+        // candidate is the change's whole point and the one filter injection may cross.
         const filters = [];
         const filterParams = [];
+        const shapeFilters = [];
+        const shapeParams = [];
         if (query.country) {
             const cid = this.#countryToID.get(query.country.toUpperCase());
             if (cid === undefined)
@@ -300,14 +488,32 @@ export class WOFCandidateTableLookup {
                 .filter((v) => v !== undefined);
             if (!ids.length)
                 return [];
-            filters.push(`placetype_id IN (${ids.map(() => "?").join(",")})`);
-            filterParams.push(...ids);
+            shapeFilters.push(`placetype_id IN (${ids.map(() => "?").join(",")})`);
+            shapeParams.push(...ids);
         }
         if (query.bbox) {
             const b = query.bbox;
-            filters.push("latitude BETWEEN ? AND ? AND longitude BETWEEN ? AND ?");
-            filterParams.push(b.minLat, b.maxLat, b.minLon, b.maxLon);
+            shapeFilters.push("latitude BETWEEN ? AND ? AND longitude BETWEEN ? AND ?");
+            shapeParams.push(b.minLat, b.maxLat, b.minLon, b.maxLon);
         }
+        // The re-reading guard (#1632, the #1626 rationale generalized to the caller): a probe whose surface
+        // is a token taken out of a longer classified span never NAMED an alias, so alias-keyed rows must not
+        // answer it — 'Savile Row''s token 'Row' resolved Rhu, Scotland (585 km) through the village's
+        // historical-name alias key. Whole-input bare probes never set this, keeping the exonym recall the
+        // #1546 note protects (Москва's alias rows answer 'Moscow').
+        if (query.primaryOnly) {
+            shapeFilters.push("is_primary = 1");
+        }
+        // The role guard (#1730): a probe may refuse abbreviation/gloss alias rows while keeping the
+        // role-NULL exonym tier open — the distinction `primaryOnly` cannot express. Degrades to a no-op
+        // on an artifact without the column.
+        if (query.excludeNameRoles?.length && this.#hasNameRole) {
+            shapeFilters.push(`(name_role IS NULL OR name_role NOT IN (${query.excludeNameRoles.map(() => "?").join(",")}))`);
+            shapeParams.push(...query.excludeNameRoles);
+        }
+        // The main-probe conds are country-then-shape, exactly the order they have always been.
+        filters.push(...shapeFilters);
+        filterParams.push(...shapeParams);
         // Region scope: when the cascade resolves a region and passes it down as `parentID` (the walk sets
         // `query.parentID = parentResolved.id`), the candidate build stamps each place's region-tier ancestor
         // id into `region_id` (build-candidate.ts `regionOf`), and that id equals the resolved region's WOF id
@@ -317,13 +523,18 @@ export class WOFCandidateTableLookup {
         // country/non-region parent (no `region_id` match), a `region_id=0` row (place with no region
         // ancestor), or a wrong parent degrades to today's behavior — never worse, recall-safe by construction.
         const regionParentID = query.parentID || undefined;
-        const probe = (nk, regionID) => {
+        const probe = (nk, regionID, countryID) => {
             const conds = ["name_key = ?", ...filters];
             const params = [nk, ...filterParams];
             if (regionID !== undefined) {
                 conds.push("region_id = ?");
                 params.push(regionID);
             }
+            // #1585: the fuzzy tier's country scope — only the corrected-key probes pass this.
+            if (typeof countryID === "number") {
+                conds.push("country_id = ?");
+                params.push(countryID);
+            }
             // Fetch population-ordered (the clustered-key order — a cheap ordered scan), over-fetching to
             // RERANK_FETCH so the bounded cross-country primary-preference re-rank (below) can promote the
             // intended primary even when a cluster of more-populous foreign aliases sits ahead of it. `is_primary`
@@ -337,9 +548,9 @@ export class WOFCandidateTableLookup {
             // whether the query was bare enough to deserve it. A backend that pre-sorted by fame would apply
             // it to every lookup, including the qualified addresses the D-rule guard exists to protect.
             const sql = "SELECT spr_id, name, country_id, placetype_id, latitude, longitude, min_lat, min_lon, max_lat, max_lon, neg_rank, is_primary, population" +
-                `${this.#importanceSelect} FROM candidate WHERE ${conds.join(" AND ")} ORDER BY neg_rank ASC LIMIT ?`;
-            const fetched = this.#db.prepare(sql).all(...params, Math.max(limit, RERANK_FETCH));
-            return rankByPrimaryPreference(fetched, limit);
+                `${this.#importanceSelect}${this.#roleSelect} FROM candidate WHERE ${conds.join(" AND ")} ORDER BY neg_rank ASC LIMIT ?`;
+            const fetched = allRows(this.#db.prepare(sql), ...params, Math.max(limit, RERANK_FETCH));
+            return rankByPrimaryPreference(fetched, limit, undefined, this.#idToPlacetype, this.#variantAliasExemption);
         };
         // The exact → qualifier-strip → typo-fuzzy probe cascade, run at a fixed region scope. Region scoping
         // only tightens an already-population-first pick, so a region MISS re-runs the whole cascade unscoped
@@ -352,7 +563,14 @@ export class WOFCandidateTableLookup {
                 // miss; the cascade's region bbox disambiguates any base-name ambiguity.
                 const strippedKey = normalizeLocalityForKey(stripLocalityQualifier(text));
                 if (strippedKey && strippedKey !== nameKey) {
-                    rows = probe(strippedKey, regionID);
+                    // #1626: a stripped probe may answer only through a NON-PRIMARY alias key, which is a
+                    // scrape, not a qualifier match — 'Savile Row' stripped to 'row' resolved Rhu, Scotland
+                    // (585 km) through the village's historical-name alias. The legitimate qualifier class
+                    // matches the place's own primary key ('Lenk im Simmental' → the Lenk row keyed 'lenk',
+                    // is_primary=1), so refusing alias-keyed rows keeps every intended case and kills the
+                    // scrape. The alias tier remains fully available to EXACT queries — only the stripped
+                    // RETRY loses it, because the query's own surface never named the alias.
+                    rows = probe(strippedKey, regionID).filter((r) => r.is_primary === 1);
                 }
             }
             // Typo-tolerant fallback (the unified gazetteer's fuzzy mode): an exact + strip miss may be a
@@ -361,7 +579,7 @@ export class WOFCandidateTableLookup {
             // the same on either backend. The country/placetype/bbox/region filters still apply via `probe`.
             // Skipped when the index is absent (byte-stable for an older candidate.db).
             //
-            // Gate: only when the name doesn't exist in the gazetteer AT ALL (unfiltered). A name that exists
+            // Condition: only when the name doesn't exist in the gazetteer AT ALL (unfiltered). A name that exists
             // but missed under the active country/placetype/bbox filter is a FILTER miss, not a spelling miss
             // — fuzzing it scrapes an unrelated same-filter place ("Vienna, Austria" misrouted to IT would
             // pull a tiny Italian name_key near Siena) and masks the cascade's country-agnostic retry that
@@ -371,17 +589,23 @@ export class WOFCandidateTableLookup {
             // DIFFERENT postcode. The 2026-08-05 Code-Point swap exposed the trap at scale: Northern Ireland's
             // `BT3 9QQ` (absent — no permissive NI source) trigram-matched Sheffield's `S3 9QQ` (Jaccard 0.4
             // on {39q, 9qq}) and resolved 200+ km wrong with full confidence. An unknown postcode must abstain.
+            // #1585: a locale HINT scopes the typo tier to its country. Only when no hard `country`
+            // filter is active (that is already narrower); a scope naming a country the table doesn't
+            // carry is a SCOPED-EMPTY — the fuzzy tier abstains rather than falling through worldwide.
+            const fuzzyCountryID = !query.country && query.fuzzyCountry ? this.#countryToID.get(query.fuzzyCountry.toUpperCase()) : undefined;
+            const fuzzyScopedOut = !query.country && !!query.fuzzyCountry && typeof fuzzyCountryID !== "number";
             if (!rows.length &&
                 !wantsPostcode &&
+                !fuzzyScopedOut &&
                 this.#ftsProbe &&
                 this.#nameKeyExistsProbe &&
                 !this.#nameKeyExistsProbe.get(nameKey)) {
                 const match = ftsTrigramQuery(nameKey);
                 if (match) {
-                    const hits = this.#ftsProbe.all(match, FUZZY_FETCH);
+                    const hits = allRows(this.#ftsProbe, match, FUZZY_FETCH);
                     const ranked = hits
-                        .map((h) => ({ nk: String(h.name_key), s: trigramJaccard(nameKey, String(h.name_key)) }))
-                        .filter((h) => h.s >= FUZZY_MIN)
+                        .map((h) => ({ nk: String(h.name_key), s: wordFuzzySimilarity(nameKey, String(h.name_key)) }))
+                        .filter((h) => h.s >= WORD_FUZZY_MIN)
                         // 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.s - a.s);
                     const seen = new Set();
@@ -391,7 +615,7 @@ export class WOFCandidateTableLookup {
                         seen.add(h.nk);
                         // #17: stamp the tier. These rows answer a name the gazetteer does not carry, so they are
                         // fuzzy matches and `exactMatch` below must say so — see `RankedRow.fuzzy`.
-                        rows.push(...probe(h.nk, regionID).map((r) => ({ ...r, fuzzy: true })));
+                        rows.push(...probe(h.nk, regionID, fuzzyCountryID).map((r) => ({ ...r, fuzzy: true })));
                         if (rows.length >= limit)
                             break;
                     }
@@ -401,19 +625,24 @@ export class WOFCandidateTableLookup {
             return rows;
         };
         let rows = cascade(regionParentID);
+        // #1731: whether the rows the caller receives came from the UNSCOPED fallback below — the backend's
+        // interior check the resolver-side trace (#1721) cannot otherwise see. Stamped onto every returned
+        // place, because the re-admission path is exactly where a wrong-instance namesake enters.
+        let regionScopeMiss = false;
         // Region-scope fallback: if scoping to the parent region found nothing across the whole cascade, retry
         // unscoped so a place with no in-region row (missing ancestry, or a country/non-region parent) still
         // resolves exactly as it does today. Only when a region scope was actually applied.
         if (!rows.length && regionParentID !== undefined) {
             rows = cascade(undefined);
+            regionScopeMiss = rows.length > 0;
         }
         // Postcode-containment coherence (#31, Mechanism 2): re-rank the rows by proximity to the postcode's
         // own centroid, so the locality that CONTAINS the postcode wins the name-match tie (the "Paris" that
         // holds 75001, not the one that holds a 75001-free namesake). The resolver sends this flag on locality
         // lookups when `ResolveOpts.postcodeContainmentCoherence` is on. Strictly beneath the #741 postal-city
         // short-circuit above — an exact (name, postcode) hit IS the answer and outranks any re-rank — and after
-        // the region-scope fallback, so it sees the final row set. Rows within the gate sort by distance first;
-        // the out-gate tail keeps its original population-first order. No in-gate row, or no postcode row in
+        // the region-scope fallback, so it sees the final row set. Rows within the radius sort by distance first;
+        // the out-of-radius tail keeps its original population-first order. No in-radius row, or no postcode row in
         // the candidate table → unchanged (byte-identical to the flag-off path).
         if (query.postcode &&
             query.postcodeContainmentCoherence === true &&
@@ -421,37 +650,51 @@ export class WOFCandidateTableLookup {
             rows.length > 1) {
             const anchor = this.#postcodeAnchor(query.postcode, query.country);
             if (anchor) {
-                const inGate = [];
-                const outGate = [];
+                const insideThreshold = [];
+                const outsideThreshold = [];
                 for (const row of rows) {
                     const distanceKm = haversineKm(anchor.lat, anchor.lon, Number(row.latitude), Number(row.longitude));
-                    if (distanceKm <= POSTCODE_CONTAINMENT_GATE_KM) {
-                        inGate.push({ row, distanceKm });
+                    if (distanceKm <= POSTCODE_CONTAINMENT_THRESHOLD_KM) {
+                        insideThreshold.push({ row, distanceKm });
                     }
                     else {
-                        outGate.push(row);
+                        outsideThreshold.push(row);
                     }
                 }
-                if (inGate.length) {
+                if (insideThreshold.length) {
                     // oxlint-disable-next-line unicorn/no-array-sort -- sorts a freshly-built array; toSorted would double-allocate on a hot path
-                    inGate.sort((a, b) => a.distanceKm - b.distanceKm);
-                    rows = [...inGate.map(({ row }) => row), ...outGate];
+                    insideThreshold.sort((a, b) => a.distanceKm - b.distanceKm);
+                    rows = [...insideThreshold.map(({ row }) => row), ...outsideThreshold];
                 }
             }
         }
+        // Admin-containment re-rank (#1717 stage 2): LAST, on the final row set — the qualifier is the
+        // address's outermost explicit statement, so its partition outranks the postcode-proximity order
+        // above (contained rows keep that order among themselves). Capability-conditioned on the sidecar
+        // (`#qualifierProbe`); when the artifact predates it, `regionQualifier` is ignored, no stamp is
+        // written, and the resolver walk reports the change `unavailable`.
+        if (query.regionQualifier?.trim() && this.#qualifierProbe && this.#wantsLocality(query.placetype)) {
+            rows = this.#applyAdminContainment(rows, query.regionQualifier.trim(), query.country, {
+                nameKey,
+                strippedKey: normalizeLocalityForKey(stripLocalityQualifier(text)),
+                shapeFilters,
+                shapeParams,
+                limit,
+            });
+        }
         const candidates = rows.map((row) => {
             const hasBbox = row.min_lat != null && row.max_lat != null && row.min_lon != null && row.max_lon != null;
             return {
                 id: Number(row.spr_id),
                 name: String(row.name ?? ""),
                 placetype: (this.#idToPlacetype.get(Number(row.placetype_id)) ?? ""),
-                // Surfaced so the cascade can country-gate a postcode by the resolved locality (an ambiguous
+                // Surfaced so the cascade can country-restrict a postcode by the resolved locality (an ambiguous
                 // international postcode like 10115 = Berlin DE AND New York US must not out-resolve the city).
                 country: this.#idToCountry.get(Number(row.country_id)) ?? "",
                 lat: Number(row.latitude),
                 lon: Number(row.longitude),
                 // `score` stays the RAW population rank (`-neg_rank`) — it feeds the resolver walk's absolute
-                // `minWinningScore` gate (`resolve.ts`), which must see real prominence, never a penalized value.
+                // `minWinningScore` floor (`resolve.ts`), which must see real prominence, never a penalized value.
                 score: -Number(row.neg_rank),
                 // `prominence` carries the bounded cross-country primary preference (the effective, penalty-adjusted
                 // rank). The walk ORDERS candidates by `prominence ?? score` (`resolve.ts`), so this is what makes the
@@ -466,6 +709,16 @@ export class WOFCandidateTableLookup {
                 // EXCEPT a row the typo-corrector produced (`fuzzy`), which by definition answers a name the
                 // gazetteer does not carry (see `RankedRow.fuzzy`).
                 exactMatch: !row.demoted && !row.fuzzy,
+                // #1731: emitted ONLY when a region scope was applied, missed, and the unscoped fallback
+                // produced this row — the re-admission path. Absence means the question never arose.
+                ...(regionScopeMiss ? { regionScopeMiss: true } : {}),
+                // #1717 stage 2 — the containment stamp, tri-state: emitted ONLY when the question was
+                // asked (a `regionQualifier` query over a sidecar-bearing artifact); its absence is what
+                // the resolver walk reports as `unavailable` (meaning-of-zero).
+                ...(row.containedByQualifier === undefined ? {} : { containedByQualifier: row.containedByQualifier }),
+                // #1893 — the exemption's firing mark, carried only when the ranker actually spared this row
+                // the cross-country penalty (see RankedRow.variantExempted).
+                ...(row.variantExempted ? { variantAliasExempted: true } : {}),
                 // The two-score split's carry (ROAD_TO_V9 §2). `referential` names the prominence this
                 // backend has always ordered by — `neg_rank` IS `-log10(population + 1)`, so the score and
                 // the sort key are two readings of the same number.
@@ -500,60 +753,15 @@ export class WOFCandidateTableLookup {
                     : {}),
             };
         });
-        // Proximity re-rank (#938): with bias hints (the demo's map viewport / user location), re-sort the
-        // exact-match candidates by the SAME prominence the FTS server uses (lookup.ts) — population and
-        // nearness in one additive scale — so an in-view namesake wins a tie without a hard filter. Byte-
-        // identical to the plain population order when no bias is passed. `score` here is -neg_rank =
-        // log10(population + 1), so popTerm is the server formula read straight off it. Constants MIRROR
-        // lookup.ts's DEFAULT_WEIGHTS (biasBoost 4, populationBoost 4, populationScaleLog10 6,
-        // proximityScaleKm 100) — the #861 server↔demo parity contract; keep them in lockstep.
+        // Proximity re-rank (#938) — the shared implementation, so the browser byte-range twin runs the same
+        // code rather than the same constants. See proximity-rerank.ts for why that distinction mattered.
         if (query.bias && query.bias.length) {
-            const BIAS_BOOST = 4;
-            const POP_BOOST = 4;
-            const POP_SCALE_LOG10 = 6;
-            // SHARPER than lookup.ts's 100 km on purpose: this backend's `score` is log-population ALONE
-            // (no bm25 document term), so the population signal is weaker relative to the bias and the
-            // gentle 100 km decay let a 230 km-distant alias-exact township ("Paris Township", OH) edge
-            // out a global city ("Paris", FR) from a nearby view. A ~30 km scale keeps the boost to
-            // candidates the user is actually LOOKING at — an in-view namesake still wins (Dublin, OH from
-            // an Ohio view), a distant one no longer does (Paris stays FR from a Michigan view).
-            const PROX_SCALE_KM = 30;
-            const combinedProminence = (c) => {
-                // Population base is the PENALIZED `prominence` (set above = -effectiveNegRank), not raw `score`, so
-                // the cross-country primary preference carries into the bias-weighted order too — a coincidental
-                // foreign alias doesn't ride population back over a primary just because a viewport hint is present.
-                const popBase = c.prominence ?? c.score;
-                const popTerm = POP_BOOST * Math.min(1, Math.max(0, popBase) / POP_SCALE_LOG10);
-                let proxTerm = 0;
-                if (!(c.lat === 0 && c.lon === 0)) {
-                    for (const b of query.bias) {
-                        const d = haversineKm(b.lat, b.lon, c.lat, c.lon);
-                        const term = (BIAS_BOOST * (b.weight ?? 1)) / (1 + d / PROX_SCALE_KM);
-                        if (term > proxTerm) {
-                            proxTerm = term;
-                        }
-                    }
-                }
-                return popTerm + proxTerm;
-            };
-            // Persist the combined value into `prominence` so the resolver walk's `prominence ?? score` sort (and any
-            // other node consumer) honors the bias order — then sort. Stable within equal prominence (preserves the
-            // population order the B-tree already gave).
-            candidates
-                .map((c, i) => {
-                c.prominence = combinedProminence(c);
-                return { c, i, p: c.prominence };
-            })
-                // 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.p - a.p || a.i - b.i)
-                .forEach((x, j) => (candidates[j] = x.c));
+            applyProximityRerank(candidates, query.bias);
         }
         return candidates;
     }
-    close() {
-        if (this.#ownsDB) {
-            this.#db.close();
-        }
+    [Symbol.dispose]() {
+        this.#resources[Symbol.dispose]();
     }
 }
 //# sourceMappingURL=candidate-lookup.js.map