@mailwoman/resolver-wof-sqlite 8.1.0 → 8.3.0

package/street-morphology-fst-builder.ts

@@ -40,7 +40,9 @@ const STREET_AFFIX_WOFID_BASE = 1_900_000_000
 const STREET_TYPES_FILENAME = "street_types.txt"
 
 export interface BuildStreetMorphologyFSTOpts {
-	/** Path to the `core/data/libpostal/dictionaries` directory containing per-locale subfolders. */
+	/**
+	 * Path to the `core/data/libpostal/dictionaries` directory containing per-locale subfolders.
+	 */
 	dictionariesDir: string
 	/**
 	 * Optional locale filter — only ingest these locale subfolders. Defaults to all that have a `street_types.txt`.
@@ -56,7 +58,9 @@ export interface BuildStreetMorphologyFSTOpts {
 	 * `rue`, `str`) while filtering out the noise.
 	 */
 	minVariantLength?: number
-	/** Optional progress callback. */
+	/**
+	 * Optional progress callback.
+	 */
 	onProgress?: (phase: string, detail?: string) => void
 }
 
@@ -78,13 +82,14 @@ export interface BuildStreetMorphologyFSTResult {
 function parseLine(line: string): { canonical: string; variants: string[] } | null {
 	const trimmed = line.trim()
 
-	if (trimmed.length === 0 || trimmed.startsWith("#")) return null
+	if (!trimmed.length || trimmed.startsWith("#")) return null
+
 	const parts = trimmed
 		.split("|")
 		.map((s) => s.trim())
 		.filter((s) => s.length > 0)
 
-	if (parts.length === 0) return null
+	if (!parts.length) return null
 
 	return { canonical: parts[0]!, variants: parts }
 }
@@ -96,7 +101,8 @@ export function buildStreetMorphologyFST(opts: BuildStreetMorphologyFSTOpts): Bu
 	// Discover locales — either provided explicitly, or all directories containing street_types.txt.
 	let locales: string[]
 
-	if (opts.locales && opts.locales.length > 0) {
+	// oxlint-disable-next-line unicorn/prefer-ternary -- the else branch is a multi-line directory scan
+	if (opts.locales && opts.locales.length) {
 		locales = opts.locales
 	} else {
 		locales = readdirSync(opts.dictionariesDir).filter((entry) => {
@@ -113,6 +119,7 @@ export function buildStreetMorphologyFST(opts: BuildStreetMorphologyFSTOpts): Bu
 			}
 		})
 	}
+
 	progress("discover", `Found ${locales.length} locales with ${STREET_TYPES_FILENAME}`)
 
 	// Collect canonical → set-of-variants across all locales. Same canonical form may appear in
@@ -132,13 +139,15 @@ export function buildStreetMorphologyFST(opts: BuildStreetMorphologyFSTOpts): Bu
 			for (const variant of parsed.variants) {
 				existing.add(variant)
 			}
+
 			canonicalToVariants.set(parsed.canonical, existing)
 		}
 	}
+
 	progress("collect", `Collected ${canonicalToVariants.size} canonical affixes`)
 
 	// Assign stable synthetic wofIDs. Sort canonicals for determinism.
