@mailwoman/codex 9.1.0 → 9.3.0

package/lib/country/population.ts

@@ -0,0 +1,265 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   GENERATED — do not edit by hand. Per-country population, derived from GeoNames countryInfo.txt
+ *   (https://download.geonames.org/export/dump/countryInfo.txt, CC-BY-4.0). Estimates are
+ *   census-vintage; a prominence race reads the magnitude, not the currency. Countries GeoNames
+ *   declines to estimate are ABSENT, never zero.
+ *   Regenerate with: mailwoman dev generate country-population
+ */
+
+/**
+ * ISO 3166-1 alpha-2 → population estimate.
+ */
+export const COUNTRY_POPULATION: Readonly<Record<string, number>> = {
+	AD: 77_006,
+	AE: 9_630_959,
+	AF: 37_172_386,
+	AG: 96_286,
+	AI: 13_254,
+	AL: 2_866_376,
+	AM: 3_090_500,
+	AN: 300_000,
+	AO: 30_809_762,
+	AR: 44_494_502,
+	AS: 55_465,
+	AT: 8_847_037,
+	AU: 24_992_369,
+	AW: 105_845,
+	AX: 26_711,
+	AZ: 10_224_900,
+	BA: 3_323_929,
+	BB: 286_641,
+	BD: 161_356_039,
+	BE: 11_422_068,
+	BF: 19_751_535,
+	BG: 7_000_039,
+	BH: 1_569_439,
+	BI: 11_175_378,
+	BJ: 11_485_048,
+	BL: 8450,
+	BM: 63_968,
+	BN: 428_962,
+	BO: 11_353_142,
+	BQ: 18_012,
+	BR: 209_469_333,
+	BS: 385_640,
+	BT: 754_394,
+	BW: 2_254_126,
+	BY: 9_485_386,
+	BZ: 383_071,
+	CA: 37_058_856,
+	CC: 628,
+	CD: 84_068_091,
+	CF: 4_666_377,
+	CG: 5_244_363,
+	CH: 8_516_543,
+	CI: 25_069_229,
+	CK: 21_388,
+	CL: 18_729_160,
+	CM: 25_216_237,
+	CN: 1_411_778_724,
+	CO: 49_648_685,
+	CR: 4_999_441,
+	CS: 10_829_175,
+	CU: 11_338_138,
+	CV: 543_767,
+	CW: 159_849,
+	CX: 1500,
+	CY: 1_189_265,
+	CZ: 10_625_695,
+	DE: 82_927_922,
+	DJ: 958_920,
+	DK: 5_797_446,
+	DM: 71_625,
+	DO: 10_627_165,
+	DZ: 42_228_429,
+	EC: 17_084_357,
+	EE: 1_320_884,
+	EG: 98_423_595,
+	EH: 273_008,
+	ER: 6_209_262,
+	ES: 46_723_749,
+	ET: 109_224_559,
+	FI: 5_518_050,
+	FJ: 883_483,
+	FK: 2638,
+	FM: 112_640,
+	FO: 48_497,
+	FR: 66_987_244,
+	GA: 2_119_275,
+	GB: 66_488_991,
+	GD: 111_454,
+	GE: 3_704_500,
+	GF: 195_506,
+	GG: 65_228,
+	GH: 29_767_108,
+	GI: 33_718,
+	GL: 56_025,
+	GM: 2_280_102,
+	GN: 12_414_318,
+	GP: 443_000,
+	GQ: 1_308_974,
+	GR: 10_727_668,
+	GS: 30,
+	GT: 17_247_807,
+	GU: 165_768,
+	GW: 1_874_309,
+	GY: 779_004,
+	HK: 7_396_076,
+	HN: 9_587_522,
+	HR: 3_871_833,
+	HT: 11_123_176,
+	HU: 9_768_785,
+	ID: 267_663_435,
+	IE: 4_853_506,
+	IL: 8_883_800,
+	IM: 84_077,
+	IN: 1_352_617_328,
+	IO: 4000,
+	IQ: 38_433_600,
+	IR: 81_800_269,
+	IS: 353_574,
+	IT: 60_431_283,
+	JE: 90_812,
+	JM: 2_934_855,
+	JO: 9_956_011,
+	JP: 126_529_100,
+	KE: 51_393_010,
+	KG: 6_315_800,
+	KH: 16_249_798,
+	KI: 115_847,
+	KM: 832_322,
+	KN: 52_441,
+	KP: 25_549_819,
+	KR: 51_635_256,
+	KW: 4_137_309,
+	KY: 64_174,
+	KZ: 18_276_499,
+	LA: 7_061_507,
+	LB: 6_848_925,
+	LC: 181_889,
+	LI: 37_910,
+	LK: 21_670_000,
+	LR: 4_818_977,
+	LS: 2_108_132,
+	LT: 2_789_533,
+	LU: 607_728,
+	LV: 1_926_542,
+	LY: 6_678_567,
+	MA: 36_029_138,
+	MC: 38_682,
+	MD: 3_545_883,
+	ME: 622_345,
+	MF: 37_264,
+	MG: 26_262_368,
+	MH: 58_413,
+	MK: 2_082_958,
+	ML: 19_077_690,
+	MM: 53_708_395,
+	MN: 3_170_208,
+	MO: 631_636,
+	MP: 56_882,
+	MQ: 432_900,
+	MR: 4_403_319,
+	MS: 9341,
+	MT: 483_530,
+	MU: 1_265_303,
+	MV: 515_696,
+	MW: 17_563_749,
+	MX: 126_190_788,
+	MY: 31_528_585,
+	MZ: 29_495_962,
+	NA: 2_448_255,
+	NC: 284_060,
+	NE: 22_442_948,
+	NF: 1828,
+	NG: 195_874_740,
+	NI: 6_465_513,
+	NL: 17_231_017,
+	NO: 5_314_336,
+	NP: 28_087_871,
+	NR: 12_704,
+	NU: 2166,
+	NZ: 4_885_500,
+	OM: 4_829_483,
+	PA: 4_176_873,
+	PE: 31_989_256,
+	PF: 277_679,
+	PG: 8_606_316,
+	PH: 106_651_922,
+	PK: 212_215_030,
+	PL: 37_978_548,
+	PM: 7012,
+	PN: 46,
+	PR: 3_195_153,
+	PS: 4_569_087,
+	PT: 10_281_762,
+	PW: 17_907,
+	PY: 6_956_071,
+	QA: 2_781_677,
+	RE: 776_948,
+	RO: 19_473_936,
+	RS: 6_982_084,
+	RU: 144_478_050,
+	RW: 12_301_939,
+	SA: 33_699_947,
+	SB: 652_858,
+	SC: 96_762,
+	SD: 41_801_533,
+	SE: 10_183_175,
+	SG: 5_638_676,
+	SH: 7460,
+	SI: 2_067_372,
+	SJ: 2550,
+	SK: 5_447_011,
+	SL: 7_650_154,
+	SM: 33_785,
+	SN: 15_854_360,
+	SO: 15_008_154,
+	SR: 575_991,
+	SS: 8_260_490,
+	ST: 197_700,
+	SV: 6_420_744,
+	SX: 40_654,
+	SY: 16_906_283,
+	SZ: 1_136_191,
+	TC: 37_665,
+	TD: 15_477_751,
+	TF: 140,
+	TG: 7_889_094,
+	TH: 69_428_524,
+	TJ: 9_100_837,
+	TK: 1466,
+	TL: 1_267_972,
+	TM: 5_850_908,
+	TN: 11_565_204,
+	TO: 103_197,
+	TR: 82_319_724,
+	TT: 1_389_858,
+	TV: 11_508,
+	TW: 23_451_837,
+	TZ: 56_318_348,
+	UA: 40_000_000,
+	UG: 42_723_139,
+	US: 327_167_434,
+	UY: 3_449_299,
+	UZ: 32_955_400,
+	VA: 921,
+	VC: 110_211,
+	VE: 28_870_195,
+	VG: 29_802,
+	VI: 106_977,
+	VN: 95_540_395,
+	VU: 292_680,
+	WF: 16_025,
+	WS: 196_130,
+	XK: 1_845_300,
+	YE: 28_498_687,
+	YT: 279_471,
+	ZA: 57_779_622,
+	ZM: 17_351_822,
+	ZW: 16_868_409,
+}

package/{country → lib/country}/reference.ts

@@ -6,12 +6,12 @@
  *   Country-reference annotators. The flag emoji is a pure function of the ISO 3166-1 alpha-2 code
  *   (two Regional Indicator Symbols); calling code + currency come from {@link COUNTRY_REFERENCE}, a
  *   table generated from mledoze/countries (provenance-tracked, not hand-typed — the
- *   no-load-bearing-trivia rule).
+ *   no-irrelevant-trivia rule).
  */
 
 import type { AnnotationSet, Annotator } from "@mailwoman/annotations"
 
