@mailwoman/corpus 10.0.0 → 10.2.0

package/lib/fr/recipes/lieudit.ts

@@ -3,49 +3,54 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   `fr-lieudit` slice recipe — FR lieu-dit (hamlet/place) `dependent_locality` coverage
- *   (`.superpowers/sdd/deploc-world-survey.md`, FR section, 2026-07-22). Streams every BAN
- *   `adresses-<dept>.csv` dump under `--ban-dir` through `@mailwoman/ban/sdk`'s
- *   `extractBANAddrPoints`, which now surfaces a cleaned `lieuDit` per record (junk/dup filtering
- *   lives in `ban/sdk/extract.ts`'s `cleanLieuDit`, not duplicated here). Only rows carrying a clean
- *   lieu-dit survive into the pool; the existing `ban`/`synth-fr` sources and their emitted rows are
- *   untouched — this recipe reads the SAME raw CSVs but emits under its own source name.
+ * `fr-lieudit` recipe: FR lieu-dit (hamlet/place) `dependent_locality` coverage.
  *
- *   Mapping: lieu-dit → `dependent_locality`, commune → `locality`. Rendered to match the formatter's
- *   FR `place`-slot convention (`fix(formatter): render dependent_locality for neither-slot templates`,
- *   b1edc1b7, verified via a `formatAddress` smoke call): house+street on line 1, the lieu-dit ALONE on
- *   line 2, postcode+commune on line 3 — French postal convention (La Poste's line 5).
+ * Streams every BAN `adresses-<dept>.csv` dump under `--ban-dir` through `@mailwoman/ban/sdk`'s
+ * `extractBANAddrPoints`, which surfaces a cleaned `lieuDit` per record. Only rows carrying a clean
+ * lieu-dit survive into the pool.
  *
- *   ~1.69M clean rows survive the filter nationally (26M total BAN rows, 1.81M raw `nom_ld` fills, ~6.6%
- *   junk/dup). The pool is read in full (small string tuples only — no coordinates needed) and
- *   Fisher-Yates shuffled with the seeded PRNG before slicing to `--count`, rather than sampled WITH
- *   replacement — at a `--count` a sizeable fraction of the pool, with-replacement draws would produce a
- *   large duplicate rate (birthday-paradox math: ~190k expected collisions at count=800k over a 1.69M
- *   pool).
+ * The recipe maps lieu-dit to `dependent_locality` and commune to `locality`. It renders to match the
+ * formatter's FR `place`-slot convention. House and street go on line 1.
+ * The lieu-dit appears by itself on line 2. Postcode and commune go on line 3.
+ * This follows French postal convention (La Poste's line 5).
+ *
+ * The pool is read in full and Fisher-Yates shuffled with the seeded prng before slicing to
+ * `--count`. With-replacement draws at a large `--count` would produce a large duplicate rate.
+ *
+ * A row's jurisdiction comes from its INSEE commune code, as it does in the `ban` adapter reading
+ * the same files. The BAN fetcher downloads departments 971, 972, 973, 974 and 976 beside the
+ * metropolitan ones, so this recipe emits Guadeloupe, Martinique, French Guiana, Réunion and
+ * Mayotte rows, and labeling them `FR` would mislabel their country and their locale.
  */
 
-import { extractBANAddrPoints } from "@mailwoman/ban/sdk"
-import { formatAddress } from "@mailwoman/codex/address-format"
+import { extractBANAddrPoints } from "@mailwoman/ban/sdk/extract"
+import { formatAddress } from "@mailwoman/codex/address/format"
 import type { ComponentTag } from "@mailwoman/codex/component"
 import { COUNTRY_SURFACE_FORMS } from "@mailwoman/codex/country"
 import { dataRootPath } from "@mailwoman/core/data-root"
+import { stringifyJSON } from "@mailwoman/core/json"
+import { sample, shuffleWith } from "@mailwoman/core/random"
 import { mulberry32 as makeMulberry32 } from "@mailwoman/core/utils"
-import { join, type PathBuilderLike } from "path-ts"
+import { PathBuilder, type PathBuilderLike } from "path-ts"
 import { Globerator } from "spliterator/node/fs"
 
-import { stableSourceID } from "#adapters/utils"
-import { decomposeFrStreet } from "#fr/adapters/ban/street-decompose"
+import { stableSourceID } from "#adapters/source-id"
+import { composeHouseNumber } from "#adapters/street-line"
+import { countryOfInseeCode } from "#fr/insee-country"
+import { decomposeFrStreet } from "#fr/street-decompose"
 import type { CorpusRecipe } from "#recipes/scaffold"
-import { pick } from "#synthesizers/utils"
+import { defaultRecipeSource } from "#recipes/sources"
 import type { CanonicalRow } from "#types"
 import { alignRow } from "#utils"
+
 /**
  * Matches the `ban` adapter's Tier-B election for BAN data.
  */
 const DEFAULT_LICENSE = "Licence Ouverte 2.0"
 
 /**
- * One BAN row surviving the lieu-dit filter — the minimal tuple the pool holds.
+ * One BAN row surviving the lieu-dit filter.
+ * The minimal tuple the pool holds.
  */
 interface LieuDitTuple {
 	numero: string
@@ -54,19 +59,30 @@ interface LieuDitTuple {
 	postcode: string | null
 	locality: string
 	dependentLocality: string
+	/**
+	 * The row's INSEE commune code.
+	 * This code decides the row's jurisdiction.
+	 *
+	 * BAN's overseas department files hold the same columns as the metropolitan ones,
+	 * so a recipe that reads the fetched BAN directory receives Guadeloupe, Martinique,
+	 * French Guiana, Réunion and Mayotte rows beside the metropolitan ones.
+	 */
+	codeInsee: string | null
 }
 
 /**
- * Enumerate `adresses-<dept>.csv[.gz]` files in `banDir`, ONE path per département. Excludes the `merged`/`france`
- * aggregates (they duplicate the per-département rows) and, when both a `.csv` and a `.csv.gz` exist for the same dept
- * (observed on disk for 13/2A/48/69/75 — a stale re-fetch artifact), prefers the uncompressed `.csv` — mirrors
- * `ban/scripts/build-address-point-slice.ts`'s `departementFiles`, which hit and fixed this exact double-count trap
- * first.
+ * Enumerate `adresses-<dept>.csv[.gz]` files in `banDir`, one path per département.
+ *
+ * Excludes the `merged` and `france` aggregates.
+ * They duplicate the per-département rows.
+ *
+ * When both a `.csv` and a `.csv.gz` exist for the same department, the uncompressed `.csv` wins.
  */
-async function departementFiles(banDir: PathBuilderLike): Promise<string[]> {
+async function departementFiles(banDir: PathBuilderLike): Promise<PathBuilder[]> {
+	const directory = PathBuilder.from(banDir)
 	const byDept = new Map<string, string>()
 
-	for (const name of await Globerator.from("*", { cwd: banDir, absolute: false }).toSorted()) {
+	for (const name of await Globerator.from("*", { cwd: directory, absolute: false }).toSorted()) {
 		const m = /^adresses-(.+?)\.csv(\.gz)?$/.exec(name)
 
 		if (!m) continue
@@ -78,15 +94,16 @@ async function departementFiles(banDir: PathBuilderLike): Promise<string[]> {
 		const existing = byDept.get(dept)
 
 		if (!existing || (existing.endsWith(".gz") && !name.endsWith(".gz"))) {
-			byDept.set(dept, join(banDir, name))
+			byDept.set(dept, name)
 		}
 	}
 
-	return [...byDept.keys()].toSorted().map((dept) => byDept.get(dept)!)
+	return [...byDept.keys()].toSorted().map((dept) => directory(byDept.get(dept)!))
 }
 
 /**
- * Stream every département file, keeping only rows with a clean `lieuDit` (junk/dup filtering lives in `ban/sdk`).
+ * Stream every département file, keeping only rows with a clean `lieuDit`
+ * (junk/dup filtering lives in `ban/sdk`).
  */
 async function readLieuDitPool(banDir: PathBuilderLike): Promise<LieuDitTuple[]> {
 	const files = await departementFiles(banDir)
@@ -115,6 +132,7 @@ async function readLieuDitPool(banDir: PathBuilderLike): Promise<LieuDitTuple[]>
 				postcode: rec.postcode,
 				locality: rec.city,
 				dependentLocality: rec.lieuDit,
+				codeInsee: rec.codeInsee,
 			})
 
 			deptCount++
@@ -131,25 +149,7 @@ async function readLieuDitPool(banDir: PathBuilderLike): Promise<LieuDitTuple[]>
 }
 
 /**
- * `house_number` = `numero` + folded `rep` ("10 bis"), matching the `ban` adapter's own composition.
- */
-function composeHouseNumber(numero: string, rep: string | null): string {
-	return rep ? `${numero} ${rep}` : numero
-}
-
-/**
- * Fisher-Yates shuffle, in place, with the recipe's seeded PRNG — reproducible sampling without replacement.
- */
-function shuffleInPlace<T>(arr: T[], random: () => number): void {
-	for (let i = arr.length - 1; i > 0; i--) {
-		const j = Math.floor(random() * (i + 1))
-		;[arr[i], arr[j]] = [arr[j]!, arr[i]!]
-	}
-}
-
-/**
- * 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 frLieuditRecipe: CorpusRecipe = {
 	name: "fr-lieudit",
@@ -167,7 +167,7 @@ export const frLieuditRecipe: CorpusRecipe = {
 	],
 	async run(opts, write) {
 		const random = makeMulberry32(opts.seed)
-		const source = opts.sourceName ?? "synth-fr-lieudit"
+		const source = opts.sourceName ?? defaultRecipeSource("synth-fr-lieudit")
 		const count = opts.count ?? 800_000
 		const banDir = opts.banDir ?? dataRootPath("corpus", "sources", "ban")
 		const countryFraction = opts.countryFraction ?? 0
@@ -182,15 +182,26 @@ export const frLieuditRecipe: CorpusRecipe = {
 			throw new Error(`No clean lieu-dit rows found under ${banDir} — see ban/sdk/extract.ts's cleanLieuDit filter.`)
 		}
 
-		shuffleInPlace(pool, random)
+		// The recipe shares one mulberry32 stream between this shuffle and the country-fraction
+		// draw below, so a fresh generator here would move every later draw and the committed rows.
+		shuffleWith(pool, random)
+
 		const selected = pool.slice(0, Math.min(count, pool.length))
 
 		let emitted = 0
 		let skipped = 0
 		let countryAppended = 0
+		/**
+		 * Rows that drew a country append where codex states no surface form for the jurisdiction.
+		 *
+		 * Counted so the run reports the gap rather than passing over it.
+		 */
+		let countrySurfaceFormAbsent = 0
+		const byCountry = new Map<string, number>()
 
 		for (const t of selected) {
-			const house = composeHouseNumber(t.numero, t.rep)
+			const house = composeHouseNumber(t.numero, t.rep ?? "", " ")
+			const country = countryOfInseeCode(t.codeInsee ?? "")
 			const decomposed = decomposeFrStreet(t.street)
 
 			const components: Partial<Record<ComponentTag, string>> = {
@@ -211,9 +222,10 @@ export const frLieuditRecipe: CorpusRecipe = {
 				components.postcode = t.postcode
 			}
 
-			// The envelope form: house+street line, the lieu-dit ALONE on its own line, postcode+commune line. That is
-			// La Poste's line 5, and it is what `FR`'s layout prints — this recipe used to restate it.
-			let raw = formatAddress(components, "FR")
+			// The envelope form is the house and street line, the lieu-dit by itself on
+			// its own line, then the postcode and commune line.
+			// That is La Poste's line 5.
+			let raw = formatAddress(components, country)
 
 			if (!raw) {
 				skipped++
@@ -221,18 +233,30 @@ export const frLieuditRecipe: CorpusRecipe = {
 				continue
 			}
 
-			// Country-append (the fr-admin-split #728 pattern, generalized): ~`countryFraction` of the time
-			// append an explicit "France" surface form onto the trailing (postcode+commune) line + a
-			// `country` component — the model relearns to emit country WHEN present without over-firing it
-			// on the (still-majority) country-less rows. `countryFraction <= 0` (the default) never draws
-			// from `random`, so the byte-stream is unaffected when the flag is unset.
+			// Country-append: ~`countryFraction` of the time, append an explicit country surface
+			// form onto the trailing (postcode+commune) line plus a `country` component.
+			// The model relearns to emit country when present without over-firing it on the country-less rows.
+			// `countryFraction <= 0` (the default) never draws from `random`,
+			// so the byte-stream is unaffected when the flag is unset.
+			//
+			// Among the jurisdictions BAN covers, codex states surface forms only for `FR`, so an overseas
+			// row draws from `random` and then leaves `raw` and `components.country` as they were.
+			// The draw happens either way.
+			// This keeps the byte-stream a function of `countryFraction` rather than of
+			// the mixture of jurisdictions in the input files.
 			if (countryFraction > 0 && random() < countryFraction) {
-				const forms = COUNTRY_SURFACE_FORMS.FR
-				const form = pick(forms, random)
-				raw = `${raw}, ${form}`
-				components.country = form
-
-				countryAppended++
+				const forms: readonly string[] | undefined =
+					COUNTRY_SURFACE_FORMS[country as keyof typeof COUNTRY_SURFACE_FORMS]
+
+				if (forms) {
+					const form = sample(forms, random)
+					raw = `${raw}, ${form}`
+					components.country = form
+
+					countryAppended++
+				} else {
+					countrySurfaceFormAbsent++
+				}
 			}
 
 			const sourceID = stableSourceID(source, {
@@ -246,8 +270,10 @@ export const frLieuditRecipe: CorpusRecipe = {
 			const canonical: CanonicalRow = {
 				raw,
 				components,
-				country: "FR",
-				locale: "fr-FR",
+				country,
+				// Every jurisdiction BAN publishes writes its addresses in French,
+				// so the language is constant and the region holds the jurisdiction.
+				locale: `fr-${country}`,
 				source,
 				source_id: sourceID,
 				corpus_version: "",
@@ -262,13 +288,25 @@ export const frLieuditRecipe: CorpusRecipe = {
 				continue
 			}
 
-			write(JSON.stringify({ ...aligned.row, synth_method: source, synth_base_id: null }) + "\n")
+			write(stringifyJSON({ ...aligned.row, synth_method: source, synth_base_id: null }))
+
+			byCountry.set(country, (byCountry.get(country) ?? 0) + 1)
 
 			emitted++
 		}
 
 		console.error(`  emitted=${emitted} skipped=${skipped} country-appended=${countryAppended} pool=${pool.length}`)
 
+		const jurisdictions = [...byCountry].toSorted((a, b) => b[1] - a[1])
+
+		console.error(`  jurisdictions: ${jurisdictions.map(([code, n]) => `${code}=${n}`).join(" ")}`)
+
+		if (countrySurfaceFormAbsent > 0) {
+			console.error(
+				`  ${countrySurfaceFormAbsent} rows drew a country append and codex states no surface form for their jurisdiction`
+			)
+		}
+
 		return { emitted, skipped }
 	},
 }

package/lib/fr/recipes/order.ts

@@ -3,61 +3,41 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   `fr-order` slice recipe — French reversed-order coverage (#560). Reads REAL OpenAddresses FR
- *   tuples (`fr/countrywide.csv` from the cached zip), then for each row picks — by
- *   `--reversed-fraction` (default 0.5) — whether to render in CANONICAL French order
- *   (number-street, postcode-city) or one of four REVERSED / postcode-first variants the
- *   v4.4.0→v0.5.0 regression exposed (the model misses house_number in every reversed one):
- *
- *   - A: "47110 Sainte-Livrade-sur-Lot, 69 Allée du Bugatel" (postcode city, HN street)
- *   - B: "Sainte-Livrade-sur-Lot, 47110, 619 Impasse de la Rose" (city, postcode, HN street)
- *   - C: "Sainte-Livrade-sur-Lot 59 bis Rue des Ecuries 47110" (city HN street postcode — NO commas)
- *   - D: "47110, 6 rue de la république, Sainte-Livrade-sur-Lot" (postcode, HN street, city)
- *
- *   Sub-modes ride alongside order: `bis`/`ter`/`quater` ordinal suffixes in house_number, and
- *   ALL-CAPS locality. `--golden` emits a held-out reversed-order eval slice with a different
- *   seed.
- *
- *   The inline synthesis (the OA-CSV reader, the ordinal/all-caps tables, the canonical + reversed
- *   renderers) is ported faithfully from scripts/build-fr-order-slice.mjs. This is a
- *   `generate`-mode recipe that still reads REAL tuples off disk — `--count` bounds the OUTPUT, not
- *   the input. The passed `random` (the framework LCG) is consumed in the exact call order the
- *   legacy script used.
- *
- *   NOT ported (diagnostic-only, no effect on emitted bytes): the post-run `runSpanCheck` self-check
- *   (it reads the finished file back with a separate PRNG and prints to stderr; the recipe's output
- *   stream is still open during `run`), and the dead `renderReversed` helper (the legacy `main`
- *   inlined the variant logic and never called it).
+ *   Generate canonical and reversed French addresses from real OpenAddresses tuples. Reversed forms
+ *   vary postcode, locality and street order. Optional sub-modes add ordinal house numbers and
+ *   uppercase localities. `--golden` emits a held-out evaluation set.
  */
 
 import type { ComponentTag } from "@mailwoman/codex/component"
 import { dataRootPath } from "@mailwoman/core/data-root"
+import { stringifyJSON } from "@mailwoman/core/json"
 import { isPresent } from "@mailwoman/core/objects"
+import { sample } from "@mailwoman/core/random"
 import { mulberry32 as makeMulberry32 } from "@mailwoman/core/utils"
 
-import { stableSourceID } from "#adapters/utils"
+import { stableSourceID } from "#adapters/source-id"
 import { readOATuples, type CorpusRecipe } from "#recipes/scaffold"
-import { pick } from "#synthesizers/utils"
+import { defaultRecipeSource } from "#recipes/sources"
 import type { CanonicalRow } from "#types"
 import { alignRow } from "#utils"
 
 const SOURCE = { zip: dataRootPath("oa-cache", "fr__countrywide.zip"), csv: "fr/countrywide.csv" }
 
 /**
- * Ordinal suffixes used in French house numbers (BAN corpus), to cover the "8 bis" sub-mode.
+ * French house-number ordinal suffixes.
  */
 const ORDINAL_SUFFIXES: readonly string[] = ["bis", "ter", "quater"]
 /**
- * Probability that a row gets an ordinal suffix injected (matches the golden's ~10-15% rate).
+ * Probability of adding an ordinal suffix.
  */
 const ORDINAL_PROB = 0.12
 /**
- * Probability that a locality renders ALL-CAPS (another sub-mode: "SAINTE-LIVRADE-SUR-LOT").
+ * Probability of rendering a locality in uppercase.
  */
 const ALLCAPS_PROB = 0.1
 
 /**
- * A real FR tuple read out of the cached OA zip.
+ * French tuple read from the cached OpenAddresses archive.
  */
 interface FrTuple {
 	house_number: string
@@ -67,10 +47,7 @@ interface FrTuple {
 }
 
 /**
- * Stream FR tuples out of the cached OA zip. The countrywide extract is GB-scale, so this reads only as far as `limit`
- * distinct tuples — the `break` closes the reader and releases the archive. Only keeps rows with a house_number (the
- * slice's core signal) and a postcode (required for reversed-order rendering to be meaningful; it is also part of this
- * recipe's dedup key).
+ * Read up to `limit` distinct tuples with house numbers and postcodes.
  */
 async function readTuples(limit: number): Promise<FrTuple[]> {
 	return readOATuples(SOURCE, {
@@ -82,19 +59,18 @@ async function readTuples(limit: number): Promise<FrTuple[]> {
 }
 
 /**
- * Optionally augment a house_number with a French ordinal suffix ("59 bis", "4 ter"). Appended with a space so it forms
- * one multi-token house_number string that alignRow can still locate verbatim.
+ * Optionally append an ordinal suffix to a house number.
  */
 function maybeAddOrdinal(random: () => number, house_number: string): string {
 	if (random() >= ORDINAL_PROB) return house_number
-	const suffix = pick(ORDINAL_SUFFIXES, random)
+	const suffix = sample(ORDINAL_SUFFIXES, random)
 
-	// Vary suffix case: "bis" (lower) vs "BIS" (upper) — a real-world split in the golden.
+	// Include lowercase and uppercase suffix forms.
 	return `${house_number} ${random() < 0.5 ? suffix : suffix.toUpperCase()}`
 }
 
 /**
- * Render a tuple in CANONICAL French order: "9 Rue de la Promenade, 01200 Villes".
+ * Render a tuple in canonical French order.
  */
 function renderCanonical(
 	hn: string,
@@ -107,15 +83,13 @@ function renderCanonical(
 	return { raw, components: { house_number: hn, street, postcode, locality } }
 }
 
-// Reversed layouts, a quarter each: A postcode+city then HN+street; B city, postcode, HN+street; C run-together;
-// D postcode, HN+street, city.
+// Cumulative cutoffs for four reversed layouts.
 const REVERSED_VARIANT_A_CUTOFF = 0.25
 const REVERSED_VARIANT_B_CUTOFF = 0.5
 const REVERSED_VARIANT_C_CUTOFF = 0.75
 
 /**
- * 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 frOrderRecipe: CorpusRecipe = {
 	name: "fr-order",
@@ -123,18 +97,17 @@ export const frOrderRecipe: CorpusRecipe = {
 	mode: "generate",
 	options: [
 		{ flag: "--reversed-fraction <p>", description: "Fraction rendered reversed-order. Default 0.5" },
-		{ flag: "--golden", description: "Emit the held-out reversed-order eval slice" },
+		{ flag: "--golden", description: "Emit the held-out reversed-order eval set" },
 	],
 	async run(opts, write) {
 		if (opts.count == null) throw new Error("fr-order recipe requires --count <N>")
 		const count = opts.count
-		// Legacy build-fr-order-slice.mjs seeded mulberry32 with the raw seed: `const random = mulberry32(opts.seed)`.
-		// (The omitted diagnostic runSpanCheck used a separate mulberry32(opts.seed + 1) — not part of generation.)
+		// Preserve the legacy random stream for generated rows.
 		const random = makeMulberry32(opts.seed)
-		const source = opts.sourceName ?? "synth-fr-order"
+		const source = opts.sourceName ?? defaultRecipeSource("synth-fr-order")
 		const reversedFraction = opts.reversedFraction ?? 0.5
 
-		// Over-read from the CSV so the dedup + filter pass can fill `count` rows.
+		// Read extra rows to account for filtering and deduplication.
 		const poolLimit = Math.max(count * 8, 40_000)
 		const pool = await readTuples(poolLimit)
 
@@ -155,7 +128,7 @@ export const frOrderRecipe: CorpusRecipe = {
 			const locality = random() < ALLCAPS_PROB ? base.locality.toUpperCase() : base.locality
 			const house_number = maybeAddOrdinal(random, base.house_number)
 
-			// Pick canonical vs reversed by --reversed-fraction.
+			// Choose canonical or reversed order.
 			const isReversed = random() < reversedFraction
 
 			let rendered: { raw: string; components: Partial<Record<ComponentTag, string>> }
@@ -165,16 +138,16 @@ export const frOrderRecipe: CorpusRecipe = {
 				let raw: string
 
 				if (variantRoll < REVERSED_VARIANT_A_CUTOFF) {
-					// Variant A: postcode+city as a unit, then HN+street
+					// Postcode and locality before number and street.
 					raw = `${postcode} ${locality}, ${house_number} ${street}`
 				} else if (variantRoll < REVERSED_VARIANT_B_CUTOFF) {
-					// Variant B: city, then postcode, then HN+street (comma-separated, postcode isolated)
+					// Locality, postcode, number and street.
 					raw = `${locality}, ${postcode}, ${house_number} ${street}`
 				} else if (variantRoll < REVERSED_VARIANT_C_CUTOFF) {
-					// Variant C: no commas — locality HN street postcode (the "run-together" format)
+					// Locality, number, street and postcode without commas.
 					raw = `${locality} ${house_number} ${street} ${postcode}`
 				} else {
-					// Variant D: postcode, HN+street, city (reversed top-to-bottom)
+					// Postcode, number, street, then locality.
 					raw = `${postcode}, ${house_number} ${street}, ${locality}`
 				}
 
@@ -185,7 +158,7 @@ export const frOrderRecipe: CorpusRecipe = {
 
 			const { raw, components } = rendered
 
-			// Safety check: every component must appear verbatim in raw (alignment precondition).
+			// Require each component value to appear verbatim in the address.
 			const componentValues = Object.values(components).filter(isPresent)
 
 			if (!componentValues.every((v) => raw.includes(v))) {
@@ -194,9 +167,9 @@ export const frOrderRecipe: CorpusRecipe = {
 				continue
 			}
 
-			// --golden: emit per-locale-f1 eval rows ({raw, components, country:"FR"}).
+			// Golden output includes parse truth without corpus metadata.
 			if (opts.golden) {
-				write(JSON.stringify({ raw, components, country: "FR" }) + "\n")
+				write(stringifyJSON({ raw, components, country: "FR" }))
 
 				emitted++
 
@@ -230,12 +203,12 @@ export const frOrderRecipe: CorpusRecipe = {
 			}
 
 			write(
-				JSON.stringify({
+				stringifyJSON({
 					...aligned.row,
 					synth_method: "fr-order",
 					synth_order: isReversed ? "reversed" : "canonical",
 					synth_base_id: null,
-				}) + "\n"
+				})
 			)
 
 			emitted++

package/lib/fr/{adapters/ban/street-decompose.ts → street-decompose.ts}

@@ -15,7 +15,7 @@
  *   Sources street types from `core/data/libpostal/dictionaries/fr/street_types.txt`.
  */
 
-import { loadLibpostalDictionary } from "#adapters/utils"
+import { loadLibpostalDictionary } from "#adapters/libpostal-dictionary"
 
 /**
  * Tokens a BAN street needs before a type/article/name decomposition is attempted.
@@ -32,8 +32,9 @@ export interface DecomposedFrStreet {
 /**
  * Decompose a French street name into prefix (leading type word) and street name.
  *
- * If the first 1-2 tokens match a known street type (allowing for multi-word like "ancien chemin"), they become the
- * prefix. Returns `{ prefix: null, street: original }` if no match.
+ * If the first 1-2 tokens match a known street type
+ * (allowing for multi-word like "ancien chemin"), they become the prefix.
+ * Returns `{ prefix: null, street: original }` if no match.
  */
 export function decomposeFrStreet(fullname: string): DecomposedFrStreet {
 	const trimmed = fullname.trim()