@mailwoman/corpus 10.6.0 → 10.7.0

package/lib/li/adapters/llv/adapter.ts

@@ -0,0 +1,246 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ * `llv-li`: the official index of building addresses of Liechtenstein, `Verzeichnis der
+ * Gebäudeadressen`, which the Liechtensteinische Landesverwaltung publishes on
+ * `service.geo.llv.li/download/` as one ZIP (`getfile.php?theme=officialAdress`).
+ *
+ * The ZIP holds `dataset.csv`, a shapefile of the same records and the license PDF. The CSV is
+ * Windows-1252 (`Äussere Wiesen` reads `\xc4ussere Wiesen`), CRLF-terminated and `;`-separated, with no
+ * quoting. The adapter reads `dataset.csv` from the ZIP, or from a path to the extracted CSV.
+ *
+ * The adapter reads `STN_NAME` as the street, `ADR_NUMBER` as the house number (it carries its own
+ * lower-case letter suffix, `12c`), `ZIP_ZIP4` as the postcode and `ZIP_NAME` as the postal locality.
+ * `COM_FOSNR` is the municipality's number and no column holds its name, so no region is emitted. The LI
+ * layout prints no region in any case.
+ *
+ * `STATUS` reads `real` or `planned`. A planned address is one assigned to a building not yet built, so
+ * the adapter refuses it. `OFFICIAL` reads `TRUE` or `FALSE`; an address the register marks as not
+ * official is refused too, because its text is not the designation the municipality assigned.
+ *
+ * The publisher grants reproduction, redistribution, enrichment, editing, combination and commercial use
+ * under its `ABI/OGD-Version 2 vom 5.2.2021` terms, on condition that the source
+ * `Liechtensteinische Landesverwaltung` is stated and the terms are enclosed or linked. Every row
+ * records that license.
+ */
+
+import { formatAddressRow } from "@mailwoman/codex/address/format"
+import { matchCountryPostcode } from "@mailwoman/codex/postcode/country-formats"
+import { readLocalBuffer } from "@mailwoman/core/fs/readers"
+import { decodeBytes } from "@mailwoman/core/fs/streams"
+import { readZipEntry } from "@mailwoman/core/fs/zip"
+import { resolvePath } from "path-ts"
+import { CSVSpliterator } from "spliterator"
+
+import { UnsupportedCountryError } from "#adapters/errors"
+import { stableSourceIDFromParts } from "#adapters/source-id"
+import { SourceRegister } from "#registers"
+import {
+	AddressRole,
+	type AdapterOptions,
+	type CanonicalRow,
+	type CorpusAdapter,
+	countDropped,
+	SurfaceOrigin,
+} from "#types"
+
+/**
+ * Registry id for this adapter, stamped into every row it emits.
+ */
+export const LLV_LI_ADAPTER_ID = "llv-li"
+
+/**
+ * The Landesverwaltung's own terms, `ABI/OGD-Version 2 vom 5.2.2021`.
+ * They have no SPDX identifier.
+ */
+export const LLV_LI_LICENSE = "LicenseRef-LI-ABI-OGD-2"
+
+/**
+ * Every jurisdiction this adapter emits, checked against a caller's `--country`.
+ */
+export const LLV_LI_COUNTRIES: readonly string[] = ["LI"]
+
+/**
+ * The ZIP member that holds the address table.
+ */
+export const LLV_LI_MEMBER = "dataset.csv"
+
+/**
+ * The columns the adapter reads from `dataset.csv`.
+ */
+export interface LLVLiechtensteinRecord {
+	ADR_EGAID: string
+	STN_NAME: string
+	ADR_NUMBER: string
+	ZIP_ZIP4: string
+	ZIP_NAME: string
+	STATUS: string
+	OFFICIAL: string
+}
+
+function present(value: string | undefined): string | null {
+	const trimmed = value?.trim() ?? ""
+
+	return trimmed || null
+}
+
+/**
+ * Maps one record onto the components the corpus asserts, or returns null when the row is refused.
+ *
+ * Each refusal increments its reason in `dropped`.
+ */
+export function componentsForLLVRecord(
+	record: LLVLiechtensteinRecord,
+	dropped?: Pick<AdapterOptions, "dropped">
+): CanonicalRow["components"] | null {
+	const tally = dropped ?? {}
+
+	if (record.STATUS?.trim() !== "real") {
+		countDropped(tally, record.STATUS?.trim() === "planned" ? "row:status-planned" : "row:status-unknown")
+
+		return null
+	}
+
+	if (record.OFFICIAL?.trim().toUpperCase() !== "TRUE") {
+		countDropped(tally, "row:not-official")
+
+		return null
+	}
+
+	const street = present(record.STN_NAME)
+
+	if (!street) {
+		countDropped(tally, "row:no-street")
+
+		return null
+	}
+
+	const number = present(record.ADR_NUMBER)
+
+	if (!number) {
+		countDropped(tally, "row:no-house-number")
+
+		return null
+	}
+
+	const components: CanonicalRow["components"] = {
+		street,
+		house_number: number,
+	}
+
+	const postcode = present(record.ZIP_ZIP4)
+	const matched = postcode ? matchCountryPostcode(postcode, "LI") : null
+
+	if (matched) {
+		components.postcode = matched
+	} else if (postcode) {
+		countDropped(tally, "component:postcode:not-country-format")
+	}
+
+	const locality = present(record.ZIP_NAME)
+
+	if (locality) {
+		components.locality = locality
+	}
+
+	if (!components.locality && !components.postcode) {
+		countDropped(tally, "row:no-locality-or-postcode")
+
+		return null
+	}
+
+	return components
+}
+
+/**
+ * The bytes of `dataset.csv`, read from the publisher's ZIP or from the extracted file.
+ *
+ * The table is about 2 MB, so it is held whole.
+ */
+async function datasetBytes(inputPath: string): Promise<Buffer> {
+	if (!inputPath.toLowerCase().endsWith(".zip")) return readLocalBuffer(inputPath)
+
+	const chunks: Uint8Array[] = []
+
+	for await (const chunk of readZipEntry(inputPath, LLV_LI_MEMBER)) {
+		chunks.push(chunk)
+	}
+
+	return Buffer.concat(chunks)
+}
+
+export function createLLVLiechtensteinAdapter(): CorpusAdapter {
+	return {
+		id: LLV_LI_ADAPTER_ID,
+		defaultLicense: LLV_LI_LICENSE,
+		addressRole: AddressRole.Premise,
+		register: SourceRegister.LiechtensteinGebaeudeadressen,
+		surface: SurfaceOrigin.Rendered,
+		description: "Verzeichnis der Gebäudeadressen (Liechtensteinische Landesverwaltung): national building addresses.",
+
+		async *rows(opts: AdapterOptions): AsyncIterable<CanonicalRow> {
+			if (opts.country && !LLV_LI_COUNTRIES.includes(opts.country)) {
+				throw new UnsupportedCountryError(LLV_LI_ADAPTER_ID, LLV_LI_COUNTRIES, opts.country)
+			}
+
+			const text = decodeBytes(await datasetBytes(resolvePath(opts.inputPath).toString()), "windows-1252")
+
+			const records = CSVSpliterator.from<LLVLiechtensteinRecord>(Buffer.from(text, "utf8"), {
+				normalizeKeys: false,
+				columnDelimiter: ";",
+			})
+
+			let emitted = 0
+
+			for (const record of records) {
+				if (opts.signal?.aborted) return
+
+				if (opts.limit !== undefined && emitted >= opts.limit) return
+
+				const components = componentsForLLVRecord(record, opts)
+
+				if (!components) continue
+
+				const rendered = formatAddressRow(components, "LI", {
+					singleLine: true,
+				})
+
+				if (!rendered) {
+					countDropped(opts, "row:render-failed")
+
+					continue
+				}
+
+				for (const tag of rendered.unplaced) {
+					countDropped(opts, `component:${tag}:not-rendered`)
+				}
+
+				const { raw, components: aligned } = rendered
+
+				yield {
+					raw,
+					components: aligned,
+					country: "LI",
+					locale: "de-LI",
+					source: LLV_LI_ADAPTER_ID,
+					// `ADR_EGAID` is the federal address identifier, unique per row of the register.
+					source_id: stableSourceIDFromParts(LLV_LI_ADAPTER_ID, {
+						...aligned,
+						egaid: record.ADR_EGAID ?? "",
+					}),
+					corpus_version: "",
+					license: LLV_LI_LICENSE,
+				}
+
+				emitted++
+			}
+		},
+	}
+}
+
+/**
+ * The configured adapter instance registered with the corpus builder.
+ */
+export const llvLiechtensteinAdapter = createLLVLiechtensteinAdapter()

