@mailwoman/corpus 9.4.0 → 10.0.0

package/lib/recipes/trailing-region.ts

@@ -80,6 +80,8 @@ export const trailingRegionRecipe: CorpusRecipe = {
 	mode: "tuples",
 	async run(opts, write) {
 		makeMulberry32(opts.seed)
+		const structuredSource = opts.sourceName ?? "synth-trailing-region-structured"
+		const bareSource = opts.sourceName ? `${opts.sourceName}-bare` : "synth-trailing-region"
 		let read = 0
 		let emitted = 0
 		let skipped = 0
@@ -152,7 +154,10 @@ export const trailingRegionRecipe: CorpusRecipe = {
 			// A DISTINCT source for the structured rows. The sampler buckets by `source` and weights each bucket,
 			// so emitting these under `synth-trailing-region` would pool them with the 88,904 bare rows and make
 			// the new surface unweightable — the dose would silently be whatever the bare slice's weight bought.
-			const sourceLabel = postcode ? "synth-trailing-region-structured" : "synth-trailing-region"
+			// `--source-name` overrides both, and for the same reason one rung up: a rebuild of one country's
+			// surfaces (#1673's corrected Spanish names) pooled under the shipped label would be dosed at
+			// whatever the rows it was built to outweigh are already drawing.
+			const sourceLabel = postcode ? structuredSource : bareSource
 			const source_id = sliceSourceID(sourceLabel, { ...components, v: String(read) })
 
 			const canonical = {

package/lib/recipes/unit.ts

@@ -21,9 +21,9 @@
  *   framework LCG) is consumed in the exact call order the legacy script used.
  */
 
+import type { ComponentTag } from "@mailwoman/codex/component"
 import { US_UNIT_DESIGNATOR_PREFERRED_ABBR, type USUnitDesignator } from "@mailwoman/codex/us"
 import { dataRootPath } from "@mailwoman/core/data-root"
-import type { ComponentTag } from "@mailwoman/core/types"
 import { mulberry32 as makeMulberry32 } from "@mailwoman/core/utils"
 import type { PathBuilderLike } from "path-ts"
 

package/lib/sg/recipes/register.ts

@@ -0,0 +1,270 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   `sg-register` slice recipe — the forms a person in Singapore types, rendered over the Overture-SG register rows
+ *   (#2204 §4). The base `overture` source carries the register's own shape, `990 OLD CHOA CHU KANG ROAD, 699814,
+ *   Singapore`, and the Latin model has no register for the three forms that dominate typed Singapore addresses:
+ *
+ *   - the HDB block line, `Blk 123 Ang Mo Kio Ave 3 #05-67 Singapore 560123` — `Blk` in front of the block number (the
+ *     register's `number`), a floor-unit `#NN-NN` after the street, the country name as the locality;
+ *   - the bracketed postcode, `123 Ang Mo Kio Ave 3 S(560123)` — the form the postal service prints;
+ *   - the building-led line, `National Shooting Centre, 990 Old Choa Chu Kang Road, Singapore 699814` — the register's
+ *     `unit` field holds the BUILDING or ESTATE name on 91,818 of 142,210 rows, which the adapter refuses as a unit and
+ *     this recipe renders as a `venue` when it reads as a building rather than an estate.
+ *
+ *   Every value in `components` is a verbatim substring of `raw`, aligned by {@link alignAndWrite}. The floor-unit is
+ *   SYNTHESIZED (the register carries one on a single row): floor 01–30, unit 01–399, zero-padded — the shape, not a
+ *   real occupancy. `Blk` and the `S(` `)` around a postcode are untagged, as the board's `sg-cs-blk-12-kallang-ave`
+ *   row expects (`house_number: "12"`). Streets arrive upper-case and are rendered title-cased; a third abbreviate the
+ *   generic (`Avenue` → `Ave`, `Road` → `Rd`, …) the way a typed line does.
+ *
+ *   Run: mailwoman corpus slice sg-register --input <overture-sg.corpus.jsonl> --count N --seed S
+ */
+
+import { mulberry32 as makeMulberry32 } from "@mailwoman/core/utils"
+
+import { titlecase } from "#au/adapters/gnaf/assemble"
+import { alignAndWrite, type CorpusRecipe, readTuples, sliceSourceID } from "#recipes/scaffold"
+
+const SOURCE = "synth-sg-register"
+
+/**
+ * The register's generics and the abbreviation a typed line uses for each.
+ */
+const GENERIC_ABBREVIATIONS: ReadonlyArray<readonly [full: string, short: string]> = [
+	["Avenue", "Ave"],
+	["Road", "Rd"],
+	["Street", "St"],
+	["Drive", "Dr"],
+	["Crescent", "Cres"],
+	["Lane", "Ln"],
+	["Boulevard", "Blvd"],
+	["Terrace", "Ter"],
+	["Place", "Pl"],
+	["Close", "Cl"],
+	["Walk", "Wk"],
+]
+
+/**
+ * Estate and area names the register's `unit` field carries beside building names. A name ending in one of these is an
+ * estate, which no one writes in front of an address line; a name without one reads as a building and is rendered as a
+ * `venue`.
+ */
+const ESTATE_TAILS = ["ESTATE", "CONSERVATION AREA", "HILLS", "PARK", "GARDENS", "GARDEN", "HEIGHTS", "GROVE", "VILLE"]
+
+/**
+ * Share of rows per register. The block line and the bracketed postcode are the two the Latin model has never seen; the
+ * official line keeps the register's own shape in the mix so the block forms train beside it.
+ */
+const P_BLOCK = 0.4
+const P_BRACKET_POSTCODE = 0.25
+const P_BUILDING_LED = 0.15
+const P_ABBREVIATE = 0.35
+const P_UPPER = 0.1
+
+const FLOOR_MAX = 30
+const UNIT_MAX = 399
+
+/**
+ * The draw value that lands each register in the branch order below, for a caller that names the form.
+ */
+const REGISTER_DRAW: Record<SGRegister, number> = {
+	block: 0,
+	bracket_postcode: P_BLOCK,
+	building_led: P_BLOCK + P_BRACKET_POSTCODE,
+	official: 1,
+}
+
+/**
+ * `OLD CHOA CHU KANG ROAD` → `Old Choa Chu Kang Road`; an already-mixed value is returned as it is. The register writes
+ * every street and building name upper-case, the same convention as G-NAF, so the G-NAF title-caser serves both.
+ */
+export function titleCaseSGName(name: string): string {
+	return name === name.toUpperCase() ? titlecase(name) : name
+}
+
+/**
+ * Abbreviate the street's generic, wherever it sits (`Ang Mo Kio Avenue 3` → `Ang Mo Kio Ave 3`).
+ */
+export function abbreviateSGStreet(street: string): string {
+	for (const [full, short] of GENERIC_ABBREVIATIONS) {
+		const pattern = new RegExp(`\\b${full}\\b`, "u")
+
+		if (pattern.test(street)) return street.replace(pattern, short)
+	}
+
+	return street
+}
+
+/**
+ * Whether the register's `unit` value names a building rather than an estate — the building-led register's lead. A name
+ * carrying a digit, a parenthesized abbreviation (`DIABETES & METABOLISM CENTRE (DMC)`) or one word only is not one.
+ */
+export function isBuildingName(unit: string): boolean {
+	const value = unit.trim().toUpperCase()
+
+	if (!value || value === "NIL" || /[\d()]/u.test(value) || !/\s/u.test(value)) return false
+
+	return !ESTATE_TAILS.some((tail) => value.endsWith(tail))
+}
+
+interface SGRow {
+	street: string
+	number: string
+	unit: string
+	postcode: string
+}
+
+/**
+ * The four typed forms this recipe renders.
+ */
+export type SGRegister = "official" | "block" | "bracket_postcode" | "building_led"
+
+/**
+ * One rendered register: the raw line plus the components it carries, every value a substring of the line.
+ */
+export interface SGRegisterRendering {
+	raw: string
+	components: Record<string, string>
+	register: SGRegister
+}
+
+/**
+ * Render one register form for one register row. Pure: every random draw comes through `random`. A `register` names the
+ * form to render instead of drawing one, for a board that wants a balanced spread; `building_led` still needs a
+ * building-shaped `unit` and falls back to `official` without one.
+ */
+export function renderSGRegister(row: SGRow, random: () => number, register?: SGRegister): SGRegisterRendering {
+	const street0 = titleCaseSGName(row.street)
+	const street = random() < P_ABBREVIATE ? abbreviateSGStreet(street0) : street0
+	const drawn = random()
+	const building = isBuildingName(row.unit) ? titleCaseSGName(row.unit) : null
+	const draw = register === undefined ? drawn : REGISTER_DRAW[register]
+
+	let raw: string
+	let rendered: SGRegister
+	const components: Record<string, string> = { house_number: row.number, street, postcode: row.postcode }
+
+	if (draw < P_BLOCK && /^\d+[A-Z]?$/u.test(row.number)) {
+		const floor = String(1 + Math.floor(random() * FLOOR_MAX)).padStart(2, "0")
+		const unitNo = String(1 + Math.floor(random() * UNIT_MAX)).padStart(2, "0")
+		const unit = `#${floor}-${unitNo}`
+
+		raw = `Blk ${row.number} ${street} ${unit} Singapore ${row.postcode}`
+		components.unit = unit
+		components.locality = "Singapore"
+		rendered = "block"
+	} else if (draw < P_BLOCK + P_BRACKET_POSTCODE) {
+		raw = `${row.number} ${street} S(${row.postcode})`
+		rendered = "bracket_postcode"
+	} else if (draw < P_BLOCK + P_BRACKET_POSTCODE + P_BUILDING_LED && building) {
+		raw = `${building}, ${row.number} ${street}, Singapore ${row.postcode}`
+		components.venue = building
+		components.locality = "Singapore"
+		rendered = "building_led"
+	} else {
+		raw = `${row.number} ${street} Singapore ${row.postcode}`
+		components.locality = "Singapore"
+		rendered = "official"
+	}
+
+	if (random() < P_UPPER) {
+		raw = raw.toUpperCase()
+
+		for (const key of Object.keys(components)) {
+			components[key] = components[key]!.toUpperCase()
+		}
+	}
+
+	return { raw, components, register: rendered }
+}
+
+/**
+ * Slice recipe registered with the corpus builder — see the file header for the registers and why each is here.
+ */
+export const sgRegisterRecipe: CorpusRecipe = {
+	name: "sg-register",
+	description:
+		"Singapore typed registers over the Overture-SG rows: the HDB block line with a #NN-NN unit, the S(NNNNNN) postcode, the building-led line",
+	mode: "tuples",
+	options: [
+		{ flag: "--count", description: "Rows to emit (default: every input row once)" },
+		{ flag: "--input", description: "The Overture-SG corpus JSONL ({ street, number, unit, postcode, locality })" },
+	],
+	async run(opts, write) {
+		if (!opts.input) {
+			throw new Error("sg-register: --input <overture-sg.corpus.jsonl> is required")
+		}
+
+		const random = makeMulberry32(opts.seed)
+		const source = opts.sourceName ?? SOURCE
+		const registers: Record<string, number> = {}
+		let read = 0
+		let emitted = 0
+		let skipped = 0
+		let quarantined = 0
+
+		for await (const tuple of readTuples(opts.input)) {
+			read++
+
+			if (opts.count !== undefined && emitted >= opts.count) break
+
+			const street = typeof tuple["street"] === "string" ? tuple["street"].trim() : ""
+			const number = typeof tuple["number"] === "string" ? tuple["number"].trim() : ""
+			const postcode = typeof tuple["postcode"] === "string" ? tuple["postcode"].trim() : ""
+			const unit = typeof tuple["unit"] === "string" ? tuple["unit"].trim() : ""
+
+			if (!street || !/^\d+[A-Z]?$/u.test(number) || !/^\d{6}$/u.test(postcode)) {
+				skipped++
+
+				continue
+			}
+
+			const rendering = renderSGRegister({ street, number, unit, postcode }, random)
+
+			if (opts.golden) {
+				const golden = { raw: rendering.raw, components: rendering.components, country: "SG", locale: "en-SG" }
+
+				write(JSON.stringify(golden) + "\n")
+
+				emitted++
+				registers[rendering.register] = (registers[rendering.register] ?? 0) + 1
+
+				continue
+			}
+
+			const ok = alignAndWrite(
+				write,
+				{
+					raw: rendering.raw,
+					components: rendering.components,
+					country: "SG",
+					locale: "en-SG",
+					source,
+					source_id: sliceSourceID(source, { raw: rendering.raw }),
+					corpus_version: "0.1.0",
+					license:
+						"CDLA-Permissive-2.0 — Overture Maps addresses over the Singapore Open Data Licence 1.0 (OneMap / Singapore Land Authority)",
+				},
+				`sg-register:${rendering.register}`
+			)
+
+			if (ok) {
+				emitted++
+				registers[rendering.register] = (registers[rendering.register] ?? 0) + 1
+			} else {
+				quarantined++
+			}
+		}
+
+		console.error(
+			`  sg-register: ${emitted} emitted (${Object.entries(registers)
+				.map(([k, v]) => `${k} ${v}`)
+				.join(", ")}), ${skipped} skipped, ${quarantined} quarantined of ${read} read`
+		)
+
+		return { read, emitted, skipped }
+	},
+}

package/lib/sg/tools/fetch/acra.ts

@@ -0,0 +1,179 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Fetch Singapore's ACRA corporate-entity register from data.gov.sg: 27 monthly CSVs (one per first
+ *   letter of the entity name plus "others"), 53 columns, the registered address FIELDED — `Block`,
+ *   `Street Name`, `Level No`, `Unit No`, `Building Name`, `Postal Code` — which is the NPPES shape,
+ *   so the corpus adapter renders the string and the spans fall out by construction. A Singapore
+ *   postcode names one building, so the postcode column is also the join to the OneMap/Overture rows.
+ *
+ *   License: Singapore Open Data Licence version 1.0 (attribution; commercial use, modification and
+ *   adaptation permitted; no share-alike). The prescribed attribution sentence goes in the manifest.
+ *
+ *   data.gov.sg serves a dataset in two calls: `initiate-download` prepares a signed URL and
+ *   `poll-download` answers it once the export is ready.
+ *
+ *   Invoke via `mailwoman corpus fetch acra-sg --out-root <path>`.
+ */
+
+import { BYTES_PER_KIB } from "@mailwoman/core/fs/formatters"
+import { pathExists } from "@mailwoman/core/fs/readers"
+import { makeDirectories } from "@mailwoman/core/fs/writers"
+import { sha256File } from "@mailwoman/core/hash"
+import { sleep } from "@mailwoman/core/utils/sleep"
+import { join } from "path-ts"
+
+import type {
+	BaseFetchOptions,
+	FetchSummary,
+	SourceCollectionManifest,
+	SourceManifest,
+} from "#tools/fetch/download/index"
+import { loadCollectionFiles, streamBodyToFile, withRetries, writeManifest } from "#tools/fetch/download/index"
+
+const SLUG = "acra-sg"
+const COLLECTION_URL = "https://api-production.data.gov.sg/v2/public/api/collections/2/metadata"
+const DATASET_API = "https://api-production.data.gov.sg/v2/public/api/datasets"
+const DOWNLOAD_API = "https://api-open.data.gov.sg/v1/public/api/datasets"
+const LICENSE = "Singapore Open Data Licence version 1.0 — https://data.gov.sg/open-data-licence"
+
+const ATTRIBUTION =
+	"Contains information from ACRA Information on Corporate Entities accessed on <date> from data.gov.sg which is made available under the terms of the Singapore Open Data Licence version 1.0 https://data.gov.sg/open-data-licence"
+
+const POLL_INTERVAL_MS = 3000
+const POLL_ATTEMPTS = 40
+
+export type FetchACRASGOptions = BaseFetchOptions
+
+interface CollectionMetadata {
+	data?: { collectionMetadata?: { childDatasets?: string[] } }
+}
+
+interface DatasetMetadata {
+	data?: { name?: string; lastUpdatedAt?: string }
+}
+
+interface PollResponse {
+	data?: { status?: string; url?: string }
+}
+
+async function readJSON<T>(url: string): Promise<T> {
+	const res = await fetch(url, { headers: { accept: "application/json" } })
+
+	if (!res.ok) throw new Error(`acra-sg: ${url} answered HTTP ${res.status}`)
+
+	return (await res.json()) as T
+}
+
+/**
+ * Ask the portal to prepare the CSV export, then poll until it names the signed URL.
+ */
+async function signedURLFor(datasetID: string): Promise<string | undefined> {
+	await readJSON(`${DOWNLOAD_API}/${datasetID}/initiate-download`)
+
+	for (let attempt = 0; attempt < POLL_ATTEMPTS; attempt++) {
+		await sleep(POLL_INTERVAL_MS)
+		const poll = await readJSON<PollResponse>(`${DOWNLOAD_API}/${datasetID}/poll-download`)
+
+		if (poll.data?.status === "DOWNLOAD_SUCCESS" && poll.data.url) return poll.data.url
+	}
+
+	return undefined
+}
+
+function filenameFor(name: string, datasetID: string): string {
+	const letter = /\('([^']+)'\)/.exec(name)?.[1]
+
+	return `acra-entities-${(letter ?? datasetID).toLowerCase().replaceAll(/[^a-z0-9]+/g, "-")}.csv`
+}
+
+export async function fetchACRASG(options: FetchACRASGOptions, report?: (line: string) => void): Promise<FetchSummary> {
+	const destDir = join(options.outRoot, SLUG)
+	await makeDirectories(destDir)
+	const manifestPath = join(destDir, "MANIFEST.json")
+
+	const collection = await readJSON<CollectionMetadata>(COLLECTION_URL)
+	const datasetIDs = collection.data?.collectionMetadata?.childDatasets ?? []
+	report?.(`=== ${SLUG}: ${datasetIDs.length} datasets in collection 2`)
+
+	const previous = await loadCollectionFiles(manifestPath)
+	const files = new Map<string, SourceManifest>()
+	let fetched = 0
+	let skipped = 0
+	const failedCodes: string[] = []
+
+	for (const datasetID of datasetIDs) {
+		const metadata = await readJSON<DatasetMetadata>(`${DATASET_API}/${datasetID}/metadata`)
+		const name = metadata.data?.name ?? datasetID
+		const filename = filenameFor(name, datasetID)
+		const dest = join(destDir, filename)
+		const before = previous.get(filename)
+
+		if (before && (await pathExists(dest))) {
+			files.set(filename, before)
+
+			skipped++
+
+			continue
+		}
+
+		report?.(`--- ${name} (${datasetID})`)
+		let bytes: number
+
+		try {
+			bytes = await withRetries(
+				async () => {
+					const url = await signedURLFor(datasetID)
+
+					if (!url) throw new Error(`the export never reached DOWNLOAD_SUCCESS for ${datasetID}`)
+					const res = await fetch(url, { signal: AbortSignal.timeout(1_800_000) })
+
+					if (!res.ok) throw new Error(`HTTP ${res.status} on the signed URL for ${datasetID}`)
+
+					return streamBodyToFile(res, dest)
+				},
+				{ report, label: name }
+			)
+		} catch (error) {
+			report?.(`  ✗ ${(error as Error).message}`)
+			failedCodes.push(datasetID)
+
+			continue
+		}
+
+		if (bytes < BYTES_PER_KIB) {
+			report?.(`  ✗ ${bytes} bytes — an error page, not the register`)
+			failedCodes.push(datasetID)
+
+			continue
+		}
+
+		const sha = await sha256File(dest)
+
+		files.set(filename, {
+			source_url: `https://data.gov.sg/datasets/${datasetID}/view`,
+			downloaded_at: new Date().toISOString(),
+			filename,
+			sha256: sha,
+			bytes,
+		})
+
+		fetched++
+		report?.(`  ✓ ${(bytes / 1024 / 1024).toFixed(1)} MB  sha256=${sha}`)
+
+		const manifest: SourceCollectionManifest = {
+			source: SLUG,
+			source_url: "https://data.gov.sg/collections/2/view",
+			license: LICENSE,
+			attribution: ATTRIBUTION,
+			downloaded_at: new Date().toISOString(),
+			files: [...files.values()],
+		}
+
+		await writeManifest(manifestPath, manifest)
+	}
+
+	return { fetched, skipped, failed: failedCodes.length, failedCodes }
+}

package/lib/south-asia/recipes/register.ts

@@ -0,0 +1,214 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   `pk-register` and `bd-register` slice recipes — the typed forms of Pakistan and Bangladesh the country templates do
+ *   not render, over the OpenStreetMap corpus JSONL the `osm` adapter reads (#1744, the F8 family). The adapter's own
+ *   rows carry the template shape (`4 38th Street, DHA Phase 6, Karachi`; `24 Road 104, Dhaka - 1207`); these two carry
+ *   the register:
+ *
+ *   - the HOUSE line, `House 4, Street 25, F-7/2, Islamabad` and `House 34, Road 4, Sector 9, Uttara, Dhaka 1230` —
+ *     `House` in front of the number (untagged, the same rule as Singapore's `Blk`), the numbered street, the scheme or
+ *     sector as the dependent locality, the city;
+ *   - the PLAIN line with the trailing postcode and no dash, `58 Kalabagan 1st Ln, Dhaka 1205` — what a person types,
+ *     where the template writes `Dhaka - 1205`.
+ *
+ *   Islamabad's sector codes (`F-7/2`, `G-10/3`) are the one synthesized value: the register carries them on a handful
+ *   of rows, mostly inside `addr:city` (`F7/2 Islamabad`), so a row whose city is Islamabad and whose scheme is unknown
+ *   draws one from the capital's grid. Every other value is the row's own. The components are the `osm` adapter's
+ *   mapping (`componentsForOSMRow`), so the two surfaces cannot disagree about what a field means.
+ *
+ *   ⚠ ODbL: the rows inherit OpenStreetMap's share-alike license, and `--exclude-share-alike` drops them.
+ *
+ *   Run: mailwoman corpus slice pk-register --input <osm-pk.corpus.jsonl> --count N --seed S
+ */
+
+import { mulberry32 as makeMulberry32 } from "@mailwoman/core/utils"
+
+import { componentsForOSMRow, OSM_LICENSE, sameName } from "#adapters/osm/adapter"
+import { alignAndWrite, type CorpusRecipe, readTuples, type SliceRecipeOpts, sliceSourceID } from "#recipes/scaffold"
+import type { CanonicalRow } from "#types"
+
+/**
+ * Islamabad's residential sectors: the lettered rows E to I, the numbered columns the Capital Development Authority has
+ * developed, and the four sub-sectors each splits into.
+ */
+const ISLAMABAD_SECTOR_ROWS = ["E", "F", "G", "I"] as const
+const ISLAMABAD_SECTOR_COLUMNS = [6, 7, 8, 9, 10, 11] as const
+const ISLAMABAD_SUB_SECTORS = [1, 2, 3, 4] as const
+
+/**
+ * Share of rows rendered in the house register; the rest take the plain line.
+ */
+const P_HOUSE = 0.55
+
+/**
+ * Share of house lines that spell the number `House No. 4` / `House # 4` rather than `House 4`.
+ */
+const P_HOUSE_NO = 0.25
+
+export type SouthAsiaRegister = "house" | "plain"
+
+export interface SouthAsiaRendering {
+	raw: string
+	components: Record<string, string>
+	register: SouthAsiaRegister
+}
+
+/**
+ * Draw one Islamabad sector code, `F-7/2`.
+ */
+export function drawIslamabadSector(random: () => number): string {
+	const row = ISLAMABAD_SECTOR_ROWS[Math.floor(random() * ISLAMABAD_SECTOR_ROWS.length)]!
+	const column = ISLAMABAD_SECTOR_COLUMNS[Math.floor(random() * ISLAMABAD_SECTOR_COLUMNS.length)]!
+	const sub = ISLAMABAD_SUB_SECTORS[Math.floor(random() * ISLAMABAD_SUB_SECTORS.length)]!
+
+	return `${row}-${column}/${sub}`
+}
+
+/**
+ * Render one register line from the adapter's components. Returns null when the row has no house number or no locality:
+ * both registers need the two.
+ */
+export function renderSouthAsiaRegister(
+	components: CanonicalRow["components"],
+	random: () => number,
+	register?: SouthAsiaRegister
+): SouthAsiaRendering | null {
+	const { house_number: number, street, locality, postcode } = components
+
+	if (!number || !street || !locality) return null
+
+	let dependent = components.dependent_locality
+
+	if (!dependent && sameName(locality, "Islamabad")) {
+		dependent = drawIslamabadSector(random)
+	}
+
+	const chosen = register ?? (random() < P_HOUSE ? "house" : "plain")
+	const out: Record<string, string> = { house_number: number, street, locality }
+	const tail = postcode ? `${locality} ${postcode}` : locality
+
+	if (postcode) {
+		out.postcode = postcode
+	}
+
+	if (dependent) {
+		out.dependent_locality = dependent
+	}
+
+	const middle = dependent ? `${street}, ${dependent}` : street
+
+	if (chosen === "house") {
+		const spelling = random() < P_HOUSE_NO ? (random() < 0.5 ? "House No. " : "House # ") : "House "
+
+		return { raw: `${spelling}${number}, ${middle}, ${tail}`, components: out, register: "house" }
+	}
+
+	return { raw: `${number} ${middle}, ${tail}`, components: out, register: "plain" }
+}
+
+function makeRecipe(name: string, country: "PK" | "BD", locale: string, description: string): CorpusRecipe {
+	const source = `synth-${name}`
+
+	return {
+		name,
+		description,
+		mode: "tuples",
+		options: [
+			{ flag: "--count", description: "Rows to emit (default: every input row once)" },
+			{
+				flag: "--input",
+				description: `The OpenStreetMap ${country} corpus JSONL (osm-${country.toLowerCase()}.corpus.jsonl)`,
+			},
+		],
+		async run(opts: SliceRecipeOpts, write) {
+			if (!opts.input) {
+				throw new Error(`${name}: --input <osm-${country.toLowerCase()}.corpus.jsonl> is required`)
+			}
+
+			const random = makeMulberry32(opts.seed)
+			const sourceName = opts.sourceName ?? source
+			const registers: Record<string, number> = {}
+			let read = 0
+			let emitted = 0
+			let skipped = 0
+			let quarantined = 0
+
+			for await (const tuple of readTuples(opts.input)) {
+				read++
+
+				if (opts.count !== undefined && emitted >= opts.count) break
+
+				const components = componentsForOSMRow(tuple as Parameters<typeof componentsForOSMRow>[0])
+				const rendering = components ? renderSouthAsiaRegister(components, random) : null
+
+				if (!rendering) {
+					skipped++
+
+					continue
+				}
+
+				if (opts.golden) {
+					write(JSON.stringify({ raw: rendering.raw, components: rendering.components, country, locale }) + "\n")
+
+					emitted++
+					registers[rendering.register] = (registers[rendering.register] ?? 0) + 1
+
+					continue
+				}
+
+				const ok = alignAndWrite(
+					write,
+					{
+						raw: rendering.raw,
+						components: rendering.components,
+						country,
+						locale,
+						source: sourceName,
+						source_id: sliceSourceID(sourceName, { raw: rendering.raw }),
+						corpus_version: "0.1.0",
+						license: OSM_LICENSE,
+					},
+					`${name}:${rendering.register}`
+				)
+
+				if (ok) {
+					emitted++
+					registers[rendering.register] = (registers[rendering.register] ?? 0) + 1
+				} else {
+					quarantined++
+				}
+			}
+
+			console.error(
+				`  ${name}: ${emitted} emitted (${Object.entries(registers)
+					.map(([k, v]) => `${k} ${v}`)
+					.join(", ")}), ${skipped} skipped, ${quarantined} quarantined of ${read} read`
+			)
+
+			return { read, emitted, skipped }
+		},
+	}
+}
+
+/**
+ * Pakistan: `House 4, Street 25, F-7/2, Islamabad` and `B230 Street 5, Block 3, Karachi`.
+ */
+export const pkRegisterRecipe: CorpusRecipe = makeRecipe(
+	"pk-register",
+	"PK",
+	"en-PK",
+	"Pakistan typed registers over the OpenStreetMap rows: the House line with the sector or scheme, the plain line with the trailing postcode"
+)
+
+/**
+ * Bangladesh: `House 34, Road 4, Sector 9, Uttara, Dhaka 1230` and `58 Kalabagan 1st Ln, Dhaka 1205`.
+ */
+export const bdRegisterRecipe: CorpusRecipe = makeRecipe(
+	"bd-register",
+	"BD",
+	"en-BD",
+	"Bangladesh typed registers over the OpenStreetMap rows: the House line, the plain line with the trailing postcode and no dash"
+)