@mailwoman/corpus 9.3.0 → 10.0.0

package/lib/adapters/wof-postalcode-json/adapter.ts

@@ -1,176 +0,0 @@
-/**
- * @copyright Sister Software
- * @license AGPL-3.0
- * @author Teffen Ellis, et al.
- *
- *   `wof-postalcode`: Who's On First postalcode GeoJSON-bundle adapter.
- *
- *   **Phase 1.5.1 pivot.** Replaces the previous SpatiaLite-backed implementation (formerly at
- *   `packages/corpus/lib/adapters/wof-postalcode/`, removed in this same change). The rationale is
- *   in `wof-admin-json/adapter.ts` and in `DECISIONS.md` — short version: the SQLite distribution
- *   mirror is dead, the live distro tags every postcode row `mz:is_current = -1` which the old
- *   `is_current = 1` predicate excluded, and localized `name:*` variants don't ship in the SQLite
- *   export at all.
- *
- *   Input: a directory containing one or more cloned `whosonfirst-data-postalcode-<cc>` repos plus
- *   the relevant `whosonfirst-data-admin-<cc>` repos (postcode records reference admin ancestry by
- *   `wof:parent_id`, so the locality / region / country records must be in the same walk for the
- *   ancestry chain to resolve). The corpus pipeline clones all four repos under
- *   `/data/corpus/sources/wof/repos/` and points the adapter at that root.
- *
- *   Per live postalcode record, the adapter emits one row per `(name-variant, hierarchy-variant)`
- *   pair:
- *
- *   - **Name variants**: canonical `wof:name` (slot key `default`, typically the postcode digits
- *       themselves) plus any `name:*` variants on the postcode feature. In practice WOF postcode
- *       records rarely carry localized name variants, so this expansion is usually a no-op — but
- *       the code path stays symmetric with the admin adapter for consistency.
- *   - **Hierarchy variants** (unchanged from the SQLite adapter): self, +locality, +locality+region,
- *       +locality+region+country.
- *
- *   `source_id` is `wof-postalcode-<wof_id>-<name-slot>-<hierarchy-variant>`. Ancestor names always
- *   come from the ancestor's canonical `wof:name`; this adapter does NOT iterate ancestor name
- *   variants (e.g. it does not emit `"75008 Париж"` even when Paris has a `name:rus_x_preferred`).
- *   That cross-product belongs to a future synthesis pass; emitting it here would multiply row
- *   counts ~10× without a clear training-value story.
- *
- *   License: CC0.
- */
-
-import type { WhosOnFirstPlacetype } from "@mailwoman/core/resources/whosonfirst"
-import type { ComponentTag } from "@mailwoman/core/types"
-
-import {
-	COUNTRY_DISPLAY_NAME,
-	emitWOFJSONRows,
-	LOCALE_BY_COUNTRY,
-	nameSlotsFor as wofNameSlotsFor,
-	type WOFVariantSpec,
-} from "#adapters/wof-json-rows"
-import type { AdapterOptions, CanonicalRow, CorpusAdapter } from "#types"
-import { buildAncestryIndex, walkFeatures, type WOFRecord } from "#utils"
-
-/**
- * Map a WOF placetype to a Mailwoman `ComponentTag`, or `undefined` to skip.
- *
- * Per-adapter deliberately (the admin adapter carries its own): each table is a record FILTER for its adapter's
- * emission set — this one keeps `postalcode` plus the ancestry placetypes its variants render — not a shared
- * vocabulary.
- */
-function placetypeToTag(placetype: WhosOnFirstPlacetype | string): ComponentTag | undefined {
-	switch (placetype) {
-		case "country":
-		case "nation":
-			return "country"
-		case "macroregion":
-		case "region":
-			return "region"
-		case "locality":
-			return "locality"
-		case "postalcode":
-			return "postcode"
-		default:
-			return undefined
-	}
-}
-
-/**
- * Compute hierarchy variants for a postcode record. `selfName` is the postcode surface form (canonical `wof:name` for
- * the `default` slot, a `name:*` localized variant otherwise).
- */
-export function postcodeVariantsFor(row: WOFRecord, ancestry: WOFRecord[], selfName: string): WOFVariantSpec[] {
-	if (placetypeToTag(row.placetype) !== "postcode") return []
-
-	const locality = ancestry.find((a) => placetypeToTag(a.placetype) === "locality")
-	const region = ancestry.find((a) => placetypeToTag(a.placetype) === "region")
-	const country = ancestry.find((a) => placetypeToTag(a.placetype) === "country")
-	const countryDisplay = COUNTRY_DISPLAY_NAME[row.country] ?? country?.name ?? row.country
-
-	const variants: WOFVariantSpec[] = [{ suffix: "self", components: { postcode: selfName } }]
-
-	if (locality) {
-		variants.push({
-			suffix: "with-locality",
-			components: { postcode: selfName, locality: locality.name },
-		})
-	}
-
-	if (locality && region) {
-		variants.push({
-			suffix: "with-locality-region",
-			components: { postcode: selfName, locality: locality.name, region: region.name },
-		})
-	}
-
-	if (locality && region && country) {
-		variants.push({
-			suffix: "with-locality-region-country",
-			components: {
-				postcode: selfName,
-				locality: locality.name,
-				region: region.name,
-				country: countryDisplay,
-			},
-		})
-	}
-
-	return variants
-}
-
-/**
- * Build the per-record name-slot list. The `default` slot uses `wof:name` verbatim (postcode digits); subsequent slots
- * come from `name:*` variants dedup'd against the default.
- */
-export function nameSlotsFor(rec: WOFRecord): Array<{ key: string; value: string }> {
-	return wofNameSlotsFor(rec)
-}
-
-/**
- * Registry id for this adapter. Stamped into every row it emits, so a corpus record can be traced back to the dataset
- * it came from.
- */
-export const WOF_POSTALCODE_ADAPTER_ID = "wof-postalcode"
-
-export function createWOFPostalcodeAdapter(): CorpusAdapter {
-	return {
-		id: WOF_POSTALCODE_ADAPTER_ID,
-		defaultLicense: "CC0-1.0",
-		description:
-			"Who's On First postalcode GeoJSON bundles (postcode → locality/region pairs). Ancestor names from sibling admin repos.",
-
-		async *rows(opts: AdapterOptions): AsyncIterable<CanonicalRow> {
-			// Pass 1: full walk. We keep every record whose placetype maps to a ComponentTag — the
-			// postcode adapter needs locality / region / country admin records in the index so it
-			// can resolve postcode ancestry, even though it only emits rows for postcode records.
-			const byID = new Map<number, WOFRecord>()
-
-			for await (const rec of walkFeatures(opts.inputPath, { signal: opts.signal })) {
-				if (opts.signal?.aborted) return
-
-				if (opts.country && rec.country !== opts.country) continue
-
-				if (!placetypeToTag(rec.placetype)) continue
-				byID.set(rec.id, rec)
-			}
-
-			const ancestry = buildAncestryIndex(byID)
-
-			// Pass 2: emit postcode rows only, sorted by id for determinism.
-			yield* emitWOFJSONRows({
-				records: byID,
-				ancestry,
-				adapterOptions: opts,
-				adapterID: WOF_POSTALCODE_ADAPTER_ID,
-				localeByCountry: LOCALE_BY_COUNTRY,
-				shouldEmit: (record) => placetypeToTag(record.placetype) === "postcode",
-				nameSlotsFor,
-				variantsFor: postcodeVariantsFor,
-			})
-		},
-	}
-}
-
-/**
- * The configured adapter instance registered with the corpus builder.
- */
-export const wofPostalcodeAdapter = createWOFPostalcodeAdapter()