-	const sortedCanonicals = [...canonicalToVariants.keys()].sort()
+	const sortedCanonicals = [...canonicalToVariants.keys()].toSorted()
 	const canonicalToWOFID = new Map<string, number>()
 
 	for (let i = 0; i < sortedCanonicals.length; i++) {
@@ -150,7 +159,7 @@ export function buildStreetMorphologyFST(opts: BuildStreetMorphologyFSTOpts): Bu
 	const nodes: FSTNode[] = [{ edges: new Map(), places: [] }]
 
 	function insertName(tokens: string[], entry: PlaceEntry): void {
-		if (tokens.length === 0) return
+		if (!tokens.length) return
 		let stateID = 0
 
 		for (const t of tokens) {
@@ -162,8 +171,10 @@ export function buildStreetMorphologyFST(opts: BuildStreetMorphologyFSTOpts): Bu
 				nodes.push({ edges: new Map(), places: [] })
 				node.edges.set(t, next)
 			}
+
 			stateID = next
 		}
+
 		const existing = nodes[stateID]!.places
 
 		if (!existing.some((p) => p.wofID === entry.wofID && p.placetype === entry.placetype)) {
@@ -177,6 +188,7 @@ export function buildStreetMorphologyFST(opts: BuildStreetMorphologyFSTOpts): Bu
 	for (const canonical of sortedCanonicals) {
 		const variants = canonicalToVariants.get(canonical)!
 		const wofID = canonicalToWOFID.get(canonical)!
+
 		const entry: PlaceEntry = {
 			wofID,
 			placetype: "street_affix",
@@ -185,7 +197,7 @@ export function buildStreetMorphologyFST(opts: BuildStreetMorphologyFSTOpts): Bu
 			// Fixed importance: street affixes are structurally unambiguous (Avenue is almost never
 			// anything but street-typing). The morphology prior caps bias separately; this value
 			// just feeds the cap formula `importance * cap`.
-			importance: 1.0,
+			importance: 1,
 			lat: 0,
 			lon: 0,
 		}
@@ -193,21 +205,25 @@ export function buildStreetMorphologyFST(opts: BuildStreetMorphologyFSTOpts): Bu
 		for (const variant of variants) {
 			const tokens = normalizeTokens(variant)
 
-			if (tokens.length === 0) continue
+			if (!tokens.length) continue
 			// Filter out collision-prone short surface forms — see `minVariantLength` docstring.
 			// We measure against the joined token form (no spaces) since FST keys are token sequences.
 			const joined = tokens.join("")
 
 			if (joined.length < minVariantLength) continue
 			insertName(tokens, entry)
+
 			insertCount++
+
 			variantCount++
 		}
 	}
+
 	progress("trie", `Built trie: ${nodes.length} states, ${insertCount} variant insertions`)
 
 	const edgeCount = nodes.reduce((sum, n) => sum + n.edges.size, 0)
 	const matcher = FSTMatcher.fromNodes(nodes)
+
 	const provenance: FSTProvenance = {
 		builtAt: new Date().toISOString(),
 		countries: locales, // Reuse `countries` slot for locale provenance — semantics differ from admin FST.

package/street-morphology-fst-loader.ts

@@ -30,10 +30,14 @@ import { deserializeFST, readFSTProvenance } from "./fst-serialize.ts"
 import type { FSTProvenance } from "./fst-types.ts"
 import { buildStreetMorphologyFST } from "./street-morphology-fst-builder.ts"
 
-/** The sealed artifact's canonical filename — identical in the data-root staging dir and as a weights-package sibling. */
+/**
+ * The sealed artifact's canonical filename — identical in the data-root staging dir and as a weights-package sibling.
+ */
 export const STREET_MORPHOLOGY_ARTIFACT_FILENAME = "fst-street-morphology.bin"
 
-/** The staged artifact's default location: `$MAILWOMAN_DATA_ROOT/wof/fst-street-morphology.bin`. */
+/**
+ * The staged artifact's default location: `$MAILWOMAN_DATA_ROOT/wof/fst-street-morphology.bin`.
+ */
 export function defaultStreetMorphologyArtifactPath(): string {
 	return String(dataRootPath("wof", STREET_MORPHOLOGY_ARTIFACT_FILENAME))
 }
@@ -44,23 +48,35 @@ export interface LoadStreetMorphologyFSTOpts {
 	 * unreadable degrades straight to the dictionary build, never a throw.
 	 */
 	artifactPath?: string
-	/** Dictionaries dir for the build fallback. Defaults to core's bundled libpostal dictionaries. */
+	/**
+	 * Dictionaries dir for the build fallback. Defaults to core's bundled libpostal dictionaries.
+	 */
 	dictionariesDir?: string
-	/** Unreadable-artifact diagnostics. Defaults to silent (the caller owns its warn channel). */
+	/**
+	 * Unreadable-artifact diagnostics. Defaults to silent (the caller owns its warn channel).
+	 */
 	onWarn?: (message: string) => void
 }
 
 export interface LoadedStreetMorphologyFST {
 	matcher: FSTMatcher
-	/** Which rung produced the matcher: a sealed-artifact deserialize, or the per-process dictionary build. */
+	/**
+	 * Which rung produced the matcher: a sealed-artifact deserialize, or the per-process dictionary build.
+	 */
 	source: "artifact" | "built"
-	/** The artifact path when `source === "artifact"`. */
+	/**
+	 * The artifact path when `source === "artifact"`.
+	 */
 	path?: string
-	/** Build provenance — read from the artifact trailer, or carried fresh off the fallback build. */
+	/**
+	 * Build provenance — read from the artifact trailer, or carried fresh off the fallback build.
+	 */
 	provenance?: FSTProvenance
 }
 
-/** Load the street-morphology matcher: sealed artifact first, per-process dictionary build as the degrade path. */
+/**
+ * Load the street-morphology matcher: sealed artifact first, per-process dictionary build as the degrade path.
+ */
 export function loadStreetMorphologyFST(opts: LoadStreetMorphologyFSTOpts = {}): LoadedStreetMorphologyFST {
 	const warn = opts.onWarn ?? (() => {})
 	const artifactPath = opts.artifactPath ?? defaultStreetMorphologyArtifactPath()
@@ -72,9 +88,9 @@ export function loadStreetMorphologyFST(opts: LoadStreetMorphologyFSTOpts = {}):
 			const provenance = readFSTProvenance(buf)
 
 			return { matcher, source: "artifact", path: artifactPath, ...(provenance ? { provenance } : {}) }
-		} catch (err) {
+		} catch (error) {
 			warn(
-				`street-morphology artifact at ${artifactPath} unreadable (${(err as Error).message}) — falling back to the dictionary build`
+				`street-morphology artifact at ${artifactPath} unreadable (${(error as Error).message}) — falling back to the dictionary build`
 			)
 		}
 	}

package/street-name-lookup.ts

@@ -39,9 +39,13 @@ function hasColumn(db: DatabaseSync, table: string, column: string): boolean {
 }
 
 export interface SQLiteStreetNameLookupOpts {
-	/** ISO-2 (upper-case) countries this index answers for. Default `["FR"]` (the BAN street-centroids instance). */
+	/**
+	 * ISO-2 (upper-case) countries this index answers for. Default `["FR"]` (the BAN street-centroids instance).
+	 */
 	countries?: Iterable<string>
-	/** Table name. Default `street_centroid`. */
+	/**
+	 * Table name. Default `street_centroid`.
+	 */
 	table?: string
 }
 
@@ -68,9 +72,11 @@ export class SQLiteStreetNameLookup implements StreetLocalityEvidence {
 			// `name_key` MUST match `foldStreetSurface` here (the fold-parity contract).
 			const keyCol = hasColumn(this.#db, table, "name_key") ? "name_key" : "street_norm"
 			this.#byName = this.#db.prepare(`SELECT 1 FROM ${table} WHERE ${keyCol} = ? LIMIT 1`)
+
 			this.#byNameLocality = this.#db.prepare(
 				`SELECT 1 FROM ${table} WHERE ${keyCol} = ? AND locality_base = ? LIMIT 1`
 			)
+
 			this.#byNamePostcode = this.#db.prepare(`SELECT 1 FROM ${table} WHERE ${keyCol} = ? AND postcode = ? LIMIT 1`)
 		}
 	}
@@ -83,18 +89,24 @@ export class SQLiteStreetNameLookup implements StreetLocalityEvidence {
 
 		// Scoped lookups tighten precision when the hypothesis carries a locality/postcode; a scoped MISS falls back to the
 		// unscoped probe (index incompleteness in the scope column is not evidence of absence — positive-evidence rule).
-		if (scope?.locality && this.#byNameLocality) {
-			if (this.#byNameLocality.get(norm, foldStreetSurface(scope.locality)) !== undefined) return true
+		if (
+			scope?.locality &&
+			this.#byNameLocality &&
+			this.#byNameLocality.get(norm, foldStreetSurface(scope.locality)) !== undefined
+		) {
+			return true
 		}
 
-		if (scope?.postcode && this.#byNamePostcode) {
-			if (this.#byNamePostcode.get(norm, scope.postcode) !== undefined) return true
+		if (scope?.postcode && this.#byNamePostcode && this.#byNamePostcode.get(norm, scope.postcode) !== undefined) {
+			return true
 		}
 
 		return this.#byName.get(norm) !== undefined
 	}
 
-	/** Close the underlying handle. */
+	/**
+	 * Close the underlying handle.
+	 */
 	close(): void {
 		this.#db.close()
 	}

package/street-normalize.ts

@@ -24,6 +24,12 @@
 
 import { AbbreviationToDirectional, US_STREET_SUFFIX_LOOKUP } from "@mailwoman/codex/us"
 
+/**
+ * Token count a street must exceed before its trailing pair is merged. At or below it the pair IS the whole street
+ * name, and merging would leave nothing to match on.
+ */
+const MIN_TOKENS_FOR_TAIL_MERGE = 3
+
 /**
  * Spelled ordinal street names → their digit-ordinal form ("tenth" → "10th"), applied ONLY when a street-type suffix
  * follows (#723 admin-tail) — so the ordinal cross-streets common in grid cities ("Tenth Street", "Fifth Avenue") match
@@ -63,14 +69,16 @@ const SPELLED_ORDINAL_TO_DIGIT = new Map<string, string>([
 	["hundredth", "100th"],
 ])
 
-/** Lowercase + diacritic-fold + punctuation strip + whitespace collapse. */
+/**
+ * Lowercase + diacritic-fold + punctuation strip + whitespace collapse.
+ */
 function fold(input: string): string {
 	return input
 		.normalize("NFKD")
-		.replace(/[̀-ͯ]/g, "")
+		.replaceAll(/[̀-ͯ]/g, "")
 		.toLowerCase()
-		.replace(/[.,'’]/g, "")
-		.replace(/\s+/g, " ")
+		.replaceAll(/[.,'’]/g, "")
+		.replaceAll(/\s+/g, " ")
 		.trim()
 }
 
@@ -81,7 +89,7 @@ function fold(input: string): string {
 export function normalizeStreetForKey(street: string): string {
 	const tokens = fold(street).split(" ")
 
-	if (tokens.length === 0) return ""
+	if (!tokens.length) return ""
 
 	// Spelled-ordinal street names → digit form when a street suffix follows ("Tenth Street" →
 	// "10th street", #723). Gated on the next token being a suffix so ordinal-WORD names are untouched.
@@ -99,6 +107,7 @@ export function normalizeStreetForKey(street: string): string {
 	// ("southeast"), and also merge an already-written two-token pair ("South East …").
 	const edgeDirectional = (raw: string) =>
 		AbbreviationToDirectional.get(raw.toUpperCase())?.toLowerCase().replace(" ", "")
+
 	const mergePair = (a?: string, b?: string) =>
 		a && b && /^(north|south)$/.test(a) && /^(east|west)$/.test(b) ? a + b : undefined
 
@@ -107,20 +116,21 @@ export function normalizeStreetForKey(street: string): string {
 	if (leadPair && tokens.length > 2) {
 		tokens.splice(0, 2, leadPair)
 	}
+
 	const first = edgeDirectional(tokens[0]!)
 
 	if (first && tokens.length > 1) {
 		tokens[0] = first
 	}
 
-	const tailPair = mergePair(tokens[tokens.length - 2], tokens[tokens.length - 1])
+	const tailPair = mergePair(tokens.at(-2), tokens.at(-1))
 
-	if (tailPair && tokens.length > 3) {
-		tokens.splice(tokens.length - 2, 2, tailPair)
+	if (tailPair && tokens.length > MIN_TOKENS_FOR_TAIL_MERGE) {
+		tokens.splice(-2, 2, tailPair)
 	}
 
 	if (tokens.length > 2) {
-		const last = edgeDirectional(tokens[tokens.length - 1]!)
+		const last = edgeDirectional(tokens.at(-1)!)
 
 		if (last) {
 			tokens[tokens.length - 1] = last
@@ -136,6 +146,7 @@ export function normalizeStreetForKey(street: string): string {
 
 		if (canonical) {
 			tokens[at] = canonical.toLowerCase()
+
 			break
 		}
 	}
@@ -196,9 +207,9 @@ export function normalizeStreetForKeyLocale(street: string, locale: StreetLocale
 	// hyphen ("Champs-Élysées", "St-Honoré") or a space — both sides fold identically, so this is pure
 	// robustness. It also splits a hyphenated abbreviation ("St-Honoré" → "st honore") into tokens the
 	// per-locale type/Saint map can see.
-	const tokens = fold(street).replace(/ß/g, "ss").replace(/-/g, " ").split(/\s+/).filter(Boolean)
+	const tokens = fold(street).replaceAll("ß", "ss").replaceAll("-", " ").split(/\s+/).filter(Boolean)
 
-	if (tokens.length === 0) return ""
+	if (!tokens.length) return ""
 
 	switch (locale) {
 		case "fr":
@@ -229,7 +240,9 @@ export function normalizeStreetForKeyLocale(street: string, locale: StreetLocale
 	return tokens.join(" ")
 }
 
-/** Normalize a locality name for address-point keying (fold only — no street semantics). */
+/**
+ * Normalize a locality name for address-point keying (fold only — no street semantics).
+ */
 export function normalizeLocalityForKey(locality: string): string {
 	return fold(locality)
 }
@@ -268,7 +281,9 @@ export function stripLocalityQualifier(locality: string): string {
 
 	if (s.includes("/")) {
 		s = s.split("/")[0]!.trim()
-	} // "Kraubath/Mur", "St.Kanzian/Klopeiner See"
+	}
+
+	// "Kraubath/Mur", "St.Kanzian/Klopeiner See"
 	s = s.replace(/\s+[a-zà-ÿ]\.\s*\S.*$/iu, "") // abbreviated " b.Graz" / " o.Bleiburg" / " a.d. …"
 	s = s.replace(/\s+(im|an der|ob|bei|in der|unter|vor)\s+\S.*$/iu, "") // " im Simmental", " bei Graz"
 	s = s.replace(/\s+(S|N|E|W|V|Ø|Sø|Fyn|Thy|Sjælland|Jylland|[A-ZÅÄÖ]{2})$/u, "") // " S", " VD", " Thy"

package/street-segment-schema.ts

@@ -23,28 +23,48 @@ import type { Kysely } from "kysely"
  * `odd`/`even`/`mixed`.
  */
 export interface StreetSegmentTable {
-	/** Shared {@link normalizeStreetForKey} of the street — the build/query-consistent probe key. */
+	/**
+	 * Shared {@link normalizeStreetForKey} of the street — the build/query-consistent probe key.
+	 */
 	street_norm: string
-	/** `L` or `R` — the TIGER side the address range sits on. */
+	/**
+	 * `L` or `R` — the TIGER side the address range sits on.
+	 */
 	side: string
 	from_hn: number
 	to_hn: number
-	/** Sorted lower bound of `(from_hn, to_hn)` — the probe filters `min_hn <= n <= max_hn`. */
+	/**
+	 * Sorted lower bound of `(from_hn, to_hn)` — the probe filters `min_hn <= n <= max_hn`.
+	 */
 	min_hn: number
-	/** Sorted upper bound of `(from_hn, to_hn)`. */
+	/**
+	 * Sorted upper bound of `(from_hn, to_hn)`.
+	 */
 	max_hn: number
-	/** `odd` | `even` | `mixed` — the house-number parity along the range. */
+	/**
+	 * `odd` | `even` | `mixed` — the house-number parity along the range.
+	 */
 	parity: string
 	postcode: string | null
-	/** 5-digit state+county FIPS the edge came from. */
+	/**
+	 * 5-digit state+county FIPS the edge came from.
+	 */
 	county_fips: string
-	/** The street as it appeared in TIGER (kept for display / debugging). */
+	/**
+	 * The street as it appeared in TIGER (kept for display / debugging).
+	 */
 	street_raw: string
-	/** GeoJSON LineString text (no SpatiaLite — read back with `JSON.parse`). */
+	/**
+	 * GeoJSON LineString text (no SpatiaLite — read back with `JSON.parse`).
+	 */
 	geometry: string
-	/** Provenance: the dataset this edge came from (e.g. `tiger:edges`). */
+	/**
+	 * Provenance: the dataset this edge came from (e.g. `tiger:edges`).
+	 */
 	source: string
-	/** The pinned TIGER release the edge was ingested from. */
+	/**
+	 * The pinned TIGER release the edge was ingested from.
+	 */
 	release: string
 }
 
@@ -56,15 +76,23 @@ export interface StreetSegmentTable {
  * and callers fall back to the in-code per-region table (never patch shipped DBs — rebuild).
  */
 export interface InterpCalibrationRow {
-	/** Conformal multiplier for the raw half-segment `uncertainty_m` radius (#374/#584) — ×Q̂ for a ~90% bound. */
+	/**
+	 * Conformal multiplier for the raw half-segment `uncertainty_m` radius (#374/#584) — ×Q̂ for a ~90% bound.
+	 */
 	radius_multiplier: number
-	/** Provenance of the multiplier (e.g. `split-conformal:2026-06-14`). */
+	/**
+	 * Provenance of the multiplier (e.g. `split-conformal:2026-06-14`).
+	 */
 	method: string
-	/** The calibration-table key the multiplier was selected by (a USPS region code, or `default` for unmeasured). */
+	/**
+	 * The calibration-table key the multiplier was selected by (a USPS region code, or `default` for unmeasured).
+	 */
 	region: string
 }
 
-/** The street-segment database schema for `new DatabaseClient<StreetSegmentDatabase>(...)`. */
+/**
+ * The street-segment database schema for `new DatabaseClient<StreetSegmentDatabase>(...)`.
+ */
 export interface StreetSegmentDatabase {
 	street_segment: StreetSegmentTable
 	interp_calibration: InterpCalibrationRow
@@ -90,7 +118,9 @@ export const STREET_SEGMENT_COLUMNS = [
 	"release",
 ] as const
 
-/** Create the `street_segment` table — called before the streaming bulk load. */
+/**
+ * Create the `street_segment` table — called before the streaming bulk load.
+ */
 export async function createStreetSegmentTable(db: Kysely<StreetSegmentDatabase>): Promise<void> {
 	await db.schema
 		.createTable("street_segment")
@@ -126,15 +156,19 @@ export async function writeInterpCalibration(
 		.addColumn("method", "text", (c) => c.notNull())
 		.addColumn("region", "text", (c) => c.notNull())
 		.execute()
+
 	await db.insertInto("interp_calibration").values(row).execute()
 }
 
-/** Create the two probe indexes the reader relies on (postcode-scope, street-scope). */
+/**
+ * Create the two probe indexes the reader relies on (postcode-scope, street-scope).
+ */
 export async function createStreetSegmentIndexes(db: Kysely<StreetSegmentDatabase>): Promise<void> {
 	await db.schema
 		.createIndex("idx_seg_postcode")
 		.on("street_segment")
 		.columns(["postcode", "street_norm", "min_hn"])
 		.execute()
+
 	await db.schema.createIndex("idx_seg_street").on("street_segment").columns(["street_norm", "min_hn"]).execute()
 }

package/types.ts

@@ -49,7 +49,9 @@ export interface PlaceCandidate {
 	id: number
 	name: string
 	placetype: WOFPlacetype
-	/** ISO 3166-1 alpha-2 country code. */
+	/**
+	 * ISO 3166-1 alpha-2 country code.
+	 */
 	country: string
 	lat: number
 	lon: number
@@ -125,9 +127,13 @@ export interface GeoBbox {
 export interface FindPlaceQuery {
 	text: string
 	placetype?: WOFPlacetype | WOFPlacetype[]
-	/** ISO 3166-1 alpha-2 — narrows to one country. */
+	/**
+	 * ISO 3166-1 alpha-2 — narrows to one country.
+	 */
 	country?: string
-	/** WOF place id — narrows to descendants of this place. */
+	/**
+	 * WOF place id — narrows to descendants of this place.
+	 */
 	parentID?: number
 	/**
 	 * Sibling postcode. When set on a `locality` query AND a `postcode_locality` table is present, triggers the
@@ -136,7 +142,9 @@ export interface FindPlaceQuery {
 	 * postcode_locality shard is present.
 	 */
 	postcode?: string
-	/** Proximity hint — candidates close to this point get a ranking boost. */
+	/**
+	 * Proximity hint — candidates close to this point get a ranking boost.
+	 */
 	near?: GeoPoint & { maxDistanceKm?: number }
 	/**
 	 * Ordered proximity-bias points (viewport center, user location, …), each optionally weighted (default 1.0, first
@@ -147,9 +155,13 @@ export interface FindPlaceQuery {
 	 * back-compat.
 	 */
 	bias?: Array<GeoPoint & { weight?: number }>
-	/** Bounding-box filter — only candidates whose bbox intersects this box are returned. */
+	/**
+	 * Bounding-box filter — only candidates whose bbox intersects this box are returned.
+	 */
 	bbox?: GeoBbox
-	/** Default 10. */
+	/**
+	 * Default 10.
+	 */
 	limit?: number
 }
 

package/unified-schema.ts

@@ -12,7 +12,7 @@
  *   `place_search` FTS5 + `place_bbox` R*Tree are built separately by `build-fts` (fts.ts).
  */
 
-import { DatabaseSync } from "node:sqlite"
+import type { DatabaseSync } from "node:sqlite"
 
 import { DatabaseClient } from "@mailwoman/core/kysley/client"
 
@@ -109,11 +109,13 @@ export async function createUnifiedSchema(db: DatabaseSync): Promise<void> {
  */
 export function populateAncestors(db: DatabaseSync): number {
 	db.exec("DELETE FROM ancestors")
+
 	const rows = db.prepare("SELECT id, parent_id, placetype FROM spr").all() as Array<{
 		id: number
 		parent_id: number
 		placetype: string
 	}>
+
 	const byID = new Map<number, { parent: number; placetype: string }>()
 
 	for (const r of rows) {
@@ -125,7 +127,9 @@ export function populateAncestors(db: DatabaseSync): number {
 	let count = 0
 
 	for (const r of rows) {
-		insert.run(r.id, r.id, r.placetype) // self
+		insert.run(r.id, r.id, r.placetype)
+
+		// self
 		count++
 		const seen = new Set<number>([r.id])
 		let cur = r.parent_id
@@ -135,11 +139,13 @@ export function populateAncestors(db: DatabaseSync): number {
 
 			if (!node) break
 			insert.run(r.id, cur, node.placetype)
+
 			count++
 			seen.add(cur)
 			cur = node.parent
 		}
 	}
+
 	db.exec("COMMIT")
 
 	return count
@@ -152,18 +158,21 @@ export async function createUnifiedIndexes(db: DatabaseSync): Promise<void> {
 	await kdb.schema.createIndex("spr_by_parent").ifNotExists().on("spr").column("parent_id").execute()
 	await kdb.schema.createIndex("names_by_id").ifNotExists().on("names").column("id").execute()
 	await kdb.schema.createIndex("names_by_name").ifNotExists().on("names").column("name").execute()
+
 	await kdb.schema
 		.createIndex("concordances_by_id")
 		.ifNotExists()
 		.on("concordances")
 		.columns(["id", "lastmodified"])
 		.execute()
+
 	await kdb.schema
 		.createIndex("concordances_by_other_id")
 		.ifNotExists()
 		.on("concordances")
 		.columns(["other_source", "other_id"])
 		.execute()
+
 	// ancestor_id is the hot column (parent-constraint queries `WHERE ancestor_id = ?`); id supports
 	// the reverse lookup.
 	await kdb.schema.createIndex("ancestors_by_ancestor").ifNotExists().on("ancestors").column("ancestor_id").execute()