-import { COUNTRY_REFERENCE } from "./reference-data.ts"
+import { COUNTRY_REFERENCE } from "#country/reference-data"
 
 const REGIONAL_INDICATOR_BASE = 0x1_f1_e6
 const A_UPPER = "A".charCodeAt(0)

package/{country → lib/country}/subdivision.ts

@@ -26,9 +26,10 @@
  *   re-keys those two existing tables into one subdivision→country view.
  */
 
-import { CA_PROVINCES } from "../ca/province.ts"
-import { foldName } from "../normalize.ts"
-import { US_STATE_BY_ABBREVIATION } from "../us/state.ts"
+import { AU_STATE_ABBREVIATIONS } from "#au/state"
+import { CA_PROVINCES } from "#ca/province"
+import { foldName } from "#normalize"
+import { US_STATE_BY_ABBREVIATION } from "#us/state"
 
 /**
  * A resolved subdivision: its ISO 3166-2 code (sans country prefix), canonical English name, and ISO 3166-1 country.
@@ -91,3 +92,61 @@ export function matchSubdivision(token: string | null | undefined): SubdivisionM
 
 	return SUBDIVISION_LOOKUP.get(foldName(token)) ?? null
 }
+
+/**
+ * Per-country subdivision lookups for callers that already KNOW the country. Kept separate from
+ * {@link SUBDIVISION_LOOKUP} on purpose: the combined map is only unambiguous because the US and CA sets are disjoint,
+ * and Australia breaks that property twice — `WA` collides with Washington and `NT` with the Northwest Territories. A
+ * country-scoped caller (the admin-coherence check reads the winner's resolver-stamped country) dissolves the collision
+ * instead of arbitrating it.
+ */
+const SCOPED_SUBDIVISION_LOOKUP: ReadonlyMap<string, ReadonlyMap<string, SubdivisionMatch>> = (() => {
+	const byCountry = new Map<string, Map<string, SubdivisionMatch>>()
+
+	const put = (country: string, key: string, match: SubdivisionMatch): void => {
+		const folded = foldName(key)
+
+		if (!folded.length) return
+
+		const scoped = byCountry.get(country) ?? new Map<string, SubdivisionMatch>()
+
+		byCountry.set(country, scoped)
+
+		if (!scoped.has(folded)) {
+			scoped.set(folded, match)
+		}
+	}
+
+	for (const [code, name] of Object.entries(US_STATE_BY_ABBREVIATION)) {
+		const match: SubdivisionMatch = { code, name, country: "US" }
+		put("US", code, match)
+		put("US", name, match)
+	}
+
+	for (const info of Object.values(CA_PROVINCES)) {
+		const match: SubdivisionMatch = { code: info.code, name: info.name, country: "CA" }
+		put("CA", info.code, match)
+		put("CA", info.name, match)
+		put("CA", info.french, match)
+	}
+
+	for (const [code, name] of Object.entries(AU_STATE_ABBREVIATIONS)) {
+		const match: SubdivisionMatch = { code, name, country: "AU" }
+		put("AU", code, match)
+		put("AU", name, match)
+	}
+
+	return byCountry
+})()
+
+/**
+ * Resolve a subdivision surface form WITHIN one country. Same folding and return shape as {@link matchSubdivision}, but
+ * scoped: `WA` under `AU` is Western Australia, under `US` Washington, and under any other country null. Use this
+ * whenever the country is already established; the unscoped lookup exists for the address-line case where the
+ * subdivision itself is the country evidence.
+ */
+export function matchSubdivisionIn(countryAlpha2: string, token: string | null | undefined): SubdivisionMatch | null {
+	if (!token || typeof token !== "string") return null
+
+	return SCOPED_SUBDIVISION_LOOKUP.get(countryAlpha2.toUpperCase())?.get(foldName(token)) ?? null
+}

