@mailwoman/resolver-wof-sqlite 10.7.0 → 11.0.0

package/lib/landmark/rows.ts

@@ -0,0 +1,91 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   The landmark table's read, shared by the native lookup and the range-read lookup a Worker uses. It holds no database
+ *   client, so a Worker bundle can import it.
+ */
+
+import type { LandmarkHit, LandmarkKind } from "@mailwoman/core/resolver"
+
+import { normalizeLocalityForKey } from "#street/normalize"
+
+/**
+ * One way of writing one place.
+ */
+export interface LandmarkNameTable {
+	name_key: string
+	qid: string
+	/**
+	 * The place's own display name.
+	 */
+	name: string
+	kind: LandmarkKind
+	country: string | null
+	latitude: number
+	longitude: number
+	sitelinks: number
+	/**
+	 * The upper-case spelling of a code alias such as `DTW`, or `null` for an ordinary name.
+	 *
+	 * A code answers only when written in that case, so `Lax` and `Sea` stay words.
+	 */
+	code: string | null
+	/**
+	 * 1 when this is the place's own name in English or its country's language, 0 for a translation or alias.
+	 */
+	is_primary: number
+	/**
+	 * The importance Photon's index holds for an OpenStreetMap place, or `null` for a Wikidata place.
+	 */
+	importance: number | null
+	/**
+	 * The place's short H3 cell, the spatial key an OpenStreetMap layer's manifest names,
+	 * or `null` for a Wikidata place.
+	 */
+	h3_cell: number | null
+}
+
+/**
+ * The read of every row under one name key, best first.
+ */
+export const LANDMARK_BY_NAME_SQL =
+	"SELECT * FROM landmark_name WHERE name_key = ? ORDER BY is_primary DESC, sitelinks DESC, importance DESC, qid"
+
+/**
+ * Returns the key a written name is stored and read under.
+ *
+ * Canonical Unicode form, a typographic apostrophe and a sentence's closing period do not change
+ * which place a name means, so `St George’s.` and `St George's` read one row.
+ */
+export function landmarkNameKey(written: string): string {
+	return normalizeLocalityForKey(written.normalize("NFC").replaceAll("’", "'").trim().replace(/\.+$/u, ""))
+}
+
+/**
+ * Turns the rows under a name's key into hits for that name as it was written.
+ *
+ * A code written in its own case is an identifier, so it ranks ahead of every word spelled the same.
+ * A code row reads only in that case.
+ */
+export function landmarkHitsFromRows(rows: readonly LandmarkNameTable[], name: string): LandmarkHit[] {
+	const written = name.trim()
+	const isCode = (row: LandmarkNameTable) => row.code === written
+
+	return rows
+		.filter((row) => !row.code || isCode(row))
+		.toSorted((a, b) => Number(isCode(b)) - Number(isCode(a)))
+		.map((row) => ({
+			code: isCode(row),
+			qid: row.qid,
+			name: row.name,
+			kind: row.kind,
+			country: row.country,
+			lat: row.latitude,
+			lon: row.longitude,
+			sitelinks: row.sitelinks,
+			primary: row.is_primary === 1,
+			importance: row.importance ?? null,
+		}))
+}

package/lib/landmark.ts

