@mailwoman/corpus 9.3.0 → 10.0.0

package/lib/recipes/trailing-region.ts

@@ -66,14 +66,9 @@
  *   fact about a place; the postcode is not, because it does.
  */
 
-import {
-	alignAndWrite,
-	makeMulberry32,
-	type PostcodePlacement,
-	readTuples,
-	type CorpusRecipe,
-	sliceSourceID,
-} from "#recipes/scaffold"
+import { mulberry32 as makeMulberry32 } from "@mailwoman/core/utils"
+
+import { alignAndWrite, type PostcodePlacement, readTuples, type CorpusRecipe, sliceSourceID } from "#recipes/scaffold"
 
 /**
  * Slice recipe registered with the corpus builder — see the file header for the parse behaviour it exists to exercise,
@@ -85,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
@@ -157,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,17 +21,17 @@
  *   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"
 
 import { stableSourceID } from "#adapters/utils"
-import { makeMulberry32, readOATuples, type CorpusRecipe } from "#recipes/scaffold"
+import { readOATuples, type CorpusRecipe } from "#recipes/scaffold"
 import { pick } from "#synthesizers/utils"
 import type { CanonicalRow } from "#types"
 import { alignRow } from "#utils"
-
 /**
  * A cached OpenAddresses extract: the zip, the CSV member, and the implied (file-level) region.
  */

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/si/recipes/bare-village.ts

@@ -0,0 +1,99 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   `si-bare-village` — the Slovenian no-street counter-slice (#901 run-2). Slovenia's rural
+ *   addressing has NO street line: the village name is the street-level token and repeats as the
+ *   locality ("Zabiče 8, 6250 Zabiče"). The v1.9.8 check FALSIFIED the fr-bare-street slice alone on
+ *   exactly this class (SI resolve −3.4pp; "Apače 108" split into street "Apače 10" + house "8") —
+ *   the bare-street boundary lesson generalizes onto a form where the leading name must keep its
+ *   number whole and the trailing mention must stay locality-bound. This slice is the paired
+ *   counter-distribution: same lesson ("name before number, comma, then admin"), opposite polarity
+ *   on the trailing mention.
+ *
+ *   Three real-order templates cycle per tuple (mirrors the coord-golden orders so the eval and the
+ *   training distribution agree):
+ *
+ *   1. canonical  "«V» «n», «pc» «V»"
+ *   2. bare       "«V» «n», «V»"        (no postcode — the anchor-free form, the fr-bare lesson)
+ *   3. pc-first   "«pc» «V», «V» «n»"
+ *
+ *   Gold spans: leading «V» = street (matches OA ground truth — the village IS the address line),
+ *   «n» = house_number (NEVER split mid-digits), «pc» = postcode (never swallowing the neighbor),
+ *   trailing «V» = locality (the binding the resolver needs).
+ */
+
+import { mulberry32 as makeMulberry32 } from "@mailwoman/core/utils"
+
+import { alignAndWrite, readTuples, type CorpusRecipe, sliceSourceID } from "#recipes/scaffold"
+
+/**
+ * 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 siBareVillageRecipe: CorpusRecipe = {
+	name: "si-bare-village",
+	description: "SI no-street village form (#901 run-2): '«V» «n», «pc» «V»' — the fr-bare-street counter-distribution",
+	mode: "tuples",
+	async run(opts, write) {
+		makeMulberry32(opts.seed)
+		let read = 0
+		let emitted = 0
+		let skipped = 0
+
+		for await (const t of readTuples(opts.input!)) {
+			read++
+			const village = String(t.locality ?? "").trim()
+			const number = String(t.number ?? "").trim()
+			const postcode = String(t.postcode ?? "").trim()
+
+			if (!village || !number || !postcode) {
+				skipped++
+
+				continue
+			}
+
+			const order = read % 3
+			let raw: string
+
+			const components: Record<string, string> = {
+				street: village,
+				house_number: number,
+				locality: village,
+			}
+
+			if (order === 0) {
+				components.postcode = postcode
+				raw = `${village} ${number}, ${postcode} ${village}`
+			} else if (order === 1) {
+				raw = `${village} ${number}, ${village}`
+			} else {
+				components.postcode = postcode
+				raw = `${postcode} ${village}, ${village} ${number}`
+			}
+
+			const source_id = sliceSourceID("synth-si-bare-village", { ...components, o: String(order), v: String(read) })
+
+			const canonical = {
+				raw,
+				components,
+				country: "SI",
+				locale: "sl-SI",
+				source: "synth-si-bare-village",
+				source_id,
+				corpus_version: "0.9.9",
+				license:
+					"Synthetic — si-bare-village; (village, number, postcode) from OpenAddresses SI (per-source attribution in the model card)",
+			}
+
+			if (alignAndWrite(write, canonical, "si-bare-village")) {
+				emitted++
+			} else {
+				skipped++
+			}
+		}
+
+		return { read, emitted, skipped }
+	},
+}