@mailwoman/corpus 9.4.0 → 10.1.0

package/lib/fr/adapters/finess/postal-lines.ts

@@ -0,0 +1,157 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ * Readers for the three French postal-line shapes that the FINESS and Annuaire de l'éducation
+ * publications share: the La Poste routing line (`97100 BASSE TERRE`, `97331 CAYENNE CEDEX`), a
+ * line holding a post-office box among other text (`ZA ESPERANCE - BP 26`), and the comparison of
+ * two place names written in different forms (`ST PIERRE` against `Saint-Pierre`).
+ *
+ * Both adapters read French overseas registers, and both publishers write these lines the same
+ * way, so the readers live in one module rather than in each adapter.
+ */
+
+import { matchCedex } from "@mailwoman/codex/fr/cedex"
+import { foldToken } from "@mailwoman/codex/normalize"
+
+/**
+ * A routing line split into the components the French address layout prints on its last line.
+ */
+export interface AcheminementLine {
+	postcode: string
+	locality: string
+	/**
+	 * The `CEDEX` phrase with its office number, as written, when the line ends with one.
+	 */
+	cedex?: string
+}
+
+/**
+ * Five digits, a space, and the routing locality.
+ */
+const ACHEMINEMENT = /^(\d{5}) (.+)$/u
+
+/**
+ * Split a La Poste routing line into postcode, locality and an optional trailing `CEDEX`.
+ *
+ * Returns `null` when the line does not open with a five-digit postcode,
+ * holds no locality after it, or holds `CEDEX` anywhere but at its end, because none
+ * of those is a routing line the French layout can print.
+ */
+export function parseAcheminementLine(line: string): AcheminementLine | null {
+	const collapsed = line.replaceAll(/\s+/gu, " ").trim()
+	const match = ACHEMINEMENT.exec(collapsed)
+
+	if (!match) return null
+
+	const postcode = match[1]!
+	const rest = match[2]!.trim()
+	const cedex = matchCedex(rest)
+
+	if (!cedex) return { postcode, locality: rest }
+
+	if (cedex.end !== rest.length) return null
+
+	const locality = rest.slice(0, cedex.start).trim()
+
+	if (!locality) return null
+
+	return { postcode, locality, cedex: cedex.matched }
+}
+
+/**
+ * A post-office box designator and its number.
+ *
+ * `BP` is boîte postale, `CS` is La Poste's course spéciale and `TSA` its tri service
+ * arrivée, all three delivered to a box rather than to the premise.
+ * New Caledonia numbers its boxes with a letter prefix (`BP M2`, `BP MGA 19`, `BP KO243`),
+ * which is why up to three letters may precede the digits.
+ */
+const POST_BOX = /(?<![\p{L}\d])(?:B\.?\s?P\.?|CS|TSA)\s*(?:N°\s*)?(?:[A-Z]{1,3}\s?)?\d+(?![\p{L}\d])/iu
+
+/**
+ * Separators a publisher leaves around a box once it is removed: `ZA ESPERANCE - BP 26`.
+ */
+const EDGE_SEPARATORS = /^[\s\-–—/,;:.]+|[\s\-–—/,;:.]+$/gu
+
+/**
+ * A line with its post-office box taken out.
+ */
+export interface PostBoxSplit {
+	/**
+	 * The box as written, with its whitespace collapsed, or `null` where the line holds none.
+	 */
+	poBox: string | null
+	/**
+	 * What the line holds besides the box, with the separators around it removed.
+	 */
+	remainder: string
+}
+
+/**
+ * Take the first post-office box out of a line.
+ *
+ * `SAVANNAH BP 90149` yields `BP 90149` and `SAVANNAH`, and `BP 381-SPRING CONCORDIA -`
+ * yields `BP 381` and `SPRING CONCORDIA`.
+ */
+export function splitPostBox(line: string): PostBoxSplit {
+	const collapsed = line.replaceAll(/\s+/gu, " ").trim()
+	const match = POST_BOX.exec(collapsed)
+
+	if (!match) return { poBox: null, remainder: collapsed.replaceAll(EDGE_SEPARATORS, "") }
+
+	const before = collapsed.slice(0, match.index).replaceAll(EDGE_SEPARATORS, "")
+	const after = collapsed.slice(match.index + match[0].length).replaceAll(EDGE_SEPARATORS, "")
+
+	return {
+		poBox: match[0].replaceAll(/\s+/gu, " "),
+		remainder: [before, after].filter((part) => part !== "").join(" "),
+	}
+}
+
+/**
+ * The opening word of a line that locates a part of a building or a landmark rather than a place:
+ * a building, a floor, a staircase, a door, a corner, a car park, a school's grounds.
+ *
+ * Both publishers put such text on the line a lieu-dit takes (`IMMEUBLE SEMAFA`, `BAT SOUS MARQUE B
+ * - RDC`, `ANGLE DES RUES JEAN JAURES`, `ENCEINTE ECOLE DE TIAPA`), and labeling it a dependent
+ * locality would teach a building name as a place name.
+ * `Lotissement` and `Résidence` are not in the list: in the overseas departments both
+ * name the housing estate an address is in, and TRE-R35 codes both as street types.
+ */
+const PREMISE_DESCRIPTOR =
+	/^(?:imm(?:euble)?|b[aâ]t(?:iment)?|appt?|appartement|étage|etage|rdc|rez[- ]de[- ]chauss[ée]e|esc(?:alier)?|porte|local|angle|centre commercial|ccial|ccal|enceinte|parking|entr[ée]e|lyc[ée]e|coll[èe]ge|[ée]cole|maison|rectorat|vice[- ]rectorat|mairie|face|derri[èe]re|pr[èe]s|[àa] c[ôo]t[ée])(?![\p{L}\d])/iu
+
+/**
+ * Whether a line locates part of a building or a landmark rather than a place.
+ */
+export function isPremiseDescriptor(line: string): boolean {
+	return PREMISE_DESCRIPTOR.test(line.trim())
+}
+
+/**
+ * The abbreviations La Poste's routing lines use for the hagionymic prefixes.
+ */
+const SAINT_FORMS: Readonly<Record<string, string>> = { st: "saint", ste: "sainte", sts: "saints", stes: "saintes" }
+
+/**
+ * A place name folded for comparison: case, diacritics, punctuation and the `ST` abbreviation.
+ */
+function placeKey(value: string): string {
+	return foldToken(value)
+		.replaceAll(/[^\p{L}\d]+/gu, " ")
+		.trim()
+		.split(" ")
+		.map((word) => SAINT_FORMS[word] ?? word)
+		.join(" ")
+}
+
+/**
+ * Whether two place names write the same place: `ST PIERRE` and `Saint-Pierre`, `MATA'UTU` and `Mata Utu`.
+ */
+export function isSamePlace(left: string, right: string): boolean {
+	const leftKey = placeKey(left)
+
+	return leftKey.length > 0 && leftKey === placeKey(right)
+}

