@mailwoman/resolver-wof-sqlite 9.1.0 → 9.3.0

package/out/candidate/own-name.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   The OWN-NAME VARIANT predicate (#1882): is an alias surface the holder's own primary name in
+ *   another orthography — a romanization (`Брэст` → `brest`), a spacing/diacritic variant
+ *   (`George Town` → `georgetown`), an abbreviation expansion (`St. George's` → `Saint George's`)
+ *   — rather than a different name that merely shares the folded key?
+ *
+ *   The comparator is `levenshteinSimilarity`, NOT Jaro-Winkler: JW's common-prefix bonus scores
+ *   the required NEGATIVE case (`chanchun` vs `cancun`, 0.925) above real positives
+ *   (`saint george s` vs `st georges` expanded, 0.914), so no JW threshold separates them.
+ *   Measured on the #1882 census contests, edit similarity separates every case with margin:
+ *
+ *   - IN: `brest`/`brest` 1.0 · `george town`/`georgetown` 0.909 · `saint george s`/`saint georges`
+ *       0.929 · `adamovka`/`adamowka` 0.875
+ *   - OUT: `lievin`/`levin` 0.833 (Liévin FR vs Levin NZ — different places with near-identical
+ *       names; the panel's `41 Weraroa Road, Levin` row needs this side) · `chanchun`/`cancun` 0.75 ·
+ *       `augsburg`/`augusta` 0.375 · `west bay`/`west end` 0.625 · `derry`/`londonderry` 0.455
+ *       (Derry/Londonderry is a DUAL NAME, not a variant — its own follow-up on #1882)
+ *
+ *   An unhandled script (Arabic, Hebrew, CJK — the romanizer covers Cyrillic only) answers NULL,
+ *   never "different name": absence of a verdict must not stamp anything (the meaning-of-zero rule).
+ *   The #1882 census counted 396 demoted Arabic/Hebrew-primary aliases left unclassified by this.
+ */
+/**
+ * Edit-similarity floor for the variant verdict. The measured band: nearest admitted pair 0.875
+ * (`adamovka`/`adamowka`), nearest refused pair 0.833 (`lievin`/`levin`).
+ */
+export declare const VARIANT_SIMILARITY_MIN = 0.85;
+/**
+ * Expand the whole-word abbreviations above.
+ */
+export declare function expandNameAbbreviations(key: string): string;
+/**
+ * Romanize a folded name key to the a–z0–9/space alphabet. `null` when characters outside the covered scripts remain —
+ * an unhandled script is NO VERDICT, not a mismatch.
+ */
+export declare function romanizeNameKey(key: string): string | null;
+/**
+ * Edit similarity between a holder's primary name key and one of its alias keys, both romanized and
+ * abbreviation-expanded. `null` when either side's script is uncovered.
+ */
+export declare function ownNameSimilarity(primaryKey: string, aliasKey: string): number | null;
+/**
+ * The stamp predicate: the alias surface is the holder's own name in another orthography.
+ */
+export declare function isOwnNameVariant(primaryKey: string, aliasKey: string): boolean;
+//# sourceMappingURL=own-name.d.ts.map

package/out/candidate/own-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"own-name.d.ts","sourceRoot":"","sources":["../../lib/candidate/own-name.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAIH;;;GAGG;AACH,eAAO,MAAM,sBAAsB,OAAO,CAAA;AA2D1C;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAQ3D;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAc1D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAOrF;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAI9E"}

package/out/candidate/own-name.js

@@ -0,0 +1,132 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   The OWN-NAME VARIANT predicate (#1882): is an alias surface the holder's own primary name in
+ *   another orthography — a romanization (`Брэст` → `brest`), a spacing/diacritic variant
+ *   (`George Town` → `georgetown`), an abbreviation expansion (`St. George's` → `Saint George's`)
+ *   — rather than a different name that merely shares the folded key?
+ *
+ *   The comparator is `levenshteinSimilarity`, NOT Jaro-Winkler: JW's common-prefix bonus scores
+ *   the required NEGATIVE case (`chanchun` vs `cancun`, 0.925) above real positives
+ *   (`saint george s` vs `st georges` expanded, 0.914), so no JW threshold separates them.
+ *   Measured on the #1882 census contests, edit similarity separates every case with margin:
+ *
+ *   - IN: `brest`/`brest` 1.0 · `george town`/`georgetown` 0.909 · `saint george s`/`saint georges`
+ *       0.929 · `adamovka`/`adamowka` 0.875
+ *   - OUT: `lievin`/`levin` 0.833 (Liévin FR vs Levin NZ — different places with near-identical
+ *       names; the panel's `41 Weraroa Road, Levin` row needs this side) · `chanchun`/`cancun` 0.75 ·
+ *       `augsburg`/`augusta` 0.375 · `west bay`/`west end` 0.625 · `derry`/`londonderry` 0.455
+ *       (Derry/Londonderry is a DUAL NAME, not a variant — its own follow-up on #1882)
+ *
+ *   An unhandled script (Arabic, Hebrew, CJK — the romanizer covers Cyrillic only) answers NULL,
+ *   never "different name": absence of a verdict must not stamp anything (the meaning-of-zero rule).
+ *   The #1882 census counted 396 demoted Arabic/Hebrew-primary aliases left unclassified by this.
+ */
+import { levenshteinSimilarity } from "@mailwoman/match/comparators";
+/**
+ * Edit-similarity floor for the variant verdict. The measured band: nearest admitted pair 0.875
+ * (`adamovka`/`adamowka`), nearest refused pair 0.833 (`lievin`/`levin`).
+ */
+export const VARIANT_SIMILARITY_MIN = 0.85;
+/**
+ * BGN/PCGN-flavored Cyrillic romanization, folded to the name-key alphabet. Digraph outputs (zh, kh, ts, ch, sh, shch,
+ * yu, ya) match the dominant transliteration conventions the gazetteer's Latin aliases actually use; the `w`/`v` and
+ * `kh`/`h` style variance between systems is what the edit-similarity threshold absorbs.
+ */
+const CYRILLIC_TO_LATIN = {
+    а: "a",
+    б: "b",
+    в: "v",
+    г: "g",
+    д: "d",
+    е: "e",
+    ё: "e",
+    ж: "zh",
+    з: "z",
+    и: "i",
+    і: "i",
+    й: "i",
+    к: "k",
+    л: "l",
+    м: "m",
+    н: "n",
+    о: "o",
+    п: "p",
+    р: "r",
+    с: "s",
+    т: "t",
+    у: "u",
+    ў: "u",
+    ф: "f",
+    х: "kh",
+    ц: "ts",
+    ч: "ch",
+    ш: "sh",
+    щ: "shch",
+    ъ: "",
+    ы: "y",
+    ь: "",
+    э: "e",
+    ю: "yu",
+    я: "ya",
+    ґ: "g",
+    є: "e",
+    ї: "i",
+};
+/**
+ * Leading-word abbreviations expanded BEFORE comparison, so `st georges` meets `saint george s` inside the edit
+ * threshold. Whole-word only — `st` inside `stanley` never expands.
+ */
+const NAME_ABBREVIATIONS = [
+    [/\bst\b/g, "saint"],
+    [/\bste\b/g, "sainte"],
+    [/\bmt\b/g, "mount"],
+    [/\bft\b/g, "fort"],
+];
+/**
+ * Expand the whole-word abbreviations above.
+ */
+export function expandNameAbbreviations(key) {
+    let out = key;
+    for (const [pattern, replacement] of NAME_ABBREVIATIONS) {
+        out = out.replaceAll(pattern, replacement);
+    }
+    return out;
+}
+/**
+ * Romanize a folded name key to the a–z0–9/space alphabet. `null` when characters outside the covered scripts remain —
+ * an unhandled script is NO VERDICT, not a mismatch.
+ */
+export function romanizeNameKey(key) {
+    let out = "";
+    for (const ch of key.toLowerCase()) {
+        out += CYRILLIC_TO_LATIN[ch] ?? ch;
+    }
+    out = out
+        .normalize("NFD")
+        .replaceAll(/[̀-ͯ]/g, "")
+        .replaceAll(/\s+/g, " ")
+        .trim();
+    return /^[a-z0-9 ]*$/.test(out) ? out : null;
+}
+/**
+ * Edit similarity between a holder's primary name key and one of its alias keys, both romanized and
+ * abbreviation-expanded. `null` when either side's script is uncovered.
+ */
+export function ownNameSimilarity(primaryKey, aliasKey) {
+    const primary = romanizeNameKey(primaryKey);
+    const alias = romanizeNameKey(aliasKey);
+    if (primary == null || alias == null || !primary || !alias)
+        return null;
+    return levenshteinSimilarity(expandNameAbbreviations(primary), expandNameAbbreviations(alias));
+}
+/**
+ * The stamp predicate: the alias surface is the holder's own name in another orthography.
+ */
+export function isOwnNameVariant(primaryKey, aliasKey) {
+    const similarity = ownNameSimilarity(primaryKey, aliasKey);
+    return similarity != null && similarity >= VARIANT_SIMILARITY_MIN;
+}
+//# sourceMappingURL=own-name.js.map

package/out/candidate/own-name.js.map

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

package/out/candidate/place-attrs.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ * @file The per-place record every candidate-staging pass writes its rows from.
+ *
+ *   Pass 1 reduces each current `spr` row to one {@link PlaceAttrs}; every later pass (alias bags,
+ *   region abbreviations, country display names, the currency backfill, the extract folds) discovers
+ *   ADDITIONAL name keys for a place already in that map and stages a row against the same record.
+ *   That is what keeps each candidate row denormalized without re-reading the source, and it is why
+ *   a pass needs exactly four things to stage: the key it found, the place, the id the row hangs on,
+ *   and whether the key is the place's canonical name.
+ */
+export interface PlaceAttrs {
+    cid: number;
+    rid: number;
+    ptid: number;
+    name: string;
+    lat: number;
+    lon: number;
+    mnLat: number;
+    mnLon: number;
+    mxLat: number;
+    mxLon: number;
+    pop: number;
+    neg: number;
+    pkey: string;
+    /**
+     * The place's toponym-fame score, or null when the score source has no measurement for it (#28). A property of the
+     * PLACE, so it rides {@link StageRow} onto the alias and abbrev rows too — that is how a bare `Moscow` reaches
+     * Москва's score through the alias row that carries the key.
+     */
+    imp: number | null;
+}
+/**
+ * Stage one candidate row: a normalized name key, the place it belongs to, the source id the row hangs on, and whether
+ * the key is that place's canonical name (`is_primary`).
+ *
+ * `sid` is passed separately rather than read off the place because a extract fold and the alias pass stage rows for
+ * ids the admin `attrs` map never held.
+ */
+export type StageRow = (k: string, a: PlaceAttrs, sid: number, isPrimary: number) => void;
+//# sourceMappingURL=place-attrs.d.ts.map

package/out/candidate/place-attrs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"place-attrs.d.ts","sourceRoot":"","sources":["../../lib/candidate/place-attrs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,WAAW,UAAU;IAC1B,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ;;;;OAIG;IACH,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;CAClB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,CAAA"}

package/out/candidate/place-attrs.js

@@ -0,0 +1,15 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ * @file The per-place record every candidate-staging pass writes its rows from.
+ *
+ *   Pass 1 reduces each current `spr` row to one {@link PlaceAttrs}; every later pass (alias bags,
+ *   region abbreviations, country display names, the currency backfill, the extract folds) discovers
+ *   ADDITIONAL name keys for a place already in that map and stages a row against the same record.
+ *   That is what keeps each candidate row denormalized without re-reading the source, and it is why
+ *   a pass needs exactly four things to stage: the key it found, the place, the id the row hangs on,
+ *   and whether the key is the place's canonical name.
+ */
+export {};
+//# sourceMappingURL=place-attrs.js.map

package/out/candidate/place-attrs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"place-attrs.js","sourceRoot":"","sources":["../../lib/candidate/place-attrs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG"}

package/out/candidate-ancestors-schema.d.ts

@@ -0,0 +1,150 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Typed schema for the candidate gazetteer's ANCESTORS sidecar (`candidate_ancestor` +
+ *   `candidate_interval`) — the containment lineage the candidate table itself cannot answer, built
+ *   into the same `candidate.db` by `build-candidate.ts` and read by
+ *   {@link WOFCandidateTableLookup.ancestors}.
+ *
+ *   ENCODING: closure-lite rows, denormalized — one row per (place, ancestor) edge carrying the
+ *   parent's placetype, display name and folded key — rather than a fixed-slot id chain on the
+ *   candidate row. Decided by the two consumers:
+ *
+ *   1. The admin-coherence check needs the WINNER's chain as (placetype, name) pairs in one probe.
+ *      A fixed-slot `[id;8]` chain answers with ids, and every id then needs a name lookup the
+ *      artifact has no per-id table for — up to 8 indirections where the closure row has zero.
+ *   2. The account layer needs EVERY candidate under a `name_key` enumerable WITH its chain from
+ *      one artifact probe ("present-but-outranked, discriminated by containment"). That is the
+ *      candidate probe (contiguous) followed by one `spr_id`-clustered closure probe per candidate
+ *      — each a handful of adjacent pages.
+ *
+ *   Denormalizing the parent onto the edge is the same discipline as the candidate table itself:
+ *   this artifact is read over HTTP byte ranges, where a join to a dimension table scatters page
+ *   fetches, and a `WITHOUT ROWID` B-tree clustered on `(spr_id, depth)` keeps a whole chain in
+ *   1-2 pages. The repeated parent strings are the price of the zero-join read, paid at build time.
+ *
+ *   `depth` is 1 for the NEAREST ancestor (deepest containment tier), increasing outward to the
+ *   country — the same nearest-first order `ancestry.ts` serves for the FTS backend, so the two
+ *   backends' `ancestors()` agree by construction. The order within a place is deterministic:
+ *   containment depth descending (`placetypeDepth`), then ancestor id ascending, capped at
+ *   {@link MAX_ANCESTOR_DEPTH}. `parent_name_key` is the SHARED {@link normalizeLocalityForKey}
+ *   fold — the same fold `candidate.name_key` is built with, so a chain entry and a candidate key
+ *   compare under one normalizer.
+ *
+ *   `candidate_interval` carries pre/post-order labels over the CANONICAL-PARENT FOREST, assigned
+ *   at build time: `a` contains `d` ⟺ `a.pre <= d.pre AND d.post <= a.post` — O(1) in either
+ *   direction with no chain scan and no knowledge of either side's tier — and the descendants of
+ *   `a` are the contiguous range `pre BETWEEN a.pre AND a.post`. Interval labels are classically
+ *   avoided for their relabel-on-update cost; this database is a sealed read-only artifact rebuilt
+ *   whole, which is exactly the regime where that cost is void.
+ *
+ *   THE DAG CAVEAT, and the recorded choice: WOF places can carry more than one parent (multiple
+ *   hierarchies, ambiguous boundaries). `candidate_ancestor` keeps EVERY parent — the closure rows
+ *   are the complete containment record. A single interval pair can only encode a tree, so the
+ *   interval forest links each place to ONE canonical parent: its depth-1 edge — the finest
+ *   containment tier, lowest ancestor id — the same MIN-stability convention the candidate table's
+ *   `region_id` stamp uses. A containment question about a NON-canonical hierarchy must consult the
+ *   closure rows; the interval answer for it is `false`, which is why interval verdicts are
+ *   "contained along the canonical hierarchy", never "not contained at all".
+ *
+ *   ABSENCE SEMANTICS (meaning-of-zero): a place with no `candidate_interval` row has no recorded
+ *   ancestry in the source (extract-fed postcodes and localities, isolated places, cycle-skipped
+ *   rows). Absence is UNVERIFIABLE, never a containment verdict.
+ */
+import { type Kysely } from "kysely";
+import type { CandidateDatabase } from "#candidate-schema";
+import type { NameKey } from "#street/normalize";
+/**
+ * The deepest chain the sidecar stores per place. WOF containment within the resolvable placetypes (country …
+ * microhood) never legitimately exceeds this; anything past it is source noise the build drops (and counts) rather than
+ * stores.
+ */
+export declare const MAX_ANCESTOR_DEPTH = 8;
+/**
+ * The closure-row table's name — probed with `hasTable` by the reader, so an artifact predating the sidecar degrades to
+ * "no ancestors capability" rather than `no such table`.
+ */
+export declare const CANDIDATE_ANCESTOR_TABLE = "candidate_ancestor";
+/**
+ * The interval-label table's name — the closure table's seal-time sibling; existence-restricted the same way.
+ */
+export declare const CANDIDATE_INTERVAL_TABLE = "candidate_interval";
+/**
+ * One (place, ancestor) edge, denormalized so a chain read is a single clustered probe (no join).
+ */
+export interface CandidateAncestorTable {
+    /**
+     * WOF id of the place whose chain this row belongs to — the same `spr_id` the candidate table resolves to.
+     */
+    spr_id: number;
+    /**
+     * 1 = nearest ancestor, increasing outward to the country. Deterministic within a place (containment depth
+     * descending, then ancestor id ascending), so `(spr_id, depth)` is a stable primary key across rebuilds.
+     */
+    depth: number;
+    /**
+     * WOF id of the ancestor.
+     */
+    parent_spr_id: number;
+    /**
+     * Small int from the shared `placetype_codes` dictionary (the same one the candidate table uses).
+     */
+    parent_placetype_id: number;
+    /**
+     * The ancestor's canonical display name — what {@link Ancestor.name} serves, matching the FTS backend's register.
+     */
+    parent_name: string;
+    /**
+     * The SHARED {@link normalizeLocalityForKey} fold of `parent_name` — comparable against `candidate.name_key` and
+     * against a query-side fold under one normalizer, by construction.
+     */
+    parent_name_key: NameKey;
+}
+/**
+ * Pre/post-order labels over the canonical-parent forest — one row per place WITH recorded ancestry (see the module
+ * docstring for absence semantics). `pre < post` always; labels are unique across the artifact.
+ */
+export interface CandidateIntervalTable {
+    spr_id: number;
+    pre: number;
+    post: number;
+}
+/**
+ * The sidecar tables, for a `Kysely` view over the candidate DB. `CandidateDatabase` (candidate-schema.ts) extends
+ * this, so the builder's one typed client sees both families.
+ */
+export interface CandidateAncestorsDatabase {
+    candidate_ancestor: CandidateAncestorTable;
+    candidate_interval: CandidateIntervalTable;
+}
+/**
+ * The `candidate_ancestor` columns in clustered-key order — the first two ARE the primary key, and the builder's
+ * positional `INSERT` binds by this order. Keep in sync with {@link CandidateAncestorTable}.
+ */
+export declare const CANDIDATE_ANCESTOR_COLUMNS: readonly ["spr_id", "depth", "parent_spr_id", "parent_placetype_id", "parent_name", "parent_name_key"];
+/**
+ * Create the clustered closure table. The builder inserts in `(spr_id, depth)` order so the B-tree leaves are
+ * contiguous per place — the byte-range read discipline.
+ */
+export declare function createCandidateAncestorTable(db: Kysely<CandidateDatabase>): Promise<void>;
+/**
+ * Create the interval-label table. Small rows probed by primary key — the `WITHOUT ROWID` win case.
+ */
+export declare function createCandidateIntervalTable(db: Kysely<CandidateDatabase>): Promise<void>;
+/**
+ * One place's interval label — the shape both sides of a containment comparison read.
+ */
+export interface IntervalLabel {
+    pre: number;
+    post: number;
+}
+/**
+ * Does `outer` contain `inner` along the canonical hierarchy? Reflexive: a place contains itself (containment
+ * degenerates to identity, the same reading the admin-coherence check gives a self-match). The shared FUNCTION for
+ * every consumer of the labels — a re-derived comparison risks disagreeing at exactly the strict/inclusive boundary
+ * this line settles.
+ */
+export declare function intervalContains(outer: IntervalLabel, inner: IntervalLabel): boolean;
+//# sourceMappingURL=candidate-ancestors-schema.d.ts.map

package/out/candidate-ancestors-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"candidate-ancestors-schema.d.ts","sourceRoot":"","sources":["../lib/candidate-ancestors-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH,OAAO,EAAO,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAA;AAKzC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAC1D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAEhD;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,IAAI,CAAA;AAEnC;;;GAGG;AACH,eAAO,MAAM,wBAAwB,uBAAuB,CAAA;AAE5D;;GAEG;AACH,eAAO,MAAM,wBAAwB,uBAAuB,CAAA;AAE5D;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACtC;;OAEG;IACH,MAAM,EAAE,MAAM,CAAA;IACd;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAA;IACb;;OAEG;IACH,aAAa,EAAE,MAAM,CAAA;IACrB;;OAEG;IACH,mBAAmB,EAAE,MAAM,CAAA;IAC3B;;OAEG;IACH,WAAW,EAAE,MAAM,CAAA;IACnB;;;OAGG;IACH,eAAe,EAAE,OAAO,CAAA;CACxB;AAED;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACtC,MAAM,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;CACZ;AAED;;;GAGG;AACH,MAAM,WAAW,0BAA0B;IAC1C,kBAAkB,EAAE,sBAAsB,CAAA;IAC1C,kBAAkB,EAAE,sBAAsB,CAAA;CAC1C;AAED;;;GAGG;AACH,eAAO,MAAM,0BAA0B,wGAO7B,CAAA;AAEV;;;GAGG;AACH,wBAAsB,4BAA4B,CAAC,EAAE,EAAE,MAAM,CAAC,iBAAiB,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAa/F;AAED;;GAEG;AACH,wBAAsB,4BAA4B,CAAC,EAAE,EAAE,MAAM,CAAC,iBAAiB,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ/F;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;CACZ;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAEpF"}

package/out/candidate-ancestors-schema.js

@@ -0,0 +1,123 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Typed schema for the candidate gazetteer's ANCESTORS sidecar (`candidate_ancestor` +
+ *   `candidate_interval`) — the containment lineage the candidate table itself cannot answer, built
+ *   into the same `candidate.db` by `build-candidate.ts` and read by
+ *   {@link WOFCandidateTableLookup.ancestors}.
+ *
+ *   ENCODING: closure-lite rows, denormalized — one row per (place, ancestor) edge carrying the
+ *   parent's placetype, display name and folded key — rather than a fixed-slot id chain on the
+ *   candidate row. Decided by the two consumers:
+ *
+ *   1. The admin-coherence check needs the WINNER's chain as (placetype, name) pairs in one probe.
+ *      A fixed-slot `[id;8]` chain answers with ids, and every id then needs a name lookup the
+ *      artifact has no per-id table for — up to 8 indirections where the closure row has zero.
+ *   2. The account layer needs EVERY candidate under a `name_key` enumerable WITH its chain from
+ *      one artifact probe ("present-but-outranked, discriminated by containment"). That is the
+ *      candidate probe (contiguous) followed by one `spr_id`-clustered closure probe per candidate
+ *      — each a handful of adjacent pages.
+ *
+ *   Denormalizing the parent onto the edge is the same discipline as the candidate table itself:
+ *   this artifact is read over HTTP byte ranges, where a join to a dimension table scatters page
+ *   fetches, and a `WITHOUT ROWID` B-tree clustered on `(spr_id, depth)` keeps a whole chain in
+ *   1-2 pages. The repeated parent strings are the price of the zero-join read, paid at build time.
+ *
+ *   `depth` is 1 for the NEAREST ancestor (deepest containment tier), increasing outward to the
+ *   country — the same nearest-first order `ancestry.ts` serves for the FTS backend, so the two
+ *   backends' `ancestors()` agree by construction. The order within a place is deterministic:
+ *   containment depth descending (`placetypeDepth`), then ancestor id ascending, capped at
+ *   {@link MAX_ANCESTOR_DEPTH}. `parent_name_key` is the SHARED {@link normalizeLocalityForKey}
+ *   fold — the same fold `candidate.name_key` is built with, so a chain entry and a candidate key
+ *   compare under one normalizer.
+ *
+ *   `candidate_interval` carries pre/post-order labels over the CANONICAL-PARENT FOREST, assigned
+ *   at build time: `a` contains `d` ⟺ `a.pre <= d.pre AND d.post <= a.post` — O(1) in either
+ *   direction with no chain scan and no knowledge of either side's tier — and the descendants of
+ *   `a` are the contiguous range `pre BETWEEN a.pre AND a.post`. Interval labels are classically
+ *   avoided for their relabel-on-update cost; this database is a sealed read-only artifact rebuilt
+ *   whole, which is exactly the regime where that cost is void.
+ *
+ *   THE DAG CAVEAT, and the recorded choice: WOF places can carry more than one parent (multiple
+ *   hierarchies, ambiguous boundaries). `candidate_ancestor` keeps EVERY parent — the closure rows
+ *   are the complete containment record. A single interval pair can only encode a tree, so the
+ *   interval forest links each place to ONE canonical parent: its depth-1 edge — the finest
+ *   containment tier, lowest ancestor id — the same MIN-stability convention the candidate table's
+ *   `region_id` stamp uses. A containment question about a NON-canonical hierarchy must consult the
+ *   closure rows; the interval answer for it is `false`, which is why interval verdicts are
+ *   "contained along the canonical hierarchy", never "not contained at all".
+ *
+ *   ABSENCE SEMANTICS (meaning-of-zero): a place with no `candidate_interval` row has no recorded
+ *   ancestry in the source (extract-fed postcodes and localities, isolated places, cycle-skipped
+ *   rows). Absence is UNVERIFIABLE, never a containment verdict.
+ */
+import { sql } from "kysely";
+/**
+ * The deepest chain the sidecar stores per place. WOF containment within the resolvable placetypes (country …
+ * microhood) never legitimately exceeds this; anything past it is source noise the build drops (and counts) rather than
+ * stores.
+ */
+export const MAX_ANCESTOR_DEPTH = 8;
+/**
+ * The closure-row table's name — probed with `hasTable` by the reader, so an artifact predating the sidecar degrades to
+ * "no ancestors capability" rather than `no such table`.
+ */
+export const CANDIDATE_ANCESTOR_TABLE = "candidate_ancestor";
+/**
+ * The interval-label table's name — the closure table's seal-time sibling; existence-restricted the same way.
+ */
+export const CANDIDATE_INTERVAL_TABLE = "candidate_interval";
+/**
+ * The `candidate_ancestor` columns in clustered-key order — the first two ARE the primary key, and the builder's
+ * positional `INSERT` binds by this order. Keep in sync with {@link CandidateAncestorTable}.
+ */
+export const CANDIDATE_ANCESTOR_COLUMNS = [
+    "spr_id",
+    "depth",
+    "parent_spr_id",
+    "parent_placetype_id",
+    "parent_name",
+    "parent_name_key",
+];
+/**
+ * Create the clustered closure table. The builder inserts in `(spr_id, depth)` order so the B-tree leaves are
+ * contiguous per place — the byte-range read discipline.
+ */
+export async function createCandidateAncestorTable(db) {
+    await db.schema
+        .createTable(CANDIDATE_ANCESTOR_TABLE)
+        .addColumn("spr_id", "integer", (c) => c.notNull())
+        .addColumn("depth", "integer", (c) => c.notNull())
+        .addColumn("parent_spr_id", "integer", (c) => c.notNull())
+        .addColumn("parent_placetype_id", "integer", (c) => c.notNull())
+        .addColumn("parent_name", "text", (c) => c.notNull())
+        .addColumn("parent_name_key", "text", (c) => c.notNull())
+        .addPrimaryKeyConstraint("candidate_ancestor_pk", ["spr_id", "depth"])
+        // `WITHOUT ROWID` has no first-class builder; the raw modifier is the idiomatic fallback.
+        .modifyEnd(sql `without rowid`)
+        .execute();
+}
+/**
+ * Create the interval-label table. Small rows probed by primary key — the `WITHOUT ROWID` win case.
+ */
+export async function createCandidateIntervalTable(db) {
+    await db.schema
+        .createTable(CANDIDATE_INTERVAL_TABLE)
+        .addColumn("spr_id", "integer", (c) => c.primaryKey())
+        .addColumn("pre", "integer", (c) => c.notNull())
+        .addColumn("post", "integer", (c) => c.notNull())
+        .modifyEnd(sql `without rowid`)
+        .execute();
+}
+/**
+ * Does `outer` contain `inner` along the canonical hierarchy? Reflexive: a place contains itself (containment
+ * degenerates to identity, the same reading the admin-coherence check gives a self-match). The shared FUNCTION for
+ * every consumer of the labels — a re-derived comparison risks disagreeing at exactly the strict/inclusive boundary
+ * this line settles.
+ */
+export function intervalContains(outer, inner) {
+    return outer.pre <= inner.pre && inner.post <= outer.post;
+}
+//# sourceMappingURL=candidate-ancestors-schema.js.map

package/out/candidate-ancestors-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"candidate-ancestors-schema.js","sourceRoot":"","sources":["../lib/candidate-ancestors-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH,OAAO,EAAE,GAAG,EAAe,MAAM,QAAQ,CAAA;AAQzC;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAA;AAEnC;;;GAGG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,oBAAoB,CAAA;AAE5D;;GAEG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,oBAAoB,CAAA;AAqD5D;;;GAGG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG;IACzC,QAAQ;IACR,OAAO;IACP,eAAe;IACf,qBAAqB;IACrB,aAAa;IACb,iBAAiB;CACR,CAAA;AAEV;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,4BAA4B,CAAC,EAA6B;IAC/E,MAAM,EAAE,CAAC,MAAM;SACb,WAAW,CAAC,wBAAwB,CAAC;SACrC,SAAS,CAAC,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;SAClD,SAAS,CAAC,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;SACjD,SAAS,CAAC,eAAe,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;SACzD,SAAS,CAAC,qBAAqB,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;SAC/D,SAAS,CAAC,aAAa,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;SACpD,SAAS,CAAC,iBAAiB,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;SACxD,uBAAuB,CAAC,uBAAuB,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QACtE,0FAA0F;SACzF,SAAS,CAAC,GAAG,CAAA,eAAe,CAAC;SAC7B,OAAO,EAAE,CAAA;AACZ,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,4BAA4B,CAAC,EAA6B;IAC/E,MAAM,EAAE,CAAC,MAAM;SACb,WAAW,CAAC,wBAAwB,CAAC;SACrC,SAAS,CAAC,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC;SACrD,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;SAC/C,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;SAChD,SAAS,CAAC,GAAG,CAAA,eAAe,CAAC;SAC7B,OAAO,EAAE,CAAA;AACZ,CAAC;AAUD;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAoB,EAAE,KAAoB;IAC1E,OAAO,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,IAAI,IAAI,KAAK,CAAC,IAAI,CAAA;AAC1D,CAAC"}

package/out/candidate-fts.d.ts

@@ -9,8 +9,10 @@
  *   raw `name`), so a diacritic-stripped query (`munchen`) trigram-matches the stored `munchen`
  *   rather than missing a raw `München`. The trigram tokenizer makes MATCH a substring/fuzzy
  *   operation; the reader ({@link WOFCandidateTableLookup}) OR's the query's trigrams to fetch a
- *   loose set, then re-ranks by the SAME `trigramJaccard` the admin/FTS backend uses, so a typo
- *   resolves identically on either.
+ *   loose set, then re-ranks it with a WORD-level similarity. The trigram index is the candidate
+ *   GENERATOR, not the scorer — trigram Jaccard scores a true transposition correction BELOW a wrong
+ *   answer, because shared generic suffixes count as evidence and transpositions count against it.
+ *   The receipts are on `candidate-lookup.ts`'s `FUZZY_FETCH` and `WORD_FUZZY_MIN`.
  *
  *   This is what unifies the two gazetteers: the candidate B-tree stays the common,
  *   byte-range-optimal fast path (the browser's contiguous probe), and FTS5 is consulted ONLY on an
@@ -22,14 +24,14 @@
  *   (a name_key fans out to many candidate rows — placetypes, regions, aliases — but the fuzzy
  *   fallback only needs to recover the name_key, then re-probes the B-tree for its rows).
  */
-import type { DatabaseSync } from "node:sqlite";
+import type { DatabaseClient } from "@mailwoman/sqlite/client";
 /**
- * Name of the FTS5 trigram virtual table this module owns. The reader gates its fuzzy fallback on it.
+ * Name of the FTS5 trigram virtual table this module owns. The reader conditions its fuzzy fallback on it.
  */
 export declare const CANDIDATE_FTS_TABLE = "candidate_fts";
 /**
  * Build (or rebuild) {@link CANDIDATE_FTS_TABLE} from the materialized `candidate` table. Call after the candidate
  * B-tree is populated (build pipeline) or against an existing candidate DB (migration).
  */
-export declare function createCandidateFTS(db: DatabaseSync): void;
+export declare function createCandidateFTS<DB>(db: DatabaseClient<DB>): void;
 //# sourceMappingURL=candidate-fts.d.ts.map

package/out/candidate-fts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"candidate-fts.d.ts","sourceRoot":"","sources":["../candidate-fts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C;;GAEG;AACH,eAAO,MAAM,mBAAmB,kBAAkB,CAAA;AAElD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,YAAY,GAAG,IAAI,CAOzD"}
+{"version":3,"file":"candidate-fts.d.ts","sourceRoot":"","sources":["../lib/candidate-fts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AAE9D;;GAEG;AACH,eAAO,MAAM,mBAAmB,kBAAkB,CAAA;AAElD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,EAAE,EAAE,cAAc,CAAC,EAAE,CAAC,GAAG,IAAI,CAOnE"}

package/out/candidate-fts.js

@@ -9,8 +9,10 @@
  *   raw `name`), so a diacritic-stripped query (`munchen`) trigram-matches the stored `munchen`
  *   rather than missing a raw `München`. The trigram tokenizer makes MATCH a substring/fuzzy
  *   operation; the reader ({@link WOFCandidateTableLookup}) OR's the query's trigrams to fetch a
- *   loose set, then re-ranks by the SAME `trigramJaccard` the admin/FTS backend uses, so a typo
- *   resolves identically on either.
+ *   loose set, then re-ranks it with a WORD-level similarity. The trigram index is the candidate
+ *   GENERATOR, not the scorer — trigram Jaccard scores a true transposition correction BELOW a wrong
+ *   answer, because shared generic suffixes count as evidence and transpositions count against it.
+ *   The receipts are on `candidate-lookup.ts`'s `FUZZY_FETCH` and `WORD_FUZZY_MIN`.
  *
  *   This is what unifies the two gazetteers: the candidate B-tree stays the common,
  *   byte-range-optimal fast path (the browser's contiguous probe), and FTS5 is consulted ONLY on an
@@ -23,7 +25,7 @@
  *   fallback only needs to recover the name_key, then re-probes the B-tree for its rows).
  */
 /**
- * Name of the FTS5 trigram virtual table this module owns. The reader gates its fuzzy fallback on it.
+ * Name of the FTS5 trigram virtual table this module owns. The reader conditions its fuzzy fallback on it.
  */
 export const CANDIDATE_FTS_TABLE = "candidate_fts";
 /**

package/out/candidate-fts.js.map

@@ -1 +1 @@
-{"version":3,"file":"candidate-fts.js","sourceRoot":"","sources":["../candidate-fts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH;;GAEG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,eAAe,CAAA;AAElD;;;GAGG;AACH,MAAM,UAAU,kBAAkB,CAAC,EAAgB;IAClD,EAAE,CAAC,IAAI,CAAC,wBAAwB,mBAAmB,EAAE,CAAC,CAAA;IACtD,EAAE,CAAC,IAAI,CAAC,wBAAwB,mBAAmB,2CAA2C,CAAC,CAAA;IAE/F,EAAE,CAAC,IAAI,CACN,eAAe,mBAAmB,+EAA+E,CACjH,CAAA;AACF,CAAC"}
+{"version":3,"file":"candidate-fts.js","sourceRoot":"","sources":["../lib/candidate-fts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAIH;;GAEG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,eAAe,CAAA;AAElD;;;GAGG;AACH,MAAM,UAAU,kBAAkB,CAAK,EAAsB;IAC5D,EAAE,CAAC,IAAI,CAAC,wBAAwB,mBAAmB,EAAE,CAAC,CAAA;IACtD,EAAE,CAAC,IAAI,CAAC,wBAAwB,mBAAmB,2CAA2C,CAAC,CAAA;IAE/F,EAAE,CAAC,IAAI,CACN,eAAe,mBAAmB,+EAA+E,CACjH,CAAA;AACF,CAAC"}