package/lib/recipes/bare/postcode.ts

@@ -44,8 +44,7 @@ const BARE_POSTCODE_PROVENANCE = {
 }
 
 /**
- * One country's postcodes: the CSV under the extracted OpenAddresses tree and the country it covers,
- * where Sweden publishes sixteen municipality files against CZ/SK/NL's one countrywide file each.
+ * One country's postcodes: the CSV under the extracted OpenAddresses tree and the country it covers.
  */
 interface PostcodeSource {
 	csv: PathBuilderLike
@@ -55,40 +54,18 @@ interface PostcodeSource {
 const EXTRACTED = dataRootPath("openaddresses", "extracted")
 
 /**
- * Read from the archive rather than guessed, because OpenAddresses keeps the Swedish
- * spelling on two of these (`savsjö`, `Österåker`) while folding the rest to ascii.
- */
-const SWEDISH_MUNICIPALITIES = [
-	"alingsas",
-	"gislaved",
-	"goteborg",
-	"helsingborg",
-	"hoganas",
-	"kalmar",
-	"kristinehamn",
-	"malmo",
-	"nacka",
-	"savsjö",
-	"stockholm",
-	"uppsala",
-	"vasteras",
-	"vaxholm",
-	"vaxjo",
-	"Österåker",
-]
-
-/**
+ * Each file's publisher has a register row whose elected decision permits transform
+ * and train, and `corpus-source-inputs.json` lists that row under `codex-bare-postcode`.
+ *
  * Greece is deliberately absent: its only member declares a `postcode` column with no values over
- * 10,877 rows, though `gr_postcode` shares `NNN NN` with CZ/SK/SE, so no row here claims to be Greek.
+ * 10,877 rows, though `gr_postcode` shares `NNN NN` with CZ/SK, so no row here claims to be Greek.
+ * Sweden's sixteen `se/municipality_of_*` files are absent because their register row,
+ * `se-property-building-2`, records no decision permitting training.
  */
 const SOURCES: PostcodeSource[] = [
 	{ csv: EXTRACTED("cz", "countrywide.csv"), country: "CZ" },
 	{ csv: EXTRACTED("sk", "countrywide.csv"), country: "SK" },
 	{ csv: EXTRACTED("nl", "countrywide.csv"), country: "NL" },
-	...SWEDISH_MUNICIPALITIES.map((name) => ({
-		csv: EXTRACTED("se", `municipality_of_${name}.csv`),
-		country: "SE",
-	})),
 ]
 
 /**
@@ -185,8 +162,7 @@ export function detectedAsPostcode(surface: string): boolean {
  */
 export const barePostcodeRecipe: CorpusRecipe = {
 	name: "bare-postcode",
-	description:
-		"A postcode alone, in its country's written form — the shape no other recipe output carries (CZ/SK/SE/NL)",
+	description: "A postcode alone, in its country's written form — the shape no other recipe output carries (CZ/SK/NL)",
 	mode: "generate",
 	options: [
 		{
@@ -201,8 +177,8 @@ export const barePostcodeRecipe: CorpusRecipe = {
 		let unrecognized = 0
 
 		// Preflight the complete input set before writing a row.
-		// A missing municipality would otherwise produce a plausible artifact with
-		// less Swedish coverage than the recipe declares.
+		// A missing file would otherwise produce a plausible artifact with less
+		// coverage than the recipe declares.
 		const missing = await findMissingPostcodeSources(SOURCES.map(({ csv }) => csv))
 
 		if (missing.length) {

package/lib/recipes/country-balanced.ts

@@ -21,6 +21,7 @@ import { readOATuples, requireRegister, type CorpusRecipe } from "#recipes/scaff
 import { defaultRecipeSource } from "#recipes/sources"
 import { SurfaceOrigin } from "#types"
 import type { CanonicalRow } from "#types"
+import { US_SKELETON_EVAL_SOURCE, US_SKELETON_TRAIN_SOURCES } from "#us/recipes/skeleton-sources"
 import { alignRow } from "#utils"
 
 // Country names are drawn without regard to the address's own country.
@@ -39,7 +40,7 @@ const COUNTRY_FORM_POOL = (() => {
 const COUNTRY_ABSENT_PROB = 0.3
 
 /**
- * One OpenAddresses archive and how to render its rows.
+ * One OA-layout archive and how to render its rows.
  */
 interface CountrySource {
 	zip: PathBuilderLike
@@ -47,76 +48,75 @@ interface CountrySource {
 	iso2: string
 	region: string
 	order: string
+	/**
+	 * The register the archive's rows come from, when it differs from the invocation's `--register`.
+	 */
+	register?: string
 }
 
 /**
- * The training sources.
+ * The training sources, in two groups that {@linkcode readSourcePool} gives equal halves of the read budget.
+ *
+ * The first group is the shared US skeletons.
+ * They take the half that the four OpenAddresses US state files held before `us/il/cook` was withdrawn.
+ *
+ * The number of US files therefore leaves the pool's country mix unchanged.
  */
-const SOURCES: readonly CountrySource[] = [
-	{
-		zip: dataRootPath("oa-cache", "us__ia__statewide.zip"),
-		csv: "us/ia/statewide.csv",
-		iso2: "US",
-		region: "IA",
-		order: "us",
-	},
-	{ zip: dataRootPath("oa-cache", "us__il__cook.zip"), csv: "us/il/cook.csv", iso2: "US", region: "IL", order: "us" },
-	{
-		zip: dataRootPath("oa-cache", "us__mt__statewide.zip"),
-		csv: "us/mt/statewide.csv",
+const SOURCE_GROUPS: readonly (readonly CountrySource[])[] = [
+	US_SKELETON_TRAIN_SOURCES.map(({ zip, csv, region, register }) => ({
+		zip,
+		csv,
 		iso2: "US",
-		region: "MT",
+		region,
 		order: "us",
-	},
-	{
-		zip: dataRootPath("oa-cache", "us__sd__statewide.zip"),
-		csv: "us/sd/statewide.csv",
-		iso2: "US",
-		region: "SD",
-		order: "us",
-	},
-	{
-		zip: dataRootPath("oa-cache", "de__sn__statewide.zip"),
-		csv: "de/sn/statewide.csv",
-		iso2: "DE",
-		region: "",
-		order: "eu",
-	},
-	{
-		zip: dataRootPath("oa-cache", "fr__countrywide.zip"),
-		csv: "fr/countrywide.csv",
-		iso2: "FR",
-		region: "",
-		order: "fr",
-	},
-	{
-		zip: dataRootPath("oa-cache", "it__countrywide.zip"),
-		csv: "it/countrywide.csv",
-		iso2: "IT",
-		region: "",
-		order: "eu",
-	},
-	{
-		zip: dataRootPath("oa-cache", "nl__countrywide.zip"),
-		csv: "nl/countrywide.csv",
-		iso2: "NL",
-		region: "",
-		order: "eu",
-	},
+		register,
+	})),
+	[
+		{
+			zip: dataRootPath("oa-cache", "de__sn__statewide.zip"),
+			csv: "de/sn/statewide.csv",
+			iso2: "DE",
+			region: "",
+			order: "eu",
+		},
+		{
+			zip: dataRootPath("oa-cache", "fr__countrywide.zip"),
+			csv: "fr/countrywide.csv",
+			iso2: "FR",
+			region: "",
+			order: "fr",
+		},
+		{
+			zip: dataRootPath("oa-cache", "it__countrywide.zip"),
+			csv: "it/countrywide.csv",
+			iso2: "IT",
+			region: "",
+			order: "eu",
+		},
+		{
+			zip: dataRootPath("oa-cache", "nl__countrywide.zip"),
+			csv: "nl/countrywide.csv",
+			iso2: "NL",
+			region: "",
+			order: "eu",
+		},
+	],
 ]
 
 /**
- * The held-out sources that `--golden` reads.
+ * The held-out sources that `--golden` reads, one per group.
  */
-const EVAL_SOURCES: readonly CountrySource[] = [
-	{
-		zip: dataRootPath("oa-cache", "us__vt__statewide.zip"),
-		csv: "us/vt/statewide.csv",
-		iso2: "US",
-		region: "VT",
-		order: "us",
-	},
-	{ zip: dataRootPath("oa-cache", "de__berlin.zip"), csv: "de/berlin.csv", iso2: "DE", region: "", order: "eu" },
+const EVAL_SOURCE_GROUPS: readonly (readonly CountrySource[])[] = [
+	[
+		{
+			zip: US_SKELETON_EVAL_SOURCE.zip,
+			csv: US_SKELETON_EVAL_SOURCE.csv,
+			iso2: "US",
+			region: US_SKELETON_EVAL_SOURCE.region,
+			order: "us",
+		},
+	],
+	[{ zip: dataRootPath("oa-cache", "de__berlin.zip"), csv: "de/berlin.csv", iso2: "DE", region: "", order: "eu" }],
 ]
 
 /**
@@ -130,6 +130,7 @@ interface CountryTuple {
 	postcode: string
 	iso2: string
 	order: string
+	register?: string
 }
 
 /**
@@ -143,10 +144,37 @@ async function readTuples(source: CountrySource, limit: number): Promise<Country
 			region: row.region || source.region,
 			iso2: source.iso2,
 			order: source.order,
+			...(source.register ? { register: source.register } : {}),
 		}),
 	})
 }
 
+/**
+ * Reads the tuple pool for `count` rows: a threefold read of the target,
+ * which leaves room for skipped rows.
+ *
+ * Each group takes an equal share of that read, split evenly between its sources.
+ */
+async function readSourcePool(groups: readonly (readonly CountrySource[])[], count: number): Promise<CountryTuple[]> {
+	const pool: CountryTuple[] = []
+
+	for (const group of groups) {
+		const perSource = Math.ceil((count * 3) / groups.length / group.length)
+
+		for (const s of group) {
+			const t = await readTuples(s, perSource)
+
+			console.error(`  ${s.csv} (${s.iso2}): ${t.length} tuples`)
+
+			for (const x of t) {
+				pool.push(x)
+			}
+		}
+	}
+
+	return pool
+}
+
 // The share of country draws taken from the curated surface forms instead of canonical names.
 const SURFACE_FORM_SHARE = 0.6
 
@@ -391,21 +419,7 @@ export const countryBalancedRecipe: CorpusRecipe = {
 		const count = opts.count
 		const random = makeMulberry32(opts.seed)
 		const source = opts.sourceName ?? defaultRecipeSource("synth-country")
-		const sources = opts.golden ? EVAL_SOURCES : SOURCES
-		// A threefold read of the target leaves room for skipped rows.
-		const perSource = Math.ceil((count * 3) / sources.length)
-
-		const pool: CountryTuple[] = []
-
-		for (const s of sources) {
-			const t = await readTuples(s, perSource)
-
-			console.error(`  ${s.csv} (${s.iso2}): ${t.length} tuples`)
-
-			for (const x of t) {
-				pool.push(x)
-			}
-		}
+		const pool = await readSourcePool(opts.golden ? EVAL_SOURCE_GROUPS : SOURCE_GROUPS, count)
 
 		if (!pool.length) {
 			throw new Error(`No tuples — are the cached OA zips present in ${dataRootPath("oa-cache")}?`)
@@ -420,6 +434,7 @@ export const countryBalancedRecipe: CorpusRecipe = {
 			const roll = random()
 			let rendered: { fmt: string; raw: string; components: Partial<Record<ComponentTag, string>> }
 			let rowISO2: string
+			let rowRegister: string | undefined
 
 			if (roll < HOMOGRAPH_FRAC) {
 				const h = renderHomograph(random)
@@ -434,6 +449,7 @@ export const countryBalancedRecipe: CorpusRecipe = {
 				const country = pickCountry(random)
 				rendered = renderCountry(random, t, country)
 				rowISO2 = t.iso2
+				rowRegister = t.register
 
 				if (country && !rendered.raw.includes(country)) {
 					skipped++
@@ -461,7 +477,8 @@ export const countryBalancedRecipe: CorpusRecipe = {
 				source,
 				source_id: stableSourceID(source, components),
 				corpus_version: "0.4.0",
-				license: "OpenAddresses multi-locale skeletons + injected ISO-3166 country surface forms (codex)",
+				license:
+					"OpenAddresses multi-locale and National Address Database US skeletons + injected ISO-3166 country surface forms (codex)",
 			}
 
 			const aligned = alignRow(canonical)
@@ -477,7 +494,7 @@ export const countryBalancedRecipe: CorpusRecipe = {
 					...aligned.row,
 					recipe: "country",
 					base_source_id: null,
-					register: requireRegister(opts, "country-balanced"),
+					register: rowRegister ?? requireRegister(opts, "country-balanced"),
 					surface: SurfaceOrigin.Composed,
 				})
 			)

package/lib/recipes/intersection.ts

@@ -20,7 +20,7 @@
  *   Junction-format variety includes padded and tight `&` and `/`, `and`, `at`, `@`, and the
  *   leading phrases `corner of` and `intersection of`, crossed with tails (bare / `, ST` / `, ST ZIP` /
  *   `, City, ST [ZIP]`) and case variants. ZIPs are the crossing's own tiger edge zipl (real). The
- *   locality tail comes from the OA Cook-county ZIP→city majority map.
+ *   locality tail comes from the NAD ZIP→city majority tables for Cook and Morris counties.
  *
  *   Audit: every emitted row is label-checked on the RAW surface via the char-offset span triple. Any
  *   violation fails the build (throws). A JSON audit report lands next to the output.
@@ -29,7 +29,8 @@
  *
  *   - <edges-dir>/tl_2023_{17031,34027,50023}_edges.shp (unzipped tiger 2023 edges. default
  *       `$MAILWOMAN_DATA_ROOT/census/tiger2023-edges`, where `mailwoman situs interpolation` puts them)
- *   - `$MAILWOMAN_DATA_ROOT/oa-cache/us__il__cook.zip` (ZIP→city tails)
+ *   - `$MAILWOMAN_DATA_ROOT/nad-skeletons/us__{il__cook,nj__morris}__zip-city.csv` (ZIP→city tails, written by
+ *       `packages/mailwoman/tools/dev-tools/corpus/nad-skeletons.run.ts`)
  */
 
 import type { DuckDBConnection } from "@duckdb/node-api"
@@ -46,10 +47,11 @@ import { JSONSpliterator } from "spliterator"
 
 import { stableSourceID } from "#adapters/source-id"
 import { openDuckDB } from "#parquet/duckdb"
-import { readZippedCSVRecords, type CorpusRecipe } from "#recipes/scaffold"
+import { readCSVRecords, type CorpusRecipe } from "#recipes/scaffold"
 import { defaultRecipeSource } from "#recipes/sources"
 import { weightedPick } from "#synthesizers/utils"
 import type { CanonicalRow, LabeledRow } from "#types"
+import { NAD_ZIP_CITY_COUNTIES, nadZipCityPath } from "#us/recipes/skeleton-sources"
 import { alignRow } from "#utils"
 
 interface County {
@@ -75,8 +77,6 @@ const EVAL_GOLD_PATH = repoRootPath("data", "eval", "external", "intersection-re
  */
 const DEFAULT_EDGES_DIR = dataRootPath("census", "tiger2023-edges")
 
-const OA_COOK = { zip: dataRootPath("oa-cache", "us__il__cook.zip"), csv: "us/il/cook.csv" }
-
 /**
  * One real crossing extracted from a county's tiger edges shapefile.
  */
@@ -257,37 +257,28 @@ async function extractCrossings(
 }
 
 /**
- * ZIP → majority city from the cached OA Cook-county CSV (real ZIP/city pairings).
+ * ZIP → majority city in the training counties, from the NAD ZIP-to-city tables (real ZIP/city pairings).
+ *
+ * A missing table throws: an empty map would silently downgrade every city tail to the region tail.
  */
 async function buildZipCityMap(): Promise<Map<string, string>> {
-	const counts = new Map<string, Map<string, number>>()
-
-	for await (const row of readZippedCSVRecords(OA_COOK.zip, OA_COOK.csv)) {
-		const city = row.city ?? ""
-		const zip = row.postcode ?? ""
+	const map = new Map<string, string>()
 
-		if (!city || !/^\d{5}$/.test(zip) || BAD_NAME.test(city)) continue
-		let byCity = counts.get(zip)
+	for (const county of NAD_ZIP_CITY_COUNTIES) {
+		const path = nadZipCityPath(county)
 
-		if (!byCity) {
-			counts.set(zip, (byCity = new Map()))
+		if (!(await pathExists(path))) {
+			throw new Error(
+				`${path} is missing; write it with packages/mailwoman/tools/dev-tools/corpus/nad-skeletons.run.ts`
+			)
 		}
 
-		byCity.set(city, (byCity.get(city) ?? 0) + 1)
-	}
-
-	const map = new Map<string, string>()
-
-	for (const [zip, byCity] of counts) {
-		let best: { city: string; n: number } | null = null
-
-		for (const [city, n] of byCity)
-			if (!best || n > best.n) {
-				best = { city, n }
-			}
+		for await (const row of readCSVRecords(path)) {
+			const city = row.city ?? ""
+			const zip = row.zip ?? ""
 
-		if (best) {
-			map.set(zip, best.city)
+			if (!city || !/^\d{5}$/.test(zip) || BAD_NAME.test(city)) continue
+			map.set(zip, city)
 		}
 	}
 
@@ -571,7 +562,8 @@ export const intersectionRecipe: CorpusRecipe = {
 				source,
 				source_id: stableSourceID(source, components),
 				corpus_version: "0.4.0",
-				license: "TIGER/Line 2023 EDGES (US Census, public domain) real street pairs; OA Cook IL zip-to-city tails",
+				license:
+					"TIGER/Line 2023 EDGES (US Census, public domain) real street pairs; National Address Database (public domain) Cook IL and Morris NJ zip-to-city tails",
 			}
 
 			// Verbatim-only alignment: raw is built from the component values, so a fuzzy fallback