@mailwoman/corpus 10.0.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

@@ -3,41 +3,23 @@
  * @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).
+ *   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/utils"
+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"
 
@@ -45,7 +27,7 @@ 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.
+ * Commune tuple with its département derived from the postcode.
  */
 interface CommuneRow {
 	commune: string
@@ -56,7 +38,7 @@ interface CommuneRow {
 }
 
 /**
- * One rendered admin-split variant.
+ * Rendered admin-split address variant.
  */
 interface AdminSplitVariant {
 	raw: string
@@ -65,14 +47,12 @@ interface AdminSplitVariant {
 }
 
 /**
- * Read the distinct commune TSV (commune, postcode, lon, lat); derive the département name.
+ * Read commune tuples and derive the département from each postcode.
  */
 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.
+	// The TSV has no header row.
 	for await (const [commune, postcode, lon, lat] of CSVSpliterator.fromAsync(path, {
 		columnDelimiter: Delimiters.Tab,
 		header: false,
@@ -80,29 +60,25 @@ async function readCommunes(path: string): Promise<CommuneRow[]> {
 		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.
+		if (!dep) continue // Skip postcodes without a mapped département.
 		rows.push({ commune, postcode, departement: dep.name, lon, lat })
 	}
 
 	return rows
 }
 
-// 10% of communes render upper-case.
+// Share of communes rendered in uppercase.
 const UPPER_LOCALITY_SHARE = 0.1
-// Layouts: 25% bare-comma, 25% bare-comma-pc, 20% space-pc, 15% canonical-pc-first, 15% commune-pc.
+// 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
-// 20% of rows append an explicit "France" + a `country` component.
+// Share of rows with an explicit 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).
+ * Render one address layout, splitting the département from the commune where present.
  */
 function render(random: () => number, c: CommuneRow): AdminSplitVariant {
 	const r = random()
@@ -112,30 +88,27 @@ function render(random: () => number, c: CommuneRow): AdminSplitVariant {
 	let out: AdminSplitVariant
 
 	if (r < BARE_COMMA_CUTOFF) {
-		// 1. bare comma, NO postcode — the Thauron/#727 shape (anchor off)
+		// Bare comma form without postcode.
 		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
+		// 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) {
-		// 3. space-delimited admin (the AU `CANBERRA ACT` fuse applied to FR) — anchor ON
+		// 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) {
-		// 4. canonical FR postcode-first (NO département) — preservation, anchor ON
+		// Canonical postcode-first form without département.
 		out = { raw: `${pc} ${loc}`, components: { postcode: pc, locality: loc }, order: "canonical-pc-first" }
 	} else {
-		// 5. commune + postcode (NO département) — preservation, anchor ON
+		// Commune and postcode without département.
 		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.
+	// 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`,
@@ -148,8 +121,7 @@ function render(random: () => number, c: CommuneRow): AdminSplitVariant {
 }
 
 /**
- * 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.
+ * Recipe registered with the corpus builder.
  */
 export const frAdminSplitRecipe: CorpusRecipe = {
 	name: "fr-admin-split",
@@ -159,10 +131,10 @@ export const frAdminSplitRecipe: CorpusRecipe = {
 		{ 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)`.
+		// Preserve the legacy generator and seed behavior.
 		const random = makeMulberry32(opts.seed)
 		const count = opts.count ?? 60_000
-		const source = opts.sourceName ?? "synth-fr-admin-split"
+		const source = opts.sourceName ?? defaultRecipeSource("synth-fr-admin-split")
 		const communesPath = opts.communes ?? DEFAULT_COMMUNES
 
 		const pool = await readCommunes(communesPath)
@@ -183,7 +155,7 @@ export const frAdminSplitRecipe: CorpusRecipe = {
 			const base = pool[Math.floor(random() * N)]!
 			const { raw, components, order } = render(random, base)
 
-			// Alignment precondition: every component surface appears verbatim in raw.
+			// 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))) {
@@ -193,8 +165,8 @@ export const frAdminSplitRecipe: CorpusRecipe = {
 			}
 
 			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")
+				// 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
@@ -228,15 +200,21 @@ export const frAdminSplitRecipe: CorpusRecipe = {
 			}
 
 			write(
-				JSON.stringify({ ...aligned.row, synth_method: "fr-admin-split", synth_order: order, synth_base_id: null }) +
-					"\n"
+				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=${JSON.stringify(orderCounts)}`)
+		console.error(`  emitted=${emitted} skipped=${skipped} order-mix=${stringifyJSON(orderCounts)}`)
 
 		return { emitted, skipped }
 	},