@@ -0,0 +1,94 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   The landmark layer: Wikidata places keyed by every name and alias they are written with, ranked by the number of
+ *   Wikipedia language editions that describe them. The source is CC0, so the database may ship.
+ */
+
+import type { LandmarkHit, LandmarkLookup } from "@mailwoman/core/resolver"
+import { DatabaseClient } from "@mailwoman/sqlite/client"
+import { sql, type Kysely } from "kysely"
+import type { PathBuilderLike } from "path-ts"
+
+import { LANDMARK_BY_NAME_SQL, landmarkHitsFromRows, landmarkNameKey, type LandmarkNameTable } from "#landmark/rows"
+import { prepareAll, type PreparedAll } from "#sqlite-utils"
+
+export interface LandmarkDatabase {
+	landmark_name: LandmarkNameTable
+}
+
+/**
+ * The column order the build's positional insert writes.
+ */
+export const LANDMARK_NAME_COLUMNS = [
+	"name_key",
+	"qid",
+	"name",
+	"kind",
+	"country",
+	"latitude",
+	"longitude",
+	"sitelinks",
+	"code",
+	"is_primary",
+	"importance",
+	"h3_cell",
+] as const satisfies ReadonlyArray<keyof LandmarkNameTable>
+
+/**
+ * Creates the table.
+ *
+ * Rows cluster by name, because every read is a probe of one name.
+ */
+export async function createLandmarkTables(db: Kysely<LandmarkDatabase>): Promise<void> {
+	await db.schema
+		.createTable("landmark_name")
+		.addColumn("name_key", "text", (c) => c.notNull())
+		.addColumn("qid", "text", (c) => c.notNull())
+		.addColumn("name", "text", (c) => c.notNull())
+		.addColumn("kind", "text", (c) => c.notNull())
+		.addColumn("country", "text")
+		.addColumn("latitude", "real", (c) => c.notNull())
+		.addColumn("longitude", "real", (c) => c.notNull())
+		.addColumn("sitelinks", "integer", (c) => c.notNull())
+		.addColumn("code", "text")
+		.addColumn("is_primary", "integer", (c) => c.notNull())
+		.addColumn("importance", "real")
+		.addColumn("h3_cell", "integer")
+		.addPrimaryKeyConstraint("landmark_name_pk", ["name_key", "qid"])
+		.modifyEnd(sql`without rowid`)
+		.execute()
+}
+
+/**
+ * Returns whether an alias is an identifier code rather than a word:
+ * two to five upper-case letters or digits.
+ */
+export function isLandmarkCode(alias: string): boolean {
+	return /^[\p{Lu}\d]{2,5}$/u.test(alias)
+}
+
+/**
+ * Reads a sealed landmark database.
+ */
+export class LandmarkSqliteLookup implements LandmarkLookup, Disposable {
+	readonly #db: DatabaseClient<LandmarkDatabase>
+
+	readonly #byName: PreparedAll<[nameKey: string], LandmarkNameTable>
+
+	constructor(path: PathBuilderLike) {
+		this.#db = new DatabaseClient<LandmarkDatabase>(path, { readOnly: true })
+
+		this.#byName = prepareAll(this.#db, LANDMARK_BY_NAME_SQL)
+	}
+
+	find(name: string): LandmarkHit[] {
+		return landmarkHitsFromRows(this.#byName(landmarkNameKey(name)), name)
+	}
+
+	[Symbol.dispose](): void {
+		this.#db[Symbol.dispose]()
+	}
+}

package/lib/lookup.ts

@@ -7,16 +7,15 @@
  */
 
 import { expandPlacetypeFilter } from "@mailwoman/codex/placetype-map"
-import type { Ancestor, CoincidentLocality } from "@mailwoman/core/resolver"
+import type { Ancestor } from "@mailwoman/core/resolver"
 import { allRows } from "@mailwoman/core/utils"
-import { haversineKm } from "@mailwoman/spatial"
+import { haversine } from "@mailwoman/spatial/geometries/point/distance"
 import type { DatabaseClient, SQLInputValue } from "@mailwoman/sqlite/client"
 import { SQLiteLookup } from "@mailwoman/sqlite/lookup"
 import type { PathBuilderLike } from "path-ts"
 
 import { ancestorLineage } from "#ancestry"
 import { candidateFromSearchRow, rankCandidates } from "#candidate/scoring"
-import { loadCoincidentLocalities } from "#coincident-roles"
 import {
 	ADDRESS_CONVENTION_TABLE,
 	resolveConvention,
@@ -81,7 +80,7 @@ export interface WOFSQLitePlaceLookupOpts {
 	 *
 	 * Absent, every alias code path is skipped and the resolver is byte-identical.
 	 */
-	postalCityAliases?: WOFPostalCityAliasLookup
+	postalCityAliases?: WOFPostalCityAliasLookup | null
 }
 
 /**
@@ -155,10 +154,6 @@ export class WOFSQLitePlaceLookup extends SQLiteLookup<WOFDatabase> implements P
 	 * Strategy names already warned about, so an unknown name surfaces once.
 	 */
 	readonly #warnedUnknownStrategies = new Set<string>()
-	/**
-	 * Lazily-built `admin_id → coincident localities` map, null until first use.
-	 */
-	#coincidentRolesCache: Map<number, CoincidentLocality[]> | null = null
 	/**
 	 * Per-id memoized ancestor lineages, queried once per chain.
 	 */
@@ -168,7 +163,7 @@ export class WOFSQLitePlaceLookup extends SQLiteLookup<WOFDatabase> implements P
 	 */
 	readonly #postalCityAliases: WOFPostalCityAliasLookup | null
 
-	constructor(opts: WOFSQLitePlaceLookupOpts, weights?: Partial<RankingWeights>) {
+	constructor(opts: WOFSQLitePlaceLookupOpts, weights?: Partial<RankingWeights> | null) {
 		if (opts.database && opts.databasePath) {
 			throw new Error("WOFSQLitePlaceLookup: pass either `database` or `databasePath`, not both")
 		}
@@ -355,21 +350,6 @@ export class WOFSQLitePlaceLookup extends SQLiteLookup<WOFDatabase> implements P
 		return found
 	}
 
-	/**
-	 * Dual-role localities coincident with an admin id, or `[]` when the relation table is absent.
-	 */
-	coincidentLocalitiesFor(adminID: number | string): CoincidentLocality[] {
-		const id = typeof adminID === "number" ? adminID : Number(adminID)
-
-		if (!Number.isFinite(id)) return []
-
-		if (!this.#coincidentRolesCache) {
-			this.#coincidentRolesCache = loadCoincidentLocalities(this.database)
-		}
-
-		return this.#coincidentRolesCache.get(id) ?? []
-	}
-
 	/**
 	 * The ancestor lineage of a place, ordered nearest-first with self excluded,
 	 * or `[]` when it has no recorded ancestry.
@@ -549,7 +529,7 @@ export class WOFSQLitePlaceLookup extends SQLiteLookup<WOFDatabase> implements P
 	#countryWOFId(code: string): number | null {
 		const cached = this.#countryWOFIdCache.get(code)
 
-		if (cached !== undefined) return cached
+		if (cached) return cached
 		let id: number | null
 
 		try {
@@ -666,12 +646,12 @@ export class WOFSQLitePlaceLookup extends SQLiteLookup<WOFDatabase> implements P
 				// oxlint-disable-next-line unicorn/no-array-sort -- sorts a freshly-built array. toSorted would double-allocate on a hot path
 				.sort((a, b) => b.containing - a.containing || a.dist - b.dist)[0]
 
-			const anchor = anchorRow ? merged.get(anchorRow.id) : undefined
+			const anchor = anchorRow ? merged.get(anchorRow.id) : null
 
 			if (
 				anchor &&
 				(top.id as number) !== anchorRow!.id &&
-				haversineKm(top.lat, top.lon, anchor.lat, anchor.lon) > CF_MISMATCH_KM
+				haversine(top.lat, top.lon, anchor.lat, anchor.lon) > CF_MISMATCH_KM
 			) {
 				top.mismatch = true
 			}

package/lib/nsul/lookup.ts

@@ -25,9 +25,10 @@
  */
 
 import type { UkCountryCode } from "@mailwoman/codex/gb/country"
+import { compactPostcode } from "@mailwoman/postcode/display-form"
 import { SQLiteLookup, type SQLiteLookupOptions } from "@mailwoman/sqlite/lookup"
 
-import { compactPostcode, type NSULDatabase } from "#nsul/schema"
+import type { NSULDatabase } from "#nsul/schema"
 import { prepareAll, prepareGet } from "#sqlite-utils"
 
 /**

package/lib/nsul/schema.ts

@@ -70,13 +70,6 @@ export interface NSULDatabase extends layerschemadatabase {
 	nsul_meta: NSULMetaTable
 }
 
-/**
- * The compact form of a unit postcode, every space removed and upper-cased.
- */
-export function compactPostcode(pcds: string): string {
-	return pcds.replaceAll(/\s+/g, "").toUpperCase()
-}
-
 export async function createUPRNPostcodeTable(db: Kysely<NSULDatabase>): Promise<void> {
 	await db.schema
 		.createTable("uprn_postcode")
@@ -102,7 +95,8 @@ export async function createNSULMetaTable(db: Kysely<NSULDatabase>): Promise<voi
 /**
  * The `pcds_compact` index the `uprnsForPostcode` probe reads.
  *
- * There is no index on the spaced `pcds` because it is derivable through {@link compactPostcode}.
+ * There is no index on the spaced `pcds` because `compactPostcode` from
+ * `@mailwoman/postcode/display-form` derives the compact column from it.
  */
 export async function createNSULIndexes(db: Kysely<NSULDatabase>): Promise<void> {
 	await db.schema.createIndex("uprn_postcode_pcds_compact").on("uprn_postcode").column("pcds_compact").execute()

package/lib/place-importance-schema.ts

@@ -262,7 +262,7 @@ export function loadImportanceSplit<DB>(db: DatabaseClient<DB>): ImportanceSplit
 		for (const row of rows) {
 			const split = splitLegacyImportance(row.importance, population.get(row.id))
 
-			if (split.encyclopedic === undefined) {
+			if (!split.encyclopedic) {
 				legacyFallbackRows++
 			} else {
 				encyclopedic.set(row.id, split.encyclopedic)

package/lib/poi/lookup.ts

@@ -7,16 +7,16 @@
  *   `without rowid` B-tree `poi-schema.ts` builds. Category, brand and name searches share one
  *   artifact. Each path has a method that returns its details.
  *
- *   `latLngToCell` and `gridDisk` come from `h3-js`. The 48-bit short-cell packing that turns a raw
+ *   `latLngToCell` and `gridDisk` come from `@sister.software/h3`. The 48-bit short-cell packing that turns a raw
  *   H3 cell into the integer `poi.h3_cell` stores is `@mailwoman/spatial`'s `shortCellToInt`, and
  *   that math is never reimplemented here.
  */
 
 import { allRows } from "@mailwoman/core/utils"
-import { haversineKm, shortCellToInt, type H3Cell } from "@mailwoman/spatial"
+import { haversine, shortCellToInt } from "@mailwoman/spatial"
 import type { DatabaseClient } from "@mailwoman/sqlite/client"
 import { SQLiteLookup, type SQLiteLookupOptions } from "@mailwoman/sqlite/lookup"
-import { gridDisk, latLngToCell } from "h3-js"
+import { gridDisk, latLngToCell } from "@sister.software/h3"
 
 import type { POICategoryCodeTable, POIDatabase, POITable } from "#poi/schema"
 /**
@@ -79,7 +79,7 @@ export interface POISearchQuery {
 	 *
 	 * Required for category/brand queries (k-ring expansion).
 	 */
-	center?: { latitude: number; longitude: number }
+	center?: { latitude: number; longitude: number } | null
 	/**
 	 * Ring budget: the count of res-9 k-rings to expand before giving up.
 	 *
@@ -88,7 +88,7 @@ export interface POISearchQuery {
 	 * @defaultValue `16` ≈ ~5.4 km
 	 */
 	maxRings?: number
-	limit?: number
+	limit?: number | null
 }
 
 export interface POISearchHit {
@@ -183,7 +183,7 @@ export class POILookup<DB extends POIDatabase = POIDatabase> extends SQLiteLooku
 		const limit = Math.max(1, query.limit ?? DEFAULT_LIMIT)
 
 		if (query.name) {
-			return this.#searchByName(query.name, limit, query.center)
+			return this.#searchByName(query.name, limit, query.center ?? undefined)
 		}
 
 		if (query.categoryIDs?.length || query.brandWikidata) {
@@ -216,7 +216,7 @@ export class POILookup<DB extends POIDatabase = POIDatabase> extends SQLiteLooku
 
 		return sortByDistance(rows, center)
 			.filter(
-				(row) => haversineKm(center.latitude, center.longitude, row.latitude, row.longitude) <= BRAND_MAX_DISTANCE_KM
+				(row) => haversine(center.latitude, center.longitude, row.latitude, row.longitude) <= BRAND_MAX_DISTANCE_KM
 			)
 			.slice(0, limit)
 			.map((row) => toHit(row, this.#idToCategory, center))
@@ -235,7 +235,7 @@ export class POILookup<DB extends POIDatabase = POIDatabase> extends SQLiteLooku
 		for (const id of query.categoryIDs ?? []) {
 			const resolved = this.#categoryToID.get(id)
 
-			if (resolved !== undefined) {
+			if (resolved) {
 				categoryIDs.push(resolved)
 			}
 		}
@@ -244,7 +244,7 @@ export class POILookup<DB extends POIDatabase = POIDatabase> extends SQLiteLooku
 		// This is a clean miss instead of a throw.
 		if (!categoryIDs.length) return []
 
-		const origin = latLngToCell(center.latitude, center.longitude, POI_H3_RESOLUTION) as H3Cell
+		const origin = latLngToCell(center.latitude, center.longitude, POI_H3_RESOLUTION)
 		const seenCells = new Set<string>()
 		let rows: POIRow[] = []
 
@@ -252,12 +252,12 @@ export class POILookup<DB extends POIDatabase = POIDatabase> extends SQLiteLooku
 		for (let ring = 0; ring < maxRings; ring++) {
 			// gridDisk(origin, ring) returns the whole disk out to `ring`, so diffing against
 			// the already-probed set derives only this ring's new cells.
-			const diskCells = gridDisk(origin, ring) as string[]
+			const diskCells = gridDisk(origin, ring)
 			const newCells = diskCells.filter((cell) => !seenCells.has(cell))
 
 			for (const cell of newCells) {
 				seenCells.add(cell)
-				const shortCell = shortCellToInt(cell as H3Cell)
+				const shortCell = shortCellToInt(cell)
 
 				for (const categoryID of categoryIDs) {
 					rows.push(...allRows<POIRow>(this.#categoryCellProbe, shortCell, categoryID, limit))
@@ -344,8 +344,8 @@ export class POILookup<DB extends POIDatabase = POIDatabase> extends SQLiteLooku
 function sortByDistance(rows: POIRow[], center: { latitude: number; longitude: number }): POIRow[] {
 	return [...rows].toSorted(
 		(a, b) =>
-			haversineKm(center.latitude, center.longitude, a.latitude, a.longitude) -
-			haversineKm(center.latitude, center.longitude, b.latitude, b.longitude)
+			haversine(center.latitude, center.longitude, a.latitude, a.longitude) -
+			haversine(center.latitude, center.longitude, b.latitude, b.longitude)
 	)
 }
 
@@ -363,7 +363,7 @@ function toHit(
 		country: row.country,
 		confidence: row.confidence,
 		gersID: row.gers_id,
-		distanceM: center ? haversineKm(center.latitude, center.longitude, row.latitude, row.longitude) * 1000 : null,
+		distanceM: center ? haversine(center.latitude, center.longitude, row.latitude, row.longitude) * 1000 : null,
 	}
 }
 

package/lib/primary-preference.ts

@@ -11,14 +11,15 @@ import type { CandidateTable } from "#candidate/schema"
  *
  * `is_primary` is optional, so an older artifact without the column skips the re-rank without an error.
  */
-export type PrimaryPreferenceRow = Pick<CandidateTable, "neg_rank" | "country_id"> &
+export type PrimaryPreferenceRow = Pick<CandidateTable, "neg_rank"> &
 	Partial<Pick<CandidateTable, "is_primary" | "placetype_id" | "population" | "name_role">>
 
 /**
- * The log10-population penalty applied to an alias row when the top primary-name
- * row for the same key is in another country.
+ * The log10-population penalty applied to an alias row when another row holds
+ * the same key as its primary name.
  *
- * An alias at least 10 times as populous still wins, so alternate names such as "LA" keep working.
+ * An alias at least 10 times as populous still wins, so alternate names such as "LA"
+ * and misspellings of a large city such as "Dehli" keep working.
  */
 export const PRIMARY_PREFERENCE_LOG10 = 1
 
@@ -37,7 +38,7 @@ export const RERANK_FETCH = 64
  */
 export type RankedRow<R> = R & {
 	/**
-	 * `neg_rank` plus any cross-country alias penalty.
+	 * `neg_rank` plus any alias penalty.
 	 *
 	 * Rows are ordered by this value.
 	 * The emitted `prominence` derives from it.
@@ -47,12 +48,11 @@ export type RankedRow<R> = R & {
 	effectiveNegRank: number
 
 	/**
-	 * True when this row is a cross-country alias that the penalty moved behind
-	 * the top primary for the same key.
+	 * True when this row is an alias that the penalty moved behind the top primary for the same key.
 	 *
 	 * A demoted row loses `exactMatch`, so the resolver's country pin cannot promote
-	 * a coincidental foreign exonym back over the primary.
-	 * A dominant alias and a same-country alias are never demoted.
+	 * a coincidental exonym back over the primary.
+	 * A dominant alias is never demoted.
 	 */
 	demoted: boolean
 
@@ -82,7 +82,7 @@ export type RankedRow<R> = R & {
 /**
  * Re-ranks population-ordered candidate rows.
  *
- * A cross-country alias must beat the top primary by `delta` in log10 population.
+ * An alias must beat the top primary by `delta` in log10 population, in any country.
  * The function returns the top `limit` rows.
  *
  * When `placetypes` is given, an exact tie prefers a populated `locality`.
@@ -103,20 +103,13 @@ export function rankByPrimaryPreference<R extends PrimaryPreferenceRow>(
 		}
 	}
 
-	const topCountry = topPrimary?.country_id
-
-	const wouldPenalize = (r: R): boolean =>
-		typeof topCountry === "number" && r.is_primary !== 1 && r.country_id !== topCountry
-
-	const isCrossCountryAlias = (r: R): boolean =>
-		wouldPenalize(r) && !(exemptVariantAliases && r.name_role === "variant")
+	const isAliasOfPrimary = (r: R): boolean => topPrimary != null && r.is_primary !== 1
 
 	const annotate = (r: R): RankedRow<R> => {
-		const penalized = isCrossCountryAlias(r)
+		const exempted = exemptVariantAliases && r.name_role === "variant" && isAliasOfPrimary(r)
+		const penalized = isAliasOfPrimary(r) && !exempted
 		const effectiveNegRank = r.neg_rank + (penalized ? delta : 0)
 
-		const exempted = !penalized && exemptVariantAliases && r.name_role === "variant" && wouldPenalize(r)
-
 		return {
 			...r,
 			effectiveNegRank,

package/lib/proximity-rerank.ts

@@ -23,7 +23,7 @@
  *      ordering silently discarded downstream.
  */
 
-import { haversineKm } from "@mailwoman/spatial"
+import { haversine } from "@mailwoman/spatial/geometries/point/distance"
 
 /**
  * Full magnitude of the nearness term at distance 0, before decay.
@@ -92,7 +92,7 @@ export function combinedProminence(candidate: ProximityRerankable, bias: readonl
 	// A 0,0 pair interpreted as a real coordinate would receive an enormous score.
 	if (!(candidate.lat === 0 && candidate.lon === 0)) {
 		for (const b of bias) {
-			const d = haversineKm(b.lat, b.lon, candidate.lat, candidate.lon)
+			const d = haversine(b.lat, b.lon, candidate.lat, candidate.lon)
 			const term = (BIAS_BOOST * (b.weight ?? 1)) / (1 + d / PROX_SCALE_KM)
 
 			if (term > proxTerm) {

package/lib/reverse.ts

@@ -24,7 +24,10 @@
 
 import { tryParsingJSON } from "@mailwoman/core/json"
 import { allRows } from "@mailwoman/core/utils"
-import { bboxAround, geometryContains, haversineKm, type ParsedGeometry } from "@mailwoman/spatial"
+import type { ParsedGeometry } from "@mailwoman/spatial"
+import { bboxAround } from "@mailwoman/spatial/bbox"
+import { haversine } from "@mailwoman/spatial/geometries/point/distance"
+import { geometryContains } from "@mailwoman/spatial/geometries/polygon"
 import { DatabaseClient } from "@mailwoman/sqlite/client"
 import { tableExists } from "@mailwoman/sqlite/introspection"
 import type { PathBuilderLike } from "path-ts"
@@ -311,7 +314,7 @@ export class WOFReverseGeocoder implements Disposable {
 			let bestKm = Infinity
 
 			for (const c of pointOnly) {
-				const km = haversineKm(lat, lon, c.lat, c.lon)
+				const km = haversine(lat, lon, c.lat, c.lon)
 
 				if (km < bestKm) {
 					bestKm = km
@@ -325,7 +328,7 @@ export class WOFReverseGeocoder implements Disposable {
 		// Approximate descent into finer tiers than the winner.
 		let current = winner
 		let currentConfirmed = winnerConfirmed
-		let currentDistanceKm = currentConfirmed ? null : haversineKm(lat, lon, current.lat, current.lon)
+		let currentDistanceKm = currentConfirmed ? null : haversine(lat, lon, current.lat, current.lon)
 
 		for (const tier of DESCENT_TIERS) {
 			if (placetypeDepth(tier) <= placetypeDepth(current.placetype)) continue
@@ -349,7 +352,7 @@ export class WOFReverseGeocoder implements Disposable {
 				}
 
 				if (contains === false) continue // known not-here, polygon rejected
-				const km = haversineKm(lat, lon, k.lat, k.lon)
+				const km = haversine(lat, lon, k.lat, k.lon)
 
 				if (km <= maxApproximateKm && km < bestKm) {
 					bestKm = km
@@ -494,7 +497,7 @@ export class WOFReverseGeocoder implements Disposable {
 		if (!this.#polygons) return null
 		const cached = this.#geometryCache.get(id)
 
-		if (cached !== undefined) return cached
+		if (cached) return cached
 
 		if (this.#geometryCache.size >= WOFReverseGeocoder.#GEOMETRY_CACHE_CAP) {
 			this.#geometryCache.clear()

package/lib/schema.ts

@@ -170,23 +170,6 @@ export interface ConcordancesTable {
 	lastmodified: number
 }
 
-/**
- * `coincident_roles`.
- *
- * The dual-role relation, where a place is both an admin region and a locality (Berlin the city-state).
- *
- * One row per (admin, locality) pair the resolver can complete a hierarchy with.
- * Surfaced by {@link MailwomanLookupLike.coincidentRolesFor}.
- */
-export interface CoincidentRolesTable {
-	admin_id: number
-	locality_id: number
-	relationship_type: string
-	admin_placetype: string
-	distance_km: number
-	locality_population: number
-}
-
 /**
  * The full schema we hand to `Kysely<WOFDatabase>` / `new DatabaseClient<WOFDatabase>(...)`.
  *
@@ -205,5 +188,4 @@ export interface WOFDatabase {
 	place_population: PlacePopulationTable
 	place_abbr: PlaceAbbrTable
 	concordances: ConcordancesTable
-	coincident_roles: CoincidentRolesTable
 }

package/lib/search-fetch.ts

@@ -13,7 +13,7 @@
  */
 
 import { allRows } from "@mailwoman/core/utils"
-import { bboxAround } from "@mailwoman/spatial"
+import { bboxAround } from "@mailwoman/spatial/bbox"
 import type { DatabaseClient, SQLInputValue } from "@mailwoman/sqlite/client"
 
 import { PLACE_BBOX_TABLE, PLACE_POPULATION_TABLE } from "#fts"
@@ -142,7 +142,7 @@ export function fetchSearchRows<DB>(options: {
 		params.push(query.country)
 	}
 
-	if (query.parentID !== undefined) {
+	if (query.parentID) {
 		where.push(`(spr.parent_id = ? OR spr.id IN (SELECT id FROM ${sch}.ancestors WHERE ancestor_id = ?))`)
 		params.push(query.parentID, query.parentID)
 	}
@@ -152,7 +152,7 @@ export function fetchSearchRows<DB>(options: {
 	// A requested filter on a legacy extract is silently treated as no bbox filter
 	// so the query does not crash.
 	const extractHasBbox = hasBboxIndex.get(sch) === true
-	const useBboxJoin = (query.bbox || query.near?.maxDistanceKm !== undefined) && extractHasBbox
+	const useBboxJoin = (query.bbox || query.near?.maxDistanceKm) && extractHasBbox
 	let joinClause = `JOIN ${sch}.spr ON spr.id = place_search.wof_id`
 
 	if (useBboxJoin) {

package/lib/sqlite/convention-source.ts

@@ -35,7 +35,7 @@ export class SqliteConventionSource<DB> implements ConventionSource {
 	get(wofID: number): Convention | null {
 		const cached = this.#cache.get(wofID)
 
-		if (cached !== undefined) return cached
+		if (cached) return cached
 		let value: Convention | null = null
 
 		try {

package/lib/street/centroid.ts

@@ -6,7 +6,7 @@
  */
 
 import type { StreetCentroidHit, StreetCentroidLookup } from "@mailwoman/core/resolver"
-import { haversineKm } from "@mailwoman/spatial"
+import { haversine } from "@mailwoman/spatial/geometries/point/distance"
 import { DatabaseClient } from "@mailwoman/sqlite/client"
 import type { PathBuilderLike } from "path-ts"
 
@@ -51,7 +51,7 @@ const AGG_SELECT =
  * Half the bounding-box diagonal in meters, used as a coarse uncertainty radius for a street centroid.
  */
 function extentRadiusM(minLat: number, maxLat: number, minLon: number, maxLon: number): number {
-	return Math.round(haversineKm(minLat, minLon, maxLat, maxLon) * 500)
+	return Math.round(haversine(minLat, minLon, maxLat, maxLon) * 500)
 }
 
 /**