@mailwoman/corpus 7.2.0 → 7.3.0

package/src/synthesize-no-street.ts

@@ -0,0 +1,341 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   No-street address synthesizer — the counter-distribution that v0.6.1's synth-street shard is
+ *   missing. Generates BIO-labelable rows where there is NO street, NO house_number, NO
+ *   street_prefix, NO street_suffix, NO intersection — only some subset of {venue, locality,
+ *   region, postcode, country}.
+ *
+ *   Rationale: the [2026-05-28 night-2
+ *   postmortem](../../docs/articles/evals/night-shifts/2026-05-28-night-2-postmortem.md) and the [layer-1
+ *   eval](../../docs/articles/evals/experiments/2026-05-28-layer-1-morphology-fst.md) showed that synth-street
+ *   pushed the model into a high-confidence "decompose mode" that leaked into `dependent_locality`.
+ *   Per DeepSeek's turn-2 recipe, the model needs explicit counter-examples: addresses where the
+ *   model should NOT emit street labels. This synthesizer is that source.
+ *
+ *   Six row templates, each producing a {raw, components} pair with no street-side tags:
+ *
+ *   1. **Plain venue + locality + region + postcode** `"Bob's Pizza, Boston, MA 02101"`
+ *   2. **Adversarial venue (containing street-typing words)** `"Wall Street Industries, NY 10005"`,
+ *        `"5th Avenue Theater, Seattle, WA"`, `"Highway 61 Diner, Memphis TN"`. These are the rows
+ *        that v0.6.1's decompose-mode would mis-tag as street_prefix/suffix; explicit negative
+ *        training kills that signal.
+ *   3. **Locality + region + postcode (minimal)** — `"Boston, MA 02101"`
+ *   4. **Locality + region** — `"Boston, MA"`
+ *   5. **Postcode-only** — `"02101"`
+ *   6. **Country-only** — `"United States"`, `"France"` (rare in real data, but the model has seen these
+ *        and should not hallucinate streets on them).
+ *
+ *   Output is a `CanonicalRow` with no street-side components. Alignment will produce BIO labels
+ *   where every token is one of {`B-venue`, `I-venue`, `B-locality`, `I-locality`, `B-region`,
+ *   `B-postcode`, `B-country`, `I-country`, `O`} — explicitly never any street tag. That IS the
+ *   counter-example signal the model is missing.
+ *
+ *   This complements (does not replace) the existing US-base-tuple source used by
+ *   `synthesize-po-box.ts`; the same `NoStreetBaseTuple` shape is consumed.
+ */
+
+import type { CanonicalRow } from "./types.ts"
+
+// -------------------------------------------------------------------------------------------------
+// Types
+// -------------------------------------------------------------------------------------------------
+
+export interface NoStreetBaseTuple {
+	locality: string
+	region: string
+	postcode: string
+	country: string
+}
+
+export type NoStreetTemplate =
+	| "venue-plain"
+	| "venue-adversarial"
+	| "locality-region-postcode"
+	| "locality-region"
+	| "postcode-only"
+	| "country-only"
+
+export interface NoStreetSynthesisOpts {
+	random?: () => number
+	/** Override the template selection entirely (used by tests for deterministic coverage). */
+	forceTemplate?: NoStreetTemplate
+}
+
+export interface SynthesizedNoStreetRow {
+	raw: string
+	components: CanonicalRow["components"]
+	locale: string
+	template: NoStreetTemplate
+}
+
+// -------------------------------------------------------------------------------------------------
+// Venue name pools
+// -------------------------------------------------------------------------------------------------
+
+/**
+ * Plain venue names — businesses without street-typing words in the name. Used as the easy-mode positive class for
+ * venue detection.
+ */
+const PLAIN_VENUES: ReadonlyArray<string> = [
+	"Bob's Pizza",
+	"Acme Corporation",
+	"Joe's Diner",
+	"Sunrise Bakery",
+	"Maple Leaf Cafe",
+	"Riverside Garden Center",
+	"Tech Solutions Inc",
+	"Pacific Industries",
+	"Atlantic Holdings",
+	"Stellar Consulting",
+	"Greenfield Partners",
+	"Mountain View Studio",
+	"The Daily Grind",
+	"Sunset Bistro",
+	"Harvest Moon Florist",
+	"Iron Forge Brewing",
+	"Crescent City Bookstore",
+	"Lighthouse Insurance Group",
+	"Pinecrest Veterinary",
+	"Westwood Realty",
+]
+
+/**
+ * Adversarial venue names — businesses whose names contain street-typing tokens (Avenue, Street, Highway, Lane, Drive,
+ * Court, Plaza, Park, ...) but are themselves venues, not streets. The model must learn that these are venues despite
+ * the street-typing tokens.
+ *
+ * **No leading digit+ordinal venues** (e.g. "5th Avenue Theatre", "7th Street Bistro"). The v0.6.2 2026-05-29 step-20K
+ * eval showed that synthesized rows starting with `<digits><ordinal>` confused the model about house_number recognition
+ * — tokens like "5th" (which should be `B-house_number` in real addresses) were being labeled `B-venue` because
+ * adversarial venues placed them in venue position. v0.6.3 omits these patterns; the `synth-house-venue` shard
+ * separately teaches that house_number and venue coexist.
+ */
+const ADVERSARIAL_VENUES: ReadonlyArray<string> = [
+	"Wall Street Industries",
+	"Highway 61 Diner",
+	"Lane Bryant",
+	"Park Avenue Dental",
+	"Broadway Theatre Company",
+	"Madison Square Garden",
+	"Main Street Bakery",
+	"Sunset Boulevard Studios",
+	"Ocean Drive Cafe",
+	"Mountain Road Outfitters",
+	"Hollywood Boulevard Salon",
+	"East Bay Auto",
+	"West End Pharmacy",
+	"North Shore Insurance",
+	"South Park Children's Center",
+	"River Road Animal Hospital",
+	"Hill Street Blues Bar",
+	"Court House Square Realty",
+	"Plaza Hotel",
+	"Lincoln Park Zoo",
+	"Central Park Conservancy",
+	"Lakeshore Boulevard Apartments",
+	"Memorial Drive Medical Center",
+	"Wabash Avenue Press",
+	"State Street Bank",
+	"Market Street Grill",
+	"Beach Boulevard Diner",
+	"Garden Lane Florist",
+]
+
+// Compile-time guard: every venue must NOT start with the digit+ordinal pattern that
+// confuses house_number recognition. If a future contributor adds a "5th Avenue Theatre"-
+// style entry, this assertion will fire at module load time.
+for (const v of ADVERSARIAL_VENUES) {
+	if (/^\d+(st|nd|rd|th)\b/i.test(v)) {
+		throw new Error(
+			`ADVERSARIAL_VENUES entry "${v}" starts with digit+ordinal; this pattern confuses ` +
+				`house_number recognition (see v0.6.3 eval doc). Use a non-numeric venue name.`
+		)
+	}
+}
+
+const COUNTRY_NAMES = new Map<string, ReadonlyArray<string>>([
+	["US", ["United States", "USA", "U.S.A.", "United States of America"]],
+	["FR", ["France"]],
+	["DE", ["Germany", "Deutschland"]],
+	["GB", ["United Kingdom", "UK", "Great Britain"]],
+	["CA", ["Canada"]],
+	["AU", ["Australia"]],
+])
+
+// -------------------------------------------------------------------------------------------------
+// Synthesis
+// -------------------------------------------------------------------------------------------------
+
+function pick<T>(arr: ReadonlyArray<T>, random: () => number): T {
+	return arr[Math.floor(random() * arr.length)]!
+}
+
+function countryToLocale(country: string): string {
+	switch (country) {
+		case "US":
+			return "en-US"
+		case "CA":
+			return "en-CA"
+		case "GB":
+			return "en-GB"
+		case "AU":
+			return "en-AU"
+		case "FR":
+			return "fr-FR"
+		case "DE":
+			return "de-DE"
+		default:
+			return "en-US"
+	}
+}
+
+/**
+ * Generate one no-street counter-example row for a base (locality, region, postcode, country) tuple. Picks a template
+ * by weighted random; the venue templates are the critical counter-distribution against synth-street's decompose-mode
+ * pressure.
+ */
+export function synthesizeNoStreetRow(
+	base: NoStreetBaseTuple,
+	opts: NoStreetSynthesisOpts = {}
+): SynthesizedNoStreetRow | null {
+	const random = opts.random ?? Math.random
+	const locale = countryToLocale(base.country)
+
+	const template: NoStreetTemplate = opts.forceTemplate ?? pickTemplate(random)
+
+	switch (template) {
+		case "venue-plain": {
+			const venue = pick(PLAIN_VENUES, random)
+			const raw = `${venue}, ${base.locality}, ${base.region} ${base.postcode}`
+
+			return {
+				raw,
+				components: {
+					venue,
+					locality: base.locality,
+					region: base.region,
+					postcode: base.postcode,
+				},
+				locale,
+				template,
+			}
+		}
+		case "venue-adversarial": {
+			// The venue-adversarial template name is descriptive — when selected, this branch
+			// always draws from the adversarial pool. The `adversarialVenueRatio` opt is what
+			// the OUTER template picker uses to bias toward this template versus the plain one;
+			// once we're inside this branch the choice is already made.
+			const venue = pick(ADVERSARIAL_VENUES, random)
+			const raw = `${venue}, ${base.locality}, ${base.region} ${base.postcode}`
+
+			return {
+				raw,
+				components: {
+					venue,
+					locality: base.locality,
+					region: base.region,
+					postcode: base.postcode,
+				},
+				locale,
+				template,
+			}
+		}
+		case "locality-region-postcode": {
+			const raw = `${base.locality}, ${base.region} ${base.postcode}`
+
+			return {
+				raw,
+				components: {
+					locality: base.locality,
+					region: base.region,
+					postcode: base.postcode,
+				},
+				locale,
+				template,
+			}
+		}
+		case "locality-region": {
+			const raw = `${base.locality}, ${base.region}`
+
+			return {
+				raw,
+				components: {
+					locality: base.locality,
+					region: base.region,
+				},
+				locale,
+				template,
+			}
+		}
+		case "postcode-only": {
+			return {
+				raw: base.postcode,
+				components: { postcode: base.postcode },
+				locale,
+				template,
+			}
+		}
+		case "country-only": {
+			const names = COUNTRY_NAMES.get(base.country) ?? [base.country]
+			const country = pick(names, random)
+
+			return {
+				raw: country,
+				components: { country },
+				locale,
+				template,
+			}
+		}
+	}
+}
+
+/**
+ * Template weights chosen so that the venue-* templates dominate (they're the counter-example shape that matters), with
+ * the minimal templates as long-tail noise.
+ */
+function pickTemplate(random: () => number): NoStreetTemplate {
+	const r = random()
+
+	if (r < 0.35) return "venue-adversarial"
+
+	// 35% — the critical slice
+	if (r < 0.6) return "venue-plain"
+
+	// 25%
+	if (r < 0.8) return "locality-region-postcode"
+
+	// 20%
+	if (r < 0.92) return "locality-region"
+
+	// 12%
+	if (r < 0.98) return "postcode-only"
+
+	// 6%
+	return "country-only" // 2%
+}
+
+/**
+ * Convenience: assert at type-level that a synthesized row carries no street-side components. Used by tests +
+ * downstream consumers who want to verify the contract at runtime.
+ */
+export const STREET_SIDE_TAGS = [
+	"street",
+	"street_prefix",
+	"street_prefix_particle",
+	"street_suffix",
+	"house_number",
+	"intersection_a",
+	"intersection_b",
+	"unit",
+] as const
+
+export function hasAnyStreetSideTag(components: CanonicalRow["components"]): boolean {
+	for (const t of STREET_SIDE_TAGS) {
+		if (components[t]) return true
+	}
+
+	return false
+}

