@mailwoman/corpus 9.1.0 → 9.2.0

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

@@ -39,9 +39,11 @@
 
 import type { WhosOnFirstPlacetype } from "@mailwoman/core/resources/whosonfirst"
 import type { ComponentTag } from "@mailwoman/core/types"
-import type { AdapterOptions, CanonicalRow, CorpusAdapter } from "@mailwoman/corpus/types"
-import { buildAncestryIndex, normalizeNameKey, walkFeatures, type WOFRecord } from "@mailwoman/corpus/utils"
-import { formatAddress, reconcileComponents } from "@mailwoman/formatter"
+
+import type { AdapterOptions, CanonicalRow, CorpusAdapter } from "#types"
+import { buildAncestryIndex, normalizeNameKey, walkFeatures, type WOFRecord } from "#utils"
+
+import { emitWOFJSONRows, type WOFVariantSpec } from "../wof-json-rows.ts"
 
 const COUNTRY_DISPLAY_NAME: Record<string, string> = {
 	US: "United States of America",
@@ -70,16 +72,11 @@ function placetypeToTag(placetype: WhosOnFirstPlacetype | string): ComponentTag
 	}
 }
 
-interface VariantSpec {
-	suffix: string
-	components: Partial<Record<ComponentTag, string>>
-}
-
 /**
  * Compute hierarchy variants for a postcode record. `selfName` is the postcode surface form (canonical `wof:name` for
  * the `default` slot, a `name:*` localized variant otherwise).
  */