package/{de → lib/de}/index.ts

@@ -3,10 +3,10 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   The German address system (Deutsche Post / ISO 3166-2:DE): street types, postal codes
+ *   The German address system (Deutsche Post / ISO 3166-2:DE): street types, postcodes
  *   (Postleitzahl), and the federal states (Bundesländer).
  */
 
-export * from "./bundesland.ts"
-export * from "./postleitzahl.ts"
-export * from "./street-type.ts"
+export * from "#de/bundesland"
+export * from "#de/postleitzahl"
+export * from "#de/street-type"

package/{de → lib/de}/postleitzahl.ts

@@ -3,7 +3,7 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   German postal codes (Postleitzahl, PLZ): the branded type, the shape, normalization, and the
+ *   German postcodes (Postleitzahl, PLZ): the branded type, the shape, normalization, and the
  *   first-digit → Leitzone geographic prior.
  *
  *   The US analog is `us/zipcode.ts`, and the contrast is the informative part. A US ZIP's first
@@ -18,7 +18,7 @@
 import type { Tagged } from "type-fest"
 
 /**
- * A German postal code: five digits since the 1993 reform (`12623`). A bare 5-digit string, same shape as a US ZIP or a
+ * A German postcode: five digits since the 1993 reform (`12623`). A bare 5-digit string, same shape as a US ZIP or a
  * French code postal — disambiguation is the parser's job, not the shape's.
  *
  * @category Postal
@@ -45,7 +45,7 @@ export function normalizePLZ(raw: unknown): Postleitzahl | null {
 }
 
 /**
- * Type-predicate for a (normalized) German postal code.
+ * Type-predicate for a (normalized) German postcode.
  */
 export function isPostleitzahl(input: unknown): input is Postleitzahl {
 	return typeof input === "string" && PLZ_PATTERN.test(input)

package/{es → lib/es}/codigo-postal.ts

@@ -3,7 +3,7 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   Spanish postal codes (código postal): the branded type, the shape, and the province prior.
+ *   Spanish postcodes (código postal): the branded type, the shape, and the province prior.
  *
  *   The contrast with a German PLZ is the informative part. A PLZ's leading digit maps to a Leitzone
  *   that deliberately CROSSES state borders, so it cannot tell you the Bundesland. A Spanish código
@@ -16,7 +16,7 @@
 import type { Tagged } from "type-fest"
 
 /**
- * A Spanish postal code: five digits, `PPNNN`, where `PP` is the province (`28001` is Madrid).
+ * A Spanish postcode: five digits, `PPNNN`, where `PP` is the province (`28001` is Madrid).
  *
  * @category Postal
  * @type string
@@ -32,20 +32,38 @@ export type CodigoPostal = Tagged<string, "CodigoPostal">
 export const CODIGO_POSTAL_PATTERN = /^\d{5}$/
 
 /**
- * Narrow a string to a {@link CodigoPostal}, or `null` when it is not one.
+ * Normalize a código-postal surface form to the bare five digits: trim surrounding whitespace (`" 28001 "` →
+ * `"28001"`). Returns null when the result is not a five-digit code.
  */
-export function parseCodigoPostal(input: string): CodigoPostal | null {
-	const s = input.trim()
+export function normalizeCodigoPostal(raw: unknown): CodigoPostal | null {
+	if (typeof raw !== "string") return null
+	const s = raw.trim()
 
 	return CODIGO_POSTAL_PATTERN.test(s) ? (s as CodigoPostal) : null
 }
 
+/**
+ * Type-predicate for a (normalized) Spanish código postal.
+ */
+export function isCodigoPostal(input: unknown): input is CodigoPostal {
+	return typeof input === "string" && CODIGO_POSTAL_PATTERN.test(input)
+}
+
+/**
+ * Narrow a string to a {@link CodigoPostal}, or `null` when it is not one.
+ *
+ * @deprecated Use {@link normalizeCodigoPostal}.
+ */
+export function parseCodigoPostal(input: string): CodigoPostal | null {
+	return normalizeCodigoPostal(input)
+}
+
 /**
  * The two-digit province prefix (`"28001"` → `"28"`), or `null` for a non-postcode. Callers map it through their own
  * province table; this module deliberately does not ship one, since the campaign that needed it only needs the shape.
  */
 export function codigoPostalProvincePrefix(input: string): string | null {
-	const code = parseCodigoPostal(input)
+	const code = normalizeCodigoPostal(input)
 
 	return code ? code.slice(0, 2) : null
 }

package/{es → lib/es}/index.ts

@@ -6,4 +6,4 @@
  *   Spanish (ES) address-system reference data.
  */
 
-export * from "./codigo-postal.ts"
+export * from "#es/codigo-postal"

package/{fr → lib/fr}/cedex.ts

@@ -9,7 +9,7 @@
  *   optionally followed by a 1–2 digit office number. The component is the `CEDEX [NN]` phrase
  *   itself (the schema's `cedex` tag); the preceding postcode/locality keep their own tags.
  *
- *   This slice closes the gap PR #516 documented: the shard builder sourced the shape from SCHEMA.mdx
+ *   This slice closes the gap PR #516 documented: the extract builder sourced the shape from SCHEMA.mdx
  *   prose because codex had no cedex home. Now it does — the builder and any future consumer import
  *   from here (the provenance-first discipline: one provenanced source).
  */

package/{fr → lib/fr}/code-postal.ts

@@ -3,7 +3,7 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   French postal codes (code postal): the branded type, the shape, normalization, and the
+ *   French postcodes (code postal): the branded type, the shape, normalization, and the
  *   first-two-digits → département mapping — the cleanest postcode→admin prior of the three
  *   systems.
  *
@@ -26,11 +26,11 @@
 
 import type { Tagged } from "type-fest"
 
-import { departementInfo, type DepartementCode, type DepartementInfo } from "./departement.ts"
-import { FR_REGIONS, type FrenchRegionInfo } from "./region.ts"
+import { departementInfo, type DepartementCode, type DepartementInfo } from "#fr/departement"
+import { FR_REGIONS, type FrenchRegionInfo } from "#fr/region"
 
 /**
- * A French postal code: five digits (`75008`). Same shape as a US ZIP or a German PLZ — the shape alone does not
+ * A French postcode: five digits (`75008`). Same shape as a US ZIP or a German PLZ — the shape alone does not
  * disambiguate the country.
  *
  * @category Postal
@@ -63,14 +63,14 @@ export function normalizeCodePostal(raw: unknown): CodePostal | null {
 }
 
 /**
- * Type-predicate for a (normalized) French postal code.
+ * Type-predicate for a (normalized) French postcode.
  */
 export function isCodePostal(input: unknown): input is CodePostal {
 	return typeof input === "string" && CODE_POSTAL_PATTERN.test(input)
 }
 
 /**
- * The département code a postal code belongs to. The clean rule plus its two exceptions:
+ * The département code a postcode belongs to. The clean rule plus its two exceptions:
  *
  * - `20xxx` → Corsica. The split is by the rest of the code: roughly `20000`–`20199` → `2A` (Ajaccio side), `20200`+ →
  *   `2B` (Bastia side). Approximate at the boundary, exact for the bulk.
@@ -102,14 +102,14 @@ export function departementOfCodePostal(codePostal: unknown): DepartementCode |
 }
 
 /**
- * The full département record a postal code resolves to (name + région), or null.
+ * The full département record a postcode resolves to (name + région), or null.
  */
 export function departementForCodePostal(codePostal: unknown): DepartementInfo | null {
 	return departementInfo(departementOfCodePostal(codePostal))
 }
 
 /**
- * The région a postal code resolves to, via its département; null if the code maps to no département.
+ * The région a postcode resolves to, via its département; null if the code maps to no département.
  */
 export function regionForCodePostal(codePostal: unknown): FrenchRegionInfo | null {
 	const dep = departementForCodePostal(codePostal)

package/{fr → lib/fr}/departement.ts

@@ -11,7 +11,7 @@
  *   département. This table is therefore the hinge between `code-postal.ts` and `region.ts`.
  */
 
-import type { FrenchRegionCode } from "./region.ts"
+import type { FrenchRegionCode } from "#fr/region"
 
 /**
  * Per-département record: code (2-digit, or `2A`/`2B`, or 3-digit DOM) + name + its région.
@@ -146,7 +146,10 @@ export type DepartementCode = keyof typeof FR_DEPARTEMENTS
 /**
  * Look up a département by code (case-insensitive for the Corsica `2A`/`2B` letters); null if unknown.
  */
-export function departementInfo(code: string | null | undefined): DepartementInfo | null {
+// `unknown`, not `string | null | undefined`: this function's whole job is to answer null for anything that is not a
+// departement code, and its callers hand it values off a CSV row or a JSON body. A narrower parameter did not make
+// those callers safer — it made the test that proves the guard work assert its way past the signature.
+export function departementInfo(code: unknown): DepartementInfo | null {
 	if (!code || typeof code !== "string") return null
 	const key = code.trim().toUpperCase()
 

package/{fr → lib/fr}/index.ts

@@ -3,12 +3,12 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   The French address system (La Poste / ISO 3166-2:FR): street types (voie), postal codes (code
+ *   The French address system (La Poste / ISO 3166-2:FR): street types (voie), postcodes (code
  *   postal), and the admin hierarchy of départements and régions.
  */
 
-export * from "./cedex.ts"
-export * from "./code-postal.ts"
-export * from "./departement.ts"
-export * from "./region.ts"
-export * from "./voie.ts"
+export * from "#fr/cedex"
+export * from "#fr/code-postal"
+export * from "#fr/departement"
+export * from "#fr/region"
+export * from "#fr/voie"

package/{fr → lib/fr}/region.ts

@@ -13,7 +13,7 @@
  *   `code-postal.ts`).
  */
 
-import { foldName } from "../normalize.ts"
+import { foldName } from "#normalize"
 
 /**
  * Per-region record: ISO 3166-2:FR code (sans `FR-` prefix) + French name.

package/{fr → lib/fr}/voie.ts

@@ -17,6 +17,8 @@
  *   {@link isFrenchStreetWord} matches a whole token rather than a suffix.
  */
 
+import { foldToken } from "#normalize"
+
 /**
  * Canonical French voie type → common written abbreviations. The leading word of a French street name. The first entry
  * of each list is the most common abbreviation where one exists.
@@ -65,19 +67,13 @@ export type FrenchVoieType = keyof typeof FR_VOIE_TYPES
  * matching. `Allée`/`allee`/`all` all resolve here.
  */
 const VOIE_TOKEN_SET: ReadonlySet<string> = (() => {
-	const fold = (s: string): string =>
-		s
-			.toLowerCase()
-			.normalize("NFD")
-			.replaceAll(/[\u0300-\u036F]/g, "")
-
 	const out = new Set<string>()
 
 	for (const canonical of Object.keys(FR_VOIE_TYPES) as FrenchVoieType[]) {
-		out.add(fold(canonical))
+		out.add(foldToken(canonical))
 
 		for (const abbr of FR_VOIE_TYPES[canonical]) {
-			out.add(fold(abbr))
+			out.add(foldToken(abbr))
 		}
 	}
 
@@ -92,11 +88,7 @@ const VOIE_TOKEN_SET: ReadonlySet<string> = (() => {
 export function isFrenchStreetWord(token: unknown): boolean {
 	if (typeof token !== "string") return false
 
-	const t = token
-		.toLowerCase()
-		.normalize("NFD")
-		.replaceAll(/[\u0300-\u036F]/g, "")
-		.replaceAll(/[^a-z-]/g, "")
+	const t = foldToken(token).replaceAll(/[^a-z-]/g, "")
 
 	return t.length > 0 && VOIE_TOKEN_SET.has(t)
 }

package/{gb → lib/gb}/country.ts

@@ -14,6 +14,8 @@
  *   postcode is the thing that actually carries the geography.
  */
 
+import { foldName } from "#normalize"
+
 /**
  * Per-country record: ISO 3166-2:GB code (sans `GB-` prefix) + English name.
  */
@@ -52,16 +54,6 @@ export function isUkCountryCode(input: unknown): input is UkCountryCode {
 	return typeof input === "string" && COUNTRY_CODE_SET.has(input.toUpperCase())
 }
 
-/**
- * Lowercase + collapse non-alphanumerics so `Northern Ireland`, `northern-ireland` key alike.
- */
-function foldName(s: string): string {
-	return s
-		.toLowerCase()
-		.replaceAll(/[^a-z0-9]+/g, " ")
-		.trim()
-}
-
 /**
  * Folded country name / code → ISO 3166-2:GB code, so a surface form maps regardless of casing.
  */

package/{gb → lib/gb}/index.ts

@@ -8,7 +8,7 @@
  *   vocabulary.
  */
 
-export * from "./country.ts"
-export * from "./postcode-area.ts"
-export * from "./postcode.ts"
-export * from "./street-type.ts"
+export * from "#gb/country"
+export * from "#gb/postcode-area"
+export * from "#gb/postcode"
+export * from "#gb/street-type"

package/{gb → lib/gb}/postcode-area.ts

@@ -22,7 +22,7 @@
  *   a UK postcode is not a county.
  */
 
-import type { UkCountryCode } from "./country.ts"
+import type { UkCountryCode } from "#gb/country"
 
 /**
  * Northern Ireland is a single postcode area: BT (Belfast).

package/{gb → lib/gb}/street-type.ts

@@ -51,7 +51,7 @@ export const GB_STREET_TYPES = [
 	"vale",
 	"wharf",
 	"yard",
-	"gate",
+	"check",
 	"croft",
 	"dene",
 	"end",