package/src/synthesize-po-box.ts

@@ -0,0 +1,307 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   PO box / PMB / Apartado / Boîte Postale synthesizer.
+ *
+ *   Generates BIO-labeled corpus rows where the delivery line is a PO box (mutually exclusive with
+ *   street + house_number per USPS Pub 28 / DMM 508). Locale-aware: emits idiomatic forms for
+ *   en-US, en-CA, en-GB, en-AU, fr-FR, fr-CA, es-ES, es-MX, es-AR.
+ *
+ *   Per-DeepSeek design:
+ *
+ *   - PMB ("Private Mailbox" — at CMRAs like UPS Store) shares the `po_box` tag with USPS PO Box.
+ *       Disambiguation is a downstream heuristic (presence of a street line).
+ *   - Whole-phrase span ("PO Box 123") not number-only ("123"). Matches existing golden eval.
+ *   - 10% of outputs receive number-format noise (commas, dashes, embedded spaces) to harden against
+ *       real-world OCR/transcription input.
+ *   - PO boxes drop street/house_number/unit/street_prefix/street_suffix from input components.
+ *
+ *   References:
+ *
+ *   - USPS Pub 28 §28C2.040 — Private Mailbox formatting
+ *   - USPS DMM 508 §4.1.4 / §4.5.4 — PO Box and street-addressed PO Box
+ */
+
+import type { CanonicalRow } from "./types.ts"
+
+export interface PoBoxBaseTuple {
+	locality: string
+	region: string
+	postcode: string
+	country: string
+}
+
+export interface LocaleTemplate {
+	locale: string
+	leaders: ReadonlyArray<string>
+	// Use 'pmb' to render as "STREET, PMB N, CITY ..." instead of replacing the street line.
+	pmb?: ReadonlyArray<string>
+}
+
+/**
+ * The per-locale PO-box designator vocabulary (DeepSeek-signed list, see the header). Exported so shard builders
+ * (scripts/build-po-box-cedex-shard.mjs) can reuse THIS list as the single source of truth for non-US leaders instead
+ * of re-deriving it — the US slice additionally has `@mailwoman/codex/us` `US_PO_BOX_DESIGNATORS`/`isPOBox` as its
+ * matcher-side truth.
+ */
+export const PO_BOX_LOCALE_TEMPLATES: ReadonlyArray<LocaleTemplate> = [
+	{
+		locale: "en-US",
+		leaders: ["PO Box", "P.O. Box", "P.O.Box", "PO BOX", "POB", "Post Office Box", "Box"],
+		pmb: ["PMB", "#"],
+	},
+	{
+		locale: "en-CA",
+		leaders: ["PO Box", "P.O. Box", "POB", "Post Office Box"],
+		pmb: ["PMB", "#"],
+	},
+	{
+		locale: "en-GB",
+		leaders: ["PO Box", "P.O. Box", "Post Office Box"],
+	},
+	{
+		locale: "en-AU",
+		leaders: ["PO Box", "P.O. Box", "Post Office Box", "GPO Box", "Locked Bag"],
+	},
+	{
+		locale: "en-NZ",
+		leaders: ["PO Box", "P.O. Box", "Post Office Box", "Private Bag", "Private Box"],
+	},
+	{
+		locale: "fr-FR",
+		leaders: ["BP", "B.P.", "Boîte Postale", "BP."],
+	},
+	{
+		locale: "fr-CA",
+		leaders: ["CP", "C.P.", "Case Postale", "BP", "B.P."],
+	},
+	{
+		locale: "es-ES",
+		leaders: ["Apdo.", "Apdo", "Apartado", "Apartado de Correos"],
+	},
+	{
+		locale: "es-MX",
+		leaders: ["Apdo.", "Apartado", "Apartado Postal", "AP"],
+	},
+	{
+		locale: "es-AR",
+		leaders: ["Casilla", "Casilla de Correo", "CC"],
+	},
+]
+
+const LEADERS_BY_LOCALE = new Map<string, LocaleTemplate>(PO_BOX_LOCALE_TEMPLATES.map((t) => [t.locale, t]))
+
+/**
+ * Inject number-format noise into a box number string. Returns the noisy variant or the original (10% probability of
+ * noise per the design).
+ */
+export function maybeNoisifyBoxNumber(num: string, random: () => number): string {
+	if (random() > 0.1) return num
+	const variants: Array<(s: string) => string> = [
+		// Thousand-separator comma (real input: "Box 1,234")
+		(s) => (s.length >= 4 ? `${s.slice(0, -3)},${s.slice(-3)}` : s),
+		// Embedded dash (real input: "PMB-200")
+		(s) => (s.length >= 3 ? `${s.slice(0, -2)}-${s.slice(-2)}` : s),
+		// Embedded spaces (real input from OCR: "1 2 3 4")
+		(s) => s.split("").join(" "),
+	]
+	const f = variants[Math.floor(random() * variants.length)]!
+
+	return f(num)
+}
+
+/**
+ * Compose a PO box phrase like "PO Box 123" or "PMB 200".
+ *
+ * Returns both the phrase and the canonical leader+number so the BIO aligner can mark the entire span as `po_box`.
+ */
+export function composePoBoxPhrase(leader: string, number: string): string {
+	return `${leader} ${number}`
+}
+
+export interface SynthesizedPoBoxRow {
+	raw: string
+	components: CanonicalRow["components"]
+	locale: string
+	template: "po-box" | "pmb-with-street" | "military-po-box"
+}
+
+export interface PoBoxSynthesisOpts {
+	/** Random function — pass deterministic seed for tests. Default Math.random. */
+	random?: () => number
+	/** Number generator. Default uniform over 1..99999. */
+	pickNumber?: (random: () => number) => string
+	/** PMB probability when locale supports it (and a street is provided in the base tuple). */
+	pmbRatio?: number
+}
+
+function defaultPickNumber(random: () => number): string {
+	// 70% of real PO boxes are 1-5 digits; long ones exist (USPS allows up to ~6 digits).
+	const r = random()
+
+	if (r < 0.3) return String(1 + Math.floor(random() * 99))
+
+	// 1-99
+	if (r < 0.7) return String(100 + Math.floor(random() * 900))
+
+	// 100-999
+	if (r < 0.95) return String(1000 + Math.floor(random() * 9000))
+
+	// 1000-9999
+	return String(10000 + Math.floor(random() * 90000)) // 10000-99999
+}
+
+/**
+ * Generate one PO box row for a base (locality, region, postcode, country) tuple. Picks a locale-appropriate leader and
+ * number. Optionally generates a PMB variant when the base tuple includes a street.
+ */
+export function synthesizePoBoxRow(
+	base: PoBoxBaseTuple & { street?: string; houseNumber?: string },
+	opts: PoBoxSynthesisOpts = {}
+): SynthesizedPoBoxRow | null {
+	const random = opts.random ?? Math.random
+	const pickNumber = opts.pickNumber ?? defaultPickNumber
+	const pmbRatio = opts.pmbRatio ?? 0.0
+
+	const locale = countryToLocale(base.country)
+	const tpl = LEADERS_BY_LOCALE.get(locale)
+
+	if (!tpl) return null
+
+	const number = maybeNoisifyBoxNumber(pickNumber(random), random)
+	const leader = tpl.leaders[Math.floor(random() * tpl.leaders.length)]!
+	const poBoxPhrase = composePoBoxPhrase(leader, number)
+
+	// PMB variant: requires both a street and a PMB-supporting locale.
+	const wantPmb = base.street && tpl.pmb && random() < pmbRatio
+
+	if (wantPmb) {
+		const pmbLeader = tpl.pmb![Math.floor(random() * tpl.pmb!.length)]!
+		const pmbPhrase = composePoBoxPhrase(pmbLeader, number)
+		const streetLine = base.houseNumber ? `${base.houseNumber} ${base.street}` : base.street!
+		const raw = `${streetLine}, ${pmbPhrase}, ${base.locality}, ${base.region} ${base.postcode}`
+
+		return {
+			raw,
+			components: {
+				...(base.houseNumber ? { house_number: base.houseNumber } : {}),
+				street: base.street!,
+				po_box: pmbPhrase,
+				locality: base.locality,
+				region: base.region,
+				postcode: base.postcode,
+				country: base.country,
+			},
+			locale,
+			template: "pmb-with-street",
+		}
+	}
+
+	// Standard PO box: replaces the street line entirely. Region-optional — NZ (and other region-less
+	// locales) read "Private Bag 12, Auckland 1010" with no region token between locality and postcode.
+	const hasRegion = Boolean(base.region && base.region.trim())
+	const tail = hasRegion ? `${base.locality}, ${base.region} ${base.postcode}` : `${base.locality} ${base.postcode}`
+	const raw = `${poBoxPhrase}, ${tail}`
+
+	return {
+		raw,
+		components: {
+			po_box: poBoxPhrase,
+			locality: base.locality,
+			...(hasRegion ? { region: base.region } : {}),
+			postcode: base.postcode,
+			country: base.country,
+		},
+		locale,
+		template: "po-box",
+	}
+}
+
+/**
+ * The US military/diplomatic PO-box class (#517). A distinct shape the leader-based locale templates can't express: a
+ * unit line (`PSC <id> Box <box>`, `CMR <id> Box <box>`, `Unit <id> [Box <box>]`) tagged `po_box`, then the post-office
+ * code (APO/FPO/DPO) as the locality and the armed-forces region (AA/AE/AP) as the region, with a theatre-specific ZIP.
+ * Authoritative reference + citations: `@mailwoman/codex` `codex/us/military-address.ts`; the small constants are
+ * inlined here so the generator is self-contained.
+ */
+const MIL_UNITS: ReadonlyArray<{ code: string; boxRequired: boolean }> = [
+	{ code: "PSC", boxRequired: true },
+	{ code: "CMR", boxRequired: true },
+	{ code: "Unit", boxRequired: false },
+]
+const MIL_PO_CODES = ["APO", "FPO", "DPO"] as const
+// region → plausible ZIP prefix (AE Europe 09xxx, AP Pacific 962-966xx, AA Americas 340xx).
+const MIL_REGION_ZIP: ReadonlyArray<{ region: string; zip: (r: () => number) => string }> = [
+	{ region: "AE", zip: (r) => `09${String(Math.floor(r() * 1000)).padStart(3, "0")}` },
+	{ region: "AP", zip: (r) => `96${String(200 + Math.floor(r() * 100)).padStart(3, "0")}` },
+	{ region: "AA", zip: (r) => `340${String(Math.floor(r() * 100)).padStart(2, "0")}` },
+]
+
+/** Generate one US military/diplomatic PO-box row (#517). Self-contained — draws no base tuple. */
+export function synthesizeMilitaryPoBoxRow(opts: PoBoxSynthesisOpts = {}): SynthesizedPoBoxRow {
+	const random = opts.random ?? Math.random
+	const unit = MIL_UNITS[Math.floor(random() * MIL_UNITS.length)]!
+	const unitID = String(1 + Math.floor(random() * 9999))
+	const { region, zip } = MIL_REGION_ZIP[Math.floor(random() * MIL_REGION_ZIP.length)]!
+	const zipStr = zip(random)
+	const po = MIL_PO_CODES[Math.floor(random() * MIL_PO_CODES.length)]!
+	const hasBox = unit.boxRequired || random() < 0.5
+	const unitLine = hasBox ? `${unit.code} ${unitID} Box ${1 + Math.floor(random() * 9999)}` : `${unit.code} ${unitID}`
+	const raw = `${unitLine}, ${po} ${region} ${zipStr}`
+
+	return {
+		raw,
+		components: {
+			po_box: unitLine,
+			locality: po,
+			region,
+			postcode: zipStr,
+			country: "US",
+		},
+		locale: "en-US",
+		template: "military-po-box",
+	}
+}
+
+/**
+ * Map a country code (ISO-3166-1 alpha-2 or alpha-3, or country display name) to the locale code we have a PO box
+ * template for.
+ */
+export function countryToLocale(country: string): string {
+	const c = country.trim().toUpperCase()
+
+	if (c === "US" || c === "USA" || c === "UNITED STATES") return "en-US"
+
+	if (c === "CA" || c === "CAN" || c === "CANADA") return "en-CA"
+
+	if (c === "GB" || c === "UK" || c === "GBR" || c === "UNITED KINGDOM") return "en-GB"
+
+	if (c === "AU" || c === "AUS" || c === "AUSTRALIA") return "en-AU"
+
+	if (c === "NZ" || c === "NZL" || c === "NEW ZEALAND") return "en-NZ"
+
+	if (c === "FR" || c === "FRA" || c === "FRANCE") return "fr-FR"
+
+	if (c === "ES" || c === "ESP" || c === "SPAIN") return "es-ES"
+
+	if (c === "MX" || c === "MEX" || c === "MEXICO") return "es-MX"
+
+	if (c === "AR" || c === "ARG" || c === "ARGENTINA") return "es-AR"
+
+	return "en-US"
+}
+
+/** All locales we synthesize for. Exposed for tests and for source-weight tuning. */
+export function supportedLocales(): ReadonlyArray<string> {
+	return PO_BOX_LOCALE_TEMPLATES.map((t) => t.locale)
+}
+
+/**
+ * Locales whose standard PO-box delivery line carries NO region token — the address reads `<po_box>, <locality>
+ * <postcode>` with nothing between locality and postcode (#517). NZ is the canonical case (`Private Bag 12, Auckland
+ * 1010`). Consumers (e.g. the synth-po-box adapter) use this to avoid discarding region-less input tuples for these
+ * locales as "missing region".
+ */
+export const REGION_OPTIONAL_LOCALES: ReadonlySet<string> = new Set(["en-NZ"])