@mailwoman/codex 9.0.0 → 9.2.0

package/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/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

package/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.
  *
@@ -30,7 +30,7 @@ import { departementInfo, type DepartementCode, type DepartementInfo } from "./d
 import { FR_REGIONS, type FrenchRegionInfo } from "./region.ts"
 
 /**
- * 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/index.ts

@@ -3,7 +3,7 @@
  * @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.
  */
 

package/index.ts

@@ -36,5 +36,14 @@ export * as gb from "./gb/index.ts"
 export * as jp from "./jp/index.ts"
 export * as levels from "./level-semantics.ts"
 export * as nz from "./nz/index.ts"
-export { candidateSystemsForPostcode, type SystemCode } from "./postcode-systems.ts"
+
+export {
+	AREA_POSTCODE_FINER_THAN_LOCALITY,
+	areaPostcodeLeadsLocality,
+	candidateSystemsForPostcode,
+	isUnitGradePostcodeHit,
+	type SystemCode,
+	UNIT_GRADE_POSTCODE,
+} from "./postcode-systems.ts"
+
 export * as us from "./us/index.ts"

package/it/cap.ts

@@ -3,7 +3,7 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   Italian postal codes (Codice di Avviamento Postale, CAP): the branded type and the shape.
+ *   Italian postcodes (Codice di Avviamento Postale, CAP): the branded type and the shape.
  *
  *   Five digits like the Spanish, French and German forms, but do NOT infer a province from the
  *   leading digits the way `es/codigo-postal.ts` documents for Spain. Italy's large cities are
@@ -15,7 +15,7 @@
 import type { Tagged } from "type-fest"
 
 /**
- * An Italian postal code: five digits (`00184` is Rome, Rione Monti).
+ * An Italian postcode: five digits (`00184` is Rome, Rione Monti).
  *
  * @category Postal
  * @type string

package/jp/index.ts

@@ -3,7 +3,7 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   The Japanese address system (Japan Post / ISO 3166-2:JP): the 47 prefectures, the postal code
+ *   The Japanese address system (Japan Post / ISO 3166-2:JP): the 47 prefectures, the postcode
  *   that is the country's most reliable geographic anchor, and the address-unit markers that stand
  *   in for the street names Japan does not use.
  */

package/jp/postal-code.ts

@@ -3,7 +3,7 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   Japanese postal codes (郵便番号, yūbin-bangō): the branded type, the shape, normalization, and the
+ *   Japanese postcodes (郵便番号, yūbin-bangō): the branded type, the shape, normalization, and the
  *   first-digit → coarse-region prior.
  *
  *   This file is the far end of a spectrum whose other end is `us/zipcode.ts`. A US address leans on
@@ -16,7 +16,7 @@
  *       navigate by named streets; you navigate by nested administrative areas and numbered
  *       blocks/lots (丁目 / 番地 / 号 — see `address-unit.ts`).
  *
- *   With no street name to anchor on and a reverse field order, the **postal code is the single most
+ *   With no street name to anchor on and a reverse field order, the **postcode is the single most
  *   reliable geographic anchor** for a Japanese address — it pins the chōme-level area directly,
  *   far tighter than a US ZIP pins a US address. So where the US parser treats the postcode as a
  *   tie-breaker behind the street, the Japan parser should treat it as the primary key.
@@ -25,9 +25,9 @@
 import type { Tagged } from "type-fest"
 
 /**
- * A Japanese postal code: three digits, a hyphen, then four digits (`100-0001`), conventionally written after the 〒
- * mark (`〒100-0001`). Branded so a normalized code is distinct from an arbitrary string — the 7-digit shape alone does
- * not prove a code is real, only well-formed.
+ * A Japanese postcode: three digits, a hyphen, then four digits (`100-0001`), conventionally written after the 〒 mark
+ * (`〒100-0001`). Branded so a normalized code is distinct from an arbitrary string — the 7-digit shape alone does not
+ * prove a code is real, only well-formed.
  *
  * @category Postal
  * @type string
@@ -57,17 +57,17 @@ export function normalizeJpPostalCode(raw: unknown): PostalCode | null {
 }
 
 /**
- * Type-predicate for a Japanese postal code (hyphen optional, `100-0001` or `1000001`).
+ * Type-predicate for a Japanese postcode (hyphen optional, `100-0001` or `1000001`).
  */
 export function isJpPostalCode(input: unknown): input is PostalCode {
 	return typeof input === "string" && JP_POSTAL_CODE_PATTERN.test(input)
 }
 
 /**
- * First digit of the postal code → a coarse region label. Japan Post's numbering grows roughly outward from Tokyo
- * (`1xx`) and is **approximate** at this granularity — a single leading digit spans large, irregular areas and the
- * boundaries are postal-routing, not administrative. Use it as a weak prior, never as a hard region assignment; the
- * full code is what actually anchors the address.
+ * First digit of the postcode → a coarse region label. Japan Post's numbering grows roughly outward from Tokyo (`1xx`)
+ * and is **approximate** at this granularity — a single leading digit spans large, irregular areas and the boundaries
+ * are postal-routing, not administrative. Use it as a weak prior, never as a hard region assignment; the full code is
+ * what actually anchors the address.
  *
  * Approximate — the labels below are illustrative routing regions, not precise prefecture sets.
  */
