@mailwoman/corpus 10.0.0 → 10.2.0

package/lib/synthesizers/anchor-absorption.ts

@@ -3,49 +3,36 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   Anchor-absorption counter-augmentation (#220/#723, Probe A1). Teaches the model the CONTEXT-
- *   DEPENDENT leading-5-digit disambiguation that the killed #723 override was faking, AND that the
- *   `anchor_paint_mode=shaped` WHERE fix alone over-corrected on (Probe A0: it flipped the default
- *   to house_number, recovering CASE-H but ERODING CASE-P — postcode F1 99.3→86.5 on
- *   leading-postcode rows like "05764 Finel Hollow Road, VT").
- *
- *   THE DISCRIMINATOR the model must learn (from the CASE-H vs CASE-P contrast, NOT a flipped
- *   default):
- *
- *   - A leading 5-digit WITH a trailing postcode + street context → it is the HOUSE NUMBER (CASE-H)
- *   - A leading 5-digit with NO trailing postcode (US-rural / DE) → it IS the POSTCODE (CASE-P) Both
- *       leading tokens are real ZIPs (so the painted anchor fires on both); only the surrounding
- *       context separates them. The model attends to the trailing token to decide the leading one.
- *
- *   Slice mix (the A0 learning sets a HEAVY CASE-P floor so the default doesn't flip — DeepSeek's
- *   ≥35% CASE-P; here CASE-P total = 35%): H-adversarial 30% US street, leading real-ZIP house# +
- *   TRAILING postcode → house_number P-us-rural 20% US rural, leading postcode, NO trailing →
- *   postcode (the A0-erosion fix) P-de 15% German leading postcode "{pc} {city}, {street} {hn}" →
- *   postcode anchor-fp 10% leading 5-digit that is NOT a real ZIP + trailing postcode →
- *   house_number locale-ambig 15% minimal context; the local token (street-type vs none) decides
- *   standard 10% normal small house# + trailing postcode → house_number (baseline)
- *
- *   Real ZIPs for the leading-5-digit are sampled from the postcode anchor lookup at build time
- *   (passed via opts.realZips) so the shaped anchor fires on them exactly as at inference; fake
- *   ZIPs (anchor-fp) are 5-digit strings deliberately absent from the lookup.
+ *   Generates address pairs in which context decides whether a leading five-digit token is a house number or a postcode.
  */
 
-import type { ComponentTag } from "@mailwoman/codex/component"
+/* oxlint-disable mailwoman/prefer-home -- every tuple comes from the hardcoded US `US_TUPLES` list.
+   The admin tails use US templates. Each row puts a bare five-digit ZIP before a street to make the anchor channel
+   fire on the wrong span. This produces a US postcode shape by construction. */
 
-import { pick } from "#synthesizers/utils"
+import type { ComponentTag } from "@mailwoman/codex/component"
+import { sample } from "@mailwoman/core/random"
 
 /* oxlint-disable sister-software/no-unnamed-threshold -- the bare decimals below are weighted-sampler
-   cutoffs, not thresholds: `const r = random()` followed by a cascade of `r < 0.4` branches IS the
-   output distribution, and reading the cascade top-to-bottom is how you see it. Naming each cutoff
+   cutoffs rather than thresholds: `const r = random()` followed by a cascade of `r < 0.4` branches defines the
+   output distribution. The cascade shows each weight from top to bottom. A separate constant for each cutoff
    would hide the distribution behind a wall of identifiers. Genuine thresholds in these files are
-   extracted as named constants above. */
+    extracted as constants above. */
 
+/**
+ * A US locality, region and postcode used as an address tail.
+ */
 export interface AnchorAbsorptionBaseTuple {
 	locality: string
 	region: string
 	postcode: string
 }
 
+/**
+ * The row templates.
+ *
+ * Names that start with `h-` produce a house number and names that start with `p-` a postcode.
+ */
 export type AnchorAbsorptionTemplate =
 	| "h-adversarial"
 	| "h-no-trailing-locality"
@@ -55,16 +42,25 @@ export type AnchorAbsorptionTemplate =
 	| "locale-ambig"
 	| "standard"
 
+/**
+ * Options for {@link synthesizeAnchorAbsorptionRow}.
+ */
 export interface AnchorAbsorptionSynthesisOpts {
 	random?: () => number
 	forceTemplate?: AnchorAbsorptionTemplate
 	/**
-	 * Real US ZIPs (in the anchor lookup) to use as the LEADING 5-digit house number — so the painted anchor fires on it,
-	 * the CASE-H/anchor-fp trigger. Builder loads these from pilot-anchor-lookup.json.
+	 * Real US ZIP codes from the postcode-anchor lookup.
+	 *
+	 * The templates place them where the anchor fires on a token that is really a house number.
+	 *
+	 * @defaultValue the postcodes of the built-in US tuples.
 	 */
 	realZips?: ReadonlyArray<string>
 }
 
+/**
+ * One synthesized row with its template.
+ */
 export interface SynthesizedAnchorAbsorptionRow {
 	raw: string
 	components: Partial<Record<ComponentTag, string>>
@@ -73,19 +69,15 @@ export interface SynthesizedAnchorAbsorptionRow {
 }
 
 /**
- * A realistic US house number: mostly 1–4 digits (the common range), 25% a real 5-digit ZIP (the HARD case — a 5-digit
- * leading number that is still a house number when a locality is present).
+ * Samples a house number.
+ * One quarter of the samples use a real ZIP code.
  */
 function houseNum(random: () => number, realZips: ReadonlyArray<string>): string {
-	if (random() < 0.25) return pick(realZips, random)
+	if (random() < 0.25) return sample(realZips, random)
 
 	return String(1 + Math.floor(random() * 9999))
 }
 
-/**
- * Curated, provenance-light reference vocab (real US street/city/state + DE). Surface forms must appear in `raw` for
- * alignRow; these are plain ASCII tokens that align cleanly.
- */
 const STREET_NAMES = [
 	"Main",
 	"Oak",
@@ -107,6 +99,7 @@ const STREET_NAMES = [
 	"Crescent Meadow",
 ]
 
+// TODO: Derive this from the US codex package exports
 const STREET_TYPES = ["St", "Ave", "Rd", "Dr", "Ln", "Blvd", "Ct", "Way", "Road", "Drive"]
 
 const US_TUPLES: ReadonlyArray<AnchorAbsorptionBaseTuple> = [
@@ -120,15 +113,8 @@ const US_TUPLES: ReadonlyArray<AnchorAbsorptionBaseTuple> = [
 	{ locality: "Sacramento", region: "CA", postcode: "95823" },
 ]
 
-/**
- * US rural states where the leading-postcode "{ZIP} {Street}, {STATE}" form (no trailing ZIP) is real — the VT/rural
- * format the #723 override broke and Probe A0 eroded.
- */
 const RURAL_REGIONS = ["VT", "ND", "SD", "NH", "ME", "MT", "WY"]
 
-/**
- * DE leading-postcode tuples: "{postcode} {locality}, {street} {house}".
- */
 const DE_TUPLES = [
 	{ postcode: "10115", locality: "Berlin", street: "Hauptstraße" },
 	{ postcode: "80331", locality: "München", street: "Sendlinger Straße" },
@@ -138,26 +124,24 @@ const DE_TUPLES = [
 ]
 
 const HOUSE_NUMS = ["5", "12", "27", "100", "212", "1450", "8"]
-/**
- * Fake 5-digit strings that are NOT real US ZIPs (so the anchor lookup MISSES them) — for anchor-fp.
- */
+// These five-digit values must stay absent from the postcode lookup.
 const FAKE_ZIPS = ["00000", "99998", "99997", "00001", "99996"]
 
 /**
- * Build one anchor-absorption counter-augmentation row.
+ * Builds one row from a sampled or forced template.
  */
 export function synthesizeAnchorAbsorptionRow(
 	opts: AnchorAbsorptionSynthesisOpts = {}
 ): SynthesizedAnchorAbsorptionRow {
 	const random = opts.random ?? Math.random
 	const realZips = opts.realZips && opts.realZips.length ? opts.realZips : US_TUPLES.map((t) => t.postcode)
-	const template = opts.forceTemplate ?? pick(ALL_TEMPLATES, random)
-	const street = `${pick(STREET_NAMES, random)} ${pick(STREET_TYPES, random)}`
+	const template = opts.forceTemplate ?? sample(ALL_TEMPLATES, random)
+	const street = `${sample(STREET_NAMES, random)} ${sample(STREET_TYPES, random)}`
 
 	if (template === "h-adversarial") {
-		// US street, leading real-ZIP house number, WITH a trailing postcode → the leading is house_number.
-		const zip = pick(realZips, random)
-		const t = pick(US_TUPLES, random)
+		// The trailing postcode makes the leading real ZIP code a house number.
+		const zip = sample(realZips, random)
+		const t = sample(US_TUPLES, random)
 		const raw = `${zip} ${street}, ${t.locality}, ${t.region} ${t.postcode}`
 
 		return {
@@ -169,9 +153,9 @@ export function synthesizeAnchorAbsorptionRow(
 	}
 
 	if (template === "p-us-rural") {
-		// US rural, leading postcode, NO trailing postcode → the leading IS the postcode (the A0-erosion fix).
-		const zip = pick(realZips, random)
-		const region = pick(RURAL_REGIONS, random)
+		// Without a locality or trailing postcode, the leading value is the postcode.
+		const zip = sample(realZips, random)
+		const region = sample(RURAL_REGIONS, random)
 		const raw = `${zip} ${street}, ${region}`
 
 		return {
@@ -183,9 +167,8 @@ export function synthesizeAnchorAbsorptionRow(
 	}
 
 	if (template === "p-de") {
-		// German leading postcode "{pc} {city}, {street} {hn}" → the leading is the postcode.
-		const d = pick(DE_TUPLES, random)
-		const hn = pick(HOUSE_NUMS, random)
+		const d = sample(DE_TUPLES, random)
+		const hn = sample(HOUSE_NUMS, random)
 		const raw = `${d.postcode} ${d.locality}, ${d.street} ${hn}`
 
 		return {
@@ -197,9 +180,9 @@ export function synthesizeAnchorAbsorptionRow(
 	}
 
 	if (template === "anchor-fp") {
-		// Leading 5-digit that is NOT a real ZIP (anchor MISSES) + trailing postcode → still house_number.
-		const fake = pick(FAKE_ZIPS, random)
-		const t = pick(US_TUPLES, random)
+		// A five-digit value absent from the ZIP lookup is still a house number here.
+		const fake = sample(FAKE_ZIPS, random)
+		const t = sample(US_TUPLES, random)
 		const raw = `${fake} ${street}, ${t.locality}, ${t.region} ${t.postcode}`
 
 		return {
@@ -211,15 +194,15 @@ export function synthesizeAnchorAbsorptionRow(
 	}
 
 	if (template === "locale-ambig") {
-		// Minimal context — the LOCAL token decides. Half: "{realZip} {street}" (street-type → house#);
-		// half: "{realZip} {locality}" (no street, leading postcode → postcode). No trailing, no region.
-		const zip = pick(realZips, random)
+		// A following street makes the value a house number.
+		// A following locality makes it a postcode.
+		const zip = sample(realZips, random)
 
 		if (random() < 0.5) {
 			return { raw: `${zip} ${street}`, components: { house_number: zip, street }, locale: "en-US", template }
 		}
 
-		const t = pick(US_TUPLES, random)
+		const t = sample(US_TUPLES, random)
 
 		return {
 			raw: `${zip} ${t.locality}`,
@@ -230,15 +213,10 @@ export function synthesizeAnchorAbsorptionRow(
 	}
 
 	if (template === "h-no-trailing-locality") {
-		// The A3 fix (#220): the common US format "{house#} {street}, {locality}, {STATE}" with NO trailing
-		// postcode → the leading number is the HOUSE NUMBER. The CONTRAST to p-us-rural (same no-trailing,
-		// state-bearing shape) is the LOCALITY: present here, absent there. The A2 slice lacked this slice,
-		// so p-us-rural's "leading-number + STATE → postcode" rule over-generalized to 98 golden house#
-		// rows ("36 Oxbow Dr, Bradford, VT" → postcode). The house# spans 1-4 digits AND real 5-digit ZIPs
-		// (the hard case: 5-digit + locality is STILL a house number, distinct from p-us-rural's no-locality).
+		// The locality separates this form from the rural postcode-first form.
 		const hn = houseNum(random, realZips)
-		const t = pick(US_TUPLES, random)
-		const region = random() < 0.5 ? pick(RURAL_REGIONS, random) : t.region
+		const t = sample(US_TUPLES, random)
+		const region = random() < 0.5 ? sample(RURAL_REGIONS, random) : t.region
 		const raw = `${hn} ${street}, ${t.locality}, ${region}`
 
 		return {
@@ -249,9 +227,8 @@ export function synthesizeAnchorAbsorptionRow(
 		}
 	}
 
-	// standard: normal house number + trailing postcode → house_number (baseline, keeps the common case).
 	const hn = houseNum(random, realZips)
-	const t = pick(US_TUPLES, random)
+	const t = sample(US_TUPLES, random)
 	const raw = `${hn} ${street}, ${t.locality}, ${t.region} ${t.postcode}`
 
 	return {
@@ -262,20 +239,8 @@ export function synthesizeAnchorAbsorptionRow(
 	}
 }
 
-// Weighted template bag — the slice mix. Expanded to a flat array so `pick` draws at the target
-// frequencies (matches the boundary-stress ALL_TEMPLATES idiom).
-//
-// A3 (#220, after the per-row diagnostic on the A2 probe): A1/A2 both held SLICE-H (100) + postcode
-// (~98) but cost house_number (95.8->92.8), and the A2 mix-rebalance did NOT move it — so it was never a
-// CASE-P-quantity problem. The row-by-row v192-vs-A2 diff (hn-regression-diff.ts) pinned it: 132/132 house#
-// regressions were house#->POSTCODE on "{house#} {street}, {locality}, {STATE}" no-trailing rows — the
-// p-us-rural rule ("leading-number + STATE + no-trailing -> postcode") OVER-GENERALIZED because the slice
-// had NO counter-slice for the common locality-bearing house# case. A3 ADDS h-no-trailing-locality (15%)
-// to teach the LOCALITY discriminator (present -> house#, absent + 5-digit -> postcode = p-us-rural) and
-// trims p-us-rural 16->13. Goal: house_number recovers WITHOUT re-eroding postcode/SLICE-H. CASE-P = 26%.
 /**
- * Every anchor-absorption template, in one list for the slice runner to sample from. Each covers a way a venue or
- * landmark name can swallow the street token that follows it.
+ * The template sampling pool, in which each template's repeat count is its weight.
  */
 export const ALL_TEMPLATES: ReadonlyArray<AnchorAbsorptionTemplate> = [
 	...new Array<AnchorAbsorptionTemplate>(25).fill("h-adversarial"),

package/lib/synthesizers/boundary-stress.ts

@@ -3,75 +3,40 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   Boundary-instability synthesizer (#375 — the highest-impact parser change). The failure taxonomy
- *
- *   The within-token-punctuation decomposition (#702) found one failure FAMILY surfacing under many
- *   names: the model mis-places token boundaries between adjacent components when the boundary is
- *   ambiguous or unmarked. This generator emits diverse BIO-labeled rows that put the gold boundary
- *   exactly where the model wobbles, so a retrain learns the boundary from context, not the
- *   lexeme.
- *
- *   The four token-aligned stress shapes, all in BASE LOCALES (US/FR/DE) so the slice never
- *   introduces tokens the base corpus lacks (the #511 base-consistency lint flagged an earlier
- *   AU-bearing draft: AU 4-digit postcodes collide with US house numbers, and AU localities are
- *   absent from the US/FR/DE base — a real contradiction). Each component is a whitespace-separated
- *   token run, so `alignRow` labels it cleanly:
- *
- *   1. `street-eats-affix` — multi-word street + suffix (`Country Club Rd` → street + street_suffix),
- *        the #1 wobble: the model keeps the suffix in the street.
- *   2. `comma-less-city-state` — no comma between street / locality / region (`100 Main St Springfield
- *        IL 62701`), the #694 family: concatenated input loses the segmentation cue. US-only (US
- *        zips are base-consistent; the boundary is locale-agnostic).
- *   3. `fr-prefix` — FR street-type prefix split from the name (`Rue Jean-Baptiste Lebas` →
- *        street_prefix
- *
- *        - Street), postcode-first order.
- *   4. `house-number-after-street` — FR/DE number-follows-street (`Neuve-des-Capucines 5` → street +
- *        house_number), the model absorbs the number into the street.
- *
- *   Two BALANCING shapes (added 2026-06-18 after the v1.6.0 probes). The first pass at weight 1.0
- *   lifted the boundaries but over-fit a NARROW distribution — every row was a clean, full,
- *   structured address — so the model regressed on out-of-distribution real rows (held-out US
- *   locality 66.3→58.2%). These two widen the distribution the slice teaches over, per the
- *   diagnosis (scripts/eval/locality-regression-probe): 5. `bare-locality` — locality with NO
- *   street (`Public Library, Lisbon ND`, `75003 Paris`), the ship-blocker: 84% of the v1.6.0
- *   locality regression was DROPPED locality on bare "City, STATE" rows, because every other shape
- *   placed a street before the city. Bare / comma-less / postcode'd / venue-prefixed forms, US +
- *   FR. 6. `house-number-before-street` — the confounding mirror of #4 (same FR vocab, number
- *   BEFORE the street). A balanced before:after mix breaks the positional shortcut behind the #4
- *   order-bias.
- *
- *   EXCLUDED: the region+postcode glue (`NY14201` — sub-token, no punctuation to split) and the
- *   AU/NZ/UK slash unit-convention (`4/2A` → unit+house_number). The slash labels cleanly (the
- *   tokenizer splits `/`) and is the worst within-token class — but it inherently requires non-base
- *   AU/NZ/UK locales, which contradict the US/FR/DE base (the lint catch). It belongs in a
- *   separately-scoped AU/NZ/UK boundary-coverage slice that ALSO adds AU base coverage, not in this
- *   base-locale slice. `synthesizers/boundary-stress.test.ts` proves the alignments.
+ *   Generates US and French address rows that stress the boundaries between adjacent components.
  */
 
+/* oxlint-disable mailwoman/prefer-home -- the admin tails below are written as US templates because every tuple this
+   synthesizer draws from is `US_TUPLES`, a hardcoded US list. The comma-less arm deliberately malforms that order.
+ A layout cannot express it. The arm stresses the segmentation cue created by commas. */
+
+import { countryDisplayNames } from "@mailwoman/codex/country/display-names"
 import type { DirectionalAbbreviation } from "@mailwoman/codex/us"
+import { sample } from "@mailwoman/core/random"
 
-import { pick } from "#synthesizers/utils"
+import { layoutAdminTail } from "#synthesizers/tail"
 import type { CanonicalRow } from "#types"
 
 /* oxlint-disable sister-software/no-unnamed-threshold -- the bare decimals below are weighted-sampler
-   cutoffs, not thresholds: `const r = random()` followed by a cascade of `r < 0.4` branches IS the
-   output distribution, and reading the cascade top-to-bottom is how you see it. Naming each cutoff
-   would hide the distribution behind a wall of identifiers. Genuine thresholds in these files are
-   extracted as named constants above. */
+   cutoffs rather than thresholds: `const r = random()` followed by a cascade of `r < 0.4` branches is the
+   output distribution. The cascade shows each weight from top to bottom. A separate constant for each cutoff
+   would hide the distribution behind identifiers. The genuine thresholds in these files are
+    extracted as constants above. */
 
+/**
+ * The row templates that {@link synthesizeBoundaryStressRow} can produce.
+ */
 export type BoundaryStressTemplate =
 	| "street-eats-affix"
 	| "comma-less-city-state"
 	| "fr-prefix"
 	| "house-number-after-street"
-	// Added 2026-06-18 after the v1.6.0 probes (the slice's NARROW distribution over-fit "full structured
-	// address" and regressed OOD). These two re-balance the contexts the model actually sees:
-	| "bare-locality" // the ship-blocker fix: locality with NO street (the 84%-dropped "City, STATE" rows)
+	| "bare-locality"
 	| "house-number-before-street"
 
-// the confounding mirror of house-number-after-street (number position)
-
+/**
+ * A locality, region, postcode and country used as an address tail.
+ */
 export interface BoundaryStressBaseTuple {
 	locality: string
 	region: string
@@ -79,14 +44,20 @@ export interface BoundaryStressBaseTuple {
 	country: string
 }
 
+/**
+ * Options for {@link synthesizeBoundaryStressRow}.
+ */
 export interface BoundaryStressSynthesisOpts {
 	random?: () => number
 	/**
-	 * Force a specific shape (tests + balanced slice composition).
+	 * A template to use instead of a sampled one.
 	 */
 	forceTemplate?: BoundaryStressTemplate
 }
 
+/**
+ * One synthesized row with its template.
+ */
 export interface SynthesizedBoundaryStressRow {
 	raw: string
 	components: CanonicalRow["components"]
@@ -94,12 +65,6 @@ export interface SynthesizedBoundaryStressRow {
 	template: BoundaryStressTemplate
 }
 
-/**
- * Multi-word street names — the suffix boundary only bites when "Club" could be read as part of the name. Single-word
- * names alone teach nothing about the suffix edge. Multi-word names are what make the suffix boundary BITE (the model
- * must not read the trailing suffix word as part of the name). Kept diverse so the slice teaches the boundary, not the
- * lexeme.
- */
 const MULTIWORD_STREETS = [
 	"Country Club",
 	"Martin Luther King",
@@ -223,14 +188,9 @@ const SUFFIXES = [
 	"Walk",
 ] as const
 
-// Vocabulary compile-checked against the codex; the ORDER stays this literal's. `Object.values(DirectionalAbbreviation)`
-// runs N,E,S,W,… — deriving the array from it would re-map every pick() draw and change shipped slice bytes.
+// Keep the order fixed because seeded sampling depends on it.
 const DIRECTIONALS = ["N", "S", "E", "W", "NE", "NW", "SE", "SW"] as const satisfies readonly DirectionalAbbreviation[]
 
-/**
- * FR street-type prefixes + hyphenated honorific street names (the hyphen is incidental; the boundary stress is the
- * prefix↔name split + the number-after-street order).
- */
 const FR_PREFIXES = [
 	"Rue",
 	"Avenue",
@@ -276,16 +236,10 @@ const FR_NAMES = [
 ] as const
 
 /**
- * Org/venue prefixes for the bare-locality shape — the v1.6.0 locality drop hit org-PREFIXED real rows hardest ("LISBON
- * PUBLIC LIBRARY, …, Lisbon ND"; "Alburg Health Center"). Teaching the locality WITH a leading venue keeps the model
- * emitting it on facility-style addresses (NPPES/HRSA shapes). `venue` is a base ComponentTag. #511-LINTED 2026-06-18
- * (scripts/lint-venue-vocab — scan of nppes/hrsa/tiger/nad/wof-admin): every token here is venue-DOMINANT in the base,
- * so the slice agrees with it. The first draft was naive — 9 terms were dropped because their tokens are dominantly
- * street/locality and would CONTRADICT the base the way Madison-as-street did (#511): "Fire" 93% street, "Veterans" 94%
- * street, "City" 68% locality, "Hall" 63% street, "Memorial"/"Hospital" 62-63% street, "Recreation" 79% street, "Town"
- * 48% locality, "Library" 51% street, "County" 68% street, "Arts"/"Courthouse"/"Municipal" dependent_locality. Kept
- * tokens: Clinic 98%, Practice 98%, Dental 100%, Health 99%, Medical 88%, Community 92%, Department 90%, Group 87%,
- * Center 65%, School 70%, Public 89%, Elementary/Family 97% (all venue).
+ * Venue prefixes for bare-locality rows.
+ *
+ * The list uses only words that the base corpus labels as venue.
+ * It avoids words that it mostly labels as street or locality.
  */
 const VENUES = [
 	"Community Center",
@@ -304,12 +258,7 @@ const VENUES = [
 	"Public School",
 ] as const
 
-/**
- * Localities DERIVED from the base corpus (#511): every name here is verified locality-DOMINANT in the training data
- * (B-locality ≫ I-street), so the slice agrees with the base instead of fighting it. The night's targeted scan caught
- * the prior vocab (Madison, Portland, Springfield IL…) at 92–100% STREET in the base ("Madison Ave"), the "5th Avenue
- * Theatre" #511 trap. See 2026-06-17-locality-vocab-fix.
- */
+// The base corpus labels each of these localities as locality.
 const US_TUPLES: ReadonlyArray<BoundaryStressBaseTuple> = [
 	{ locality: "Albuquerque", region: "NM", postcode: "87102", country: "US" },
 	{ locality: "Indianapolis", region: "IN", postcode: "46203", country: "US" },
@@ -341,13 +290,7 @@ const US_TUPLES: ReadonlyArray<BoundaryStressBaseTuple> = [
 	{ locality: "Springfield", region: "MA", postcode: "01108", country: "US" },
 ]
 
-/**
- * FR localities DERIVED from the FR (ban) slices specifically — where these famous cities are 95–99% locality-DOMINANT
- * (Paris 515605/24789, Marseille 247014/1752, Lyon 106239/3114). NB: the all-slice scan falsely flagged them
- * street-dominant by undersampling the FR block (parts 180–209) and mixing in US street-contexts; the FR-block scan is
- * the honest distribution. Dept-diverse (28 depts), region empty (French addresses carry no region token; the
- * generator's region-optional path handles it).
- */
+// French rows have no region component.
 const FR_TUPLES: ReadonlyArray<BoundaryStressBaseTuple> = [
 	{ locality: "Paris", region: "", postcode: "75003", country: "FR" },
 	{ locality: "Marseille", region: "", postcode: "13016", country: "FR" },
@@ -369,9 +312,6 @@ const FR_TUPLES: ReadonlyArray<BoundaryStressBaseTuple> = [
 	{ locality: "Rambouillet", region: "", postcode: "78120", country: "FR" },
 ]
 
-// NB: no DE_TUPLES — German cities are street-dominated too ("Berliner Straße"), and the base yielded
-// zero locality-dominant DE towns in the scan, so house-number-after-street is FR-only here. DE's
-// native-order number-after-street is covered by the dedicated synth-german slice.
 const houseNumber = (random: () => number): string => String(1 + Math.floor(random() * 4999))
 const localeFor: Record<string, string> = { US: "en-US", FR: "fr-FR", DE: "de-DE" }
 
@@ -385,63 +325,46 @@ const ALL_TEMPLATES: readonly BoundaryStressTemplate[] = [
 ]
 
 /**
- * Synthesize one boundary-stress row. `base` is optional — when omitted, a locale-appropriate tuple is drawn from the
- * internal pools (so the generator is self-contained; a build script can pass real tuples for scale + diversity). Every
- * component value is a verbatim substring of `raw`, so `alignRow` locates + BIO-labels it.
+ * Synthesizes one row from a sampled or forced template.
+ *
+ * When `base` is absent, the function samples a built-in US or French tuple that suits the template.
  */
 export function synthesizeBoundaryStressRow(
-	base: BoundaryStressBaseTuple | undefined,
+	base: BoundaryStressBaseTuple | null,
 	opts: BoundaryStressSynthesisOpts = {}
 ): SynthesizedBoundaryStressRow {
 	const random = opts.random ?? Math.random
-	const template = opts.forceTemplate ?? pick(ALL_TEMPLATES, random)
+	const template = opts.forceTemplate ?? sample(ALL_TEMPLATES, random)
 
 	if (template === "bare-locality") {
-		// The v1.6.0 ship-blocker fix: locality was DROPPED on bare/short "City, STATE" rows (84% of the
-		// regression) because every prior shape placed a street before the city, so the model learned "the
-		// city follows a street" and stopped emitting locality without one. Teach the locality with NO street,
-		// across the forms real data carries it — bare, comma-LESS, postcode'd, and venue/org-prefixed.
-		const b = base ?? (random() < 0.3 ? pick(FR_TUPLES, random) : pick(US_TUPLES, random))
-		const venue = random() < 0.45 ? pick(VENUES, random) : ""
-		// ~12% carry a trailing country token — the v1.7.1 country patch (DeepSeek 2026-06-18). The pure
-		// "City, STATE" bare rows carry NO country token, which cost ~4pp on us.country_homograph in v1.7.0;
-		// teaching "…, USA"/"…, France" recovers it as a single-variable additive without diluting locality.
+		const b = base ?? (random() < 0.3 ? sample(FR_TUPLES, random) : sample(US_TUPLES, random))
+		const venue = random() < 0.45 ? sample(VENUES, random) : ""
 		const withCountry = random() < 0.12
 
-		if (b.country === "FR") {
-			// FR carries no region token; "{postcode} {locality}" is the bare FR form.
-			const core = `${b.postcode} ${b.locality}${withCountry ? ", France" : ""}`
-
-			return {
-				raw: venue ? `${venue}, ${core}` : core,
-				components: {
-					...(venue ? { venue } : {}),
-					postcode: b.postcode,
-					locality: b.locality,
-					...(withCountry ? { country: "France" } : {}),
-				},
-				locale: "fr-FR",
-				template,
-			}
-		}
-
 		const withZip = random() < 0.5
-		const comma = random() < 0.6 ? "," : "" // include the comma-LESS "City STATE" form too
-		// "United States" (United 98% / States 98% country in the base), NOT "USA" — the #511 lint found
-		// "USA" is locality-DOMINANT (75%, only 6% country) in the base; labeling it country would contradict.
-		const countryName = "United States"
-		const core = `${b.locality}${comma} ${b.region}${withZip ? ` ${b.postcode}` : ""}${withCountry ? `, ${countryName}` : ""}`
+		const comma = random() < 0.6
+		// The base corpus labels these spellings as country.
+		const countryName = countryDisplayNames(b.country, ["en"])[0] ?? b.country
+
+		// The layout renders the tail in the country's order: `75005 Paris` for FR
+		// and `Boston, MA 02116` for the US.
+		// Dropping the layout's commas is a surface perturbation that applies to any country.
+		const tail = layoutAdminTail(b.country, {
+			locality: b.locality,
+			region: b.region,
+			postcode: withZip ? b.postcode : undefined,
+			country: withCountry ? countryName : undefined,
+		})
+
+		const core = tail ? (comma ? tail.raw : tail.raw.replaceAll(", ", " ")) : b.locality
 
 		return {
 			raw: venue ? `${venue}, ${core}` : core,
 			components: {
 				...(venue ? { venue } : {}),
-				locality: b.locality,
-				region: b.region,
-				...(withZip ? { postcode: b.postcode } : {}),
-				...(withCountry ? { country: countryName } : {}),
+				...(tail ? tail.components : { locality: b.locality }),
 			},
-			locale: "en-US",
+			locale: localeFor[b.country] ?? "en-US",
 			template,
 		}
 	}
@@ -451,17 +374,12 @@ export function synthesizeBoundaryStressRow(
 		template === "house-number-after-street" ||
 		template === "house-number-before-street"
 	) {
-		// FR-only (no base-consistent DE locality vocab; see the DE_TUPLES note above).
-		const b = base ?? pick(FR_TUPLES, random)
-		const name = pick(FR_NAMES, random)
+		const b = base ?? sample(FR_TUPLES, random)
+		const name = sample(FR_NAMES, random)
 		const hn = houseNumber(random)
 
 		if (template === "house-number-before-street") {
-			// The confounding MIRROR of house-number-after-street: the SAME FR street vocab with the number
-			// BEFORE the name. A balanced before:after mix (the build/recipe sets the ratio, ~7:3 to keep US
-			// house_number 99.8% safe) teaches the model a street-adjacent number is a house_number by FORM,
-			// not position — the probe found v1.6.0 confidently absorbs the TRAILING number into street (I-street
-			// P=0.96), the order-bias.
+			// This form balances the number-after-street form with the same vocabulary.
 			const raw = `${hn} ${name}, ${b.postcode} ${b.locality}`
 
 			return {
@@ -473,8 +391,7 @@ export function synthesizeBoundaryStressRow(
 		}
 
 		if (template === "fr-prefix") {
-			const prefix = pick(FR_PREFIXES, random)
-			// "{hn} {prefix} {name}, {postcode} {locality}" — postcode-first, prefix split from the name.
+			const prefix = sample(FR_PREFIXES, random)
 			const raw = `${hn} ${prefix} ${name}, ${b.postcode} ${b.locality}`
 
 			return {
@@ -491,7 +408,6 @@ export function synthesizeBoundaryStressRow(
 			}
 		}
 
-		// house-number-after-street: "{name} {hn}, {postcode} {locality}" — number FOLLOWS the street.
 		const raw = `${name} ${hn}, ${b.postcode} ${b.locality}`
 
 		return {
@@ -502,13 +418,11 @@ export function synthesizeBoundaryStressRow(
 		}
 	}
 
-	// en-US street shapes (street-eats-affix + comma-less). US-only — US zips are base-consistent and
-	// the boundary these teach is locale-agnostic; no need to introduce a non-base locale.
-	const b = base ?? pick(US_TUPLES, random)
+	const b = base ?? sample(US_TUPLES, random)
 	const hn = houseNumber(random)
-	const dir = random() < 0.4 ? pick(DIRECTIONALS, random) : ""
-	const name = random() < 0.7 ? pick(MULTIWORD_STREETS, random) : pick(SINGLE_STREETS, random)
-	const suffix = pick(SUFFIXES, random)
+	const dir = random() < 0.4 ? sample(DIRECTIONALS, random) : ""
+	const name = random() < 0.7 ? sample(MULTIWORD_STREETS, random) : sample(SINGLE_STREETS, random)
+	const suffix = sample(SUFFIXES, random)
 	const streetCore = `${dir ? `${dir} ` : ""}${name} ${suffix}`
 
 	const components: CanonicalRow["components"] = {
@@ -523,10 +437,8 @@ export function synthesizeBoundaryStressRow(
 
 	const raw =
 		template === "comma-less-city-state"
-			? // no commas anywhere — the segmentation cue is gone
-				`${hn} ${streetCore} ${b.locality} ${b.region} ${b.postcode}`
-			: // standard delimited, multi-word street stresses the suffix boundary
-				`${hn} ${streetCore}, ${b.locality}, ${b.region} ${b.postcode}`
+			? `${hn} ${streetCore} ${b.locality} ${b.region} ${b.postcode}`
+			: `${hn} ${streetCore}, ${b.locality}, ${b.region} ${b.postcode}`
 
 	return { raw, components, locale: localeFor[b.country] ?? "en-US", template }
 }