package/lib/name-prone-us-suffixes.ts

@@ -1,12 +0,0 @@
-/**
- * @copyright Sister Software
- * @license AGPL-3.0
- * @author Teffen Ellis, et al.
- *
- * Re-export shim: the name-prone set moved to `@mailwoman/codex/us` (data in
- * `codex/us/street-suffix.json`, 2026-08-10) so the golden relabel flags, the #1569 slice
- * recipe, AND the Python relabel pass (via the `gazetteer affix-relabel` v2 lexicon) all read
- * one record. Import from `@mailwoman/codex/us` in new code.
- */
-
-export { NAME_PRONE_US_SUFFIXES } from "@mailwoman/codex/us"

package/lib/recipes/bare-country.ts

@@ -1,95 +0,0 @@
-/**
- * @copyright Sister Software
- * @license AGPL-3.0
- * @author Teffen Ellis, et al.
- *
- *   `bare-country` — the country name as the WHOLE query. Addresses almost never consist of one bare
- *   country name, so the class is out of the model's training distribution and the tag is a coin
- *   flip: measured on the 2026-08-13 panel, France/Germany/United States/New Zealand parsed
- *   `country` while Japan/China/Nigeria/Australia/Deutschland parsed `locality`. The retrieval-side
- *   bare-country race (#1651) covers the answer either way; this slice closes the PARSE half so the
- *   tag itself is right.
- *
- *   Source is the codex country table — every ISO canonical English name plus the curated surface
- *   forms (endonyms and long-form names). The 2–3 letter CODES are deliberately excluded: a bare
- *   `JP` or `GER` is an abbreviation register with its own ambiguity surface (`IN`, `DE`, `TO` are
- *   English words), and teaching it here would be an unmeasured claim. Case augmentation is the
- *   loader's job, as everywhere.
- */
-
-import { COUNTRY_SURFACE_FORMS, CountryNames, matchCountry } from "@mailwoman/codex/country"
-
-import { alignAndWrite, makeMulberry32, type CorpusRecipe, sliceSourceID } from "#recipes/scaffold"
-
-/**
- * Surfaces shorter than this are the code register (`JP`, `GER`), not a name — excluded (see the module doc).
- */
-const MIN_NAME_LENGTH = 4
-
-/**
- * Every (surface, iso2) pair the slice emits: the ISO canonical names plus each country's curated surface forms,
- * deduplicated on the surface string (a form shared across countries — none known — would keep its first bearer).
- */
-function* bareCountrySurfaces(): Generator<{ surface: string; iso2: string }> {
-	const seen = new Set<string>()
-
-	for (const [iso2, forms] of Object.entries(COUNTRY_SURFACE_FORMS)) {
-		for (const surface of forms) {
-			if (surface.length < MIN_NAME_LENGTH || seen.has(surface)) continue
-			seen.add(surface)
-			yield { surface, iso2 }
-		}
-	}
-
-	for (const name of CountryNames) {
-		if (name.length < MIN_NAME_LENGTH || seen.has(name)) continue
-		const matched = matchCountry(name)
-
-		if (!matched) continue
-		seen.add(name)
-		yield { surface: name, iso2: matched.iso2 }
-	}
-}
-
-/**
- * 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 bareCountryRecipe: CorpusRecipe = {
-	name: "bare-country",
-	description: "The country name as the whole query (#1651 parse half): ISO names + curated endonyms, no codes",
-	mode: "generate",
-	async run(opts, write) {
-		// Seeded for parity with the other recipes; the surfaces themselves drive the content.
-		makeMulberry32(opts.seed)
-		let read = 0
-		let emitted = 0
-		let skipped = 0
-
-		for (const { surface, iso2 } of bareCountrySurfaces()) {
-			read++
-
-			const components: Record<string, string> = { country: surface }
-			const source_id = sliceSourceID("synth-bare-country", { country: surface, cc: iso2, v: String(read) })
-
-			const canonical = {
-				raw: surface,
-				components,
-				country: iso2,
-				locale: "und",
-				source: "synth-bare-country",
-				source_id,
-				corpus_version: "0.11.0",
-				license: "Synthetic — bare-country; surfaces from the codex country table (ISO 3166 + curated forms)",
-			}
-
-			if (alignAndWrite(write, canonical, "bare-country")) {
-				emitted++
-			} else {
-				skipped++
-			}
-		}
-
-		return { read, emitted, skipped }
-	},
-}

package/lib/recipes/cz-pcfirst-preposition.ts

@@ -1,111 +0,0 @@
-/**
- * @copyright Sister Software
- * @license AGPL-3.0
- * @author Teffen Ellis, et al.
- *
- *   `cz-pcfirst-preposition` — the Czech pc-first prepositional-locality slice, fourth orthography
- *   of the #901 leading-name-boundary family. The #897 close-out read all 8 residual CZ rows as one
- *   class: a LEADING postcode mis-assigned as house_number while the multi-word "nad/pod/u X"
- *   locality shatters ("51244 Rokytnice nad Jizerou, Dolní Rokytnice 111" → street
- *   'RokytnicenadJizerou' + house_number '51244'). That leading-5-digit confusion is the
- *   anchor-pollution class whose decode-time OVERRIDE was correctly killed in #723 — this slice is
- *   the model-first fix as DATA: real prepositional localities in the order that breaks, so the
- *   model learns that a leading postcode before a multi-word name is a postcode. pc-first leads the
- *   cycle (the lesson); canonical and city-first keep the polarity balanced (the v1.9.9 lesson).
- */
-
-import { alignAndWrite, makeMulberry32, readTuples, type CorpusRecipe, sliceSourceID } from "#recipes/scaffold"
-
-/**
- * The order-cycle slot for the STREET-LESS form (`«city» «pc», Česko`) — the exact surface of the
- * `cz-full-praha-100-00` board row, whose absence from the street-bearing orders was the v4.5.0 no-promote's measured
- * gap.
- */
-const STREETLESS_ORDER = 3
-
-/**
- * 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 czPcFirstPrepositionRecipe: CorpusRecipe = {
-	name: "cz-pcfirst-preposition",
-	description:
-		"CZ pc-first + prepositional locality (#901 family): '«pc» «city nad X», «st» «n»' — the #723 class as data",
-	mode: "tuples",
-	async run(opts, write) {
-		makeMulberry32(opts.seed)
-		let read = 0
-		let emitted = 0
-		let skipped = 0
-
-		for await (const t of readTuples(opts.input!)) {
-			read++
-			const street = String(t.street ?? "").trim()
-			const city = String(t.locality ?? "").trim()
-			const number = String(t.number ?? "").trim()
-			const postcode = String(t.postcode ?? "").trim()
-
-			if (!street || !city || !number || !postcode) {
-				skipped++
-
-				continue
-			}
-
-			const order = read % 4
-			// The OFFICIAL Czech rendering spaces the PSČ as `NNN NN` ('512 44'); OpenAddresses stores it
-			// unspaced ('51244'), and a model trained only on the source form reads the spaced surface as
-			// house_number + garbage (the 'Praha 100 00' mangle). Alternate the two renderings so both
-			// orthographies are attested — the LABEL is the postcode either way.
-			const spaced = read % 2 === 0 && /^\d{5}$/.test(postcode)
-			const postcodeSurface = spaced ? `${postcode.slice(0, 3)} ${postcode.slice(3)}` : postcode
-			let raw: string
-
-			const components: Record<string, string> =
-				order === STREETLESS_ORDER
-					? { locality: city, postcode: postcodeSurface, country: "Česko" }
-					: { street, house_number: number, postcode: postcodeSurface, locality: city }
-
-			if (order === 0) {
-				raw = `${postcodeSurface} ${city}, ${street} ${number}`
-			} else if (order === 1) {
-				raw = `${street} ${number}, ${postcodeSurface} ${city}`
-			} else if (order === 2) {
-				raw = `${city}, ${postcodeSurface}, ${street} ${number}`
-			} else {
-				// order === STREETLESS_ORDER: the street-less form — `«city» «pc», Česko` — the exact surface of the
-				// cz-full-praha-100-00 board row. The v4.5.0 no-promote receipt measured the gap: every
-				// prior order was street-bearing, so the model never saw a spaced PSČ beside a bare
-				// locality and mangled 'Praha 100 00, Czechia' into house_number spans. Street/number
-				// stay OUT of the components for this form (they are not in the surface).
-				raw = `${city} ${postcodeSurface}, Česko`
-			}
-
-			const source_id = sliceSourceID("synth-cz-pcfirst-preposition", {
-				...components,
-				o: String(order),
-				s: spaced ? "1" : "0",
-				v: String(read),
-			})
-
-			const canonical = {
-				raw,
-				components,
-				country: "CZ",
-				locale: "cs-CZ",
-				source: "synth-cz-pcfirst-preposition",
-				source_id,
-				corpus_version: "0.10.0",
-				license:
-					"Synthetic — cz-pcfirst-preposition; (street, number, postcode, city) from OpenAddresses CZ (per-source attribution in the model card)",
-			}
-
-			if (alignAndWrite(write, canonical, "cz-pcfirst-preposition")) {
-				emitted++
-			} else {
-				skipped++
-			}
-		}
-
-		return { read, emitted, skipped }
-	},
-}

package/lib/recipes/fr-admin-split.ts

@@ -1,242 +0,0 @@
-/**
- * @copyright Sister Software
- * @license AGPL-3.0
- * @author Teffen Ellis, et al.
- *
- *   `fr-admin-split` slice recipe — the FR admin-split coverage slice (night 2026-06-19,
- *   surpass-v1.5.0). Teaches the model to SPLIT the département out of the locality on
- *   bare/space/comma-delimited French place rows — the admin-deciding failure class the pre-GPU
- *   self-validation proved moves the resolved coordinate (collision communes −61%; see
- *   docs/articles/evals/experiments/2026-06-19-fr-admin-split-prevalidation.md). Ported from
- *   scripts/build-fr-admin-split-slice.mjs.
- *
- *   Failure shapes (the model currently mis-handles all of these):
- *
- *   - `Thauron, Creuse` → région dropped to null (the comma+full-name miss)
- *   - `Montredon, Lozère` → région = "ère" (the diacritic subword split, #727)
- *   - (AU analog) `CANBERRA ACT` → the space-delimited admin fuse
- *
- *   The département is the essential admin unit for FR postal geography and maps to the `region`
- *   component tag in our schema. We derive it DETERMINISTICALLY from the real postcode via codex
- *   `departementForCodePostal` (first two digits = département) — salvage-first, no re-derived
- *   table.
- *
- *   Data (`--communes`, opts.communes): REAL BAN (Base Adresse Nationale) commune+postcode+coord
- *   tuples, one per line, TAB-separated `commune <TAB> postcode <TAB> lon <TAB> lat`. Build the
- *   input TSV once from the BAN staging CSV (see the legacy script header). Anchor-ON by
- *   construction: rows carry a REAL postcode token in `raw` + a `postcode` component, so the
- *   training loader paints the anchor feature onto that span automatically. The trailing-postcode
- *   anchor REINFORCES the FR split (FR postcode is trailing, unlike German PLZ-leading — the v0.9.2
- *   scar is positional, not universal).
- */
-
-import { departementForCodePostal } from "@mailwoman/codex/fr"
-import { tempRootPath } from "@mailwoman/core/data-root"
-import type { ComponentTag } from "@mailwoman/core/types"
-import { CSVSpliterator, Delimiters } from "spliterator"
-
-import { stableSourceID } from "#adapters/utils"
-import { makeMulberry32, type CorpusRecipe } from "#recipes/scaffold"
-import type { CanonicalRow } from "#types"
-import { alignRow } from "#utils"
-
-const DEFAULT_COMMUNES = tempRootPath("reg", "fr-communes.tsv")
-const LICENSE = "BAN (Base Adresse Nationale) commune+postcode tuples, rendered admin-split — see ingest SOURCE"
-
-/**
- * One distinct commune row from the TSV, with the département derived from its postcode.
- */
-interface CommuneRow {
-	commune: string
-	postcode: string
-	departement: string
-	lon: string | undefined
-	lat: string | undefined
-}
-
-/**
- * One rendered admin-split variant.
- */
-interface AdminSplitVariant {
-	raw: string
-	components: Partial<Record<ComponentTag, string>>
-	order: string
-}
-
-/**
- * Read the distinct commune TSV (commune, postcode, lon, lat); derive the département name.
- */
-async function readCommunes(path: string): Promise<CommuneRow[]> {
-	const rows: CommuneRow[] = []
-
-	// The TSV is headerless — every line is a commune tuple — so `header: false` keeps row 1 instead of
-	// spending it on column names. Source is repo-generated (LF); even under CRLF only the trailing `lat`
-	// column carries a CR, and it's consumed via `Number()` (whitespace-trimming), so it stays harmless.
-	for await (const [commune, postcode, lon, lat] of CSVSpliterator.fromAsync(path, {
-		columnDelimiter: Delimiters.Tab,
-		header: false,
-	})) {
-		if (!commune || !postcode) continue
-		const dep = departementForCodePostal(postcode)
-
-		if (!dep) continue // bad/unmappable postcode — skip (CEDEX, etc.)
-		// Substring invariant: a département whose name isn't a clean token (none are) or a commune
-		// containing the département name would confuse alignment — both are vanishingly rare here.
-		rows.push({ commune, postcode, departement: dep.name, lon, lat })
-	}
-
-	return rows
-}
-
-// 10% of communes render upper-case.
-const UPPER_LOCALITY_SHARE = 0.1
-// Layouts: 25% bare-comma, 25% bare-comma-pc, 20% space-pc, 15% canonical-pc-first, 15% commune-pc.
-const BARE_COMMA_CUTOFF = 0.25
-const BARE_COMMA_PC_CUTOFF = 0.5
-const SPACE_PC_CUTOFF = 0.7
-const CANONICAL_PC_FIRST_CUTOFF = 0.85
-// 20% of rows append an explicit "France" + a `country` component.
-const APPEND_COUNTRY_SHARE = 0.2
-
-/**
- * Render one admin-split variant. The CORE teaching signal: the département, even as a full word after a comma or a
- * space, is `region` — never folded into `locality`. Variants 1-3 are the failure class; 4-5 are canonical-FR
- * preservation so the model doesn't over-fire region on every trailing token (and the bare commune still resolves).
- */
-function render(random: () => number, c: CommuneRow): AdminSplitVariant {
-	const r = random()
-	const loc = random() < UPPER_LOCALITY_SHARE ? c.commune.toUpperCase() : c.commune
-	const dep = c.departement
-	const pc = c.postcode
-	let out: AdminSplitVariant
-
-	if (r < BARE_COMMA_CUTOFF) {
-		// 1. bare comma, NO postcode — the Thauron/#727 shape (anchor off)
-		out = { raw: `${loc}, ${dep}`, components: { locality: loc, region: dep }, order: "bare-comma" }
-	} else if (r < BARE_COMMA_PC_CUTOFF) {
-		// 2. bare comma + postcode — anchor ON
-		out = {
-			raw: `${loc}, ${dep} ${pc}`,
-			components: { locality: loc, region: dep, postcode: pc },
-			order: "bare-comma-pc",
-		}
-	} else if (r < SPACE_PC_CUTOFF) {
-		// 3. space-delimited admin (the AU `CANBERRA ACT` fuse applied to FR) — anchor ON
-		out = { raw: `${loc} ${dep} ${pc}`, components: { locality: loc, region: dep, postcode: pc }, order: "space-pc" }
-	} else if (r < CANONICAL_PC_FIRST_CUTOFF) {
-		// 4. canonical FR postcode-first (NO département) — preservation, anchor ON
-		out = { raw: `${pc} ${loc}`, components: { postcode: pc, locality: loc }, order: "canonical-pc-first" }
-	} else {
-		// 5. commune + postcode (NO département) — preservation, anchor ON
-		out = { raw: `${loc} ${pc}`, components: { locality: loc, postcode: pc }, order: "commune-pc" }
-	}
-
-	// fr.country preservation (the v1.8.0 #728 finding): the v1.8.0 slice's bare rows carried NO country
-	// token, so the model under-emitted country on FR (fr.country −3.5pp). ~20% of rows now append an
-	// explicit "France" + 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. Substring invariant holds.
-	if (random() < APPEND_COUNTRY_SHARE) {
-		out = {
-			raw: `${out.raw}, France`,
-			components: { ...out.components, country: "France" },
-			order: `${out.order}+fr`,
-		}
-	}
-
-	return out
-}
-
-/**
- * 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 frAdminSplitRecipe: CorpusRecipe = {
-	name: "fr-admin-split",
-	description: "FR admin-split rows: BAN communes → split département into `region` (+ canonical-FR preservation)",
-	mode: "generate",
-	options: [
-		{ flag: "--communes <tsv>", description: "BAN commune+postcode+coord TSV. Default /tmp/reg/fr-communes.tsv" },
-	],
-	async run(opts, write) {
-		// Legacy build-fr-admin-split-slice.mjs seeded `mulberry32(opts.seed)`.
-		const random = makeMulberry32(opts.seed)
-		const count = opts.count ?? 60_000
-		const source = opts.sourceName ?? "synth-fr-admin-split"
-		const communesPath = opts.communes ?? DEFAULT_COMMUNES
-
-		const pool = await readCommunes(communesPath)
-
-		console.error(`  ${communesPath}: ${pool.length} communes with derived département`)
-
-		if (!pool.length) {
-			throw new Error("No communes — build the TSV from BAN first (see the recipe header).")
-		}
-
-		let emitted = 0
-		let skipped = 0
-		let guard = 0
-		const orderCounts: Record<string, number> = {}
-		const N = pool.length
-
-		while (emitted < count && guard++ < count * 12) {
-			const base = pool[Math.floor(random() * N)]!
-			const { raw, components, order } = render(random, base)
-
-			// Alignment precondition: every component surface appears verbatim in raw.
-			const values = Object.values(components).filter((v): v is string => Boolean(v))
-
-			if (!values.every((v) => raw.includes(v))) {
-				skipped++
-
-				continue
-			}
-
-			if (opts.golden) {
-				// Held-out eval slice for the centroid check — carries the truth coordinate.
-				write(JSON.stringify({ raw, components, country: "FR", lat: Number(base.lat), lon: Number(base.lon) }) + "\n")
-
-				emitted++
-				orderCounts[order] = (orderCounts[order] ?? 0) + 1
-
-				continue
-			}
-
-			const sourceID = stableSourceID(source, {
-				locality: components.locality,
-				region: components.region,
-				postcode: components.postcode,
-			})
-
-			const canonical: CanonicalRow = {
-				raw,
-				components,
-				country: "FR",
-				locale: "fr-FR",
-				source,
-				source_id: sourceID,
-				corpus_version: "0.5.0",
-				license: LICENSE,
-			}
-
-			const aligned = alignRow(canonical)
-
-			if (aligned.kind !== "labeled" || !aligned.row) {
-				skipped++
-
-				continue
-			}
-
-			write(
-				JSON.stringify({ ...aligned.row, synth_method: "fr-admin-split", synth_order: order, synth_base_id: null }) +
-					"\n"
-			)
-
-			emitted++
-			orderCounts[order] = (orderCounts[order] ?? 0) + 1
-		}
-
-		console.error(`  emitted=${emitted} skipped=${skipped} order-mix=${JSON.stringify(orderCounts)}`)
-
-		return { emitted, skipped }
-	},
-}