-export function postcodeVariantsFor(row: WOFRecord, ancestry: WOFRecord[], selfName: string): VariantSpec[] {
+export function postcodeVariantsFor(row: WOFRecord, ancestry: WOFRecord[], selfName: string): WOFVariantSpec[] {
 	if (placetypeToTag(row.placetype) !== "postcode") return []
 
 	const locality = ancestry.find((a) => placetypeToTag(a.placetype) === "locality")
@@ -87,7 +84,7 @@ export function postcodeVariantsFor(row: WOFRecord, ancestry: WOFRecord[], selfN
 	const country = ancestry.find((a) => placetypeToTag(a.placetype) === "country")
 	const countryDisplay = COUNTRY_DISPLAY_NAME[row.country] ?? country?.name ?? row.country
 
-	const variants: VariantSpec[] = [{ suffix: "self", components: { postcode: selfName } }]
+	const variants: WOFVariantSpec[] = [{ suffix: "self", components: { postcode: selfName } }]
 
 	if (locality) {
 		variants.push({
@@ -166,46 +163,16 @@ export function createWOFPostalcodeAdapter(): CorpusAdapter {
 			const ancestry = buildAncestryIndex(byID)
 
 			// Pass 2: emit postcode rows only, sorted by id for determinism.
-			const ids = [...byID.keys()].toSorted((a, b) => a - b)
-			let emitted = 0
-
-			for (const id of ids) {
-				if (opts.signal?.aborted) return
-				const rec = byID.get(id)!
-
-				if (placetypeToTag(rec.placetype) !== "postcode") continue
-
-				const chain = ancestry.get(id) ?? []
-				const slots = nameSlotsFor(rec)
-
-				for (const slot of slots) {
-					const variants = postcodeVariantsFor(rec, chain, slot.value)
-
-					for (const variant of variants) {
-						if (opts.limit !== undefined && emitted >= opts.limit) return
-
-						const raw = formatAddress(variant.components, rec.country, { separator: ", " })
-
-						if (!raw) continue
-						const aligned = reconcileComponents(variant.components, raw)
-
-						if (!Object.keys(aligned).length) continue
-
-						yield {
-							raw,
-							components: aligned,
-							country: rec.country,
-							locale: LOCALE_BY_COUNTRY[rec.country],
-							source: WOF_POSTALCODE_ADAPTER_ID,
-							source_id: `${WOF_POSTALCODE_ADAPTER_ID}-${rec.id}-${slot.key}-${variant.suffix}`,
-							corpus_version: "",
-							license: "CC0-1.0",
-						}
-
-						emitted++
-					}
-				}
-			}
+			yield* emitWOFJSONRows({
+				records: byID,
+				ancestry,
+				adapterOptions: opts,
+				adapterID: WOF_POSTALCODE_ADAPTER_ID,
+				localeByCountry: LOCALE_BY_COUNTRY,
+				shouldEmit: (record) => placetypeToTag(record.placetype) === "postcode",
+				nameSlotsFor,
+				variantsFor: postcodeVariantsFor,
+			})
 		},
 	}
 }

package/src/build.ts

@@ -53,22 +53,22 @@ import { join } from "node:path"
 
 import { $public } from "@mailwoman/core/env"
 import { parseJSONStrict } from "@mailwoman/core/objects"
-import { defaultAdapterRegistry } from "@mailwoman/corpus/adapters/utils"
-import { runAdapter, type AdapterRunManifest } from "@mailwoman/corpus/runner"
-import { defaultAugmentationsForCountry, synthesizeRow } from "@mailwoman/corpus/synthesizers/utils"
-import type { AdapterOptions, CanonicalRow, CorpusAdapter, LabeledRow } from "@mailwoman/corpus/types"
+import { JSONSpliterator } from "spliterator"
+
+import { defaultAdapterRegistry } from "#adapters/utils"
+import { runAdapter, type AdapterRunManifest } from "#runner"
+import { defaultAugmentationsForCountry, synthesizeRow } from "#synthesizers/utils"
+import type { AdapterOptions, CanonicalRow, CorpusAdapter, LabeledRow } from "#types"
+import { alignRow } from "#utils/align"
+import { licenseExcluded } from "#utils/license"
+import { writeShards, type ShardManifest } from "#utils/parquet"
 import {
-	alignRow,
-	licenseExcluded,
-	writeShards,
 	defaultHoldouts,
 	splitForRow,
 	writeSplitManifestsFromLabeledFiles,
-	type ShardManifest,
 	type SplitManifest,
 	type SplitName,
-} from "@mailwoman/corpus/utils"
-import { JSONSpliterator } from "spliterator"
+} from "#utils/split"
 
 /**
  * Stage tags surfaced to `onProgress`.

package/src/index.ts

@@ -11,4 +11,4 @@ export * from "./build.ts"
 export * from "./runner.ts"
 export * from "./parquet-wrapper/index.ts"
 export * from "./shard-recipes/index.ts"
-export * from "@mailwoman/corpus/types"
+export * from "#types"

package/src/parquet-wrapper/reader.ts

@@ -67,6 +67,15 @@ export class ParquetReader<T extends ParquetRecordLike> extends BaseParquetReade
 	 * caller wanting the whole record should use.
 	 */
 	public async *project<K extends keyof T>(...columns: K[]): AsyncGenerator<Pick<T, K>, void, unknown> {
+		const missing = columns.filter((column) => !Object.hasOwn(this.schema.schema, column))
+
+		if (missing.length) {
+			throw new Error(
+				`Parquet projection requested column${missing.length === 1 ? "" : "s"} absent from the file schema: ` +
+					missing.map(String).join(", ")
+			)
+		}
+
 		const cursor = this.getCursor(columns.map((column) => [column as string]))
 
 		for (;;) {

package/src/runner.ts

@@ -31,13 +31,8 @@ import { createWriteStream, type WriteStream } from "node:fs"
 import { mkdir, writeFile } from "node:fs/promises"
 import { dirname, join } from "node:path"
 
-import {
-	canonicalDedupKey,
-	streamingSha256,
-	type AdapterRegistry,
-	type StreamingHasher,
-} from "@mailwoman/corpus/adapters/utils"
-import type { AdapterOptions, CanonicalRow, CorpusAdapter } from "@mailwoman/corpus/types"
+import { canonicalDedupKey, streamingSha256, type AdapterRegistry, type StreamingHasher } from "#adapters/utils"
+import type { AdapterOptions, CanonicalRow, CorpusAdapter } from "#types"
 
 /**
  * Snapshot of the runner's state, emitted on every progress tick.

package/src/shard-recipes/anchor-absorption.ts

@@ -16,11 +16,11 @@ import { readFileSync } from "node:fs"
 
 import { parseJSONStrict } from "@mailwoman/core/objects"
 import { dataRootPath } from "@mailwoman/core/utils"
-import { stableSourceID } from "@mailwoman/corpus/adapters/utils"
-import { synthesizeAnchorAbsorptionRow } from "@mailwoman/corpus/synthesizers/anchor-absorption"
-import { alignRow } from "@mailwoman/corpus/utils"
 
-import { makeLcg, type ShardRecipe } from "./scaffold.ts"
+import { synthesizeAnchorAbsorptionRow } from "#synthesizers/anchor-absorption"
+import { alignRow } from "#utils"
+
+import { makeLcg, shardSourceID, type ShardRecipe } from "./scaffold.ts"
 
 /**
  * The leading-5-digit source: the real US ZIPs in the postcode anchor's pilot lookup. Resolved through the data-root
@@ -76,7 +76,7 @@ export const anchorAbsorptionRecipe: ShardRecipe = {
 				country,
 				locale: synth.locale,
 				source,
-				source_id: stableSourceID(source, `${i}` as unknown as Parameters<typeof stableSourceID>[1]),
+				source_id: shardSourceID(source, { v: String(i) }),
 			}
 
 			const aligned = alignRow(canonical as Parameters<typeof alignRow>[0])

package/src/shard-recipes/bare-country.ts

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

package/src/shard-recipes/boundary-stress.ts

@@ -12,11 +12,8 @@
  *   `synthesizeBoundaryStressRow` is NOT re-exported from the corpus index — imported directly here.
  */
 
-import {
-	type BoundaryStressTemplate,
-	synthesizeBoundaryStressRow,
-} from "@mailwoman/corpus/synthesizers/boundary-stress"
-import { alignRow } from "@mailwoman/corpus/utils"
+import { type BoundaryStressTemplate, synthesizeBoundaryStressRow } from "#synthesizers/boundary-stress"
+import { alignRow } from "#utils"
 
 import { makeMulberry32, type ShardRecipe, shardSourceID } from "./scaffold.ts"
 

package/src/shard-recipes/country-balanced.ts

@@ -25,11 +25,13 @@
  */
 
 import { COUNTRY_SURFACE_FORMS, CountryNames } from "@mailwoman/codex/country"
+import { isPresent } from "@mailwoman/core/objects"
 import type { ComponentTag } from "@mailwoman/core/types"
 import { dataRootPath } from "@mailwoman/core/utils"
-import { stableSourceID } from "@mailwoman/corpus/adapters/utils"
-import type { CanonicalRow } from "@mailwoman/corpus/types"
-import { alignRow } from "@mailwoman/corpus/utils"
+
+import { stableSourceID } from "#adapters/utils"
+import type { CanonicalRow } from "#types"
+import { alignRow } from "#utils"
 
 import { makeMulberry32, readZippedCSVRecords, type ShardRecipe } from "./scaffold.ts"
 
@@ -220,14 +222,14 @@ function renderCountry(
 	let body: string
 
 	if (order === "us") {
-		const regPc = [reg, pc].filter(Boolean).join(" ")
+		const regPc = [reg, pc].filter(isPresent).join(" ")
 		body = `${hn} ${street}, ${loc}${regPc ? ", " + regPc : ""}`
 	} else if (order === "fr") {
 		// French is NUMBER-street, postcode-city: "84 Route de la Fontaine, 75008 Paris".
-		body = `${hn} ${street}, ${[pc, loc].filter(Boolean).join(" ")}`
+		body = `${hn} ${street}, ${[pc, loc].filter(isPresent).join(" ")}`
 	} else {
 		// DE/IT/NL: street-number, postcode-city: "Pariser Platz 1, 10117 Berlin".
-		const pcCity = [pc, loc].filter(Boolean).join(" ")
+		const pcCity = [pc, loc].filter(isPresent).join(" ")
 		body = `${street} ${hn}, ${pcCity}`
 	}
 

package/src/shard-recipes/cz-pcfirst-preposition.ts

@@ -16,6 +16,13 @@
 
 import { alignAndWrite, makeMulberry32, readTuples, type ShardRecipe, shardSourceID } from "./scaffold.ts"
 
+/**
+ * The order-cycle slot for the STREET-LESS form (`«city» «pc», Česko`) — the exact surface of the
+ * `cz-full-praha-100-00` board row, whose absence from the street-bearing orders was the v4.5.0 no-promote's measured
+ * gap.
+ */
+const STREETLESS_ORDER = 3
+
 /**
  * Shard 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.
@@ -44,27 +51,39 @@ export const czPcFirstPrepositionRecipe: ShardRecipe = {
 				continue
 			}
 
-			const order = read % 3
+			const order = read % 4
+			// The OFFICIAL Czech rendering spaces the PSČ as `NNN NN` ('512 44'); OpenAddresses stores it
+			// unspaced ('51244'), and a model trained only on the source form reads the spaced surface as
+			// house_number + garbage (the 'Praha 100 00' mangle). Alternate the two renderings so both
+			// orthographies are attested — the LABEL is the postcode either way.
+			const spaced = read % 2 === 0 && /^\d{5}$/.test(postcode)
+			const postcodeSurface = spaced ? `${postcode.slice(0, 3)} ${postcode.slice(3)}` : postcode
 			let raw: string
 
-			const components: Record<string, string> = {
-				street,
-				house_number: number,
-				postcode,
-				locality: city,
-			}
+			const components: Record<string, string> =
+				order === STREETLESS_ORDER
+					? { locality: city, postcode: postcodeSurface, country: "Česko" }
+					: { street, house_number: number, postcode: postcodeSurface, locality: city }
 
 			if (order === 0) {
-				raw = `${postcode} ${city}, ${street} ${number}`
+				raw = `${postcodeSurface} ${city}, ${street} ${number}`
 			} else if (order === 1) {
-				raw = `${street} ${number}, ${postcode} ${city}`
+				raw = `${street} ${number}, ${postcodeSurface} ${city}`
+			} else if (order === 2) {
+				raw = `${city}, ${postcodeSurface}, ${street} ${number}`
 			} else {
-				raw = `${city}, ${postcode}, ${street} ${number}`
+				// order === STREETLESS_ORDER: the street-less form — `«city» «pc», Česko` — the exact surface of the
+				// cz-full-praha-100-00 board row. The v4.5.0 no-promote receipt measured the gap: every
+				// prior order was street-bearing, so the model never saw a spaced PSČ beside a bare
+				// locality and mangled 'Praha 100 00, Czechia' into house_number spans. Street/number
+				// stay OUT of the components for this form (they are not in the surface).
+				raw = `${city} ${postcodeSurface}, Česko`
 			}
 
 			const source_id = shardSourceID("synth-cz-pcfirst-preposition", {
 				...components,
 				o: String(order),
+				s: spaced ? "1" : "0",
 				v: String(read),
 			})
 

package/src/shard-recipes/fr-admin-split.ts

@@ -32,11 +32,13 @@
 
 import { departementForCodePostal } from "@mailwoman/codex/fr"
 import type { ComponentTag } from "@mailwoman/core/types"
-import { stableSourceID } from "@mailwoman/corpus/adapters/utils"
-import type { CanonicalRow } from "@mailwoman/corpus/types"
-import { alignRow } from "@mailwoman/corpus/utils"
+import { tempRootPath } from "@mailwoman/core/utils"
 import { CSVSpliterator, Delimiters } from "spliterator"
 
+import { stableSourceID } from "#adapters/utils"
+import type { CanonicalRow } from "#types"
+import { alignRow } from "#utils"
+
 import { makeMulberry32, type ShardRecipe } from "./scaffold.ts"
 
 /* oxlint-disable sister-software/no-unnamed-threshold -- the bare decimals below are weighted-sampler
@@ -45,7 +47,7 @@ import { makeMulberry32, type ShardRecipe } from "./scaffold.ts"
    would hide the distribution behind a wall of identifiers. Genuine thresholds in these files are
    extracted as named constants above. */
 
-const DEFAULT_COMMUNES = "/tmp/reg/fr-communes.tsv"
+const DEFAULT_COMMUNES = tempRootPath("reg", "fr-communes.tsv")
 const LICENSE = "BAN (Base Adresse Nationale) commune+postcode tuples, rendered admin-split — see ingest SOURCE"
 
 /**

package/src/shard-recipes/fr-bare-street.ts

@@ -20,9 +20,25 @@
  *   run including this shard.
  */
 
+import { FR_VOIE_TYPES } from "@mailwoman/codex/fr"
+
 import { decomposeFrStreet } from "../adapters/ban/street-decompose.ts"
 import { alignAndWrite, makeMulberry32, readTuples, type ShardRecipe, shardSourceID } from "./scaffold.ts"
 
+/**
+ * Canonical voie type (lowercase, accent-kept) → its most common written abbreviation, from the codex table's first
+ * entry. Types with no attested abbreviation stay canonical in the abbreviated form.
+ */
+const FR_VOIE_ABBREV: Record<string, string> = Object.fromEntries(
+	Object.entries(FR_VOIE_TYPES).flatMap(([canonical, abbrevs]) => (abbrevs[0] ? [[canonical, abbrevs[0]]] : []))
+)
+
+/**
+ * The order-cycle slot for the BARE-STREET-ONLY form (`«voie» «name»`, no number, no locality) — the absence
+ * counterweight to the locality-terminated comma-free forms (see the cycle comment).
+ */
+const BARE_STREET_ONLY_FORM = 3
+
 /**
  * Shard 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.
@@ -30,7 +46,7 @@ import { alignAndWrite, makeMulberry32, readTuples, type ShardRecipe, shardSourc
 export const frBareStreetRecipe: ShardRecipe = {
 	name: "fr-bare-street",
 	description:
-		"FR bare comma-form street+city, NO postcode (#251): '<n> Rue <name>, <City>' — the postcode-anchoring lever",
+		"FR bare street+city, NO postcode (#251): comma / comma-free / abbreviated-voie surfaces over one label set",
 	mode: "tuples",
 	async run(opts, write) {
 		// Seeded for parity with the other recipes; unused beyond reproducibility (the tuples drive the content).
@@ -53,23 +69,82 @@ export const frBareStreetRecipe: ShardRecipe = {
 
 			const { prefix, street } = decomposeFrStreet(fullStreet)
 
-			// The failing class is the prefix-led FR street; a no-prefix nom_voie ("La Ville Mois") isn't it.
+			// A no-prefix nom_voie ("La Ville Mois") is not the prefix-led class the numbered forms
+			// exercise — but as a BARE surface it is exactly the non-voie-led counterweight the v4.5.1
+			// probe showed missing ('Savile Row'-shaped spans still fell to the trailing-locality
+			// prior; the voie-led bare form protected only voie-led spans). Alternate rows emit the
+			// whole span as a bare street; the rest skip as before.
 			if (!prefix || !street) {
+				if (read % 2 === 0 && fullStreet.split(" ").length >= 2) {
+					const bare = {
+						raw: fullStreet,
+						components: { street: fullStreet } as Record<string, string>,
+						country: "FR",
+						locale: "fr-FR",
+						source: "synth-fr-bare-street",
+						source_id: shardSourceID("synth-fr-bare-street", {
+							street: fullStreet,
+							f: "bare-nonvoie",
+							v: String(read),
+						}),
+						corpus_version: "0.9.4",
+						license:
+							"Synthetic — fr-bare-street; (street, number, city) from BAN (Base Adresse Nationale, Licence Ouverte)",
+					}
+
+					if (alignAndWrite(write, bare, "fr-bare-street")) {
+						emitted++
+					} else {
+						skipped++
+					}
+
+					continue
+				}
+
 				skipped++
 
 				continue
 			}
 
-			const components: Record<string, string> = {
-				house_number: number,
-				street_prefix: prefix,
-				street,
-				locality,
+			// Four surfaces over the same tuple, cycled deterministically. The comma form was the
+			// original lever; the COMMA-FREE form is the colloquial register users actually type
+			// ('12 rue de Rome Paris' — the street↔locality boundary with NO delimiter, the fr-fr
+			// panel's named loss); the ABBREVIATED form is the typeahead register the geocoder-tester
+			// FR slice attests at scale; and the BARE-STREET-ONLY form is the absence counterweight —
+			// without it, every delimiter-free surface in the mix ENDS in a locality, the model learns
+			// "trailing span = locality" as categorical, and bare street names across locales flip to
+			// locality wholesale (the v4.5.0 no-promote's measured erosion: 'Calle de Alcalá',
+			// 'Madison Square West', and COMER's fork all fell to that prior). Tags are identical
+			// where present; each component VALUE is the span as written (BIO alignment binds value
+			// to surface); the bare form carries NO number and NO locality because the surface has
+			// neither.
+			const form = read % 4
+			const prefixSurface = form >= 2 ? (FR_VOIE_ABBREV[prefix.toLowerCase()] ?? prefix) : prefix
+
+			const components: Record<string, string> =
+				form === BARE_STREET_ONLY_FORM
+					? { street_prefix: prefix, street }
+					: { house_number: number, street_prefix: prefixSurface, street, locality }
+
+			// When the tuple carries a WOF-attested neighbourhood, the comma slot renders the
+			// THREE-slot middle surface — the dependent-locality counterweight (the v4.5.1 erosion's
+			// untouched half: the two-slot comma-free endings squeezed the middle tag out).
+			const hood = String(t.neighbourhood ?? "").trim()
+
+			if (form === 0 && hood) {
+				components.dependent_locality = hood
 			}
 
-			// BARE comma form, number-before (FR's dominant order), NO postcode — the whole point.
-			const raw = `${number} ${prefix} ${street}, ${locality}`
-			const source_id = shardSourceID("synth-fr-bare-street", { ...components, v: String(read) })
+			const raw =
+				form === 0
+					? hood
+						? `${number} ${prefix} ${street}, ${hood}, ${locality}`
+						: `${number} ${prefix} ${street}, ${locality}`
+					: form === BARE_STREET_ONLY_FORM
+						? `${prefix} ${street}`
+						: `${number} ${prefixSurface} ${street} ${locality}`
+
+			const source_id = shardSourceID("synth-fr-bare-street", { ...components, f: String(form), v: String(read) })
 
 			const canonical = {
 				raw,

package/src/shard-recipes/fr-lieudit.ts

@@ -29,11 +29,13 @@ import { join } from "node:path"
 
 import { extractBANAddrPoints } from "@mailwoman/ban/sdk"
 import { COUNTRY_SURFACE_FORMS } from "@mailwoman/codex/country"
+import { isPresent } from "@mailwoman/core/objects"
 import type { ComponentTag } from "@mailwoman/core/types"
 import { dataRootPath } from "@mailwoman/core/utils"
-import { stableSourceID } from "@mailwoman/corpus/adapters/utils"
-import type { CanonicalRow } from "@mailwoman/corpus/types"
-import { alignRow } from "@mailwoman/corpus/utils"
+
+import { stableSourceID } from "#adapters/utils"
+import type { CanonicalRow } from "#types"
+import { alignRow } from "#utils"
 
 import { decomposeFrStreet } from "../adapters/ban/street-decompose.ts"
 import { makeMulberry32, type ShardRecipe } from "./scaffold.ts"
@@ -156,7 +158,7 @@ function composeRaw(
 	}
 
 	lines.push(dependentLocality)
-	const cityLine = [postcode, locality].filter(Boolean).join(" ").trim()
+	const cityLine = [postcode, locality].filter(isPresent).join(" ").trim()
 
 	if (cityLine) {
 		lines.push(cityLine)

package/src/shard-recipes/fr-order.ts

@@ -30,11 +30,13 @@
  *   inlined the variant logic and never called it).
  */
 
+import { isPresent } from "@mailwoman/core/objects"
 import type { ComponentTag } from "@mailwoman/core/types"
 import { dataRootPath } from "@mailwoman/core/utils"
-import { stableSourceID } from "@mailwoman/corpus/adapters/utils"
-import type { CanonicalRow } from "@mailwoman/corpus/types"
-import { alignRow } from "@mailwoman/corpus/utils"
+
+import { stableSourceID } from "#adapters/utils"
+import type { CanonicalRow } from "#types"
+import { alignRow } from "#utils"
 
 import { makeMulberry32, readZippedCSVRecords, type ShardRecipe } from "./scaffold.ts"
 
@@ -196,7 +198,7 @@ export const frOrderRecipe: ShardRecipe = {
 			const { raw, components } = rendered
 
 			// Safety check: every component must appear verbatim in raw (alignment precondition).
-			const componentValues = Object.values(components).filter(Boolean) as string[]
+			const componentValues = Object.values(components).filter(isPresent)
 
 			if (!componentValues.every((v) => raw.includes(v))) {
 				skipped++

package/src/shard-recipes/german.ts

@@ -16,9 +16,10 @@
  */
 
 import { dataRootPath } from "@mailwoman/core/utils"
-import { stableSourceID } from "@mailwoman/corpus/adapters/utils"
-import { synthesizeGermanRow, type LocaleBaseTuple } from "@mailwoman/corpus/synthesizers/german"
-import { alignRow } from "@mailwoman/corpus/utils"
+
+import { stableSourceID } from "#adapters/utils"
+import { synthesizeGermanRow, type LocaleBaseTuple } from "#synthesizers/german"
+import { alignRow } from "#utils"
 
 import { makeMulberry32, readZippedCSVRecords, type ShardRecipe } from "./scaffold.ts"
 

package/src/shard-recipes/house-venue.ts

@@ -10,7 +10,7 @@
  *   scripts/build-house-venue-shard.mjs.
  */
 
-import { synthesizeHouseVenueRow, type HouseVenueBaseTuple } from "@mailwoman/corpus/synthesizers/house-venue"
+import { synthesizeHouseVenueRow, type HouseVenueBaseTuple } from "#synthesizers/house-venue"
 
 import { alignAndWrite, makeLcg, readTuples, shardSourceID, type ShardRecipe } from "./scaffold.ts"