@mailwoman/corpus 9.2.0 → 9.3.0

package/lib/recipes/locale.ts

@@ -0,0 +1,599 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   `locale` slice recipe — the multi-locale generalization of the `german` recipe. Reads REAL
+ *   OpenAddresses tuples for a `--country` (DE/FR/NL/IT/ES), renders each via
+ *   {@link synthesizeLocaleRow} in BOTH orders (`--intl-fraction`, default 0.4 international / the
+ *   rest country-native), aligns to BIO, and emits a labeled JSONL. Generate-mode: it STREAMS each
+ *   source CSV (a streamed zip member for cached zips, plain `createReadStream` for extracted CSVs) and
+ *   reservoir-samples to {@link RESERVOIR_CAP} (so FR/ES countrywide work in bounded memory), then
+ *   draws `--count` rows from the pool with the passed `random`. Ported from
+ *   scripts/build-locale-slice.mjs.
+ *
+ *   The reservoir uses its OWN seeded PRNG ({@link makeMulberry32}, per part), independent of the
+ *   emit `random`, so the input sample is reproducible WITHOUT perturbing the synth/order draws.
+ *
+ *   SURFACE DIVERSITY (#241): two per-country shape draws ride the emit loop, sized by the
+ *   2026-07-02 format-diversity audit against the `openaddresses-{es,nl,it}-sample.jsonl` observed
+ *   forms. ES: the OpenCage template comma-joins the house number (`CALLE MAYOR, 12`) but all 3,000
+ *   eval rows space-join (`CALLE MAYOR 12`) — {@link ES_SPACE_JOIN_FRACTION} of native rows collapse
+ *   the comma. NL: OA (and the eval, 3,000/3,000) glue the postcode (`1187LM`) while the national
+ *   convention spaces it (`1187 LM`) — {@link NL_GLUED_POSTCODE_FRACTION} of rows keep the glued
+ *   source shape, the rest the spaced conventional one. These draws are consumed ONLY for their
+ *   country, so DE/FR emit streams are unchanged for a given seed.
+ */
+
+import { COUNTRY_SURFACE_FORMS } from "@mailwoman/codex/country"
+import { dataRootPath } from "@mailwoman/core/data-root"
+import { openReadStream } from "@mailwoman/core/fs/streams"
+import { readZipEntry } from "@mailwoman/core/fs/zip"
+import { isPresent } from "@mailwoman/core/objects"
+import type { PathBuilderLike } from "path-ts"
+import { CSVSpliterator } from "spliterator"
+
+import { stableSourceID } from "#adapters/utils"
+import { makeMulberry32, type CorpusRecipe } from "#recipes/scaffold"
+import { type LocaleBaseTuple, type SynthesizedLocaleRow, synthesizeLocaleRow } from "#synthesizers/german"
+import { pick } from "#synthesizers/utils"
+import { alignRow } from "#utils"
+
+/**
+ * One per-country OA source part: either a cached `zip` + `csv` member (streamed out of the archive) or an extracted
+ * plain `path` (streamed via `createReadStream`). Both carry the standard OA header
+ * (LON,LAT,NUMBER,STREET,UNIT,CITY,DISTRICT,REGION,POSTCODE,ID,HASH). An optional `region` fallback covers countries
+ * whose REGION column is empty (DE — the Bundesland is implied by the per-state file).
+ */
+export interface LocalePart {
+	zip?: PathBuilderLike
+	csv?: string
+	path?: PathBuilderLike
+	region?: string
+	/**
+	 * NZ — the OA DISTRICT column holds the city (`Auckland`) and CITY holds the suburb (`Birkenhead`). When set, map
+	 * DISTRICT→locality and CITY→dependent_locality (falling back to CITY→locality when DISTRICT is empty, ~18% of NZ
+	 * rows). Without this, the default CITY→locality mapping wrongly trains the suburb as the locality.
+	 */
+	districtAsLocality?: boolean
+	/**
+	 * ES pedanía part only — the header is the RAW (un-conformed) CNIG export schema (`numero`, `tipo_vial`,
+	 * `nombre_via`, `poblacion`, `municipio`, `comunidad_autonoma`, `cod_postal`), NOT the standard OA
+	 * NUMBER/STREET/CITY/DISTRICT/REGION/POSTCODE header every other part uses. Verified 2026-07-22 by exact- coordinate
+	 * cross-check: the OA-conformed `extracted/es/countrywide.csv` collapses CITY to `municipio` and drops `poblacion`
+	 * (Spain's below-municipio núcleo/pedanía name) entirely, so the pedanía signal survives ONLY in this raw export.
+	 * `street` is reconstructed as `tipo_vial + " " + nombre_via` (verified byte-identical to the conformed STREET column
+	 * for the same row). CITY-analog = `poblacion`, DISTRICT-analog = `municipio`.
+	 */
+	cnigRaw?: boolean
+}
+
+export interface LocaleCountrySource {
+	source: string
+	parts: LocalePart[]
+	/**
+	 * The `corpus_version` stamped on emitted rows. DE/FR keep the historical `0.4.0` (regenerating those slices must
+	 * stay lineage-identical); ES/IT/NL are the #241 staging lineage (`v0.9.9-es-it-nl`).
+	 */
+	corpusVersion: string
+	/**
+	 * An ALTERNATE part list, read instead of {@link parts} when the `--district-as-locality` override is explicitly
+	 * `true` for this invocation (see `run()`). ES-only for now — the standard `parts` entry can't supply real
+	 * dependent-locality signal (its OA-conformed CSV drops `poblacion`; see {@link LocalePart.cnigRaw}), so the pedanía
+	 * build reads a wholly different raw source instead of flipping the standard CITY/DISTRICT columns. `undefined` for
+	 * every other country — the override then just forces `districtAsLocality` on the normal `parts`, as GB/NZ already do
+	 * per-part.
+	 */
+	pedaniaParts?: LocalePart[]
+}
+
+/**
+ * Per-country OA sources + the source name used in the corpus. DE/FR read their historical build inputs, the cached
+ * zips under `$MAILWOMAN_DATA_ROOT/oa-cache` — materialize them there to regenerate. ES/NL read the extracted
+ * countrywide CSVs and IT the cached national zip under `$MAILWOMAN_DATA_ROOT` (#241; the fresh ES extract is
+ * OA-conformed, so the old raw-CNIG conform map is gone). DE carries a per-part `region` fallback (its REGION column is
+ * empty; the international-order tail needs it, #327). FR/NL/IT/ES REGION is populated per-row (ES = comunidad
+ * autónoma, IT = regione, NL = province).
+ */
+const COUNTRY_SOURCES: Record<string, LocaleCountrySource> = {
+	DE: {
+		source: "synth-german",
+		corpusVersion: "0.4.0",
+		parts: [
+			{ zip: dataRootPath("oa-cache", "de__berlin.zip"), csv: "de/berlin.csv", region: "Berlin" },
+			{ zip: dataRootPath("oa-cache", "de__sn__statewide.zip"), csv: "de/sn/statewide.csv", region: "Sachsen" },
+		],
+	},
+	FR: {
+		source: "synth-fr",
+		corpusVersion: "0.4.0",
+		parts: [{ zip: dataRootPath("oa-cache", "fr__countrywide.zip"), csv: "fr/countrywide.csv" }],
+	},
+	NL: {
+		source: "synth-nl",
+		corpusVersion: "0.9.9",
+		parts: [{ path: dataRootPath("openaddresses", "extracted", "nl", "countrywide.csv") }],
+	},
+	IT: {
+		source: "synth-it",
+		corpusVersion: "0.9.9",
+		parts: [{ zip: dataRootPath("oa-cache", "it__countrywide.zip"), csv: "it/countrywide.csv" }],
+	},
+	ES: {
+		source: "synth-es",
+		corpusVersion: "0.9.9",
+		parts: [{ path: dataRootPath("openaddresses", "extracted", "es", "countrywide.csv") }],
+		// Pedanía slice (`synth-es-pedania`, `--district-as-locality`). Reads the RAW (un-conformed) CNIG export
+		// cached at oa-cache/es__countrywide.zip — the `parts` CSV above lost `poblacion` in OA's own conform step
+		// (see {@link LocalePart.cnigRaw}). districtAsLocality is pinned true here (this part only exists to be
+		// read pedanía-style); the CLI override still applies harmlessly on top.
+		pedaniaParts: [
+			{
+				zip: dataRootPath("oa-cache", "es__countrywide.zip"),
+				csv: "es_addresses.csv",
+				cnigRaw: true,
+				districtAsLocality: true,
+			},
+		],
+	},
+	NZ: {
+		// LINZ-derived OA countrywide extract (2.12M rows). `districtAsLocality` inverts the CITY/DISTRICT
+		// mapping: DISTRICT holds the city (Auckland), CITY the suburb (Birkenhead). NZ OA carries no postcode.
+		source: "synth-nz",
+		corpusVersion: "0.9.9",
+		// Eval holdout: a probe build excludes ~12% of NZ localities (a locality-bucket split) for a source-disjoint
+		// coord board; that split is a BUILD-TIME concern (scratchpad), so the committed recipe reads the full CSV.
+		parts: [{ path: dataRootPath("openaddresses", "extracted", "nz", "countrywide.csv"), districtAsLocality: true }],
+	},
+	GB: {
+		// HM Land Registry Price Paid Data tuples (25.67M rows out of the PPD ingest). PPD's DISTRICT is the
+		// postal town (locality) and CITY is the dependent locality — legitimately EMPTY on the majority of rows
+		// (most GB addresses have no dependent locality). `districtAsLocality` maps DISTRICT→locality and, when
+		// present, CITY→dependent_locality; the `readTuples` check above only drops a row when BOTH are empty, so
+		// the majority empty-CITY rows survive.
+		source: "synth-gb",
+		corpusVersion: "0.9.9",
+		parts: [{ path: dataRootPath("ppd", "2026-07-22", "gb-tuples.csv"), districtAsLocality: true }],
+	},
+}
+
+/**
+ * Per-part reservoir cap. Streaming + Algorithm-R reservoir sampling to this size keeps memory bounded regardless of
+ * source size, where buffering the whole CSV OOMs / overflows on FR/ES countrywide (~2.5 GB, ~25M rows). DE/NL-scale
+ * sources (≤ ~1.2M) fit entirely, so they're sampled losslessly.
+ */
+const RESERVOIR_CAP = 1_200_000
+
+/**
+ * Fraction of NATIVE-order ES rows whose street→house join is space-collapsed (`CALLE MAYOR 12`) instead of the
+ * template's comma (`CALLE MAYOR, 12`). Both are real Spanish surfaces — the comma is the official convention, the
+ * space is what OA-derived feeds (and all 3,000 `openaddresses-es-sample.jsonl` rows) carry. 0.5 teaches both.
+ */
+const ES_SPACE_JOIN_FRACTION = 0.5
+
+/**
+ * Fraction of NL rows whose postcode keeps OA's glued shape (`1187LM`) instead of the spaced national convention (`1187
+ * LM`). The eval sample is 100% glued; the conventional spaced form is the `1012 LM` two-letter-suffix shape the model
+ * currently glues onto the city (#241). 0.5 teaches both.
+ */
+const NL_GLUED_POSTCODE_FRACTION = 0.5
+
+/**
+ * OA CITY-noise normalization (#241) — the documented cleaning step, derived from the 2026-07-02 FULL-STREAM audit of
+ * the ES (15.6M rows), IT (13.9M), and NL (9.1M) sources (not a hand-list). Returns the cleaned city, or `null` to drop
+ * the tuple.
+ *
+ * Cleaned classes:
+ *
+ * 1. DROP pseudo-localities — the ES cadastral aggregates (`Comunidad de 09076, 09150 y 09578`, `Ledanía de …`; 0.06% of
+ *    ES rows): any CITY containing a comma or a ≥4-digit run is a land-register aggregate, not a renderable city.
+ *    Structural, locale-safe — NL's genuine `2e Valthermond` (one digit) survives; IT/NL have zero hits.
+ * 2. STRIP a trailing parenthesized 1–3-letter admin code — the NL BAG province disambiguator (`Bergen (NH)`, `Rijswijk
+ *    (GLD)` → `Bergen`, `Rijswijk`; 0.13% of NL rows). The analogue of the German Kreis/region-suffix class (#241 names
+ *    `Rabenau Sachs` / `Weißwasser /O.L.`): an admin-region gloss glued onto the locality value that dirties locality
+ *    labels.
+ *
+ * Audit-verified NON-noise, deliberately NOT cleaned (a naive suffix rule would mangle real names):
+ *
+ * - ES/IT city-ends-with-province (`Alhama de Almería`, `GENZANO DI ROMA`; ~0.8% each): genuine toponyms whose linking
+ *   `de`/`di` makes them full names, unlike the German glued-abbreviation class.
+ * - ES bilingual slash names (`Laudio/Llodio`; 2.16%): official co-names — the eval expects them verbatim.
+ * - IT ALL-CAPS city casing (98.79% of the source, and the eval's observed form): casing is the #829 case-augmentation
+ *   change, not this slice's.
+ */
+export function cleanCityNoise(city: string): string | null {
+	if (/,|\d{4}/.test(city)) return null
+
+	const stripped = city.replace(/\s*\(\p{L}{1,3}\)\s*$/u, "").trim()
+
+	return stripped || null
+}
+
+interface ColumnIndex {
+	num: number
+	street: number
+	city: number
+	district: number
+	region: number
+	post: number
+	/**
+	 * {@link LocalePart.cnigRaw} only — the road-type column (`tipo_vial`) joined onto `street` (`nombre_via`). -1
+	 * otherwise.
+	 */
+	tipoVial: number
+}
+
+/**
+ * Stream real tuples out of an OA source part and reservoir-sample to {@link RESERVOIR_CAP}. Reads the CSV row-by-row —
+ * `readZipEntry | CSVSpliterator` for zip parts, `createReadStream | CSVSpliterator` for extracted parts (both bounded
+ * memory) — and keeps a uniform random sample (Algorithm R) seeded by `rng`, separate from the emit loop's PRNG. NO
+ * global dedup (a 25M-key Set would OOM; OA rows are near-unique). The city passes through {@link cleanCityNoise}; the
+ * region falls back to `part.region` when the row's REGION cell is empty (DE).
+ *
+ * Exported for {@link locale.test.ts} — the CSV read path (quote handling, CRLF, region fallback) has no other test.
+ */
+export async function readTuples(part: LocalePart, rng: () => number): Promise<LocaleBaseTuple[]> {
+	// No `encoding` on the file path — CSVSpliterator delimits raw bytes and decodes utf-8 itself; a string stream
+	// (from `{ encoding: "utf8" }`) would defeat its byte-range scanner.
+	const input: NodeJS.ReadableStream | AsyncIterable<Uint8Array> = part.path
+		? openReadStream(part.path)
+		: readZipEntry(part.zip!, part.csv!)
+
+	const get = (cells: string[], i: number): string => (i >= 0 && i < cells.length ? (cells[i] ?? "").trim() : "")
+	const reservoir: LocaleBaseTuple[] = []
+	let cols: ColumnIndex | null = null
+	let header: string[] | null = null
+	let seen = 0
+	let dropped = 0
+
+	try {
+		// CSVSpliterator handles OA's quoted fields (embedded commas/newlines) and CRLF row terminators
+		// (spliterator ≥ 3.2.0); `header: false` yields the header row too, so the column index is built
+		// from that first row rather than from a header option.
+		for await (const cells of CSVSpliterator.fromAsync<string[]>(input, {
+			mode: "array",
+			header: false,
+			enableQuoteHandling: true,
+		})) {
+			if (header === null) {
+				header = cells.map((h) => h.trim().toLowerCase())
+				// oxlint-disable-next-line no-loop-func -- the binding is per-iteration (for-of/for-await) and the batch is awaited before the next
+				const ix = (name: string): number => header!.indexOf(name)
+
+				// `cnigRaw` (ES pedanía only): the RAW CNIG header has no NUMBER/STREET/CITY/DISTRICT/REGION/POSTCODE
+				// at all — `numero`/`nombre_via`/`poblacion`/`municipio`/`comunidad_autonoma`/`cod_postal` instead.
+				// See {@link LocalePart.cnigRaw}.
+				cols = part.cnigRaw
+					? {
+							num: ix("numero"),
+							street: ix("nombre_via"),
+							tipoVial: ix("tipo_vial"),
+							city: ix("poblacion"),
+							district: ix("municipio"),
+							region: ix("comunidad_autonoma"),
+							post: ix("cod_postal"),
+						}
+					: {
+							num: ix("number"),
+							street: ix("street"),
+							tipoVial: -1,
+							city: ix("city"),
+							district: ix("district"),
+							region: ix("region"),
+							post: ix("postcode"),
+						}
+
+				continue
+			}
+
+			if (cols === null) continue
+
+			// cnigRaw: STREET is split into a road-type column (`tipo_vial`, e.g. "CARRETERA") and the name
+			// (`nombre_via`) — rejoin them exactly as OA's own conform step does (verified byte-identical to the
+			// conformed STREET column for the same source row). Every other part's header already carries the
+			// pre-joined STREET column, so `cols.tipoVial === -1` and this is a no-op there.
+			const street =
+				cols.tipoVial >= 0
+					? [get(cells, cols.tipoVial), get(cells, cols.street)].filter(isPresent).join(" ")
+					: get(cells, cols.street)
+
+			const rawCity = get(cells, cols.city)
+
+			if (!street) continue
+
+			// Default: CITY → locality. NZ/GB (`districtAsLocality`) inverts it — the OA DISTRICT holds the city
+			// (`Auckland`) and CITY holds the suburb (`Birkenhead`), so DISTRICT → locality and CITY →
+			// dependent_locality. When DISTRICT is empty (~18% of NZ rows), fall back to CITY → locality with no
+			// sub-locality. GB PPD tuples flip which side is legitimately empty — on the MAJORITY of GB rows CITY
+			// (the dependent_locality) is empty and DISTRICT (the locality) is populated, so the check below only
+			// drops a `districtAsLocality` row when BOTH are empty, never when CITY alone is — filtering on CITY
+			// alone silently discards most of the GB source. See {@link LocalePart.districtAsLocality}.
+			let locality: string | null
+			let dependent_locality: string | undefined
+
+			if (part.districtAsLocality) {
+				const rawDistrict = get(cells, cols.district)
+
+				if (!rawCity && !rawDistrict) continue
+
+				const cleanedDistrict = cleanCityNoise(rawDistrict)
+
+				if (cleanedDistrict) {
+					locality = cleanedDistrict
+					const cleanedCity = cleanCityNoise(rawCity)
+
+					// ES pedanía lesson (2026-07-22): the CNIG `poblacion` column is filled on ~93% of rows but
+					// EQUALS `municipio` on the majority of those (the address point sits in the municipio's own
+					// main town, not a below-municipio pedanía) — only ~32.6% of ES rows carry a genuinely
+					// DISTINCT poblacion. GB/NZ never hit this (CITY/DISTRICT name the same place only by rare
+					// coincidence), but the guard is general: a dependent_locality equal to its own locality is
+					// never a real sub-locality, so drop it rather than emit a same-value pair (would fail the
+					// dep_loc≠locality invariant every recipe otherwise upholds).
+					dependent_locality =
+						cleanedCity && cleanedCity.localeCompare(locality, undefined, { sensitivity: "base" }) !== 0
+							? cleanedCity
+							: undefined
+				} else {
+					locality = cleanCityNoise(rawCity)
+				}
+			} else {
+				if (!rawCity) continue
+				locality = cleanCityNoise(rawCity)
+			}
+
+			if (!locality) {
+				dropped++
+
+				continue
+			}
+
+			const tuple: LocaleBaseTuple = {
+				house_number: get(cells, cols.num),
+				street,
+				locality,
+				region: get(cells, cols.region) || part.region || "",
+				postcode: get(cells, cols.post),
+				...(dependent_locality ? { dependent_locality } : {}),
+			}
+
+			seen++
+
+			if (reservoir.length < RESERVOIR_CAP) {
+				reservoir.push(tuple)
+			} else {
+				const j = Math.floor(rng() * seen)
+
+				// 0 .. seen-1
+				if (j < RESERVOIR_CAP) {
+					reservoir[j] = tuple
+				}
+			}
+		}
+	} catch (error) {
+		console.error(`  WARN: read failed for ${part.path ?? part.zip}: ${(error as Error).message}`)
+
+		return []
+	}
+
+	console.error(`  ${part.path ?? part.csv}: ${reservoir.length} sampled of ${seen} rows (${dropped} city-noise drops)`)
+
+	return reservoir
+}
+
+/**
+ * Country-append fraction (the fr-admin-split #728 pattern, generalized to the locale recipe): mutates `synth` in
+ * place, `countryFraction` of the time appending an explicit country surface form ("United Kingdom") to `raw` + a
+ * `country` component — the model relearns to emit country WHEN the token is present without over-firing it on the
+ * (still-majority) country-less rows. `countryFraction <= 0` (the default) short-circuits the `random()` draw away
+ * entirely — no `synth` mutation and no RNG consumption — so every existing locale's emit stream stays byte-identical
+ * to before this option existed. Exported for {@link locale.test.ts}.
+ */
+export function applyCountryAppend(
+	synth: SynthesizedLocaleRow,
+	country: string,
+	countryFraction: number,
+	random: () => number
+): void {
+	if (countryFraction > 0 && random() < countryFraction) {
+		const forms = COUNTRY_SURFACE_FORMS[country as keyof typeof COUNTRY_SURFACE_FORMS]
+
+		if (!forms?.length) {
+			// The BR/NZ lesson: a missing table entry must never silently no-op a requested fraction —
+			// it must raise so the gap is caught at build time, not discovered later as a 0% check failure.
+			throw new Error(
+				`No COUNTRY_SURFACE_FORMS entry for ${country} — add it to codex/country/country.ts before using --country-fraction`
+			)
+		}
+
+		const form = pick(forms, random)
+		synth.raw = `${synth.raw}, ${form}`
+		synth.components = { ...synth.components, country: form }
+	}
+}
+
+/**
+ * Merge the `--district-as-locality` CLI override onto one part. `undefined` (flag absent) returns `part` unchanged
+ * (same object — no allocation, no behavior change); `true`/`false` returns a shallow copy with `districtAsLocality`
+ * forced to that value for this invocation only. Exported for {@link locale.test.ts}.
+ */
+export function applyDistrictAsLocalityOverride(part: LocalePart, override: boolean | undefined): LocalePart {
+	return override === undefined ? part : { ...part, districtAsLocality: override }
+}
+
+/**
+ * Pick which part list a `--country` run reads: {@link LocaleCountrySource.pedaniaParts} when the override is explicitly
+ * `true` AND the country registers one (ES only, so far), else the default `parts` — unchanged for every other
+ * country/override combination. Exported for {@link locale.test.ts}.
+ */
+export function resolveLocaleParts(countrySource: LocaleCountrySource, override: boolean | undefined): LocalePart[] {
+	return override === true && countrySource.pedaniaParts ? countrySource.pedaniaParts : countrySource.parts
+}
+
+/**
+ * Slice recipe registered with the corpus builder — see the file header for the parse behaviour it exists to exercise,
+ * and `description` below for the surface form it generates.
+ */
+export const localeRecipe: CorpusRecipe = {
+	name: "locale",
+	description: "Per-locale coverage rows (DE/FR/NL/IT/ES/NZ/GB) from real OA tuples, both orders → synthesizeLocaleRow",
+	mode: "generate",
+	options: [
+		{ flag: "--country <cc>", description: "Target country (DE|FR|NL|IT|ES|NZ|GB). Default DE" },
+		{ flag: "--intl-fraction <f>", description: "Fraction rendered international order. Default 0.4" },
+		{
+			flag: "--country-fraction <f>",
+			description:
+				"Fraction of rows that append an explicit country surface form (`, United Kingdom`) + a `country` component (fr-admin-split pattern). Default 0 — byte-identical to before when unset.",
+		},
+		{
+			flag: "--district-as-locality / --no-district-as-locality",
+			description:
+				"Override the per-part districtAsLocality mapping for this run. Unset (default) leaves each COUNTRY_SOURCES part's own value untouched — every existing build stays byte-identical. ES additionally switches to the pedanía (poblacion→dependent_locality) source when passed as true — combine with --source-name synth-es-pedania.",
+		},
+	],
+	async run(opts, write) {
+		// Emit PRNG: the legacy build-locale-slice.mjs seeded mulberry32(opts.seed). The reservoir uses a
+		// SEPARATE per-part mulberry32 (below) so input sampling never perturbs this emit stream.
+		const random = makeMulberry32(opts.seed)
+		const country = (opts.country ?? "DE").toUpperCase()
+		const countrySource = COUNTRY_SOURCES[country]
+
+		if (!countrySource) {
+			throw new Error(
+				`No OA sources registered for --country ${country}. Known: ${Object.keys(COUNTRY_SOURCES).join(", ")}.`
+			)
+		}
+
+		const intlFraction = opts.intlFraction ?? 0.4
+
+		if (!(intlFraction >= 0 && intlFraction <= 1)) {
+			throw new Error(`--intl-fraction must be in [0, 1], got ${intlFraction}`)
+		}
+
+		// Default 0 → the `random() < countryFraction` draw below is short-circuited away entirely (never
+		// consumed), so every existing locale's emit stream is byte-identical to before this option existed.
+		const countryFraction = opts.countryFraction ?? 0
+
+		if (!(countryFraction >= 0 && countryFraction <= 1)) {
+			throw new Error(`--country-fraction must be in [0, 1], got ${countryFraction}`)
+		}
+
+		const source = opts.sourceName ?? countrySource.source
+		const count = opts.count ?? 4000
+		// Tri-state: `undefined` (flag absent) touches nothing below — `parts` stays the default list and each
+		// part keeps its own `districtAsLocality`, so every existing locale build is byte-identical to before this
+		// option existed. `true` additionally selects `pedaniaParts` when the country registers one (ES); `false`
+		// forces the mapping off on every part read this run (a debugging override for GB/NZ).
+		const districtAsLocalityOverride = opts.districtAsLocality
+		const parts = resolveLocaleParts(countrySource, districtAsLocalityOverride)
+
+		const pool: LocaleBaseTuple[] = []
+
+		for (let pi = 0; pi < parts.length; pi++) {
+			// A reservoir PRNG per part, seeded but independent of the emit loop's `random`, so the sample is
+			// reproducible without perturbing the synth/order draws.
+			const reservoirRng = makeMulberry32((opts.seed ^ (0x9e_37_79_b9 * (pi + 1))) >>> 0)
+			const effectivePart = applyDistrictAsLocalityOverride(parts[pi]!, districtAsLocalityOverride)
+			const t = await readTuples(effectivePart, reservoirRng)
+
+			for (const x of t) {
+				pool.push(x)
+			} // NOT pool.push(...t) — spreading huge arrays overflows the stack
+		}
+
+		if (!pool.length) {
+			throw new Error(`No ${country} tuples found — are the source CSVs/zips present? (see COUNTRY_SOURCES)`)
+		}
+
+		let emitted = 0
+		let skipped = 0
+		let guard = 0
+		const N = pool.length
+
+		while (emitted < count && guard++ < count * 6) {
+			const base = pool[Math.floor(random() * N)]!
+			const order = random() < intlFraction ? "international" : "native"
+
+			// Per-country surface-shape draws (#241) — consumed ONLY for that country, so the DE/FR emit
+			// streams for a given seed are unchanged by their existence.
+			const nativeHouseJoin =
+				country === "ES" ? (random() < ES_SPACE_JOIN_FRACTION ? ("space" as const) : ("template" as const)) : undefined
+
+			const postcodeShape =
+				country === "NL"
+					? random() < NL_GLUED_POSTCODE_FRACTION
+						? ("as-source" as const)
+						: ("conventional" as const)
+					: undefined
+
+			const synth = synthesizeLocaleRow(base, country, { random, order, nativeHouseJoin, postcodeShape })
+
+			if (!synth) {
+				skipped++
+
+				continue
+			}
+
+			applyCountryAppend(synth, country, countryFraction, random)
+
+			if (opts.golden) {
+				// Golden rows must round-trip through alignRow exactly like training rows (#241 done-when): a
+				// render that can't be BIO-labeled can't serve as a parser golden either. Consumes no RNG draw.
+				const goldenCanonical = {
+					raw: synth.raw,
+					components: synth.components,
+					country,
+					locale: synth.locale,
+					source,
+					source_id: "golden:align-check",
+				}
+
+				const goldenAligned = alignRow(goldenCanonical as Parameters<typeof alignRow>[0])
+
+				if (goldenAligned.kind !== "labeled" || !goldenAligned.row) {
+					skipped++
+
+					continue
+				}
+
+				write(JSON.stringify({ raw: synth.raw, components: synth.components, country, order }) + "\n")
+
+				emitted++
+
+				continue
+			}
+
+			const sourceID = stableSourceID(source, {
+				street: synth.components.street,
+				house_number: synth.components.house_number,
+				locality: synth.components.locality,
+				postcode: synth.components.postcode,
+			})
+
+			const canonical = {
+				raw: synth.raw,
+				components: synth.components,
+				country,
+				locale: synth.locale,
+				source,
+				source_id: sourceID,
+				corpus_version: countrySource.corpusVersion,
+				license: `OpenAddresses ${country} tuples, rendered ${order}-order — see ingest SOURCES`,
+			}
+
+			const aligned = alignRow(canonical as Parameters<typeof alignRow>[0])
+
+			if (aligned.kind !== "labeled" || !aligned.row) {
+				skipped++
+
+				continue
+			}
+
+			write(JSON.stringify({ ...aligned.row, synth_method: source, synth_order: order, synth_base_id: null }) + "\n")
+
+			emitted++
+		}
+
+		return { emitted, skipped }
+	},
+}