package/lib/fr/adapters/finess/voie-type.ts

@@ -0,0 +1,200 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ * The written street-type word for a FINESS `typvoie` code, and the test for a street name whose
+ * digits belong to the name.
+ *
+ * ## Where the codes come from
+ *
+ * FINESS codes `typvoie` against the Agence du Numérique en Santé's terminology TRE-R35 `TypeVoie`,
+ * published in the Nomenclatures des Objets de Santé at
+ * `https://mos.esante.gouv.fr/NOS/TRE_R35-TypeVoie/FHIR/TRE-R35-TypeVoie` and as FHIR JSON at
+ * `https://ansforge.github.io/IG-terminologie-de-sante/ig/main/CodeSystem-TRE-R35-TypeVoie.json`.
+ * The list holds 170 codes, each one to four capital letters as the FINESS schema's "typeTypeVoie"
+ * pattern `[A-Z]{1,4}` requires. Every code the overseas rows of the 2026-05-04 extract use is in it.
+ *
+ * {@linkcode expandFinessVoieType} reads the codex's `FR_VOIE_TYPES` in reverse first, mapping each
+ * abbreviation and each canonical word back to its canonical word, so `R` reads `rue` and `AV`
+ * reads `avenue`. {@linkcode TRE_R35_VOIE_TYPES} then supplies the codes that table does not hold,
+ * transcribed from TRE-R35, and the one code where the two disagree: TRE-R35 writes `PASS` for
+ * `passe`, where `FR_VOIE_TYPES` lists `pass` as an abbreviation of `passage`. The publisher's list
+ * decides that code, so the local table is consulted before the reverse lookup.
+ */
+
+import { FR_VOIE_TYPES, type FrenchVoieType, isFrenchStreetWord } from "@mailwoman/codex/fr/voie"
+import { foldToken } from "@mailwoman/codex/normalize"
+
+import { decomposeFrStreet } from "#fr/street-decompose"
+
+/**
+ * TRE-R35 codes that `FR_VOIE_TYPES` does not resolve, or resolves to another word,
+ * with the word an address writes for each.
+ *
+ * Five zone codes keep their acronym, because the acronym is the written form:
+ * an address reads `ZAC DE MOUDONG` rather than `Zone d'aménagement concerté de Moudong`,
+ * and TRE-R35's own display for `HLM` is the acronym.
+ *
+ * `LD` maps to `null`.
+ * A lieu-dit is written by its name alone, so the code adds no word to the line.
+ *
+ * `VAL` keeps the code as its word.
+ * TRE-R35 displays it as `Vallée, vallon`, two words the code does not choose between,
+ * and `Val` is itself the written word of many French place names.
+ */
+export const TRE_R35_VOIE_TYPES: Readonly<Record<string, string | null>> = {
+	ANSE: "anse",
+	ART: "ancienne route",
+	BRG: "bourg",
+	CAR: "carrefour",
+	CCAL: "centre commercial",
+	CHEM: "cheminement",
+	CHS: "chaussée",
+	CTRE: "centre",
+	EN: "enceinte",
+	ESP: "esplanade",
+	ESPA: "espace",
+	GR: "grande rue",
+	HLM: "HLM",
+	IMM: "immeuble",
+	JARD: "jardin",
+	LD: null,
+	MTE: "montée",
+	PARC: "parc",
+	PASS: "passe",
+	PAT: "patio",
+	PKG: "parking",
+	PLAG: "plage",
+	QU: "quai",
+	QUA: "quartier",
+	RLE: "ruelle",
+	ROC: "rocade",
+	TRA: "traverse",
+	VAL: "val",
+	VGE: "village",
+	VLA: "villa",
+	VLGE: "village",
+	VOI: "voie",
+	ZA: "ZA",
+	ZAC: "ZAC",
+	ZI: "ZI",
+	ZONE: "zone",
+	ZUP: "ZUP",
+}
+
+/**
+ * The code that TRE-R35 gives a care-of line, `Chez`.
+ * Such a line gives the person whose premises the address is.
+ */
+export const CARE_OF_VOIE_TYPE = "CHEZ"
+
+/**
+ * Each folded abbreviation and canonical word in `FR_VOIE_TYPES`, mapped to its canonical word.
+ */
+const FR_VOIE_WORD_BY_TOKEN: ReadonlyMap<string, string> = (() => {
+	const out = new Map<string, string>()
+
+	for (const canonical of Object.keys(FR_VOIE_TYPES) as FrenchVoieType[]) {
+		out.set(foldToken(canonical), canonical)
+
+		for (const abbreviation of FR_VOIE_TYPES[canonical]) {
+			out.set(foldToken(abbreviation), canonical)
+		}
+	}
+
+	return out
+})()
+
+/**
+ * The street-type word for a `typvoie` code, in lower case as the codex writes it.
+ *
+ * Returns `null` for a code that adds no word (`LD`) and `undefined` for a code neither
+ * table resolves, so a caller can refuse a code it cannot read rather than print the code.
+ */
+export function expandFinessVoieType(code: string): string | null | undefined {
+	const trimmed = code.trim().toUpperCase()
+
+	if (!trimmed) return null
+
+	if (Object.hasOwn(TRE_R35_VOIE_TYPES, trimmed)) return TRE_R35_VOIE_TYPES[trimmed]
+
+	return FR_VOIE_WORD_BY_TOKEN.get(foldToken(trimmed))
+}
+
+/**
+ * TRE-R35's one-word street types, folded, for the words the BAN reader's dictionary does not hold.
+ */
+const TRE_R35_WORDS: ReadonlySet<string> = new Set(
+	Object.values(TRE_R35_VOIE_TYPES)
+		.filter((word): word is string => word !== null && !word.includes(" "))
+		.map((word) => foldToken(word))
+)
+
+/**
+ * A street line split into its leading type word and the name after it.
+ */
+export interface FrenchStreetSplit {
+	street_prefix: string
+	street: string
+}
+
+/**
+ * Split a written street into its leading type word and its name, or return `null`
+ * where the first word is not a street type.
+ *
+ * The BAN reader's {@linkcode decomposeFrStreet} is consulted first, then TRE-R35's words and the
+ * codex's `FR_VOIE_TYPES`, which hold the overseas types it lacks (`quartier`, `lotissement`, `ZAC`).
+ * The name may come back empty, as it does for a line reading `Rue` alone.
+ */
+export function splitFrenchStreetType(line: string): FrenchStreetSplit | null {
+	const decomposed = decomposeFrStreet(line)
+	const [first = "", ...rest] = line.split(" ")
+
+	// The dictionary reads `route nationale` as one type word.
+	// That split leaves the route number by itself as the street name.
+	// Here the type is the first word, and the name keeps `nationale 2`.
+	if (decomposed.prefix && /^\d+[a-z]?$/iu.test(decomposed.street)) {
+		return { street_prefix: first, street: rest.join(" ") }
+	}
+
+	if (decomposed.prefix) return { street_prefix: decomposed.prefix, street: decomposed.street }
+
+	if (TRE_R35_WORDS.has(foldToken(first).replace(/\.$/u, "")) || isFrenchStreetWord(first)) {
+		return { street_prefix: first, street: rest.join(" ") }
+	}
+
+	return null
+}
+
+/**
+ * The French month names, folded, which a date-named street writes after its day.
+ */
+const MONTHS = "janvier|fevrier|mars|avril|mai|juin|juillet|aout|septembre|octobre|novembre|decembre"
+
+/**
+ * Street names whose digits are part of the name rather than a house number or a building.
+ *
+ * A numbered route (`NATIONALE 2`, `DEPARTEMENTAL 5`, `RN1`, `CD 11`, `route Nationale 2`)
+ * and a date (`DU 22 MAI`, `DU 8 MAI 1945`) are both names: a publisher that stores the
+ * house number in its own field leaves these digits in the street because they belong to it.
+ */
+const NUMBERED_NAMES: readonly RegExp[] = [
+	/^(?:(?:route|rte|chemin|che|ch) )?(?:(?:de la|du) )?(?:nationale|departementale?|communale|rn|rd|cd|n|d) ?(?:n° ?|n ?)?\d+[a-z]?$/u,
+	new RegExp(`^(?:du |des )?\\d{1,2}(?:er)? (?:${MONTHS})(?: \\d{4})?$`, "u"),
+]
+
+/**
+ * Whether the digits in a street name belong to the name.
+ *
+ * A name with no digit is not in question and returns `true`.
+ * A name such as `VALLÉE 3 BP 208` or `DIAKA BAT A4 PORTE 2` returns `false`, which is the
+ * case a reader refuses rather than print a box or a door number as part of a street.
+ */
+export function isStreetNameDigitPlaced(name: string): boolean {
+	if (!/\d/u.test(name)) return true
+
+	const folded = foldToken(name).replaceAll(/\s+/gu, " ").trim()
+
+	return NUMBERED_NAMES.some((pattern) => pattern.test(folded))
+}

