@mailwoman/corpus 9.4.0 → 10.1.0

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

@@ -0,0 +1,215 @@
+/**
+ * @copyright Sister Software
+ */
+
+import { dataRootPath } from "@mailwoman/core/data-root"
+import { stringifyJSON } from "@mailwoman/core/json"
+import { sample } from "@mailwoman/core/random"
+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 { recipeSourceID, type CanonicalRecipeRow, type CorpusRecipe } from "#recipes/scaffold"
+import { defaultRecipeSource } from "#recipes/sources"
+import { synthesizeMilitaryPoBoxRow } from "#synthesizers/po-box"
+import { SurfaceOrigin } from "#types"
+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 source pools in the US, France, Canada, Australia and New Zealand.
+ */
+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 ?? defaultRecipeSource("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, sample(usPool, random))
+				country = "US"
+				locale = "en-US"
+			} else if (kind === "pmb-us") {
+				const tuple = sample(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, sample(frPool, random))
+				country = "FR"
+				locale = "fr-FR"
+			} else if (kind === "cedex-fr") {
+				rendered = renderCedexFr(random, sample(frPool, random))
+				country = "FR"
+				locale = "fr-FR"
+			} else if (kind === "cp-ca-fr") {
+				rendered = renderCaFr(random, sample(qcPool, random))
+				country = "CA"
+				locale = "fr-CA"
+			} else if (kind === "po-box-au") {
+				rendered = renderAUPoBox(random, sample(auPool, random))
+				country = "AU"
+				locale = "en-AU"
+			} else if (kind === "po-box-nz") {
+				rendered = renderNZPoBox(random, sample(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, sample(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(stringifyJSON({ raw, components: orderComponents(components), country }))
+
+				emitted++
+
+				continue
+			}
+
+			const canonical: CanonicalRecipeRow = {
+				raw,
+				components: orderComponents(components),
+				country,
+				locale,
+				source,
+				source_id: recipeSourceID(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
+			}
+
+			// The CEDEX number is drawn rather than read from La Poste's own file.
+			write(
+				stringifyJSON({
+					...aligned.row,
+					recipe: kind,
+					base_source_id: null,
+					register: null,
+					surface: SurfaceOrigin.Invented,
+				})
+			)
+
+			emitted++
+		}
+
+		return { emitted, skipped }
+	},
+}

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

@@ -0,0 +1,189 @@
+/**
+ * @copyright Sister Software
+ */
+
+import { isAuPostcode, isAuStateAbbreviation } from "@mailwoman/codex/au"
+import { isNZPostcode } from "@mailwoman/codex/nz"
+import { dataRootPath } from "@mailwoman/core/data-root"
+import { pathExists } from "@mailwoman/core/fs/readers"
+import { readZipEntry } from "@mailwoman/core/fs/zip"
+import type { PathBuilderLike } from "path-ts"
+import { TextSpliterator, TSVSpliterator } from "spliterator"
+
+import type { AUTuple, FRTuple, NZTuple, USTuple } from "#recipes/po/box/cedex/types"
+import { readCSVRecords, readZippedCSVRecords } from "#recipes/scaffold"
+
+/**
+ * Non-Vermont OpenAddresses files used for training rows.
+ */
+export const US_TRAIN_SOURCES = [
+	{ zip: dataRootPath("oa-cache", "us__ca__berkeley.zip"), csv: "us/ca/berkeley.csv", region: "CA" },
+	{ zip: dataRootPath("oa-cache", "us__ca__marin.zip"), csv: "us/ca/marin.csv", region: "CA" },
+	{ zip: dataRootPath("oa-cache", "us__dc__statewide.zip"), csv: "us/dc/statewide.csv", region: "DC" },
+	{ zip: dataRootPath("oa-cache", "us__ia__statewide.zip"), csv: "us/ia/statewide.csv", region: "IA" },
+	{ zip: dataRootPath("oa-cache", "us__il__cook.zip"), csv: "us/il/cook.csv", region: "IL" },
+	{ zip: dataRootPath("oa-cache", "us__mt__statewide.zip"), csv: "us/mt/statewide.csv", region: "MT" },
+	{ zip: dataRootPath("oa-cache", "us__sd__statewide.zip"), csv: "us/sd/statewide.csv", region: "SD" },
+]
+
+/**
+ * Vermont OpenAddresses file reserved for golden rows.
+ */
+export const US_EVAL_SOURCE = {
+	zip: dataRootPath("oa-cache", "us__vt__statewide.zip"),
+	csv: "us/vt/statewide.csv",
+	region: "VT",
+}
+
+/**
+ * Countrywide French OpenAddresses source.
+ */
+export const FR_SOURCE = { zip: dataRootPath("oa-cache", "fr__countrywide.zip"), csv: "fr/countrywide.csv" }
+/**
+ * GeoNames Canada feature dump.
+ */
+export const GEONAMES_CA = dataRootPath("geonames", "CA.zip")
+/**
+ * GeoNames Australian postal-code dump.
+ */
+export const GEONAMES_POSTAL_AU = { zip: dataRootPath("geonames-postal", "AU.zip"), txt: "AU.txt" }
+/**
+ * GeoNames New Zealand postal-code dump.
+ */
+export const GEONAMES_POSTAL_NZ = { zip: dataRootPath("geonames-postal", "NZ.zip"), txt: "NZ.txt" }
+
+const MAX_LOCALITY_LENGTH = 40
+const FR_STRIDE = 211
+const FR_STRIDE_OFFSET = 3
+const CA_LOCALITY_MIN_POPULATION = 1000
+
+export const localityHash = (name: string): number => {
+	let hash = 5381
+
+	for (const character of name.toLowerCase()) {
+		hash = ((hash << 5) + hash + character.charCodeAt(0)) >>> 0
+	}
+
+	return hash
+}
+
+export const isHoldoutLocality = (name: string): boolean => localityHash(name) % 10 === 0
+
+const cleanLocality = (locality: string) =>
+	locality && locality.length <= MAX_LOCALITY_LENGTH && !/\d|,/.test(locality) && !/cedex/i.test(locality)
+
+export async function readUsTuples(source: { zip: PathBuilderLike; csv: string; region: string }): Promise<USTuple[]> {
+	const tuples: USTuple[] = []
+	const seen = new Set<string>()
+
+	for await (const row of readZippedCSVRecords(source.zip, source.csv)) {
+		const locality = row.city ?? ""
+
+		if (!cleanLocality(locality)) continue
+		const street = row.street ?? ""
+		const pairKey = `${locality}|${street}`.toLowerCase()
+
+		if (seen.has(pairKey)) continue
+		seen.add(pairKey)
+
+		tuples.push({
+			house_number: row.number ?? "",
+			street,
+			locality,
+			region: source.region,
+			postcode: row.postcode ?? "",
+		})
+	}
+
+	return tuples
+}
+
+export async function readFrTuples(limit: number): Promise<FRTuple[]> {
+	if (!(await pathExists(FR_SOURCE.zip))) {
+		console.error(`  WARN: ${FR_SOURCE.zip} is not cached — skipping ${FR_SOURCE.csv}`)
+
+		return []
+	}
+
+	const encoder = new TextEncoder()
+
+	const strided = TextSpliterator.fromAsync(readZipEntry(FR_SOURCE.zip, FR_SOURCE.csv), { skipEmpty: false })
+		.filter((_line, index) => index === 0 || (index + 1) % FR_STRIDE === FR_STRIDE_OFFSET)
+		.take(limit + 1)
+		.map((line) => encoder.encode(line + "\n"))
+
+	const tuples: FRTuple[] = []
+	const seen = new Set<string>()
+
+	for await (const row of readCSVRecords(strided)) {
+		const locality = row.city ?? "",
+			postcode = row.postcode ?? "",
+			street = row.street ?? "",
+			house_number = row.number ?? ""
+
+		if (!cleanLocality(locality) || !/^\d{5}$/.test(postcode) || !street || !house_number) continue
+		const key = `${locality}|${street}`.toLowerCase()
+
+		if (seen.has(key)) continue
+		seen.add(key)
+		tuples.push({ house_number, street, locality, postcode })
+	}
+
+	return tuples
+}
+
+export async function readCaLocalities(admin1: string): Promise<string[]> {
+	if (!(await pathExists(GEONAMES_CA))) {
+		console.error(`  WARN: ${GEONAMES_CA} is not cached — skipping CA localities (admin1=${admin1})`)
+
+		return []
+	}
+
+	const localities = new Set<string>()
+
+	for await (const columns of TSVSpliterator.fromAsync(readZipEntry(GEONAMES_CA, "CA.txt"), { header: false })) {
+		if (
+			columns[6] === "P" &&
+			columns[8] === "CA" &&
+			columns[10] === admin1 &&
+			Number(columns[14]) > CA_LOCALITY_MIN_POPULATION &&
+			cleanLocality(columns[1] ?? "")
+		) {
+			localities.add(columns[1]!)
+		}
+	}
+
+	return [...localities]
+}
+
+export async function readPostalTuples(
+	source: { zip: PathBuilderLike; txt: string },
+	opts: { withState: boolean }
+): Promise<Array<AUTuple | NZTuple>> {
+	if (!(await pathExists(source.zip))) {
+		console.error(`  WARN: ${source.zip} is not cached — skipping ${source.txt}`)
+
+		return []
+	}
+
+	const tuples: Array<AUTuple | NZTuple> = []
+	const seen = new Set<string>()
+	const validPostcode = opts.withState ? isAuPostcode : isNZPostcode
+
+	for await (const columns of TSVSpliterator.fromAsync(readZipEntry(source.zip, source.txt), { header: false })) {
+		const postcode = columns[1] ?? "",
+			locality = columns[2] ?? "",
+			region = columns[4] ?? ""
+
+		if (!cleanLocality(locality) || !validPostcode(postcode) || (opts.withState && !isAuStateAbbreviation(region)))
+			continue
+
+		const key = `${locality}|${postcode}`.toLowerCase()
+
+		if (seen.has(key)) continue
+		seen.add(key)
+		tuples.push(opts.withState ? { locality, region, postcode } : { locality, postcode })
+	}
+
+	return tuples
+}

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

@@ -0,0 +1,35 @@
+/**
+ * @copyright Sister Software
+ */
+
+export interface USTuple {
+	house_number: string
+	street: string
+	locality: string
+	region: string
+	postcode: string
+}
+
+export interface FRTuple {
+	house_number: string
+	street: string
+	locality: string
+	postcode: string
+}
+
+export interface AUTuple {
+	locality: string
+	region: string
+	postcode: string
+}
+
+export interface NZTuple {
+	locality: string
+	postcode: string
+}
+
+export interface Rendered {
+	fmt: string
+	raw: string
+	components: Record<string, string>
+}

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

@@ -0,0 +1,74 @@
+/**
+ * @copyright Sister Software
+ */
+
+/* oxlint-disable mailwoman/prefer-home -- this module is the US arm of the cedex recipe, identified by its path. Its
+ sibling arms cover the other countries. A layout call would answer the same string for the only country that reaches
+   it. */
+
+import { sample } from "@mailwoman/core/random"
+
+import { makePoBoxPhrase } from "#recipes/po/box/cedex/phrases"
+import type { Rendered, USTuple } from "#recipes/po/box/cedex/types"
+import { US_LEADERS_COMMON, US_LEADERS_RARE, US_PMB_LEADERS, VENUES_EN } from "#recipes/po/box/cedex/vocabulary"
+
+const US_FULL_CUTOFF = 0.4,
+	US_NO_POSTCODE_CUTOFF = 0.55,
+	US_BARE_CUTOFF = 0.75,
+	US_VENUE_CUTOFF = 0.9
+
+const PMB_AFTER_STREET_CUTOFF = 0.5,
+	PMB_COMMA_CUTOFF = 0.85
+
+export function renderPoBoxUs(random: () => number, tuple: USTuple): Rendered {
+	const phrase = makePoBoxPhrase(random, US_LEADERS_COMMON, US_LEADERS_RARE)
+	const { locality, region, postcode } = tuple
+	const base = { po_box: phrase, locality, region }
+	const draw = random()
+
+	if (draw < US_FULL_CUTOFF && postcode)
+		return { fmt: "full", raw: `${phrase}, ${locality}, ${region} ${postcode}`, components: { ...base, postcode } }
+
+	if (draw < US_NO_POSTCODE_CUTOFF)
+		return { fmt: "no-postcode", raw: `${phrase}, ${locality}, ${region}`, components: base }
+
+	if (draw < US_BARE_CUTOFF) return { fmt: "bare", raw: phrase, components: { po_box: phrase } }
+
+	if (draw < US_VENUE_CUTOFF) {
+		const venue = sample(VENUES_EN, random)
+
+		return {
+			fmt: "venue",
+			raw: postcode
+				? `${venue}, ${phrase}, ${locality}, ${region} ${postcode}`
+				: `${venue}, ${phrase}, ${locality}, ${region}`,
+			components: { venue, ...base, ...(postcode ? { postcode } : {}) },
+		}
+	}
+
+	const upper = (value: string) => value.toUpperCase()
+
+	return {
+		fmt: "label-nocomma",
+		raw: postcode
+			? `${upper(phrase)} ${upper(locality)} ${region} ${postcode}`
+			: `${upper(phrase)} ${upper(locality)} ${region}`,
+		components: { po_box: upper(phrase), locality: upper(locality), region, ...(postcode ? { postcode } : {}) },
+	}
+}
+
+export function renderPmbUs(random: () => number, tuple: USTuple): Rendered {
+	const phrase = makePoBoxPhrase(random, US_PMB_LEADERS)
+	const { house_number, street, locality, region, postcode } = tuple
+	const road = `${house_number} ${street}`
+	const components = { house_number, street, po_box: phrase, locality, region, postcode }
+	const draw = random()
+
+	if (draw < PMB_AFTER_STREET_CUTOFF)
+		return { fmt: "pmb-after-street", raw: `${road} ${phrase}, ${locality}, ${region} ${postcode}`, components }
+
+	if (draw < PMB_COMMA_CUTOFF)
+		return { fmt: "pmb-comma", raw: `${road}, ${phrase}, ${locality}, ${region} ${postcode}`, components }
+
+	return { fmt: "pmb-bare", raw: `${road} ${phrase}`, components: { house_number, street, po_box: phrase } }
+}

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

@@ -0,0 +1,106 @@
+/**
+ * @copyright Sister Software
+ */
+
+import { FSA_LETTER_TO_PROVINCE } from "@mailwoman/codex/ca"
+import { US_PO_BOX_DESIGNATORS } from "@mailwoman/codex/us"
+
+import { PO_BOX_LOCALE_TEMPLATES, type LocaleTemplate } from "#synthesizers/po-box"
+
+const templates: Record<string, LocaleTemplate> = Object.fromEntries(
+	PO_BOX_LOCALE_TEMPLATES.map((template) => [template.locale, template])
+)
+
+/**
+ * Common US PO-box leaders from the en-US corpus template.
+ */
+export const US_LEADERS_COMMON = templates["en-US"]!.leaders
+
+/**
+ * Less-common USPS designators derived from the codex list.
+ */
+export const US_LEADERS_RARE = US_PO_BOX_DESIGNATORS.filter(
+	(designator) => !["POST OFFICE BOX", "PO BOX", "P O BOX", "BOX"].includes(designator)
+).map((designator) =>
+	designator
+		.toLowerCase()
+		.split(" ")
+		.map((word) => `${word[0]!.toUpperCase()}${word.slice(1)}`)
+		.join(" ")
+)
+
+/**
+ * US private-mailbox leaders excluding the conflicting hash sign.
+ */
+export const US_PMB_LEADERS = templates["en-US"]!.pmb!.filter((leader) => leader !== "#")
+/**
+ * French PO-box leaders from the fr-FR corpus template.
+ */
+export const FR_LEADERS = templates["fr-FR"]!.leaders
+/**
+ * French-language Canadian PO-box leaders from the fr-CA template.
+ */
+export const CA_FR_LEADERS = templates["fr-CA"]!.leaders
+/**
+ * English-language Canadian PO-box leaders from the en-CA template.
+ */
+export const CA_EN_LEADERS = templates["en-CA"]!.leaders
+/**
+ * Current Australian delivery-service leaders.
+ */
+export const AU_LEADERS_CURRENT = ["PO Box", "P.O. Box", "Post Office Box", "GPO Box", "Locked Bag", "Private Bag"]
+/**
+ * Recognized legacy Australian delivery-service leaders.
+ */
+export const AU_LEADERS_LEGACY = ["RMB", "RSD", "CMB"]
+/**
+ * Common New Zealand delivery-service leaders.
+ */
+export const NZ_LEADERS_COMMON = ["PO Box", "Private Bag"]
+/**
+ * Rare New Zealand delivery-service leader.
+ */
+export const NZ_LEADERS_RARE = ["CMB"]
+
+/**
+ * Quebec first-letter choices from the Canadian FSA prior.
+ */
+export const QC_FSA_LETTERS = Object.entries(FSA_LETTER_TO_PROVINCE)
+	.filter(([, province]) => province === "QC")
+	.map(([letter]) => letter)
+
+/**
+ * Ontario first-letter choices from the Canadian FSA prior.
+ */
+export const ON_FSA_LETTERS = Object.entries(FSA_LETTER_TO_PROVINCE)
+	.filter(([, province]) => province === "ON")
+	.map(([letter]) => letter)
+
+/**
+ * Valid Canadian postal-code interior letters.
+ */
+export const CA_INTERIOR_LETTERS = "ABCEGHJKLMNPRSTVWXYZ"
+
+/**
+ * Weighted country and address-form mix for generated rows.
+ */
+export const CLASS_MIX: ReadonlyArray<[string, number]> = [
+	["po-box-us", 0.27],
+	["po-box-us-military", 0.05],
+	["pmb-us", 0.07],
+	["bp-fr", 0.1],
+	["cedex-fr", 0.17],
+	["cp-ca-fr", 0.12],
+	["po-box-ca-en", 0.04],
+	["po-box-au", 0.12],
+	["po-box-nz", 0.06],
+]
+
+/**
+ * English recipient prefixes used in venue layouts.
+ */
+export const VENUES_EN = ["John Doe", "Jane Smith", "Acme Inc", "Wayne Enterprises", "Maria Garcia", "Riverside Clinic"]
+/**
+ * French recipient prefixes used in venue layouts.
+ */
+export const VENUES_FR = ["Société Dupont", "Cabinet Martin", "Hôpital Central", "Mairie Annexe", "Imprimerie Moderne"]

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

@@ -0,0 +1,9 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ * The recipe's implementation is partitioned by data source and postal system in `cedex/`.
+ */
+
+export { poBoxCedexRecipe } from "#recipes/po/box/cedex/recipe"