@mailwoman/resolver-wof-sqlite 9.0.0 → 9.2.0

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 load-bearing 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":["../../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 shard 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 shard 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":["../../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 shard 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":["../../candidate/place-attrs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG"}

package/out/candidate/shard-fold.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ * @file Pass 4 of the candidate build — fold a postcode or locality shard into the staging table.
+ */
+import { DatabaseSync } from "node:sqlite";
+import type { StageRow } from "./place-attrs.ts";
+/**
+ * Fold ONE shard (`spr` rows at `shardPlacetype` carrying real coordinates) in, then pass 4b: the alias names hanging
+ * off that same shard's `names` table.
+ *
+ * Self-contained by construction — it shares only the staging statement and the code dictionaries with the admin passes
+ * above it, and nothing downstream reads anything it produces except the two counters it returns.
+ */
+export declare function foldShard(ctx: {
+    /**
+     * The staging connection. The shard itself is opened read-only here and closed before returning.
+     */
+    out: DatabaseSync;
+    shardPath: string;
+    shardPlacetype: "postalcode" | "locality";
+    ccID: (code: string | null) => number;
+    ptID: (pt: string | null) => number;
+    stageRow: StageRow;
+    progress: (phase: string, message: string) => void;
+}): {
+    primaries: number;
+    aliases: number;
+};
+//# sourceMappingURL=shard-fold.d.ts.map

package/out/candidate/shard-fold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shard-fold.d.ts","sourceRoot":"","sources":["../../candidate/shard-fold.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAG1C,OAAO,KAAK,EAAc,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAE5D;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE;IAC9B;;OAEG;IACH,GAAG,EAAE,YAAY,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,cAAc,EAAE,YAAY,GAAG,UAAU,CAAA;IACzC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,KAAK,MAAM,CAAA;IACrC,IAAI,EAAE,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,KAAK,MAAM,CAAA;IACnC,QAAQ,EAAE,QAAQ,CAAA;IAClB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAClD,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CA0GzC"}

package/out/candidate/shard-fold.js

@@ -0,0 +1,104 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ * @file Pass 4 of the candidate build — fold a postcode or locality shard into the staging table.
+ */
+import { DatabaseSync } from "node:sqlite";
+import { normalizeLocalityForKey } from "../street-normalize.js";
+/**
+ * Fold ONE shard (`spr` rows at `shardPlacetype` carrying real coordinates) in, then pass 4b: the alias names hanging
+ * off that same shard's `names` table.
+ *
+ * Self-contained by construction — it shares only the staging statement and the code dictionaries with the admin passes
+ * above it, and nothing downstream reads anything it produces except the two counters it returns.
+ */
+export function foldShard(ctx) {
+    const { out, shardPath, shardPlacetype, ccID, ptID, stageRow, progress } = ctx;
+    progress(shardPlacetype === "postalcode" ? "postcodes" : "localities", `reading ${shardPath}`);
+    const pc = new DatabaseSync(shardPath, { readOnly: true });
+    const pcPtid = ptID(shardPlacetype);
+    // Per-shard, not the admin `attrs` map: pass 1 only ever sees the admin DB, so the alias pass
+    // below has nothing to join against unless this primary loop records what it staged.
+    const pcAttrs = new Map();
+    let primaries = 0;
+    let aliases = 0;
+    out.exec("BEGIN");
+    for (const r of pc
+        .prepare(`SELECT id, name, country, latitude, longitude,
+				min_latitude AS mnlat, min_longitude AS mnlon, max_latitude AS mxlat, max_longitude AS mxlon
+			 FROM spr WHERE placetype = ? AND latitude != 0 AND longitude != 0`)
+        .iterate(shardPlacetype)) {
+        const name = String(r.name ?? "");
+        const key = normalizeLocalityForKey(name);
+        if (!key)
+            continue;
+        const lat = r.latitude;
+        const lon = r.longitude;
+        // region_id 0 (a postcode is unique by name+country — no same-name disambiguation); neg_rank 0
+        // (no population). bbox = the postcode's own min/max (falls back to the centroid point).
+        const a = {
+            cid: ccID(r.country),
+            rid: 0,
+            ptid: pcPtid,
+            name,
+            lat,
+            lon,
+            mnLat: r.mnlat || lat,
+            mnLon: r.mnlon || lon,
+            mxLat: r.mxlat || lat,
+            mxLon: r.mxlon || lon,
+            pop: 0,
+            neg: 0,
+            pkey: key,
+            // A postcode has no toponym fame — nobody writes an encyclopedia article about SW1A 2AA — and
+            // the score source carries no `postalcode` rows to join against anyway. NULL is the truthful
+            // value: unmeasured, so the ranking key leaves postcode rows exactly where they were.
+            imp: null,
+        };
+        pcAttrs.set(Number(r.id), a);
+        stageRow(key, a, Number(r.id), 1);
+        primaries++;
+    }
+    out.exec("COMMIT");
+    // --- pass 4b: postcode ALIAS names (#1495) ---
+    //
+    // The delivery-city names GeoNames supplies for a ZIP ("Brooklyn" for 11201) are written into
+    // the shard's `names` table by `postcode/centroid-fills.ts`'s `geonamesNameFill`. Everything
+    // downstream of `names` picked them up EXCEPT this build: `fts.ts` unions `spr.name` with every
+    // `names` row into `place_search.alt_names`, so the FTS backend resolved "Brooklyn" → 11201
+    // while the candidate backend — whose every row IS an exact-tier row — had no key for it at
+    // all. Pass 2 does the equivalent fold for admin places, but reads the ADMIN `place_search`,
+    // and `attrs` holds admin ids only, so a postcode shard could never reach it.
+    //
+    // Same discipline as pass 2: `is_primary = 0` (so `rankByPrimaryPreference` treats it as an
+    // alias, not a canonical postcode name), the row stays denormalized onto the POSTCODE's own
+    // spr_id/coords/bbox, and the display `name` stays the postcode — resolving "brooklyn" answers
+    // with place 11201, it does not rename the place to its delivery city.
+    const hasNames = pc.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='names'").get() !== undefined;
+    if (hasNames) {
+        out.exec("BEGIN");
+        for (const r of pc.prepare("SELECT id, name FROM names").iterate()) {
+            const a = pcAttrs.get(Number(r.id));
+            if (!a)
+                continue;
+            const k = normalizeLocalityForKey(String(r.name ?? ""));
+            // The postcode's own key is already staged as the primary; `INSERT OR IGNORE` at
+            // materialization dedupes repeats, so this only skips the obvious self-alias.
+            if (!k || k === a.pkey)
+                continue;
+            stageRow(k, a, Number(r.id), 0);
+            aliases++;
+        }
+        out.exec("COMMIT");
+    }
+    else {
+        // Never a silent zero: real shards come from `createUnifiedSchema`, which always creates
+        // `names`. A shard without it has no alias surface to lose, but say so rather than reporting
+        // "0 aliases" from a table that was never read.
+        progress("postcode-aliases", `${shardPath} has no \`names\` table — no delivery-city aliases to fold`);
+    }
+    pc.close();
+    return { primaries, aliases };
+}
+//# sourceMappingURL=shard-fold.js.map

package/out/candidate/shard-fold.js.map

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

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 (shard-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.ts";
+import type { NameKey } from "./street-normalize.ts";
+/**
+ * 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-gated 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":["../candidate-ancestors-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH,OAAO,EAAO,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAA;AAKzC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAC9D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AAEpD;;;;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 (shard-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-gated 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":["../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"}