@mailwoman/corpus 9.2.0 → 9.3.0

package/lib/recipes/fr-fragment.ts

@@ -0,0 +1,333 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   `fr-fragment` slice recipe (#727 T2) — the HOUSE-NUMBER-LICENCE change.
+ *
+ *   The measured problem (T1c, `2026-07-16-t1c-fragment-board-verdict.md`): the shipped model scores
+ *   **0.925** on `<n> Rue X` and **0.215** on `Rue X`. Same streets, same model; the only difference
+ *   is a leading number. It has learned that a house number LICENSES a street reading at all — strip
+ *   it and a designator-led phrase parses as a locality, designator included:
+ *
+ *   ```
+ *   "Rue Montmartre"        -> locality="Rue Montmartre"
+ *   "Allee Poque"           -> locality="Allee Poque"
+ *   ```
+ *
+ *   `Rue` can only mean street in French. The model is not mislabelling an ambiguous toponym; it is
+ *   mislabelling `Rue`.
+ *
+ *   WHY THE EXISTING RECIPE DOESN'T COVER THIS. {@link frBareStreetRecipe} (#251) mints
+ *   `<n> Rue <name>, <City>` — the bare COMMA form, no postcode. It targets postcode-anchoring
+ *   imbalance, and every row it emits still carries a house number AND a locality. It cannot teach
+ *   the class above, because it never shows the model a street standing alone.
+ *
+ *   WHAT THIS MINTS. Five street forms — the first three carry NO house number and NO locality, which
+ *   is the whole point — plus the counter-distribution:
+ *
+ *   1. `bare-street`         "Rue Montmartre"
+ *   2. `street-particle`     "Rue de la Paix"
+ *   3. `date-name`           "Allee du 11 Novembre 1918"
+ *   4. `street-housenumber`  "12 Rue Montmartre"     — the anchor, so the licence isn't UNLEARNED
+ *   5. `alnum-housenumber`   "12 bis Rue Montmartre"
+ *   6. `bare-locality`       "Mery-sur-Oise"         — NEGATIVE: a bare toponym that IS a locality
+ *
+ *   The **admin/street homonym** class (`Rue de Rome`) is deliberately NOT a separate form. Homonym
+ *   streets are already in the register and fall into 1–3 naturally; there is nothing different to
+ *   teach about them, because the lesson is identical — the designator makes it a street. The
+ *   fragment board scores them separately (they need measuring, not minting), and the recipe would
+ *   need a second pass over the commune set to label them, buying a `synth_method` string and no
+ *   training signal.
+ *
+ *   FORM 7 IS NOT OPTIONAL. T1c's standing prediction: the board's `bare-locality` cell reads 0.980
+ *   for the WRONG REASON — the model calls everything without a house number a locality, and on bare
+ *   localities that is accidentally right. Teach bare streets alone and the model has every incentive
+ *   to flip that default rather than learn the distinction, trading a 0.215 for a 0.980. The slice
+ *   must show BOTH bare forms so the discriminating evidence is the designator, which is the only
+ *   thing that actually distinguishes them. This is the same counter-distribution principle
+ *   {@link noStreetRecipe} established after synth-street pushed the model into "decompose mode".
+ *
+ *   SPLIT. `--exclude-surfaces` takes the fragment board's reserved surface list
+ *   (`mailwoman/eval-harness/fixtures/ban-fragments-fr.surfaces.txt`). Every listed surface is
+ *   skipped — source-disjoint by normalized street SURFACE, never by record row. Row-disjoint leaks
+ *   the surface across the boundary and measures memorization of `Rue de Rivoli` while claiming
+ *   generalization to unseen streets. The recipe REFUSES to run without the list rather than
+ *   silently minting a contaminated slice.
+ *
+ *   MIX. The slice is ~145K rows off a 120K-tuple draw; the intended corpus mix is **5–10%**, set at
+ *   assembly time by slice weight rather than by row count. Keep the cap: a slice that fixes fragments
+ *   by degrading full addresses has moved the failure, not fixed it — which is what
+ *   `street-housenumber` / `alnum-housenumber` on the fragment board and the global parity floor are
+ *   there to catch. `date-name` is ~0.5% of the slice because BAN only holds ~1,418 date-name streets
+ *   after filtering and the tuple extractor already takes every one; if that class needs more, the
+ *   change is slice weight, not invented data.
+ *
+ *   ⚠ Convention loss-mask: like {@link frBareStreetRecipe}, this recipe TEACHES FR `street_prefix`.
+ *   The conventions loss-mask forbids it for FR and will `-inf` these gold labels (the v1.6.0 ~7M-loss
+ *   blow-up). Disable that mask for any run including this slice.
+ */
+
+import { TextSpliterator } from "spliterator"
+
+import { decomposeFrStreet } from "#adapters/ban/street-decompose"
+import { alignAndWrite, makeMulberry32, readTuples, type CorpusRecipe, sliceSourceID } from "#recipes/scaffold"
+import { pick } from "#synthesizers/utils"
+
+/**
+ * House numbers, weighted toward the small values that dominate real BAN rows.
+ */
+
+const HOUSE_NUMBERS = [
+	1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 18, 20, 21, 24, 27, 30, 33, 42, 57, 68, 84, 102, 115, 140,
+]
+
+/**
+ * FR alphanumeric house-number forms. `bis`/`ter` are separated; a bare letter is suffixed.
+ */
+const ALNUM_SUFFIXES = ["bis", "ter", "A", "B"]
+
+// Recipe-fidelity: this accent-STRIPPING fold is the surface key every committed fr-fragment slice and the fragment
+// board's reserved list were built with — not the diacritic-KEEPING `foldNOSurface` the Norwegian slices share.
+const norm = (value: string): string =>
+	value
+		.normalize("NFD")
+		.replaceAll(/[̀-ͯ]/g, "")
+		.toLowerCase()
+		.replaceAll(/\s+/g, " ")
+		.trim()
+
+/**
+ * French commune convention: capitalize each element, leave the joining particles lowercase. `saint-jean-de-luz` →
+ * `Saint-Jean-de-Luz`, not `Saint-Jean-De-Luz`.
+ *
+ * Needed because BAN's sliced DBs keep only `locality_base` — normalized, lowercase, accent-stripped. Emitting that
+ * verbatim would teach the counter-distribution that a lowercase accent-stripped string is a locality, which is not a
+ * fact about French and would not match the fragment board (which reconstructs the same casing). The accents are gone
+ * from the source and cannot be recovered here; the casing can.
+ */
+const FR_LOWER = new Set([
+	"le",
+	"la",
+	"les",
+	"de",
+	"du",
+	"des",
+	"d",
+	"l",
+	"sur",
+	"sous",
+	"en",
+	"aux",
+	"au",
+	"et",
+	"lez",
+])
+
+export function frTitleCase(value: string): string {
+	const cap = (token: string, first: boolean): string =>
+		!first && FR_LOWER.has(token) ? token : token.charAt(0).toUpperCase() + token.slice(1)
+
+	return value
+		.split(" ")
+		.map((word, wordIndex) =>
+			word
+				.split("-")
+				.map((bit, bitIndex) => cap(bit, wordIndex === 0 && bitIndex === 0))
+				.join("-")
+		)
+		.join(" ")
+}
+
+/**
+ * Does the street name carry a particle? Decides the particle vs bare classification.
+ */
+const PARTICLE = /\b(de la|de l'|du|des|de|d'|le|la|les)\b/i
+
+/**
+ * Does the street name carry date material (a year, or a day + French month)?
+ */
+const DATEISH =
+	/\b(1[0-9]|20)\d{2}\b|\b\d{1,2}\s+(janvier|f[ée]vrier|mars|avril|mai|juin|juillet|ao[ûu]t|septembre|octobre|novembre|d[ée]cembre)\b/i
+
+// A quarter of house numbers carry an alphanumeric suffix (`8 bis`, `12B`).
+const ALNUM_HOUSE_NUMBER_SHARE = 0.25
+
+/**
+ * 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 frFragmentRecipe: CorpusRecipe = {
+	name: "fr-fragment",
+	description:
+		"FR street fragments with NO house number (#727 T2): the house-number-licence change — bare/particle/date-name/homonym + the bare-locality counter",
+	mode: "tuples",
+	options: [
+		{
+			flag: "--exclude-surfaces <path>",
+			description: "REQUIRED. The fragment board's reserved surface list; every listed street is skipped.",
+		},
+		{
+			flag: "--hn-prob <n>",
+			description: "Share of rows carrying a house number (default 0.35 — the anchor, not the point)",
+		},
+		{
+			flag: "--bare-prob <n>",
+			description: "Share of NO-house-number rows that are bare LOCALITIES (default 0.25 — the counter)",
+		},
+	],
+	async run(opts, write) {
+		const random = makeMulberry32(opts.seed)
+		const excludePath = opts.excludeSurfaces
+
+		if (!excludePath) {
+			throw new Error(
+				"fr-fragment: --exclude-surfaces is REQUIRED. Pass the fragment board's reserved list " +
+					"(mailwoman/eval-harness/fixtures/ban-fragments-fr.surfaces.txt) or this slice trains on its own eval set. " +
+					"Source-disjoint by street SURFACE is the split discipline; there is no safe default."
+			)
+		}
+
+		const excluded = new Set<string>()
+
+		for await (const line of TextSpliterator.fromAsync(excludePath)) {
+			const trimmed = line.trim()
+
+			if (trimmed && !trimmed.startsWith("#")) {
+				excluded.add(trimmed)
+			}
+		}
+
+		if (!excluded.size) throw new Error(`fr-fragment: --exclude-surfaces "${excludePath}" listed no surfaces`)
+
+		const hnProb = opts.hnProb ?? 0.35
+		const bareLocalityProb = opts.bareProb ?? 0.25
+
+		// The locality pool is harvested from the tuples themselves — every BAN row carries its
+		// commune, so the counter-distribution needs no second source.
+		const localities = new Set<string>()
+
+		let read = 0
+		let emitted = 0
+		let skipped = 0
+		let contaminated = 0
+
+		for await (const tuple of readTuples(opts.input!)) {
+			read++
+			const fullStreet = String(tuple.street ?? "").trim()
+			const locality = String(tuple.locality ?? "").trim()
+
+			if (locality) {
+				localities.add(locality)
+			}
+
+			if (!fullStreet) {
+				skipped++
+
+				continue
+			}
+
+			// THE SPLIT. A surface on the fragment board never enters training.
+			if (excluded.has(norm(fullStreet))) {
+				contaminated++
+
+				continue
+			}
+
+			const { prefix, street } = decomposeFrStreet(fullStreet)
+
+			// The failing class is the designator-led street. A no-prefix nom_voie ("La Ville Mois")
+			// is a different problem and would muddy the signal.
+			if (!prefix || !street) {
+				skipped++
+
+				continue
+			}
+
+			const carriesNumber = random() < hnProb
+			const components: Record<string, string> = { street_prefix: prefix, street }
+			let raw = `${prefix} ${street}`
+			let klass = DATEISH.test(street) ? "date-name" : PARTICLE.test(street) ? "street-particle" : "bare-street"
+
+			if (carriesNumber) {
+				const number = pick(HOUSE_NUMBERS, random)
+				const alnum = random() < ALNUM_HOUSE_NUMBER_SHARE
+				const suffix = pick(ALNUM_SUFFIXES, random)
+
+				const houseNumber = alnum
+					? suffix === "bis" || suffix === "ter"
+						? `${number} ${suffix}`
+						: `${number}${suffix}`
+					: String(number)
+
+				components.house_number = houseNumber
+				raw = `${houseNumber} ${prefix} ${street}`
+				klass = alnum ? "alnum-housenumber" : "street-housenumber"
+			}
+
+			const sourceID = sliceSourceID("synth-fr-fragment", { ...components, v: String(read) })
+
+			if (
+				alignAndWrite(
+					write,
+					{
+						raw,
+						components,
+						country: "FR",
+						locale: "fr-FR",
+						source: "synth-fr-fragment",
+						source_id: sourceID,
+						corpus_version: "0.9.4",
+						license: "Synthetic — fr-fragment; (street, commune) from BAN (Base Adresse Nationale, Licence Ouverte)",
+					},
+					`fr-fragment:${klass}`
+				)
+			) {
+				emitted++
+			} else {
+				skipped++
+			}
+		}
+
+		// MARK: counter-distribution — bare localities
+		// Minted last so the locality pool is complete. Without these the model can satisfy every row
+		// above by flipping its default from "bare => locality" to "bare => street", which trades one
+		// broken prior for another and would show up as bare-locality collapsing on the board.
+		const pool = [...localities].toSorted()
+		const wanted = Math.round((emitted / Math.max(1, 1 - bareLocalityProb)) * bareLocalityProb)
+
+		for (let i = 0; i < wanted && pool.length; i++) {
+			// BAN gives `locality_base` normalized; restore the casing the fragment board also
+			// reconstructs, so train and eval show the model the same shape of French.
+			const name = frTitleCase(pick(pool, random))
+			const sourceID = sliceSourceID("synth-fr-fragment", { locality: name, v: `neg-${i}` })
+
+			if (
+				alignAndWrite(
+					write,
+					{
+						raw: name,
+						components: { locality: name },
+						country: "FR",
+						locale: "fr-FR",
+						source: "synth-fr-fragment",
+						source_id: sourceID,
+						corpus_version: "0.9.4",
+						license: "Synthetic — fr-fragment counter-distribution; commune from BAN (Licence Ouverte)",
+					},
+					"fr-fragment:bare-locality"
+				)
+			) {
+				emitted++
+			} else {
+				skipped++
+			}
+		}
+
+		if (contaminated) {
+			console.error(`fr-fragment: skipped ${contaminated} rows whose street surface is reserved by the fragment board`)
+		}
+
+		return { read, emitted, skipped }
+	},
+}

package/lib/recipes/fr-lieudit.ts

@@ -0,0 +1,301 @@
+/**
+ * @copyright Sister Software
+ * @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.
+ *
+ *   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).
+ *
+ *   ~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).
+ */
+
+import { extractBANAddrPoints } from "@mailwoman/ban/sdk"
+import { COUNTRY_SURFACE_FORMS } from "@mailwoman/codex/country"
+import { dataRootPath } from "@mailwoman/core/data-root"
+import { readDirectory } from "@mailwoman/core/fs/readers"
+import { isPresent } from "@mailwoman/core/objects"
+import type { ComponentTag } from "@mailwoman/core/types"
+import { join, type PathBuilderLike } from "path-ts"
+
+import { decomposeFrStreet } from "#adapters/ban/street-decompose"
+import { stableSourceID } from "#adapters/utils"
+import { makeMulberry32, type CorpusRecipe } from "#recipes/scaffold"
+import { pick } from "#synthesizers/utils"
+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.
+ */
+interface LieuDitTuple {
+	numero: string
+	rep: string | null
+	street: string
+	postcode: string | null
+	locality: string
+	dependentLocality: string
+}
+
+/**
+ * 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.
+ */
+async function departementFiles(banDir: PathBuilderLike): Promise<string[]> {
+	const byDept = new Map<string, string>()
+
+	for (const name of (await readDirectory(banDir)).toSorted()) {
+		const m = /^adresses-(.+?)\.csv(\.gz)?$/.exec(name)
+
+		if (!m) continue
+
+		const dept = m[1]!
+
+		if (dept === "merged" || dept === "france") continue
+
+		const existing = byDept.get(dept)
+
+		if (!existing || (existing.endsWith(".gz") && !name.endsWith(".gz"))) {
+			byDept.set(dept, join(banDir, name))
+		}
+	}
+
+	return [...byDept.keys()].toSorted().map((dept) => byDept.get(dept)!)
+}
+
+/**
+ * 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)
+
+	if (!files.length) {
+		throw new Error(
+			`No BAN adresses-<dept>.csv files found in ${banDir} — fetch BAN first (\`mailwoman corpus fetch ban\`).`
+		)
+	}
+
+	const pool: LieuDitTuple[] = []
+	let scanned = 0
+
+	for (const path of files) {
+		let deptCount = 0
+
+		for await (const rec of extractBANAddrPoints(path)) {
+			scanned++
+
+			if (!rec.lieuDit || !rec.city) continue
+
+			pool.push({
+				numero: rec.numero,
+				rep: rec.rep,
+				street: rec.street,
+				postcode: rec.postcode,
+				locality: rec.city,
+				dependentLocality: rec.lieuDit,
+			})
+
+			deptCount++
+		}
+
+		console.error(`  ${path}: ${deptCount.toLocaleString()} clean lieu-dit rows`)
+	}
+
+	console.error(
+		`  scanned ${scanned.toLocaleString()} BAN rows across ${files.length} départements → pool=${pool.length.toLocaleString()}`
+	)
+
+	return pool
+}
+
+/**
+ * `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
+}
+
+/**
+ * Render the raw address string: house+street line, the lieu-dit ALONE on its own line, postcode+commune line — the
+ * exact shape `formatAddress` produces for FR's `place`-slot mapping (verified via a smoke call before this recipe was
+ * written; see the module docstring).
+ */
+function composeRaw(
+	house: string,
+	street: string,
+	dependentLocality: string,
+	postcode: string | null,
+	locality: string
+): string {
+	const lines: string[] = []
+	const streetLine = `${house} ${street}`.trim()
+
+	if (streetLine) {
+		lines.push(streetLine)
+	}
+
+	lines.push(dependentLocality)
+	const cityLine = [postcode, locality].filter(isPresent).join(" ").trim()
+
+	if (cityLine) {
+		lines.push(cityLine)
+	}
+
+	return lines.join("\n")
+}
+
+/**
+ * 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.
+ */
+export const frLieuditRecipe: CorpusRecipe = {
+	name: "fr-lieudit",
+	description: "FR lieu-dit rows: BAN nom_ld → dependent_locality (commune → locality), lieu-dit on its own line",
+	mode: "generate",
+	options: [
+		{
+			flag: "--ban-dir <dir>",
+			description: "BAN adresses-<dept>.csv directory. Default $MAILWOMAN_DATA_ROOT/corpus/sources/ban",
+		},
+		{
+			flag: "--country-fraction <f>",
+			description: "Fraction of rows that append an explicit 'France' surface form + a `country` component. Default 0",
+		},
+	],
+	async run(opts, write) {
+		const random = makeMulberry32(opts.seed)
+		const source = opts.sourceName ?? "synth-fr-lieudit"
+		const count = opts.count ?? 800_000
+		const banDir = opts.banDir ?? dataRootPath("corpus", "sources", "ban")
+		const countryFraction = opts.countryFraction ?? 0
+
+		if (!(countryFraction >= 0 && countryFraction <= 1)) {
+			throw new Error(`--country-fraction must be in [0, 1], got ${countryFraction}`)
+		}
+
+		const pool = await readLieuDitPool(banDir)
+
+		if (!pool.length) {
+			throw new Error(`No clean lieu-dit rows found under ${banDir} — see ban/sdk/extract.ts's cleanLieuDit filter.`)
+		}
+
+		shuffleInPlace(pool, random)
+		const selected = pool.slice(0, Math.min(count, pool.length))
+
+		let emitted = 0
+		let skipped = 0
+		let countryAppended = 0
+
+		for (const t of selected) {
+			const house = composeHouseNumber(t.numero, t.rep)
+			const decomposed = decomposeFrStreet(t.street)
+
+			const components: Partial<Record<ComponentTag, string>> = {
+				house_number: house,
+				dependent_locality: t.dependentLocality,
+				locality: t.locality,
+			}
+
+			if (decomposed.prefix) {
+				components.street_prefix = decomposed.prefix
+			}
+
+			if (decomposed.street) {
+				components.street = decomposed.street
+			}
+
+			if (t.postcode) {
+				components.postcode = t.postcode
+			}
+
+			let raw = composeRaw(house, t.street, t.dependentLocality, t.postcode, t.locality)
+
+			if (!raw) {
+				skipped++
+
+				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.
+			if (countryFraction > 0 && random() < countryFraction) {
+				const forms = COUNTRY_SURFACE_FORMS.FR
+				const form = pick(forms, random)
+				raw = `${raw}, ${form}`
+				components.country = form
+
+				countryAppended++
+			}
+
+			const sourceID = stableSourceID(source, {
+				street: t.street,
+				house_number: house,
+				dependent_locality: t.dependentLocality,
+				locality: t.locality,
+				postcode: t.postcode ?? undefined,
+			})
+
+			const canonical: CanonicalRow = {
+				raw,
+				components,
+				country: "FR",
+				locale: "fr-FR",
+				source,
+				source_id: sourceID,
+				corpus_version: "",
+				license: DEFAULT_LICENSE,
+			}
+
+			const aligned = alignRow(canonical)
+
+			if (aligned.kind !== "labeled" || !aligned.row) {
+				skipped++
+
+				continue
+			}
+
+			write(JSON.stringify({ ...aligned.row, synth_method: source, synth_base_id: null }) + "\n")
+
+			emitted++
+		}
+
+		console.error(`  emitted=${emitted} skipped=${skipped} country-appended=${countryAppended} pool=${pool.length}`)
+
+		return { emitted, skipped }
+	},
+}