@@ -85,7 +85,7 @@ export const JP_FIRST_DIGIT_REGION: Record<string, string> = {
 }
 
 /**
- * The coarse region label for a postal code's first digit, or null if the input is not a Japanese postal code. A weak,
+ * The coarse region label for a postcode's first digit, or null if the input is not a Japanese postcode. A weak,
  * approximate prior (see {@link JP_FIRST_DIGIT_REGION}); the full code anchors the address.
  */
 export function firstDigitRegion(postalCode: unknown): string | null {

package/out/ca/index.d.ts

@@ -4,7 +4,7 @@
  * @author Teffen Ellis, et al.
  *
  *   The Canadian address system (Canada Post / ISO 3166-2:CA): bilingual street types, alphanumeric
- *   postal codes, and the provinces and territories.
+ *   postcodes, and the provinces and territories.
  */
 export * from "./postal-code.ts";
 export * from "./province.ts";

package/out/ca/index.js

@@ -4,7 +4,7 @@
  * @author Teffen Ellis, et al.
  *
  *   The Canadian address system (Canada Post / ISO 3166-2:CA): bilingual street types, alphanumeric
- *   postal codes, and the provinces and territories.
+ *   postcodes, and the provinces and territories.
  */
 export * from "./postal-code.js";
 export * from "./province.js";

package/out/ca/postal-code.d.ts

@@ -3,7 +3,7 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   Canadian postal codes: the branded type, the shape, normalization, and the FSA-letter →
+ *   Canadian postcodes: the branded type, the shape, normalization, and the FSA-letter →
  *   province/territory prior — the only ALPHANUMERIC postcode of the systems the codex models.
  *
  *   The informative contrast across `us/zipcode.ts`, `de/postleitzahl.ts`, `fr/code-postal.ts`, and
@@ -12,7 +12,7 @@
  *   - A US ZIP is numeric; its first digit maps to a loose BAND of states.
  *   - A German PLZ is numeric; its first digit maps to a Leitzone that CROSSES Bundesland borders.
  *   - A French code postal is numeric; its first TWO digits ARE the département.
- *   - A Canadian postal code is `A1A 1A1` — Letter Digit Letter, then Digit Letter Digit — and its
+ *   - A Canadian postcode is `A1A 1A1` — Letter Digit Letter, then Digit Letter Digit — and its
  *       first LETTER pins the province or territory directly (`M` → Ontario, `H` → Quebec, `V` →
  *       British Columbia). So like the French prefix it is a clean admin prior, but it does the job
  *       with a single ALPHA character rather than digits.
@@ -27,13 +27,13 @@
 import type { Tagged } from "type-fest";
 import type { CanadianProvinceCode } from "./province.ts";
 /**
- * A Canadian postal code: `A1A 1A1`. Six alphanumeric characters in a strict Letter-Digit-Letter-Digit-Letter-Digit
+ * A Canadian postcode: `A1A 1A1`. Six alphanumeric characters in a strict Letter-Digit-Letter-Digit-Letter-Digit
  * pattern, conventionally written with a single space after the third. Unlike the other systems' bare five digits, the
  * shape alone already says "Canada".
  *
  * @category Postal
  * @type string
- * @title Postal Code
+ * @title Postcode
  * @pattern ^[ABCEGHJ-NPRSTVXY]\d[ABCEGHJ-NPRSTV-Z] ?\d[ABCEGHJ-NPRSTV-Z]\d$
  */
 export type PostalCode = Tagged<string, "CaPostalCode">;
@@ -46,11 +46,11 @@ export declare const CA_POSTAL_CODE_PATTERN: RegExp;
 /**
  * Normalize a postal-code surface form to canonical `A1A 1A1`: uppercase and ensure exactly one space between the FSA
  * (first three chars) and the LDU (last three) — `K1A0B1` → `K1A 0B1`, `k1a 0b1` → `K1A 0B1`. Returns null if the input
- * is not a valid Canadian postal code.
+ * is not a valid Canadian postcode.
  */
 export declare function normalizeCaPostalCode(raw: unknown): PostalCode | null;
 /**
- * Type-predicate for a Canadian postal code (accepts the spaced or unspaced surface form).
+ * Type-predicate for a Canadian postcode (accepts the spaced or unspaced surface form).
  */
 export declare function isCaPostalCode(input: unknown): input is PostalCode;
 /**
@@ -60,13 +60,13 @@ export declare function isCaPostalCode(input: unknown): input is PostalCode;
  */
 export declare const FSA_LETTER_TO_PROVINCE: Record<string, CanadianProvinceCode | CanadianProvinceCode[]>;
 /**
- * The province/territory a postal code belongs to, via its FSA first letter. Returns the single code for the clean
- * letters, the `["NT", "NU"]` pair for the shared `X`, and null if the input is not a valid Canadian postal code (or
- * its first letter has no province, which the pattern already forbids).
+ * The province/territory a postcode belongs to, via its FSA first letter. Returns the single code for the clean
+ * letters, the `["NT", "NU"]` pair for the shared `X`, and null if the input is not a valid Canadian postcode (or its
+ * first letter has no province, which the pattern already forbids).
  */
 export declare function provinceOfPostalCode(postalCode: unknown): CanadianProvinceCode | CanadianProvinceCode[] | null;
 /**
- * True when a postal code is RURAL: its SECOND character (the FSA's first digit) is `0`. Canada Post uses a `0` in that
+ * True when a postcode is RURAL: its SECOND character (the FSA's first digit) is `0`. Canada Post uses a `0` in that
  * position to mark the lower-density delivery zones (rural routes, small communities) — the contrast with the urban
  * `1`–`9` FSAs. Returns false for a non-code.
  */

package/out/ca/postal-code.js

@@ -3,7 +3,7 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   Canadian postal codes: the branded type, the shape, normalization, and the FSA-letter →
+ *   Canadian postcodes: the branded type, the shape, normalization, and the FSA-letter →
  *   province/territory prior — the only ALPHANUMERIC postcode of the systems the codex models.
  *
  *   The informative contrast across `us/zipcode.ts`, `de/postleitzahl.ts`, `fr/code-postal.ts`, and
@@ -12,7 +12,7 @@
  *   - A US ZIP is numeric; its first digit maps to a loose BAND of states.
  *   - A German PLZ is numeric; its first digit maps to a Leitzone that CROSSES Bundesland borders.
  *   - A French code postal is numeric; its first TWO digits ARE the département.
- *   - A Canadian postal code is `A1A 1A1` — Letter Digit Letter, then Digit Letter Digit — and its
+ *   - A Canadian postcode is `A1A 1A1` — Letter Digit Letter, then Digit Letter Digit — and its
  *       first LETTER pins the province or territory directly (`M` → Ontario, `H` → Quebec, `V` →
  *       British Columbia). So like the French prefix it is a clean admin prior, but it does the job
  *       with a single ALPHA character rather than digits.
@@ -25,7 +25,7 @@
  *   the bridge to the wider, lower-density delivery zones.
  */
 /**
- * Characters in a Canadian postal code once spaces are stripped: `A1A1A1`.
+ * Characters in a Canadian postcode once spaces are stripped: `A1A1A1`.
  */
 const POSTAL_CODE_LENGTH = 6;
 /**
@@ -37,7 +37,7 @@ export const CA_POSTAL_CODE_PATTERN = /^[ABCEGHJ-NPRSTVXY]\d[ABCEGHJ-NPRSTV-Z] ?
 /**
  * Normalize a postal-code surface form to canonical `A1A 1A1`: uppercase and ensure exactly one space between the FSA
  * (first three chars) and the LDU (last three) — `K1A0B1` → `K1A 0B1`, `k1a 0b1` → `K1A 0B1`. Returns null if the input
- * is not a valid Canadian postal code.
+ * is not a valid Canadian postcode.
  */
 export function normalizeCaPostalCode(raw) {
     if (typeof raw !== "string")
@@ -49,7 +49,7 @@ export function normalizeCaPostalCode(raw) {
     return CA_POSTAL_CODE_PATTERN.test(spaced) ? spaced : null;
 }
 /**
- * Type-predicate for a Canadian postal code (accepts the spaced or unspaced surface form).
+ * Type-predicate for a Canadian postcode (accepts the spaced or unspaced surface form).
  */
 export function isCaPostalCode(input) {
     return typeof input === "string" && CA_POSTAL_CODE_PATTERN.test(input);
@@ -80,9 +80,9 @@ export const FSA_LETTER_TO_PROVINCE = {
     Y: "YT",
 };
 /**
- * The province/territory a postal code belongs to, via its FSA first letter. Returns the single code for the clean
- * letters, the `["NT", "NU"]` pair for the shared `X`, and null if the input is not a valid Canadian postal code (or
- * its first letter has no province, which the pattern already forbids).
+ * The province/territory a postcode belongs to, via its FSA first letter. Returns the single code for the clean
+ * letters, the `["NT", "NU"]` pair for the shared `X`, and null if the input is not a valid Canadian postcode (or its
+ * first letter has no province, which the pattern already forbids).
  */
 export function provinceOfPostalCode(postalCode) {
     const normalized = normalizeCaPostalCode(postalCode);
@@ -91,7 +91,7 @@ export function provinceOfPostalCode(postalCode) {
     return FSA_LETTER_TO_PROVINCE[normalized[0]] ?? null;
 }
 /**
- * True when a postal code is RURAL: its SECOND character (the FSA's first digit) is `0`. Canada Post uses a `0` in that
+ * True when a postcode is RURAL: its SECOND character (the FSA's first digit) is `0`. Canada Post uses a `0` in that
  * position to mark the lower-density delivery zones (rural routes, small communities) — the contrast with the urban
  * `1`–`9` FSAs. Returns false for a non-code.
  */

package/out/country/display-names.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Country surface forms across scripts, enumerated from the RUNTIME's own ICU via `Intl.DisplayNames`.
+ *
+ *   The gazetteer holds country names in English and little else, which is why a bare `格鲁吉亚` (Georgia the country,
+ *   Chinese), `沙特阿拉伯` or `巴布亚新几内亚` resolves to nothing while `佐治亚州` (Georgia the US state) resolves
+ *   correctly — the state is a real WOF record carrying multilingual names, and 140 of the 237 country rows are
+ *   synthetic and carry only a canonical English name. Measured 2026-08-15; WOF has no Chinese country names at all,
+ *   and `geonames-aliases.ts` filters every alias through a Latin-script regex.
+ *
+ *   ICU already knows all of it. No download, no vendored corpus, no licence question, and no drift against a snapshot
+ *   we would otherwise have to refresh: the names come from the same ICU the runtime uses for every other
+ *   locale-sensitive operation. Measured coverage at time of writing: **280 regions, 5,244 distinct surfaces** across
+ *   the locale × style grid below.
+ *
+ *   This module ENUMERATES. It does not decide what the gazetteer stores — see the candidate build for that, and note
+ *   that a surface here is a NAME THE WORLD USES, never an authority's designation.
+ */
+/**
+ * The locales whose display names are enumerated. Chosen for script coverage rather than speaker count: each entry
+ * either contributes a distinct script (Han simplified/traditional, Kana, Hangul, Arabic, Cyrillic, Devanagari, Hebrew,
+ * Greek, Thai) or a major Latin-script exonym set that diverges from English.
+ *
+ * Adding a locale is additive and safe — surfaces are deduplicated — but every addition grows the candidate table, so
+ * it earns its place by contributing surfaces a user would plausibly type.
+ */
+export declare const DISPLAY_NAME_LOCALES: readonly ["en", "zh-Hans", "zh-Hant", "ja", "ko", "ar", "ru", "es", "fr", "de", "hi", "pt", "it", "nl", "pl", "tr", "vi", "th", "id", "fa", "he", "uk", "sv", "el"];
+/**
+ * `long` is the ordinary name, `short` supplies the abbreviations people actually type (`UK`, `US`, `アメリカ`), and
+ * `narrow` occasionally differs again. All three are enumerated because the query register is whatever the user wrote.
+ */
+export declare const DISPLAY_NAME_STYLES: readonly ["long", "short", "narrow"];
+/**
+ * One country surface and where it came from.
+ */
+export interface CountryDisplayName {
+    /**
+     * ISO 3166-1 alpha-2.
+     */
+    iso2: string;
+    /**
+     * The surface as ICU renders it, unmodified — normalisation is the consumer's job, and the raw form is what a
+     * provenance record needs to be auditable.
+     */
+    name: string;
+    /**
+     * BCP-47 tag this surface came from. Carried so a consumer can scope by locale rather than accepting every script for
+     * every query.
+     */
+    locale: string;
+}
+/**
+ * Enumerate every AA–ZZ code against the locale × style grid, keeping what ICU recognises.
+ *
+ * Deduplicated per (iso2, name): the same surface reached from several locales is one row, and the FIRST locale that
+ * produced it wins the attribution — deterministic because {@link DISPLAY_NAME_LOCALES} is ordered.
+ */
+export declare function enumerateCountryDisplayNames(locales?: readonly string[]): Generator<CountryDisplayName>;
+/**
+ * Every surface ICU knows for one country. Convenience over {@link enumerateCountryDisplayNames} for a single lookup;
+ * the generator is the bulk path.
+ */
+export declare function countryDisplayNames(iso2: string, locales?: readonly string[]): string[];
+//# sourceMappingURL=display-names.d.ts.map

package/out/country/display-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"display-names.d.ts","sourceRoot":"","sources":["../../country/display-names.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,qKAyBvB,CAAA;AAEV;;;GAGG;AACH,eAAO,MAAM,mBAAmB,sCAAuC,CAAA;AAEvE;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC;;OAEG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAA;CACd;AAiBD;;;;;GAKG;AACH,wBAAiB,4BAA4B,CAC5C,OAAO,GAAE,SAAS,MAAM,EAAyB,GAC/C,SAAS,CAAC,kBAAkB,CAAC,CAiC/B;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAIvF"}

package/out/country/display-names.js

@@ -0,0 +1,118 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Country surface forms across scripts, enumerated from the RUNTIME's own ICU via `Intl.DisplayNames`.
+ *
+ *   The gazetteer holds country names in English and little else, which is why a bare `格鲁吉亚` (Georgia the country,
+ *   Chinese), `沙特阿拉伯` or `巴布亚新几内亚` resolves to nothing while `佐治亚州` (Georgia the US state) resolves
+ *   correctly — the state is a real WOF record carrying multilingual names, and 140 of the 237 country rows are
+ *   synthetic and carry only a canonical English name. Measured 2026-08-15; WOF has no Chinese country names at all,
+ *   and `geonames-aliases.ts` filters every alias through a Latin-script regex.
+ *
+ *   ICU already knows all of it. No download, no vendored corpus, no licence question, and no drift against a snapshot
+ *   we would otherwise have to refresh: the names come from the same ICU the runtime uses for every other
+ *   locale-sensitive operation. Measured coverage at time of writing: **280 regions, 5,244 distinct surfaces** across
+ *   the locale × style grid below.
+ *
+ *   This module ENUMERATES. It does not decide what the gazetteer stores — see the candidate build for that, and note
+ *   that a surface here is a NAME THE WORLD USES, never an authority's designation.
+ */
+/**
+ * The locales whose display names are enumerated. Chosen for script coverage rather than speaker count: each entry
+ * either contributes a distinct script (Han simplified/traditional, Kana, Hangul, Arabic, Cyrillic, Devanagari, Hebrew,
+ * Greek, Thai) or a major Latin-script exonym set that diverges from English.
+ *
+ * Adding a locale is additive and safe — surfaces are deduplicated — but every addition grows the candidate table, so
+ * it earns its place by contributing surfaces a user would plausibly type.
+ */
+export const DISPLAY_NAME_LOCALES = [
+    "en",
+    "zh-Hans",
+    "zh-Hant",
+    "ja",
+    "ko",
+    "ar",
+    "ru",
+    "es",
+    "fr",
+    "de",
+    "hi",
+    "pt",
+    "it",
+    "nl",
+    "pl",
+    "tr",
+    "vi",
+    "th",
+    "id",
+    "fa",
+    "he",
+    "uk",
+    "sv",
+    "el",
+];
+/**
+ * `long` is the ordinary name, `short` supplies the abbreviations people actually type (`UK`, `US`, `アメリカ`), and
+ * `narrow` occasionally differs again. All three are enumerated because the query register is whatever the user wrote.
+ */
+export const DISPLAY_NAME_STYLES = ["long", "short", "narrow"];
+/**
+ * Two-letter sequences that are not ISO 3166-1 regions. `Intl.DisplayNames.of` echoes its input for an unknown code, so
+ * the echo IS the miss signal — no separate region list to keep in sync.
+ */
+/**
+ * The AA–ZZ sweep bounds. ISO 3166-1 alpha-2 is exactly two uppercase ASCII letters, so enumerating the whole square
+ * and keeping what ICU recognises avoids carrying a region list that would need its own upkeep.
+ */
+const ASCII_A = 65;
+const ASCII_Z = 90;
+function isEcho(code, rendered) {
+    return !rendered || rendered === code;
+}
+/**
+ * Enumerate every AA–ZZ code against the locale × style grid, keeping what ICU recognises.
+ *
+ * Deduplicated per (iso2, name): the same surface reached from several locales is one row, and the FIRST locale that
+ * produced it wins the attribution — deterministic because {@link DISPLAY_NAME_LOCALES} is ordered.
+ */
+export function* enumerateCountryDisplayNames(locales = DISPLAY_NAME_LOCALES) {
+    const formatters = locales.flatMap((locale) => DISPLAY_NAME_STYLES.map((style) => {
+        try {
+            return { locale, formatter: new Intl.DisplayNames([locale], { type: "region", style }) };
+        }
+        catch {
+            // A runtime without this locale's data degrades to fewer surfaces, never to an error.
+            return undefined;
+        }
+    }).filter((f) => f !== null && f !== undefined));
+    for (let a = ASCII_A; a <= ASCII_Z; a++) {
+        for (let b = ASCII_A; b <= ASCII_Z; b++) {
+            const iso2 = String.fromCharCode(a, b);
+            const seen = new Set();
+            for (const { locale, formatter } of formatters) {
+                let rendered;
+                try {
+                    rendered = formatter.of(iso2);
+                }
+                catch {
+                    continue;
+                }
+                if (isEcho(iso2, rendered) || seen.has(rendered))
+                    continue;
+                seen.add(rendered);
+                yield { iso2, name: rendered, locale };
+            }
+        }
+    }
+}
+/**
+ * Every surface ICU knows for one country. Convenience over {@link enumerateCountryDisplayNames} for a single lookup;
+ * the generator is the bulk path.
+ */
+export function countryDisplayNames(iso2, locales) {
+    const upper = iso2.toUpperCase();
+    return [...enumerateCountryDisplayNames(locales)].filter((n) => n.iso2 === upper).map((n) => n.name);
+}
+//# sourceMappingURL=display-names.js.map

package/out/country/display-names.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"display-names.js","sourceRoot":"","sources":["../../country/display-names.ts"],"names":[],"mappings":"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"}

package/out/country/index.d.ts

@@ -7,8 +7,10 @@
  */
 export * from "./codes.ts";
 export * from "./country.ts";
+export * from "./display-names.ts";
 export * from "./names.ts";
 export * from "./official-languages.ts";
+export * from "./population.ts";
 export * from "./reference-data.ts";
 export * from "./reference.ts";
 export * from "./subdivision.ts";

package/out/country/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../country/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAC1B,cAAc,yBAAyB,CAAA;AACvC,cAAc,qBAAqB,CAAA;AACnC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../country/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,oBAAoB,CAAA;AAClC,cAAc,YAAY,CAAA;AAC1B,cAAc,yBAAyB,CAAA;AACvC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,qBAAqB,CAAA;AACnC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,kBAAkB,CAAA"}

package/out/country/index.js

@@ -7,8 +7,10 @@
  */
 export * from "./codes.js";
 export * from "./country.js";
+export * from "./display-names.js";
 export * from "./names.js";
 export * from "./official-languages.js";
+export * from "./population.js";
 export * from "./reference-data.js";
 export * from "./reference.js";
 export * from "./subdivision.js";

package/out/country/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../country/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAC1B,cAAc,yBAAyB,CAAA;AACvC,cAAc,qBAAqB,CAAA;AACnC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../country/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,oBAAoB,CAAA;AAClC,cAAc,YAAY,CAAA;AAC1B,cAAc,yBAAyB,CAAA;AACvC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,qBAAqB,CAAA;AACnC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,kBAAkB,CAAA"}

package/out/country/population.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @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 declare const COUNTRY_POPULATION: Readonly<Record<string, number>>;
+//# sourceMappingURL=population.d.ts.map

package/out/country/population.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"population.d.ts","sourceRoot":"","sources":["../../country/population.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAyP/D,CAAA"}