@mailwoman/corpus 9.4.0 → 10.0.0

package/lib/recipes/index.ts

@@ -8,36 +8,39 @@
  *   to them. A new slice is a new entry here, not a new script.
  */
 
+import { cnOrganizationalUnitsRecipe } from "#cn/recipes/organizational-units"
+import { czPcFirstPrepositionRecipe } from "#cz/recipes/pcfirst-preposition"
+import { germanRecipe } from "#de/recipes/locale"
+import { frAdminSplitRecipe } from "#fr/recipes/admin-split"
+import { frBareStreetRecipe } from "#fr/recipes/bare-street"
+import { frFragmentRecipe } from "#fr/recipes/fragment"
+import { frLieuditRecipe } from "#fr/recipes/lieudit"
+import { frOrderRecipe } from "#fr/recipes/order"
+import { localeRecipe } from "#international/recipes/locale"
+import { nlPostcodeRecipe } from "#nl/recipes/postcode"
+import { noFragmentRecipe } from "#no/recipes/fragment"
+import { noStreetRecipe } from "#no/recipes/street/index"
+import { noStreetLedRecipe } from "#no/recipes/street/led"
 import { anchorAbsorptionRecipe } from "#recipes/anchor-absorption"
-import { bareCountryRecipe } from "#recipes/bare-country"
+import { bareCountryRecipe } from "#recipes/bare/country"
+import { barePostcodeRecipe } from "#recipes/bare/postcode/index"
 import { boundaryStressRecipe } from "#recipes/boundary-stress"
-import { cnOrganizationalUnitsRecipe } from "#recipes/cn-organizational-units"
 import { countryBalancedRecipe } from "#recipes/country-balanced"
-import { czPcFirstPrepositionRecipe } from "#recipes/cz-pcfirst-preposition"
-import { frAdminSplitRecipe } from "#recipes/fr-admin-split"
-import { frBareStreetRecipe } from "#recipes/fr-bare-street"
-import { frFragmentRecipe } from "#recipes/fr-fragment"
-import { frLieuditRecipe } from "#recipes/fr-lieudit"
-import { frOrderRecipe } from "#recipes/fr-order"
-import { germanRecipe } from "#recipes/german"
 import { houseVenueRecipe } from "#recipes/house-venue"
 import { intersectionRecipe } from "#recipes/intersection"
-import { localeRecipe } from "#recipes/locale"
-import { nlPostcodeRecipe } from "#recipes/nl-postcode"
-import { noFragmentRecipe } from "#recipes/no-fragment"
-import { noStreetRecipe } from "#recipes/no-street"
-import { noStreetLedRecipe } from "#recipes/no-street-led"
-import { poBoxRecipe } from "#recipes/po-box"
-import { poBoxCedexRecipe } from "#recipes/po-box-cedex"
-import { reviewedPostcodeTailRecipe } from "#recipes/reviewed-postcode-tail"
+import { poBoxCedexRecipe } from "#recipes/po/box/cedex"
+import { poBoxRecipe } from "#recipes/po/box/index"
 import type { CorpusRecipe } from "#recipes/scaffold"
-import { siBareVillageRecipe } from "#recipes/si-bare-village"
 import { streetRecipe } from "#recipes/street"
-import { streetAffixRecipe, suffixBoundaryRecipe } from "#recipes/street-affix"
-import { streetBareRecipe } from "#recipes/street-bare"
-import { subVenueRecipe } from "#recipes/sub-venue"
+import { streetAffixRecipe, suffixBoundaryRecipe } from "#recipes/street/affix"
+import { streetBareRecipe } from "#recipes/street/bare"
+import { subVenueRecipe } from "#recipes/sub/venue/index"
 import { trailingRegionRecipe } from "#recipes/trailing-region"
 import { unitRecipe } from "#recipes/unit"
+import { sgRegisterRecipe } from "#sg/recipes/register"
+import { siBareVillageRecipe } from "#si/recipes/bare-village"
+import { bdRegisterRecipe, pkRegisterRecipe } from "#south-asia/recipes/register"
+import { reviewedPostcodeTailRecipe } from "#ve/recipes/reviewed-postcode-tail"
 
 export * from "#recipes/scaffold"
 
