@mailwoman/corpus 9.2.0 → 9.4.0

package/src/adapters/utils/index.ts

@@ -1,233 +0,0 @@
-/**
- * @copyright Sister Software
- * @license AGPL-3.0
- * @author Teffen Ellis, et al.
- *
- *   Adapter framework helpers — the pieces every corpus adapter and the runner share.
- *
- *   This file does **not** define `CorpusAdapter` (that lives in `./types.ts`, which is the single
- *   canonical schema module). It exposes:
- *
- *   - `AdapterRegistry`: a tiny lookup table the CLI + build pipeline use to find adapters by id.
- *   - `InMemoryAdapterRegistry`: the default implementation.
- *   - `stableSourceID(adapterID, components)`: deterministic content-addressed id for adapters whose
- *       source data has no native primary key (CSV, GeoJSON).
- *   - `HOUSE_NUMBER_PREFIX` + `splitStreetLine(line)`: the one house-number/street split every
- *       US CSV adapter uses.
- *   - `canonicalDedupKey(row)`: normalized signature used to drop near-identical rows during a run.
- *       Adapter-internal dedup; cross-adapter dedup is the runner's job.
- *   - `streamingSha256()`: thin wrapper around `node:crypto` so the runner can hash JSONL output as it
- *       streams (avoids re-reading the shard for the manifest checksum).
- *
- *   Everything here is pure (no I/O); side-effecting code goes in `./runner.ts`.
- */
-
-import { createHash, type Hash } from "node:crypto"
-
-import type { ComponentTag } from "@mailwoman/core/types"
-import { sha256Hex } from "@mailwoman/core/utils"
-
-import type { CanonicalRow, CorpusAdapter } from "#types"
-
-/**
- * Lookup table for corpus adapters.
- *
- * The CLI's `npx mailwoman corpus run <adapter-id>` resolves `<adapter-id>` against this registry; the same registry is
- * iterated by the `corpus build` pipeline. Adapters do not self-register at module load — they're added explicitly so
- * the dependency graph stays traceable.
- */
-export interface AdapterRegistry {
-	/**
-	 * Add an adapter. Throws if `adapter.id` is already registered.
-	 */
-	register(adapter: CorpusAdapter): void
-
-	/**
-	 * Return the adapter for `id`, or `undefined`.
-	 */
-	get(id: string): CorpusAdapter | undefined
-
-	/**
-	 * All registered adapters, in insertion order.
-	 */
-	list(): readonly CorpusAdapter[]
-
-	/**
-	 * Convenience: ids only, in insertion order.
-	 */
-	ids(): readonly string[]
-}
-
-/**
- * Default in-memory registry. The runner constructs one per invocation; the CLI re-uses a shared singleton
- * (`defaultAdapterRegistry`) populated by `./adapters/index.ts` as adapters come online.
- */
-export class InMemoryAdapterRegistry implements AdapterRegistry {
-	#byID = new Map<string, CorpusAdapter>()
-
-	register(adapter: CorpusAdapter): void {
-		if (this.#byID.has(adapter.id)) {
-			throw new Error(`AdapterRegistry: id ${JSON.stringify(adapter.id)} already registered`)
-		}
-
-		this.#byID.set(adapter.id, adapter)
-	}
-
-	get(id: string): CorpusAdapter | undefined {
-		return this.#byID.get(id)
-	}
-
-	list(): readonly CorpusAdapter[] {
-		return Array.from(this.#byID.values())
-	}
-
-	ids(): readonly string[] {
-		return Array.from(this.#byID.keys())
-	}
-}
-
-/**
- * Process-wide default registry. Populated by `./adapters/index.ts` as adapters are built; imported by the CLI. Tests
- * should construct their own `InMemoryAdapterRegistry` to avoid cross-test pollution.
- */
-export const defaultAdapterRegistry = new InMemoryAdapterRegistry()
-
-/**
- * Deterministic content-addressed source id.
- *
- * For adapters whose upstream source has no native primary key (CSV rows, GeoJSON features), the runner expects a
- * stable id so dedup, holdout manifests, and resumability work across reruns. This helper produces one by hashing the
- * adapter id and a canonical serialization of the components dict (keys sorted, values verbatim).
- *
- * Output format: `<adapterID>-<first-12-hex-chars-of-sha256>`. 48 bits of entropy is enough for ~17M rows per adapter
- * before the expected collision count exceeds 1 (birthday paradox); adapters with more rows should extend the prefix
- * length.
- */
-export function stableSourceID(adapterID: string, components: Partial<Record<ComponentTag, string>>): string {
-	return stableSourceIDFromParts(adapterID, components)
-}
-
-/**
- * {@link stableSourceID} over arbitrary disambiguator keys — a variant index, a slot number, anything that is not a
- * `ComponentTag`. Every key handed in is sorted and hashed either way; only the key vocabulary differs, and the narrow
- * signature above is what stops an adapter hashing a misspelled component name.
- */
-export function stableSourceIDFromParts(
-	adapterID: string,
-	parts: Readonly<Record<string, string | undefined>>
-): string {
-	const sortedKeys = Object.keys(parts).toSorted()
-	const payload = sortedKeys.map((k) => `${k}=${parts[k] ?? ""}`).join("\u001F")
-	// One `update` over the joined string, not three chained ones — identical byte stream either way,
-	// but the separator has to stay inline or every id in every shard changes.
-	const digest = sha256Hex(`${adapterID}\u001E${payload}`)
-
-	return `${adapterID}-${digest.slice(0, 12)}`
-}
-
-/**
- * Leading house number on a US-style street line: digits, an optional hyphenated range (Queens `40-12`), an optional
- * single alpha suffix (`101A`), then whitespace, then the rest.
- *
- * This decides where the house number ends and the street begins for every US CSV adapter, so an edge case fixed here
- * is fixed for all of them.
- *
- * The remainder must stay `(\S.*)` and must NOT become `(.+)`: `\s+` and `.` both match a tab, so `\s+(.+)$` lets the
- * engine split a run of tabs between the two groups every possible way before failing — quadratic backtracking on
- * attacker-shaped input. Requiring a non-space start removes the overlap. Group 2 is trimmed by the caller either way,
- * so the two forms are indistinguishable on real input; only the failure cost differs.
- */
-export const HOUSE_NUMBER_PREFIX = /^(\d+(?:-\d+)?[A-Za-z]?)\s+(\S.*)$/
-
-/**
- * A street line split into its house number and the remainder.
- */
-export interface SplitStreetLine {
-	house_number?: string
-	street: string
-}
-
-/**
- * Split a US-style street line on {@link HOUSE_NUMBER_PREFIX}.
- *
- * The US CSV sources follow USPS Publication 28 conventions with hand-entry drift. The leading digit run is the house
- * number (`"123 Main St"`, `"6450 W Indian School Rd"`), and the regex tolerates one trailing letter (`"123A Main St"`)
- * plus an optional hyphenated half (`"40-12 Bell Blvd"`, common in NYC and suburban garden-apartment numbering; Hawaii
- * uses it island-wide — `"47-470 Hui Aeko Place"`).
- *
- * Returns `null` for blank input. Anything that does not match the prefix shape (`"PO Box 1234"`, `"RR 2 Box 67"`, `"HC
- * 1"`) becomes a single `street` value rather than being mangled — the model sees the original surface form and
- * downstream classifiers pick it up. Callers that need those forms recognized as something other than a street (see
- * `usgov-irs-bmf`) test for them BEFORE calling this.
- */
-export function splitStreetLine(line: string): SplitStreetLine | null {
-	const trimmed = line.trim()
-
-	if (!trimmed) return null
-
-	const match = HOUSE_NUMBER_PREFIX.exec(trimmed)
-
-	if (match) return { house_number: match[1], street: match[2]!.trim() }
-
-	return { street: trimmed }
-}
-
-/**
- * Canonical dedup key for a row.
- *
- * Two rows that share this key are treated as duplicates and only the first wins. The key is built from `country`, the
- * sorted `components` dict, and a normalized `raw` (lower-cased, whitespace collapsed). License and provenance fields
- * are intentionally excluded so the same address from multiple adapters is recognized as a duplicate.
- *
- * Synthetic rows are never deduplicated against natural rows: `synth.method` is folded into the key when present,
- * ensuring each augmentation variant survives.
- */
-export function canonicalDedupKey(row: CanonicalRow): string {
-	const sortedKeys = Object.keys(row.components).toSorted() as ComponentTag[]
-	const compPart = sortedKeys.map((k) => `${k}=${row.components[k] ?? ""}`).join("\u001F")
-	const rawNorm = row.raw.toLowerCase().replaceAll(/\s+/g, " ").trim()
-	const synthPart = row.synth ? `\u001E${row.synth.method}` : ""
-
-	return `${row.country}\u001E${rawNorm}\u001E${compPart}${synthPart}`
-}
-
-/**
- * Streaming SHA-256 hasher.
- *
- * The runner feeds every JSONL line into one of these so the per-shard checksum can be recorded in `MANIFEST.json`
- * without a second pass over the shard. Implementation is a one-line wrapper, but giving it a name keeps the runner's
- * hash-tracking intent obvious.
- */
-export interface StreamingHasher {
-	update(chunk: string | Uint8Array): void
-	digest(): string
-}
-
-/**
- * Default `StreamingHasher` (SHA-256, hex).
- */
-/**
- * @see {@link StreamingHasher} — this is the incremental counterpart to `sha256Hex`, not a copy of
- *   it. `@mailwoman/core/utils` exposes one-shot digests (`sha256Hex`) and whole-file digests
- *   (`sha256File`); the runner needs neither, because it hashes JSONL lines as they stream past.
- */
-export function streamingSha256(): StreamingHasher {
-	const h: Hash = createHash("sha256")
-	let finalized = false
-	let digestHex = ""
-
-	return {
-		update(chunk) {
-			if (finalized) throw new Error("streamingSha256: update() called after digest()")
-			h.update(typeof chunk === "string" ? chunk : chunk)
-		},
-		digest() {
-			if (!finalized) {
-				digestHex = h.digest("hex")
-				finalized = true
-			}
-
-			return digestHex
-		},
-	}
-}

package/src/adapters/wof-admin-jp/adapter.ts

@@ -1,216 +0,0 @@
-/**
- * @copyright Sister Software
- * @license AGPL-3.0
- * @author Teffen Ellis, et al.
- *
- *   `wof-admin-jp`: Japanese admin-hierarchy adapter.
- *
- *   PROTOTYPE — not yet wired into the Stage 3 training corpus. Demonstrates the JP address shape and
- *   synthesizes BIO-labeled training rows from the global WOF SQLite.
- *
- *   JP addresses differ from US/EU in three ways:
- *
- *   1. **Reversed ordering** — region → county → locality → block → house_number "東京都世田谷区南町1-2-3" not
- *        "1-2-3 Minamicho, Setagaya, Tokyo"
- *   2. **No street names** — most JP addresses use a block/sub-block grid system. The "neighbourhood"
- *        placetype (丁目) is the closest analog to a street but is actually a grid cell.
- *   3. **Postcode-first convention** — addresses are often prefixed with `〒NNN-NNNN`.
- *
- *   Schema mapping to ComponentTags (subset of Stage 3 + JP-specific Phase 6 tags):
- *
- *   | JP concept | WOF placetype | ComponentTag (Phase 6) |
- *   |-----------------|--------------------|-----------------------| | 都道府県 (prefecture) | region |
- *   region (or prefecture) | | 市区町村 (city/ward) | county/locality | locality (or municipality) | |
- *   丁目 (chome) | neighbourhood | block (Phase 6 tag) | | 番地 (banchi) | (synth) | sub_block | | 号
- *   (gō) | (synth) | house_number | | 〒 (postcode prefix) | — | postcode |
- *
- *   This adapter currently emits only the admin chain (region → locality → block). House numbers and
- *   sub-blocks require a different data source (JP postcode database or real-world address dumps
- *   from MLIT/JapanPost).
- */
-
-import { DatabaseSync } from "node:sqlite"
-
-import { isPresent } from "@mailwoman/core/objects"
-import { allRows, getRow } from "@mailwoman/core/utils"
-
-import type { AdapterOptions, CanonicalRow, CorpusAdapter } from "#types"
-
-/**
- * Ancestry hops walked upward from a WOF record before giving up — deeper than any real JP admin chain.
- */
-const MAX_ANCESTRY_DEPTH = 6
-
-/**
- * Registry id for this adapter. Stamped into every row it emits, so a corpus record can be traced back to the dataset
- * it came from.
- */
-export const WOF_ADMIN_JP_ADAPTER_ID = "wof-admin-jp"
-
-interface PlaceRow {
-	id: number
-	name: string
-	placetype: string
-	parent_id: number
-	country: string
-}
-
-/**
- * Walk parent chain up to 6 levels, over a place table already resident in memory.
- *
- * `resolve` is the escape hatch for a parent outside the preloaded set (a chain that leaves the country); it is a point
- * query, so keeping the common case out of it is the whole point.
- */
-function chainOf(
-	byID: Map<number, PlaceRow>,
-	resolve: (id: number) => PlaceRow | undefined,
-	startID: number
-): PlaceRow[] {
-	const out: PlaceRow[] = []
-	let id = startID
-
-	for (let i = 0; i < MAX_ANCESTRY_DEPTH && id > 0; i++) {
-		const row = byID.get(id) ?? resolve(id)
-
-		if (!row) break
-		out.push(row)
-		id = row.parent_id
-	}
-
-	return out
-}
-
-/**
- * Pick the best display name for a place: prefer Japanese variant, fall back to English.
- */
-function pickName(row: PlaceRow, jpnNames: Map<number, string>): string {
-	return jpnNames.get(row.id) ?? row.name
-}
-
-/**
- * Synthesize a JP address from a hierarchy chain.
- *
- * Format: `〒<postcode>? <region><locality><neighbourhood>?`
- *
- * No house numbers yet — needs MLIT data.
- */
-export function synthesizeJpAddress(
-	chain: PlaceRow[],
-	jpnNames: Map<number, string>
-): {
-	raw: string
-	components: CanonicalRow["components"]
-} | null {
-	const region = chain.find((r) => r.placetype === "region")
-	const locality = chain.find((r) => r.placetype === "locality" || r.placetype === "county")
-
-	if (!region || !locality) return null
-
-	const neighbourhood = chain.find((r) => r.placetype === "neighbourhood")
-
-	const regionName = pickName(region, jpnNames)
-	const localityName = pickName(locality, jpnNames)
-	const neighbourhoodName = neighbourhood ? pickName(neighbourhood, jpnNames) : null
-
-	const components: CanonicalRow["components"] = {
-		region: regionName,
-		locality: localityName,
-		country: "JP",
-	}
-
-	if (neighbourhoodName) {
-		components.dependent_locality = neighbourhoodName
-	}
-
-	const raw = [regionName, localityName, neighbourhoodName].filter(isPresent).join("")
-
-	return { raw, components }
-}
-
-/**
- * Build the JP adapter. Reads from the unified global WOF SQLite, walks admin chains starting from neighbourhoods, and
- * yields canonical rows.
- */
-export function createWOFAdminJpAdapter(): CorpusAdapter {
-	return {
-		id: WOF_ADMIN_JP_ADAPTER_ID,
-		defaultLicense: "CC-BY-4.0",
-		description: "Japanese admin hierarchy from WOF (synthesized addresses without house numbers).",
-
-		async *rows(opts: AdapterOptions): AsyncIterable<CanonicalRow> {
-			if (opts.country && opts.country !== "JP") {
-				throw new Error(`wof-admin-jp adapter: only JP supported, got country=${opts.country}`)
-			}
-
-			const db = new DatabaseSync(opts.inputPath, { readOnly: true })
-
-			try {
-				const jpnNamesStmt = db.prepare(`SELECT id, name FROM names WHERE language = 'jpn'`)
-				const jpnNames = new Map<number, string>()
-
-				for (const row of jpnNamesStmt.all() as { id: number; name: string }[]) {
-					if (!jpnNames.has(row.id)) {
-						jpnNames.set(row.id, row.name)
-					}
-				}
-
-				// One read of the JP place table instead of a fresh `prepare` + up to six point queries per
-				// seed; there are tens of thousands of neighbourhood seeds.
-				const byID = new Map<number, PlaceRow>()
-
-				for (const row of allRows<PlaceRow>(
-					db.prepare(`SELECT id, name, placetype, parent_id, country FROM spr WHERE country='JP'`)
-				)) {
-					byID.set(row.id, row)
-				}
-
-				const outsideStmt = db.prepare(`SELECT id, name, placetype, parent_id, country FROM spr WHERE id = ?`)
-
-				const resolveOutside = (id: number): PlaceRow | undefined => {
-					const row = getRow<PlaceRow>(outsideStmt, id)
-
-					if (row) {
-						byID.set(id, row)
-					}
-
-					return row
-				}
-
-				const seeds = [...byID.values()].filter((row) => row.placetype === "neighbourhood")
-
-				let emitted = 0
-
-				for (const seed of seeds) {
-					if (opts.signal?.aborted) break
-
-					if (opts.limit !== undefined && emitted >= opts.limit) break
-
-					const chain = chainOf(byID, resolveOutside, seed.id)
-					const synth = synthesizeJpAddress(chain, jpnNames)
-
-					if (!synth) continue
-
-					yield {
-						raw: synth.raw,
-						components: synth.components,
-						country: "JP",
-						locale: "ja-JP",
-						source: WOF_ADMIN_JP_ADAPTER_ID,
-						source_id: `${WOF_ADMIN_JP_ADAPTER_ID}-${seed.id}`,
-						corpus_version: "",
-						license: "CC-BY-4.0",
-					}
-
-					emitted++
-				}
-			} finally {
-				db.close()
-			}
-		},
-	}
-}
-
-/**
- * The configured adapter instance registered with the corpus builder.
- */
-export const wofAdminJpAdapter = createWOFAdminJpAdapter()

package/src/adapters/wof-admin-json/adapter.ts

@@ -1,256 +0,0 @@
-/**
- * @copyright Sister Software
- * @license AGPL-3.0
- * @author Teffen Ellis, et al.
- *
- *   `wof-admin`: Who's On First admin GeoJSON-bundle adapter.
- *
- *   **Phase 1.5.1 pivot.** The original Phase 1.5 SQLite adapter (formerly at
- *   `packages/corpus/src/adapters/wof-admin/`, removed in this same change) was replaced by this
- *   one because the SQLite distribution path was unworkable for the real corpus build:
- *
- *   1. `dist.whosonfirst.org/sqlite/` is dead (NXDOMAIN); the Geocode-Earth mirror is the only one.
- *   2. The Geocode-Earth-hosted postalcode DB tags every row `mz:is_current = -1` ("unknown but treated
- *        as active"); the SQLite adapter's `is_current = 1` predicate emitted zero rows.
- *   3. The `names` table in the SQLite distribution is empty — localized `name:*` variants live in a
- *        separate distribution. The St. Petersburg / Mt. Vernon / Ft. Lauderdale alternation cases
- *        (the original Phase 1.5.1 motivator) cannot be solved on the SQLite path even with a
- *        patched `is_current` predicate.
- *
- *   Input: a directory containing one or more cloned `whosonfirst-data-admin-<cc>` GitHub repos. Each
- *   repo has `data/XXX/YYY/ZZZ/<wof-id>.geojson` files; `**\/*.geojson` walks the tree recursively.
- *   Alternate-geometry siblings (`-alt-*`) are skipped — they're separate exports of the same
- *   record, not new records.
- *
- *   Per record, the adapter emits one row per `(name-variant, hierarchy-variant)` pair:
- *
- *   - **Name variants**: the canonical `wof:name` (slot key `default`) plus every `name:*` localized
- *       variant present on the feature (`name:eng_x_preferred`, `name:eng_x_colloquial`,
- *       `name:rus_x_preferred`, ...). This is the Phase 1.5.1 fix for the St. Petersburg case:
- *       `"Saint Petersburg"` (canonical) and `"St. Petersburg"` (eng_x_colloquial) both become
- *       training rows for the same WOF id.
- *   - **Hierarchy variants** (unchanged from the SQLite adapter): locality → 3 variants, region → 2,
- *       country → 1, county → 1.
- *
- *   `source_id` is `wof-admin-<wof_id>-<name-slot>-<hierarchy-variant>`. The previous SQLite adapter
- *   used `wof-admin-<wof_id>-<hierarchy-variant>` (no name slot); the new format adds a name-slot
- *   segment so the colloquial / preferred / per-locale variants survive dedup independently.
- *
- *   License: CC0. The adapter stamps every row with `CC0-1.0`.
- */
-
-import type { WhosOnFirstPlacetype } from "@mailwoman/core/resources/whosonfirst"
-import type { ComponentTag } from "@mailwoman/core/types"
-
-import type { AdapterOptions, CanonicalRow, CorpusAdapter } from "#types"
-import { buildAncestryIndex, normalizeNameKey, walkFeatures, type WOFRecord } from "#utils"
-
-import { emitWOFJSONRows, type WOFVariantSpec } from "../wof-json-rows.ts"
-
-/**
- * Display name for the country, keyed by ISO 3166-1 alpha-2.
- *
- * Must be the **OpenCage-canonical** surface form: the `address-formatter` library expands some country names en route
- * to its output (e.g. `"United States"` → `"United States of America"`). If `components.country` and the formatted
- * `raw` disagree, alignment will fail downstream. Keying off the canonical form keeps the two in lockstep.
- *
- * Phase 1 US + FR only; extend as new locales come online. Missing countries fall back to the country row's `wof:name`,
- * accepting the alignment risk for non-canonicalized names.
- */
-const COUNTRY_DISPLAY_NAME: Record<string, string> = {
-	US: "United States of America",
-	FR: "France",
-}
-
-/**
- * BCP-47 locale defaulting for the corpus row's `locale` field. Defaulted by country.
- */
-const LOCALE_BY_COUNTRY: Record<string, string> = {
-	US: "en-US",
-	FR: "fr-FR",
-}
-
-/**
- * Map a WOF placetype to a Mailwoman `ComponentTag`, or `undefined` to skip.
- */
-function placetypeToTag(placetype: WhosOnFirstPlacetype | string): ComponentTag | undefined {
-	switch (placetype) {
-		case "country":
-		case "nation":
-			return "country"
-		case "macroregion":
-		case "region":
-			return "region"
-		case "macrocounty":
-		case "county":
-		case "localadmin":
-			return "subregion"
-		case "locality":
-			return "locality"
-		case "borough":
-		case "macrohood":
-		case "neighbourhood":
-		case "microhood":
-			return "dependent_locality"
-		default:
-			return undefined
-	}
-}
-
-/**
- * Compute the hierarchy variants for a record given its ancestry chain and the chosen `selfName`.
- *
- * `selfName` is the surface form to use for the record's own component (locality / region / country / subregion).
- * Callers pass the canonical `wof:name` for the `"default"` slot and a `name:*` localized value for variant slots;
- * ancestor names always come from the ancestor's canonical `wof:name`.
- *
- * Country variants substitute `COUNTRY_DISPLAY_NAME` for the default slot so the OpenCage template produces the
- * canonicalized form (`"United States of America"`), matching the legacy SQLite adapter's behavior.
- */
-export function variantsFor(row: WOFRecord, ancestry: WOFRecord[], selfName: string): WOFVariantSpec[] {
-	const selfTag = placetypeToTag(row.placetype)
-
-	if (!selfTag) return []
-
-	const region = ancestry.find((a) => placetypeToTag(a.placetype) === "region")
-	const country = ancestry.find((a) => placetypeToTag(a.placetype) === "country")
-	const countryDisplay = COUNTRY_DISPLAY_NAME[row.country] ?? country?.name ?? row.country
-
-	const variants: WOFVariantSpec[] = []
-
-	switch (selfTag) {
-		case "locality":
-		case "dependent_locality": {
-			variants.push({ suffix: "self", components: { [selfTag]: selfName } })
-
-			if (region) {
-				variants.push({
-					suffix: "with-region",
-					components: { [selfTag]: selfName, region: region.name },
-				})
-			}
-
-			if (region && country) {
-				variants.push({
-					suffix: "with-region-country",
-					components: { [selfTag]: selfName, region: region.name, country: countryDisplay },
-				})
-			} else if (!region && country) {
-				variants.push({
-					suffix: "with-country",
-					components: { [selfTag]: selfName, country: countryDisplay },
-				})
-			}
-
-			return variants
-		}
-
-		case "region": {
-			variants.push({ suffix: "self", components: { region: selfName } })
-
-			if (country) {
-				variants.push({
-					suffix: "with-country",
-					components: { region: selfName, country: countryDisplay },
-				})
-			}
-
-			return variants
-		}
-
-		case "country": {
-			variants.push({ suffix: "self", components: { country: selfName } })
-
-			return variants
-		}
-
-		case "subregion": {
-			variants.push({ suffix: "self", components: { subregion: selfName } })
-
-			return variants
-		}
-
-		default:
-			return []
-	}
-}
-
-/**
- * Build the per-record name-slot list. The canonical `"default"` slot uses the OpenCage-canonical country form when the
- * record is itself a country (matches SQLite-adapter behavior); every other placetype's default slot uses `wof:name`
- * verbatim.
- *
- * Subsequent slots come from `name:*` variants, deduplicated against the default name so we don't emit a redundant
- * `"default"`-equivalent row under a localized key.
- */
-export function nameSlotsFor(rec: WOFRecord): Array<{ key: string; value: string }> {
-	const selfTag = placetypeToTag(rec.placetype)
-	const canonicalSelfName = selfTag === "country" ? (COUNTRY_DISPLAY_NAME[rec.country] ?? rec.name) : rec.name
-
-	const seen = new Set<string>([canonicalSelfName])
-	const slots: Array<{ key: string; value: string }> = [{ key: "default", value: canonicalSelfName }]
-
-	for (const [rawKey, value] of rec.nameVariants) {
-		if (seen.has(value)) continue
-		seen.add(value)
-		slots.push({ key: normalizeNameKey(rawKey), value })
-	}
-
-	return slots
-}
-
-/**
- * Registry id for this adapter. Stamped into every row it emits, so a corpus record can be traced back to the dataset
- * it came from.
- */
-export const WOF_ADMIN_ADAPTER_ID = "wof-admin"
-
-/**
- * Construct the wof-admin JSON-bundle adapter. The adapter is stateless across runs; calling this twice with the same
- * input directory produces byte-identical `canonical.jsonl` (records are emitted in sorted `wof:id` order to be
- * insensitive to filesystem walk ordering).
- */
-export function createWOFAdminAdapter(): CorpusAdapter {
-	return {
-		id: WOF_ADMIN_ADAPTER_ID,
-		defaultLicense: "CC0-1.0",
-		description:
-			"Who's On First admin GeoJSON bundles (countries, regions, counties, localities) — multi-name variants per record.",
-
-		async *rows(opts: AdapterOptions): AsyncIterable<CanonicalRow> {
-			// Pass 1: scan every GeoJSON file once, build the in-memory record index.
-			// We keep only records whose placetype maps to a ComponentTag — irrelevant placetypes
-			// (campus, county-region hybrids on which Mailwoman has no opinion) are dropped here so
-			// they don't inflate the ancestry index. Country-filtered runs prune to the matching
-			// country code too; the ancestors of a same-country record live in the same admin repo.
-			const byID = new Map<number, WOFRecord>()
-
-			for await (const rec of walkFeatures(opts.inputPath, { signal: opts.signal })) {
-				if (opts.signal?.aborted) return
-
-				if (opts.country && rec.country !== opts.country) continue
-
-				if (!placetypeToTag(rec.placetype)) continue
-				byID.set(rec.id, rec)
-			}
-
-			const ancestry = buildAncestryIndex(byID)
-
-			// Pass 2: emit rows in sorted-id order for deterministic JSONL.
-			yield* emitWOFJSONRows({
-				records: byID,
-				ancestry,
-				adapterOptions: opts,
-				adapterID: WOF_ADMIN_ADAPTER_ID,
-				localeByCountry: LOCALE_BY_COUNTRY,
-				nameSlotsFor,
-				variantsFor,
-			})
-		},
-	}
-}
-
-/**
- * Single shared instance, suitable for `defaultAdapterRegistry`.
- */
-export const wofAdminAdapter = createWOFAdminAdapter()