package/lib/fr/insee-country.ts

@@ -0,0 +1,62 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   The ISO 3166-1 jurisdiction an INSEE commune code belongs to.
+ *
+ * Every French source this repository reads keys its rows by INSEE commune code, and France's
+ * overseas departments and collectivities are separate ISO 3166-1 jurisdictions. A reader that
+ * labels every INSEE-coded row `FR` therefore mislabels the overseas ones. This module is the one
+ * home for that mapping, so the BAN adapter and the French recipes that read the same files agree.
+ */
+
+/**
+ * The jurisdiction each overseas INSEE department prefix belongs to.
+ *
+ * An INSEE commune code is five characters.
+ * A metropolitan code's department is its first two, including `2A` and `2B` for Corsica,
+ * and an overseas code's department is its first three.
+ *
+ * Every overseas prefix begins `97` or `98`, so three characters separate the
+ * two cases without a length test.
+ *
+ * `984` and `986` are mapped although IGN publishes both files with no header line
+ * and no rows, so a row appearing under either is labeled rather than read as metropolitan.
+ * `989` Clipperton has no ISO 3166-1 alpha-2 code assigned to it, so a row there
+ * has nowhere correct to go and this map leaves it out.
+ */
+export const COUNTRY_BY_INSEE_DEPARTMENT: Readonly<Record<string, string>> = {
+	"971": "GP",
+	"972": "MQ",
+	"973": "GF",
+	"974": "RE",
+	"975": "PM",
+	"976": "YT",
+	"977": "BL",
+	"978": "MF",
+	"984": "TF",
+	"986": "WF",
+	"987": "PF",
+	"988": "NC",
+}
+
+/**
+ * Every jurisdiction an INSEE-coded French source can carry, so a caller's `--country`
+ * is checked against the set rather than against one value.
+ *
+ * `TF` and `WF` are in the set and currently yield no rows, because the set describes what
+ * the publisher's files can carry rather than what the address-source register has elected.
+ */
+export const INSEE_COUNTRIES: readonly string[] = ["FR", ...Object.values(COUNTRY_BY_INSEE_DEPARTMENT)]
+
+/**
+ * The country a row belongs to, read from its INSEE commune code.
+ *
+ * A code outside the overseas prefixes is metropolitan France.
+ * An empty or short code also reads `FR`, because a missing commune code does
+ * not move the row to another country.
+ */
+export function countryOfInseeCode(codeInsee: string): string {
+	return COUNTRY_BY_INSEE_DEPARTMENT[codeInsee.trim().slice(0, 3)] ?? "FR"
+}

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