@@ -60,6 +63,9 @@ const RECIPES: readonly CorpusRecipe[] = [
 	intersectionRecipe,
 	germanRecipe,
 	cnOrganizationalUnitsRecipe,
+	sgRegisterRecipe,
+	pkRegisterRecipe,
+	bdRegisterRecipe,
 	localeRecipe,
 	frOrderRecipe,
 	frAdminSplitRecipe,
@@ -68,6 +74,7 @@ const RECIPES: readonly CorpusRecipe[] = [
 	frLieuditRecipe,
 	czPcFirstPrepositionRecipe,
 	nlPostcodeRecipe,
+	barePostcodeRecipe,
 	noStreetLedRecipe,
 	noFragmentRecipe,
 	siBareVillageRecipe,

package/lib/recipes/intersection.ts

@@ -35,11 +35,11 @@
  */
 
 import type { DuckDBConnection } from "@duckdb/node-api"
+import type { ComponentTag } from "@mailwoman/codex/component"
 import { dataRootPath } from "@mailwoman/core/data-root"
 import { pathExists } from "@mailwoman/core/fs/readers"
 import { writeLocalJSONFile } from "@mailwoman/core/fs/writers"
 import { repoRootPath } from "@mailwoman/core/paths"
-import type { ComponentTag } from "@mailwoman/core/types"
 import { mulberry32 as makeMulberry32 } from "@mailwoman/core/utils"
 import type { PathBuilderLike } from "path-ts"
 import { JSONSpliterator } from "spliterator"

package/lib/recipes/po/box/cedex/au-nz.ts

@@ -0,0 +1,82 @@
+/**
+ * @copyright Sister Software
+ */
+
+import { isAuDeliveryService } from "@mailwoman/codex/au"
+import { isNZDeliveryService } from "@mailwoman/codex/nz"
+
+import { makeAuNZPoBoxPhrase } from "#recipes/po/box/cedex/phrases"
+import type { AUTuple, NZTuple, Rendered } from "#recipes/po/box/cedex/types"
+import {
+	AU_LEADERS_CURRENT,
+	AU_LEADERS_LEGACY,
+	NZ_LEADERS_COMMON,
+	NZ_LEADERS_RARE,
+	VENUES_EN,
+} from "#recipes/po/box/cedex/vocabulary"
+import { pick } from "#synthesizers/utils"
+
+const AU_UPPER_LOCALITY_CUTOFF = 0.6,
+	AU_STANDARD_CUTOFF = 0.45,
+	AU_LABEL_CUTOFF = 0.6,
+	AU_NO_POSTCODE_CUTOFF = 0.75,
+	AU_BARE_CUTOFF = 0.88
+
+const NZ_STANDARD_CUTOFF = 0.55,
+	NZ_NO_POSTCODE_CUTOFF = 0.7,
+	NZ_BARE_CUTOFF = 0.85
+
+export function renderAUPoBox(random: () => number, tuple: AUTuple): Rendered {
+	const phrase = makeAuNZPoBoxPhrase(random, AU_LEADERS_CURRENT, AU_LEADERS_LEGACY, isAuDeliveryService)
+	const { locality, region, postcode } = tuple
+	const draw = random()
+	const location = draw < AU_UPPER_LOCALITY_CUTOFF ? locality.toUpperCase() : locality
+	const base = { po_box: phrase, locality: location, region, postcode }
+
+	if (draw < AU_STANDARD_CUTOFF)
+		return { fmt: "au-standard", raw: `${phrase}, ${location} ${region} ${postcode}`, components: base }
+
+	if (draw < AU_LABEL_CUTOFF) {
+		const upper = phrase.toUpperCase()
+
+		return {
+			fmt: "au-label-nocomma",
+			raw: `${upper} ${locality.toUpperCase()} ${region} ${postcode}`,
+			components: { po_box: upper, locality: locality.toUpperCase(), region, postcode },
+		}
+	}
+
+	if (draw < AU_NO_POSTCODE_CUTOFF)
+		return {
+			fmt: "au-no-postcode",
+			raw: `${phrase}, ${location} ${region}`,
+			components: { po_box: phrase, locality: location, region },
+		}
+
+	if (draw < AU_BARE_CUTOFF) return { fmt: "au-bare", raw: phrase, components: { po_box: phrase } }
+	const venue = pick(VENUES_EN, random)
+
+	return {
+		fmt: "au-venue",
+		raw: `${venue}, ${phrase}, ${location} ${region} ${postcode}`,
+		components: { venue, ...base },
+	}
+}
+
+export function renderNZPoBox(random: () => number, tuple: NZTuple): Rendered {
+	const phrase = makeAuNZPoBoxPhrase(random, NZ_LEADERS_COMMON, NZ_LEADERS_RARE, isNZDeliveryService)
+	const { locality, postcode } = tuple
+	const base = { po_box: phrase, locality, postcode }
+	const draw = random()
+
+	if (draw < NZ_STANDARD_CUTOFF)
+		return { fmt: "nz-standard", raw: `${phrase}, ${locality} ${postcode}`, components: base }
+
+	if (draw < NZ_NO_POSTCODE_CUTOFF)
+		return { fmt: "nz-no-postcode", raw: `${phrase}, ${locality}`, components: { po_box: phrase, locality } }
+
+	if (draw < NZ_BARE_CUTOFF) return { fmt: "nz-bare", raw: phrase, components: { po_box: phrase } }
+	const venue = pick(VENUES_EN, random)
+
+	return { fmt: "nz-venue", raw: `${venue}, ${phrase}, ${locality} ${postcode}`, components: { venue, ...base } }
+}

package/lib/recipes/po/box/cedex/ca.ts

@@ -0,0 +1,58 @@
+/**
+ * @copyright Sister Software
+ */
+
+import { makeCaPostcode, makePoBoxPhrase } from "#recipes/po/box/cedex/phrases"
+import type { Rendered } from "#recipes/po/box/cedex/types"
+import {
+	CA_EN_LEADERS,
+	CA_FR_LEADERS,
+	ON_FSA_LETTERS,
+	QC_FSA_LETTERS,
+	VENUES_FR,
+} from "#recipes/po/box/cedex/vocabulary"
+import { pick } from "#synthesizers/utils"
+
+const CA_FR_GOLDEN_ORDER_CUTOFF = 0.4,
+	CA_FR_NATIVE_CUTOFF = 0.7,
+	CA_FR_BARE_CUTOFF = 0.85
+
+const CA_EN_STANDARD_CUTOFF = 0.5,
+	CA_EN_GOLDEN_ORDER_CUTOFF = 0.8
+
+export function renderCaFr(random: () => number, locality: string): Rendered {
+	const phrase = makePoBoxPhrase(random, CA_FR_LEADERS)
+	const postcode = makeCaPostcode(random, QC_FSA_LETTERS)
+	const components = { po_box: phrase, postcode, locality, region: "QC" }
+	const draw = random()
+
+	if (draw < CA_FR_GOLDEN_ORDER_CUTOFF)
+		return { fmt: "ca-fr-golden-order", raw: `${phrase}, ${postcode} ${locality}, QC`, components }
+
+	if (draw < CA_FR_NATIVE_CUTOFF)
+		return { fmt: "ca-fr-native", raw: `${phrase}, ${locality} QC ${postcode}`, components }
+
+	if (draw < CA_FR_BARE_CUTOFF) return { fmt: "ca-fr-bare", raw: phrase, components: { po_box: phrase } }
+	const venue = pick(VENUES_FR, random)
+
+	return {
+		fmt: "ca-fr-venue",
+		raw: `${venue}, ${phrase}, ${locality} QC ${postcode}`,
+		components: { venue, ...components },
+	}
+}
+
+export function renderCaEn(random: () => number, locality: string): Rendered {
+	const phrase = makePoBoxPhrase(random, CA_EN_LEADERS)
+	const postcode = makeCaPostcode(random, ON_FSA_LETTERS)
+	const components = { po_box: phrase, locality, region: "ON", postcode }
+	const draw = random()
+
+	if (draw < CA_EN_STANDARD_CUTOFF)
+		return { fmt: "ca-en-standard", raw: `${phrase}, ${locality}, ON ${postcode}`, components }
+
+	if (draw < CA_EN_GOLDEN_ORDER_CUTOFF)
+		return { fmt: "ca-en-golden-order", raw: `${phrase}, ${postcode} ${locality}, ON`, components }
+
+	return { fmt: "ca-en-bare", raw: phrase, components: { po_box: phrase } }
+}

package/lib/recipes/po/box/cedex/fr.ts

@@ -0,0 +1,76 @@
+/**
+ * @copyright Sister Software
+ */
+
+import { makeCedex, makePoBoxPhrase } from "#recipes/po/box/cedex/phrases"
+import type { FRTuple, Rendered } from "#recipes/po/box/cedex/types"
+import { FR_LEADERS, VENUES_FR } from "#recipes/po/box/cedex/vocabulary"
+import { pick } from "#synthesizers/utils"
+
+const BP_TAIL_CUTOFF = 0.45,
+	BP_BARE_CUTOFF = 0.6,
+	BP_CEDEX_CUTOFF = 0.8
+
+const CEDEX_UPPER_LOCALITY_SHARE = 0.6,
+	CEDEX_LINE_CUTOFF = 0.4,
+	CEDEX_FULL_CUTOFF = 0.75,
+	CEDEX_GOLDEN_ORDER_CUTOFF = 0.85
+
+export function renderBpFr(random: () => number, tuple: FRTuple): Rendered {
+	const phrase = makePoBoxPhrase(random, FR_LEADERS)
+	const { locality, postcode } = tuple
+	const location = random() < 0.5 ? locality.toUpperCase() : locality
+	const draw = random()
+
+	if (draw < BP_TAIL_CUTOFF)
+		return {
+			fmt: "bp-tail",
+			raw: `${phrase}, ${postcode} ${location}`,
+			components: { po_box: phrase, postcode, locality: location },
+		}
+
+	if (draw < BP_BARE_CUTOFF) return { fmt: "bp-bare", raw: phrase, components: { po_box: phrase } }
+
+	if (draw < BP_CEDEX_CUTOFF) {
+		const cedex = makeCedex(random)
+		const upperLocality = locality.toUpperCase()
+
+		return {
+			fmt: "bp-cedex",
+			raw: `${phrase}, ${postcode} ${upperLocality} ${cedex}`,
+			components: { po_box: phrase, postcode, locality: upperLocality, cedex },
+		}
+	}
+
+	const venue = pick(VENUES_FR, random)
+
+	return {
+		fmt: "bp-venue",
+		raw: `${venue}, ${phrase}, ${postcode} ${location}`,
+		components: { venue, po_box: phrase, postcode, locality: location },
+	}
+}
+
+export function renderCedexFr(random: () => number, tuple: FRTuple): Rendered {
+	const cedex = makeCedex(random)
+	const { house_number, street, locality, postcode } = tuple
+	const location = random() < CEDEX_UPPER_LOCALITY_SHARE ? locality.toUpperCase() : locality
+	const line = { postcode, locality: location, cedex }
+	const draw = random()
+
+	if (draw < CEDEX_LINE_CUTOFF) return { fmt: "cedex-line", raw: `${postcode} ${location} ${cedex}`, components: line }
+
+	if (draw < CEDEX_FULL_CUTOFF)
+		return {
+			fmt: "cedex-full",
+			raw: `${house_number} ${street}, ${postcode} ${location} ${cedex}`,
+			components: { house_number, street, ...line },
+		}
+
+	if (draw < CEDEX_GOLDEN_ORDER_CUTOFF)
+		return { fmt: "cedex-golden-order", raw: `${postcode} ${cedex} ${location}`, components: line }
+
+	const venue = pick(VENUES_FR, random)
+
+	return { fmt: "cedex-venue", raw: `${venue}, ${postcode} ${location} ${cedex}`, components: { venue, ...line } }
+}

package/lib/recipes/po/box/cedex/phrases.ts

@@ -0,0 +1,108 @@
+/**
+ * @copyright Sister Software
+ */
+
+import { normalizeCaPostalCode } from "@mailwoman/codex/ca"
+import { isCedex } from "@mailwoman/codex/fr"
+import { isNZDeliveryService } from "@mailwoman/codex/nz"
+import { isUSPoBoxDesignator, matchPOBox } from "@mailwoman/codex/us"
+
+import { CA_INTERIOR_LETTERS } from "#recipes/po/box/cedex/vocabulary"
+import { maybeNoisifyBoxNumber } from "#synthesizers/po-box"
+import { pick, tieredNumber } from "#synthesizers/utils"
+
+const BOX_TWO_DIGIT_CUTOFF = 0.3
+const BOX_THREE_DIGIT_CUTOFF = 0.7
+const BOX_FOUR_DIGIT_CUTOFF = 0.95
+const TEMPLATE_CASE_CUTOFF = 0.7
+const UPPER_CASE_CUTOFF = 0.92
+const RARE_LEADER_SHARE = 0.1
+const CEDEX_UPPER_CUTOFF = 0.6
+const CEDEX_TITLE_CUTOFF = 0.9
+const CEDEX_UNNUMBERED_SHARE = 0.2
+
+const pickBoxNumber = (random: () => number): string =>
+	tieredNumber(random, [
+		{ cutoff: BOX_TWO_DIGIT_CUTOFF, base: 1, span: 99 },
+		{ cutoff: BOX_THREE_DIGIT_CUTOFF, base: 100, span: 900 },
+		{ cutoff: BOX_FOUR_DIGIT_CUTOFF, base: 1000, span: 9000 },
+		{ base: 10_000, span: 90_000 },
+	])
+
+const caseDial = (random: () => number, value: string): string => {
+	const draw = random()
+
+	return draw < TEMPLATE_CASE_CUTOFF ? value : draw < UPPER_CASE_CUTOFF ? value.toUpperCase() : value.toLowerCase()
+}
+
+export function makePoBoxPhrase(
+	random: () => number,
+	leaders: ReadonlyArray<string>,
+	rareLeaders?: ReadonlyArray<string>
+): string {
+	let leader = pick(leaders, random)
+
+	if (rareLeaders && random() < RARE_LEADER_SHARE) {
+		leader = pick(rareLeaders, random)
+	}
+
+	const number = maybeNoisifyBoxNumber(pickBoxNumber(random), random)
+	const phrase = leader === "#" ? `#${number}` : `${caseDial(random, leader)} ${number}`
+
+	if (isUSPoBoxDesignator(leader) && /^[\dA-Za-z][\dA-Za-z-]*$/.test(number) && !matchPOBox(phrase))
+		throw new Error(`generated a po_box phrase the codex matcher rejects: "${phrase}"`)
+
+	return phrase
+}
+
+export function makeCedex(random: () => number): string {
+	const draw = random()
+	const word = draw < CEDEX_UPPER_CUTOFF ? "CEDEX" : draw < CEDEX_TITLE_CUTOFF ? "Cedex" : "cedex"
+	let phrase = word
+
+	if (random() >= CEDEX_UNNUMBERED_SHARE) {
+		const number = 1 + Math.floor(random() * 20)
+		phrase = `${word} ${random() < 0.5 ? String(number).padStart(2, "0") : String(number)}`
+	}
+
+	if (!isCedex(phrase)) throw new Error(`makeCedex emitted a phrase the codex matcher rejects: "${phrase}"`)
+
+	return phrase
+}
+
+export function makeAuNZPoBoxPhrase(
+	random: () => number,
+	leaders: ReadonlyArray<string>,
+	rareLeaders: ReadonlyArray<string>,
+	validate: (input: unknown) => boolean
+): string {
+	let leader = pick(leaders, random)
+
+	if (random() < RARE_LEADER_SHARE) {
+		leader = pick(rareLeaders, random)
+	}
+
+	let number = maybeNoisifyBoxNumber(pickBoxNumber(random), random)
+
+	if (leader === "CMB" && validate === isNZDeliveryService) {
+		number = `B${number}`
+	}
+
+	const phrase = `${caseDial(random, leader)} ${number}`
+	const cleanID = validate === isNZDeliveryService ? /^[\dA-Za-z]+$/ : /^[\dA-Za-z][\dA-Za-z-]*$/
+
+	if (cleanID.test(number) && !validate(phrase))
+		throw new Error(`generated a phrase the codex matcher rejects: "${phrase}"`)
+
+	return phrase
+}
+
+export function makeCaPostcode(random: () => number, fsaLetters: string[]): string {
+	const letter = () => CA_INTERIOR_LETTERS[Math.floor(random() * CA_INTERIOR_LETTERS.length)]!
+	const digit = () => String(Math.floor(random() * 10))
+	const postcode = `${pick(fsaLetters, random)}${digit()}${letter()} ${digit()}${letter()}${digit()}`
+
+	if (!normalizeCaPostalCode(postcode)) throw new Error(`generated an invalid CA postcode: ${postcode}`)
+
+	return postcode
+}

package/lib/recipes/po/box/cedex/recipe.ts

@@ -0,0 +1,203 @@
+/**
+ * @copyright Sister Software
+ */
+
+import { dataRootPath } from "@mailwoman/core/data-root"
+import { mulberry32 as makeMulberry32 } from "@mailwoman/core/utils"
+
+import { renderAUPoBox, renderNZPoBox } from "#recipes/po/box/cedex/au-nz"
+import { renderCaEn, renderCaFr } from "#recipes/po/box/cedex/ca"
+import { renderBpFr, renderCedexFr } from "#recipes/po/box/cedex/fr"
+import {
+	FR_SOURCE,
+	GEONAMES_CA,
+	GEONAMES_POSTAL_AU,
+	GEONAMES_POSTAL_NZ,
+	isHoldoutLocality,
+	readCaLocalities,
+	readFrTuples,
+	readPostalTuples,
+	readUsTuples,
+	US_EVAL_SOURCE,
+	US_TRAIN_SOURCES,
+} from "#recipes/po/box/cedex/sources"
+import type { AUTuple, NZTuple, Rendered, USTuple } from "#recipes/po/box/cedex/types"
+import { renderPmbUs, renderPoBoxUs } from "#recipes/po/box/cedex/us"
+import { CLASS_MIX } from "#recipes/po/box/cedex/vocabulary"
+import { sliceSourceID, type CanonicalSliceRow, type CorpusRecipe } from "#recipes/scaffold"
+import { synthesizeMilitaryPoBoxRow } from "#synthesizers/po-box"
+import { pick } from "#synthesizers/utils"
+import { alignRow } from "#utils"
+
+const COMPONENT_ORDER = ["house_number", "street", "po_box", "venue", "locality", "postcode", "region", "cedex"]
+
+const orderComponents = (components: Record<string, string>): Record<string, string> =>
+	Object.fromEntries(COMPONENT_ORDER.filter((key) => components[key]).map((key) => [key, components[key]!]))
+
+const pickClass = (draw: number): string => {
+	let accumulated = 0
+
+	for (const [name, weight] of CLASS_MIX) {
+		accumulated += weight
+
+		if (draw < accumulated) return name
+	}
+
+	return CLASS_MIX.at(-1)![0]
+}
+
+/**
+ * Generate PO-box and CEDEX rows from US, French, Canadian, Australian, and New Zealand source pools.
+ */
+export const poBoxCedexRecipe: CorpusRecipe = {
+	name: "po-box-cedex",
+	description: "PO box / CEDEX coverage rows (US/FR/CA/AU/NZ) — self-generated from cached OA + GeoNames pools",
+	mode: "generate",
+	options: [{ flag: "--golden", description: "Emit the leakage-safe holdout variant ({raw, components, country})" }],
+	async run(opts, write) {
+		const random = makeMulberry32(opts.seed)
+		const count = opts.count ?? 50_000
+		const source = opts.sourceName ?? "synth-po-box-cedex"
+		const usPool: USTuple[] = []
+
+		for (const sourceEntry of opts.golden ? [US_EVAL_SOURCE] : US_TRAIN_SOURCES) {
+			const tuples = await readUsTuples(sourceEntry)
+
+			console.error(`  ${sourceEntry.csv}: ${tuples.length} tuples`)
+
+			for (const tuple of tuples) {
+				usPool.push(tuple)
+			}
+		}
+
+		const frAll = await readFrTuples(80_000)
+		const frPool = frAll.filter((tuple) => isHoldoutLocality(tuple.locality) === opts.golden)
+
+		console.error(`  ${FR_SOURCE.csv}: ${frAll.length} tuples (${frPool.length} after holdout split)`)
+
+		const qcAll = await readCaLocalities("10"),
+			onAll = await readCaLocalities("08")
+
+		const qcPool = qcAll.filter((locality) => isHoldoutLocality(locality) === opts.golden),
+			onPool = onAll.filter((locality) => isHoldoutLocality(locality) === opts.golden)
+
+		console.error(`  GeoNames CA: QC ${qcAll.length}→${qcPool.length}, ON ${onAll.length}→${onPool.length}`)
+
+		const auAll = (await readPostalTuples(GEONAMES_POSTAL_AU, { withState: true })) as AUTuple[],
+			nzAll = (await readPostalTuples(GEONAMES_POSTAL_NZ, { withState: false })) as NZTuple[]
+
+		const auPool = auAll.filter((tuple) => isHoldoutLocality(tuple.locality) === opts.golden),
+			nzPool = nzAll.filter((tuple) => isHoldoutLocality(tuple.locality) === opts.golden)
+
+		console.error(`  GeoNames postal: AU ${auAll.length}→${auPool.length}, NZ ${nzAll.length}→${nzPool.length}`)
+
+		if (!usPool.length || !frPool.length || !qcPool.length || !onPool.length || !auPool.length || !nzPool.length)
+			throw new Error(
+				`A base pool is empty — check ${dataRootPath("oa-cache")}, ${GEONAMES_CA}, ${GEONAMES_POSTAL_AU.zip}, and ${GEONAMES_POSTAL_NZ.zip}.`
+			)
+
+		let emitted = 0,
+			skipped = 0,
+			guard = 0
+
+		while (emitted < count && guard++ < count * 10) {
+			const kind = pickClass(random())
+			let rendered: Rendered
+			let country: string
+			let locale: string
+
+			if (kind === "po-box-us") {
+				rendered = renderPoBoxUs(random, pick(usPool, random))
+				country = "US"
+				locale = "en-US"
+			} else if (kind === "pmb-us") {
+				const tuple = pick(usPool, random)
+
+				if (!tuple.postcode || !tuple.street || !tuple.house_number) continue
+				rendered = renderPmbUs(random, tuple)
+				country = "US"
+				locale = "en-US"
+			} else if (kind === "bp-fr") {
+				rendered = renderBpFr(random, pick(frPool, random))
+				country = "FR"
+				locale = "fr-FR"
+			} else if (kind === "cedex-fr") {
+				rendered = renderCedexFr(random, pick(frPool, random))
+				country = "FR"
+				locale = "fr-FR"
+			} else if (kind === "cp-ca-fr") {
+				rendered = renderCaFr(random, pick(qcPool, random))
+				country = "CA"
+				locale = "fr-CA"
+			} else if (kind === "po-box-au") {
+				rendered = renderAUPoBox(random, pick(auPool, random))
+				country = "AU"
+				locale = "en-AU"
+			} else if (kind === "po-box-nz") {
+				rendered = renderNZPoBox(random, pick(nzPool, random))
+				country = "NZ"
+				locale = "en-NZ"
+			} else if (kind === "po-box-us-military") {
+				const military = synthesizeMilitaryPoBoxRow({ random })
+				const { country: _country, ...components } = military.components
+				rendered = { fmt: "po-box-military", raw: military.raw, components: components as Record<string, string> }
+				country = "US"
+				locale = "en-US"
+			} else {
+				rendered = renderCaEn(random, pick(onPool, random))
+				country = "CA"
+				locale = "en-CA"
+			}
+
+			const { raw, components } = rendered
+
+			if (!Object.values(components).every((value) => raw.includes(value))) {
+				skipped++
+
+				continue
+			}
+
+			if (opts.golden) {
+				write(JSON.stringify({ raw, components: orderComponents(components), country }) + "\n")
+
+				emitted++
+
+				continue
+			}
+
+			const canonical: CanonicalSliceRow = {
+				raw,
+				components: orderComponents(components),
+				country,
+				locale,
+				source,
+				source_id: sliceSourceID(source, components),
+				corpus_version: "0.4.0",
+				license:
+					country === "CA"
+						? "GeoNames CA (CC-BY 4.0) locality skeletons + Canada Post box forms (corpus templates); postcodes synthesized to the codex CA pattern"
+						: country === "FR"
+							? "OpenAddresses FR (BAN-derived) skeletons + La Poste BP/CEDEX forms (corpus templates, NF Z 10-011)"
+							: country === "AU"
+								? "GeoNames AU postal dump (CC-BY 4.0) locality/state/postcode tails + Australia Post Postal Delivery Type designators (@mailwoman/codex/au)"
+								: country === "NZ"
+									? "GeoNames NZ postal dump (CC-BY 4.0) locality/postcode tails + NZ Post ADV358 Delivery Service Types (@mailwoman/codex/nz)"
+									: "OpenAddresses US (non-VT) skeletons + USPS Pub-28 §29 PO-box designators (codex/corpus templates)",
+			}
+
+			const aligned = alignRow(canonical as Parameters<typeof alignRow>[0])
+
+			if (aligned.kind !== "labeled" || !aligned.row) {
+				skipped++
+
+				continue
+			}
+
+			write(JSON.stringify({ ...aligned.row, synth_method: kind, synth_base_id: null }) + "\n")
+
+			emitted++
+		}
+
+		return { emitted, skipped }
+	},
+}