@@ -0,0 +1,221 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Generate French training rows that distinguish a département (`region`) from a commune
+ *   (`locality`). Forms include bare, comma-separated and space-separated names.
+ *   Derive the département from each real BAN postcode. Input rows are tab-separated commune, postcode, longitude and latitude.
+ */
+
+import type { ComponentTag } from "@mailwoman/codex/component"
+import { departementForCodePostal } from "@mailwoman/codex/fr"
+import { tempRootPath } from "@mailwoman/core/data-root"
+import { stringifyJSON } from "@mailwoman/core/json"
+import { mulberry32 as makeMulberry32 } from "@mailwoman/core/utils"
+import { CSVSpliterator, Delimiters } from "spliterator"
+
+import { stableSourceID } from "#adapters/source-id"
+import type { CorpusRecipe } from "#recipes/scaffold"
+import { defaultRecipeSource } from "#recipes/sources"
+import { SourceRegister } from "#registers"
+import { SurfaceOrigin } from "#types"
+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"
+
+/**
+ * Commune tuple with its département derived from the postcode.
+ */
+interface CommuneRow {
+	commune: string
+	postcode: string
+	departement: string
+	lon: string | undefined
+	lat: string | undefined
+}
+
+/**
+ * Rendered admin-split address variant.
+ */
+interface AdminSplitVariant {
+	raw: string
+	components: Partial<Record<ComponentTag, string>>
+	order: string
+}
+
+/**
+ * Read commune tuples and derive the département from each postcode.
+ */
+async function readCommunes(path: string): Promise<CommuneRow[]> {
+	const rows: CommuneRow[] = []
+
+	// The TSV has no header row.
+	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 // Skip postcodes without a mapped département.
+		rows.push({ commune, postcode, departement: dep.name, lon, lat })
+	}
+
+	return rows
+}
+
+// Share of communes rendered in uppercase.
+const UPPER_LOCALITY_SHARE = 0.1
+// Cumulative cutoffs for the five address layouts.
+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
+// Share of rows with an explicit country component.
+const APPEND_COUNTRY_SHARE = 0.2
+
+/**
+ * Render one address layout, splitting the département from the commune where present.
+ */
+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) {
+		// Bare comma form without postcode.
+		out = { raw: `${loc}, ${dep}`, components: { locality: loc, region: dep }, order: "bare-comma" }
+	} else if (r < BARE_COMMA_PC_CUTOFF) {
+		// Comma form with postcode.
+		out = {
+			raw: `${loc}, ${dep} ${pc}`,
+			components: { locality: loc, region: dep, postcode: pc },
+			order: "bare-comma-pc",
+		}
+	} else if (r < SPACE_PC_CUTOFF) {
+		// Space-delimited region with postcode.
+		out = { raw: `${loc} ${dep} ${pc}`, components: { locality: loc, region: dep, postcode: pc }, order: "space-pc" }
+	} else if (r < CANONICAL_PC_FIRST_CUTOFF) {
+		// Canonical postcode-first form without département.
+		out = { raw: `${pc} ${loc}`, components: { postcode: pc, locality: loc }, order: "canonical-pc-first" }
+	} else {
+		// Commune and postcode without département.
+		out = { raw: `${loc} ${pc}`, components: { locality: loc, postcode: pc }, order: "commune-pc" }
+	}
+
+	// Add an explicit France suffix to a subset of rows to retain country-token examples.
+	if (random() < APPEND_COUNTRY_SHARE) {
+		out = {
+			raw: `${out.raw}, France`,
+			components: { ...out.components, country: "France" },
+			order: `${out.order}+fr`,
+		}
+	}
+
+	return out
+}
+
+/**
+ * Recipe registered with the corpus builder.
+ */
+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) {
+		// Preserve the legacy generator and seed behavior.
+		const random = makeMulberry32(opts.seed)
+		const count = opts.count ?? 60_000
+		const source = opts.sourceName ?? defaultRecipeSource("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)
+
+			// Ensure every component appears verbatim in the rendered address.
+			const values = Object.values(components).filter((v): v is string => Boolean(v))
+
+			if (!values.every((v) => raw.includes(v))) {
+				skipped++
+
+				continue
+			}
+
+			if (opts.golden) {
+				// Golden rows include the source coordinates.
+				write(stringifyJSON({ raw, components, country: "FR", lat: Number(base.lat), lon: Number(base.lon) }))
+
+				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(
+				stringifyJSON({
+					...aligned.row,
+					recipe: "fr-admin-split",
+					order,
+					base_source_id: null,
+					register: SourceRegister.BaseAdresseNationale,
+					surface: SurfaceOrigin.Composed,
+				})
+			)
+
+			emitted++
+			orderCounts[order] = (orderCounts[order] ?? 0) + 1
+		}
+
+		console.error(`  emitted=${emitted} skipped=${skipped} order-mix=${stringifyJSON(orderCounts)}`)
+
+		return { emitted, skipped }
+	},
+}