@mailwoman/corpus 8.6.0 → 9.0.0

package/src/adapters/ban/adapter.ts

@@ -25,14 +25,13 @@
  *   conservative `ODbL-1.0` label, which wrongly read as Tier-C-denied in the corpus license audit.
  *   The model card MUST carry the BAN attribution (Tier B obligation).
  *
- *   The adapter is streaming-aware: it uses `csv-parse` in streaming mode so a 25M-row dump never
- *   sits in memory. Honors `opts.limit` for fixture / smoke runs, `opts.signal` for cancellation,
- *   and `opts.country` for a self-consistency check (errors if country !== FR).
+ *   The adapter is streaming-aware: `CSVSpliterator.fromAsync` reads the `;`-delimited dump row by
+ *   row, so a 25M-row file never sits in memory. Honors `opts.limit` for fixture / smoke runs,
+ *   `opts.signal` for cancellation, and `opts.country` for a self-consistency check (errors if
+ *   country !== FR).
  */
 
-import { createReadStream } from "node:fs"
-
-import { parse as csvParse } from "csv-parse"
+import { CSVSpliterator } from "spliterator"
 
 import { stableSourceID } from "../../adapter.ts"
 import { reconcileComponents } from "../../format.ts"
@@ -108,86 +107,77 @@ export function createBanAdapter(): CorpusAdapter {
 				throw new Error(`ban adapter: only FR supported, got country=${opts.country}`)
 			}
 
-			const stream = createReadStream(opts.inputPath, { encoding: "utf8" })
-
-			const parser = stream.pipe(
-				csvParse({
-					delimiter: ";",
-					columns: true,
-					skip_empty_lines: true,
-					relax_quotes: true,
-					relax_column_count: true,
-				})
-			)
+			const rows = CSVSpliterator.fromAsync(opts.inputPath, {
+				mode: "object",
+				normalizeKeys: false,
+				columnDelimiter: ";",
+				enableQuoteHandling: true,
+			})
 
 			let emitted = 0
 
-			try {
-				for await (const record of parser as AsyncIterable<BanRow>) {
-					if (opts.signal?.aborted) break
-
-					if (opts.limit !== undefined && emitted >= opts.limit) break
+			for await (const record of rows as AsyncIterable<BanRow>) {
+				if (opts.signal?.aborted) break
 
-					const house = composeHouseNumber(record.numero ?? "", record.rep ?? "")
-					const street = (record.nom_voie ?? "").trim()
-					const postcode = (record.code_postal ?? "").trim()
-					const locality = (record.nom_commune ?? "").trim()
+				if (opts.limit !== undefined && emitted >= opts.limit) break
 
-					if (!street || !locality) continue
+				const house = composeHouseNumber(record.numero ?? "", record.rep ?? "")
+				const street = (record.nom_voie ?? "").trim()
+				const postcode = (record.code_postal ?? "").trim()
+				const locality = (record.nom_commune ?? "").trim()
 
-					if (!house && !postcode) continue
+				if (!street || !locality) continue
 
-					const decomposed = decomposeFrStreet(street)
+				if (!house && !postcode) continue
 
-					const components: CanonicalRow["components"] = {}
+				const decomposed = decomposeFrStreet(street)
 
-					if (house) {
-						components.house_number = house
-					}
+				const components: CanonicalRow["components"] = {}
 
-					if (decomposed.prefix) {
-						components.street_prefix = decomposed.prefix
-					}
+				if (house) {
+					components.house_number = house
+				}
 
-					if (decomposed.street) {
-						components.street = decomposed.street
-					}
+				if (decomposed.prefix) {
+					components.street_prefix = decomposed.prefix
+				}
 
-					if (postcode) {
-						components.postcode = postcode
-					}
+				if (decomposed.street) {
+					components.street = decomposed.street
+				}
 
-					if (locality) {
-						components.locality = locality
-					}
+				if (postcode) {
+					components.postcode = postcode
+				}
 
-					const raw = composeRaw(house, street, postcode, locality)
+				if (locality) {
+					components.locality = locality
+				}
 
-					if (!raw) continue
+				const raw = composeRaw(house, street, postcode, locality)
 
-					const aligned = reconcileComponents(components, raw)
+				if (!raw) continue
 
-					if (!Object.keys(aligned).length) continue
+				const aligned = reconcileComponents(components, raw)
 
-					const sourceID = record.id?.trim()
-						? `${BAN_ADAPTER_ID}-${record.id.trim()}`
-						: stableSourceID(BAN_ADAPTER_ID, aligned)
+				if (!Object.keys(aligned).length) continue
 
-					yield {
-						raw,
-						components: aligned,
-						country: "FR",
-						locale: "fr-FR",
-						source: BAN_ADAPTER_ID,
-						source_id: sourceID,
-						corpus_version: "",
-						license: "Licence Ouverte 2.0",
-					}
+				const sourceID = record.id?.trim()
+					? `${BAN_ADAPTER_ID}-${record.id.trim()}`
+					: stableSourceID(BAN_ADAPTER_ID, aligned)
 
-					emitted++
+				yield {
+					raw,
+					components: aligned,
+					country: "FR",
+					locale: "fr-FR",
+					source: BAN_ADAPTER_ID,
+					source_id: sourceID,
+					corpus_version: "",
+					license: "Licence Ouverte 2.0",
 				}
-			} finally {
-				stream.destroy()
+
+				emitted++
 			}
 		},
 	}

package/src/adapters/ban/street-decompose.ts

@@ -16,9 +16,9 @@
  */
 
 import { readFileSync } from "node:fs"
-import { resolve } from "node:path"
 
 import { resourceDictionaryPath } from "@mailwoman/core/utils"
+import { TextSpliterator } from "spliterator"
 
 /**
  * Tokens a BAN street needs before a type/article/name decomposition is attempted.
@@ -26,38 +26,30 @@ import { resourceDictionaryPath } from "@mailwoman/core/utils"
 const MIN_TOKENS_FOR_DECOMPOSE = 3
 
 function loadDictionary(filename: string): Set<string> {
-	const candidates = [
-		resourceDictionaryPath("libpostal", "fr", filename),
-		resourceDictionaryPath("libpostal", "fr", filename),
-		resolve(process.cwd(), "core/data/libpostal/dictionaries/fr", filename),
-	]
+	// `resourceDictionaryPath` already resolves both layouts — `core/data/...` from source and from the
+	// packaged `out/` tree. The candidate list this replaced named it TWICE and then guessed a third path
+	// off `process.cwd()`, and swallowed every error while probing, so a corrupt dictionary reported as a
+	// missing one.
+	const text = readFileSync(resourceDictionaryPath("libpostal", "fr", filename), "utf8")
+	const set = new Set<string>()
 
-	for (const path of candidates) {
-		try {
-			const text = readFileSync(path, "utf8")
-			const set = new Set<string>()
+	// The largest libpostal dictionary is 8.4 KB, and this runs once per process at module load.
+	for (const line of TextSpliterator.from(text)) {
+		const trimmed = line.trim()
 
-			for (const line of text.split("\n")) {
-				const trimmed = line.trim()
+		if (!trimmed || trimmed.startsWith("#")) continue
 
-				if (!trimmed || trimmed.startsWith("#")) continue
+		// libpostal format: canonical|abbr|abbr|... — index all forms
+		for (const form of trimmed.split("|")) {
+			const f = form.trim().toLowerCase()
 
-				for (const form of trimmed.split("|")) {
-					const f = form.trim().toLowerCase()
-
-					if (f) {
-						set.add(f)
-					}
-				}
+			if (f) {
+				set.add(f)
 			}
-
-			return set
-		} catch {
-			// try next
 		}
 	}
 
-	throw new Error(`Could not load FR libpostal dictionary: ${filename}`)
+	return set
 }
 
 const STREET_TYPES_FR = loadDictionary("street_types.txt")

package/src/adapters/fcc-bdc/adapter.ts

@@ -36,6 +36,7 @@
 
 import { DatabaseSync } from "node:sqlite"
 
+import { splitStreetLine } from "../../adapter.ts"
 import { lookupStateAbbreviation } from "../../codex/us-fips-state.ts"
 import { formatAddress, reconcileComponents } from "../../format.ts"
 import type { AdapterOptions, CanonicalRow, CorpusAdapter } from "../../types.ts"
@@ -63,38 +64,6 @@ interface BdcLocationRow {
 	zip_suffix: string | null
 }
 
-/**
- * Split `address_primary` into a `(house_number, street)` pair.
- *
- * BDC's `address_primary` follows USPS Publication 28 conventions but with hand-entry drift. The canonical
- * leading-digit prefix is the house number (`"123 Main St"`, `"6450 W Indian School Rd"`, even hyphenated forms `"40-12
- * Bell Blvd"`). Anything that doesn't match the prefix shape (`"PO Box 1234"`, `"RR 2 Box 67"`, `"HC 1"`) is left as a
- * single `street` value — the model sees the original surface form, and downstream classifiers/po-box handling can pick
- * it up.
- *
- * The regex tolerates one trailing letter (`"123A Main St"`) and an optional hyphenated half (`"40-12"`) which is
- * common in NYC + suburban garden-apartment numbering.
- */
-const HOUSE_NUMBER_PREFIX = /^(\d+(?:-\d+)?[A-Za-z]?)\s+(.+)$/
-
-interface SplitAddress {
-	house_number?: string
-	street: string
-}
-
-export function splitAddressPrimary(address: string): SplitAddress | null {
-	const trimmed = address.trim()
-
-	if (!trimmed) return null
-	const match = HOUSE_NUMBER_PREFIX.exec(trimmed)
-
-	if (match) {
-		return { house_number: match[1], street: match[2]!.trim() }
-	}
-
-	return { street: trimmed }
-}
-
 /**
  * Combine `zip` + optional `zip_suffix` into the canonical USPS postcode surface form.
  *
@@ -150,7 +119,7 @@ export function createFccBdcAdapter(): CorpusAdapter {
 
 					if (opts.limit !== undefined && emitted >= opts.limit) return
 
-					const split = splitAddressPrimary(row.address_primary ?? "")
+					const split = splitStreetLine(row.address_primary ?? "")
 
 					if (!split) continue
 					const state = lookupStateAbbreviation(row.state)

package/src/adapters/geonames/adapter.ts

@@ -28,10 +28,10 @@
  *   License: stamped `"CC-BY-4.0"` per row (GeoNames' terms); provenance is the `geonames-<id>` key.
  */
 
-import { createReadStream, existsSync, readFileSync } from "node:fs"
-import { dirname, join } from "node:path"
+import { existsSync } from "node:fs"
 
-import { parse as csvParse } from "csv-parse"
+import { dirname, join } from "path-ts"
+import { TSVSpliterator } from "spliterator"
 
 import { stableSourceID } from "../../adapter.ts"
 import { reconcileComponents } from "../../format.ts"
@@ -69,16 +69,14 @@ const NON_CURRENT_PPL = new Set(["PPLH", "PPLQ", "PPLW", "PPLCH"])
 /**
  * Load `admin1CodesASCII.txt` → Map("<CC>.<admin1>" → region name). Empty map if absent.
  */
-function loadAdmin1(dir: string): Map<string, string> {
+async function loadAdmin1(dir: string): Promise<Map<string, string>> {
 	const map = new Map<string, string>()
 	const fp = join(dir, "admin1CodesASCII.txt")
 
 	if (!existsSync(fp)) return map
 
-	for (const line of readFileSync(fp, "utf8").split("\n")) {
-		if (!line) continue
-		const cols = line.split("\t")
-
+	// `header: false` — the file is headerless, and the spliterator eats row 1 as a header otherwise.
+	for await (const cols of TSVSpliterator.fromAsync(fp, { header: false })) {
 		if (cols[0] && cols[1]) {
 			map.set(cols[0], cols[1])
 		}
@@ -90,15 +88,16 @@ function loadAdmin1(dir: string): Map<string, string> {
 /**
  * Load `countryInfo.txt` → Map(ISO → country name). Empty map if absent. The file is `#`-commented.
  */
-function loadCountries(dir: string): Map<string, string> {
+async function loadCountries(dir: string): Promise<Map<string, string>> {
 	const map = new Map<string, string>()
 	const fp = join(dir, "countryInfo.txt")
 
 	if (!existsSync(fp)) return map
 
-	for (const line of readFileSync(fp, "utf8").split("\n")) {
-		if (!line || line.startsWith("#")) continue
-		const cols = line.split("\t")
+	// `header: false` — the file's header IS a `#` comment, so it falls out with the other comments
+	// rather than being consumed as column names.
+	for await (const cols of TSVSpliterator.fromAsync(fp, { header: false })) {
+		if (cols[0]?.startsWith("#")) continue
 
 		// ISO(0), ISO3(1), iso-numeric(2), fips(3), Country(4), ...
 		if (cols[0] && cols[4]) {
@@ -118,85 +117,78 @@ export function createGeonamesAdapter(): CorpusAdapter {
 
 		async *rows(opts: AdapterOptions): AsyncIterable<CanonicalRow> {
 			const dir = dirname(opts.inputPath)
-			const admin1 = loadAdmin1(dir)
-			const countries = loadCountries(dir)
-
-			const stream = createReadStream(opts.inputPath, { encoding: "utf8" })
+			const admin1 = await loadAdmin1(dir)
+			const countries = await loadCountries(dir)
 
-			const parser = stream.pipe(
-				csvParse({ delimiter: "\t", quote: false, relax_column_count: true, skip_empty_lines: true })
-			)
+			// `header: false` — the per-country dump is headerless.
+			const rows = TSVSpliterator.fromAsync(opts.inputPath, { header: false })
 
 			let emitted = 0
 
-			try {
-				for await (const rec of parser as AsyncIterable<string[]>) {
-					if (opts.signal?.aborted) break
+			for await (const rec of rows) {
+				if (opts.signal?.aborted) break
 
-					if (opts.limit !== undefined && emitted >= opts.limit) break
+				if (opts.limit !== undefined && emitted >= opts.limit) break
 
-					if (rec[COL.featureClass] !== "P") continue
+				if (rec[COL.featureClass] !== "P") continue
 
-					if (NON_CURRENT_PPL.has(rec[COL.featureCode] ?? "")) continue
+				if (NON_CURRENT_PPL.has(rec[COL.featureCode] ?? "")) continue
 
-					const cc = (rec[COL.country] ?? "").trim()
+				const cc = (rec[COL.country] ?? "").trim()
 
-					if (!cc) continue
+				if (!cc) continue
 
-					if (opts.country && cc !== opts.country) continue
+				if (opts.country && cc !== opts.country) continue
 
-					const locality = (rec[COL.name] ?? "").trim()
+				const locality = (rec[COL.name] ?? "").trim()
 
-					if (!locality) continue
-					const geonameid = (rec[COL.geonameid] ?? "").trim()
-					const region = admin1.get(`${cc}.${(rec[COL.admin1] ?? "").trim()}`)
-					const country = countries.get(cc)
+				if (!locality) continue
+				const geonameid = (rec[COL.geonameid] ?? "").trim()
+				const region = admin1.get(`${cc}.${(rec[COL.admin1] ?? "").trim()}`)
+				const country = countries.get(cc)
 
-					// Two hierarchy variants (domestic + international order) — but only emit the
-					// distinct ones the available names support.
-					const variants: Array<{ slot: string; comp: CanonicalRow["components"]; raw: string }> = []
+				// Two hierarchy variants (domestic + international order) — but only emit the
+				// distinct ones the available names support.
+				const variants: Array<{ slot: string; comp: CanonicalRow["components"]; raw: string }> = []
 
-					if (region) {
-						variants.push({ slot: "lr", comp: { locality, region }, raw: `${locality}, ${region}` })
+				if (region) {
+					variants.push({ slot: "lr", comp: { locality, region }, raw: `${locality}, ${region}` })
 
-						if (country) {
-							variants.push({
-								slot: "lrc",
-								comp: { locality, region, country },
-								raw: `${locality}, ${region}, ${country}`,
-							})
-						}
-					} else if (country) {
-						variants.push({ slot: "lc", comp: { locality, country }, raw: `${locality}, ${country}` })
-					} else {
-						variants.push({ slot: "l", comp: { locality }, raw: locality })
+					if (country) {
+						variants.push({
+							slot: "lrc",
+							comp: { locality, region, country },
+							raw: `${locality}, ${region}, ${country}`,
+						})
 					}
+				} else if (country) {
+					variants.push({ slot: "lc", comp: { locality, country }, raw: `${locality}, ${country}` })
+				} else {
+					variants.push({ slot: "l", comp: { locality }, raw: locality })
+				}
 
-					for (const v of variants) {
-						if (opts.limit !== undefined && emitted >= opts.limit) break
-						const aligned = reconcileComponents(v.comp, v.raw)
-
-						if (!Object.keys(aligned).length) continue
-
-						const sourceID = geonameid
-							? `${GEONAMES_ADAPTER_ID}-${geonameid}-${v.slot}`
-							: stableSourceID(GEONAMES_ADAPTER_ID, aligned)
-
-						yield {
-							raw: v.raw,
-							components: aligned,
-							country: cc,
-							source: GEONAMES_ADAPTER_ID,
-							source_id: sourceID,
-							corpus_version: "",
-							license: GEONAMES_DEFAULT_LICENSE,
-						}
-
-						emitted++
+				for (const v of variants) {
+					if (opts.limit !== undefined && emitted >= opts.limit) break
+					const aligned = reconcileComponents(v.comp, v.raw)
+
+					if (!Object.keys(aligned).length) continue
+
+					const sourceID = geonameid
+						? `${GEONAMES_ADAPTER_ID}-${geonameid}-${v.slot}`
+						: stableSourceID(GEONAMES_ADAPTER_ID, aligned)
+
+					yield {
+						raw: v.raw,
+						components: aligned,
+						country: cc,
+						source: GEONAMES_ADAPTER_ID,
+						source_id: sourceID,
+						corpus_version: "",
+						license: GEONAMES_DEFAULT_LICENSE,
 					}
+
+					emitted++
 				}
-			} finally {
-				stream.destroy()
 			}
 		},
 	}

package/src/adapters/geonames-postal/adapter.ts

@@ -23,9 +23,7 @@
  *        `"CC-BY-4.0"` per row (attribute "GeoNames").
  */
 
-import { createReadStream } from "node:fs"
-
-import { parse as csvParse } from "csv-parse"
+import { TSVSpliterator } from "spliterator"
 
 import { stableSourceID } from "../../adapter.ts"
 import { reconcileComponents } from "../../format.ts"
@@ -55,67 +53,61 @@ export function createGeonamesPostalAdapter(): CorpusAdapter {
 			"GeoNames postal codes (CC-BY-4.0) — multi-locale postcode→locality→region, names inline; international postcode-first order.",
 
 		async *rows(opts: AdapterOptions): AsyncIterable<CanonicalRow> {
-			const stream = createReadStream(opts.inputPath, { encoding: "utf8" })
-
-			const parser = stream.pipe(
-				csvParse({ delimiter: "\t", quote: false, relax_column_count: true, skip_empty_lines: true })
-			)
+			// `header: false` — the GeoNames postal dump is headerless, and the spliterator would
+			// otherwise consume row 1 as column names and lose its first postcode.
+			const rows = TSVSpliterator.fromAsync(opts.inputPath, { header: false })
 
 			let emitted = 0
 
-			try {
-				for await (const rec of parser as AsyncIterable<string[]>) {
-					if (opts.signal?.aborted) break
-
-					if (opts.limit !== undefined && emitted >= opts.limit) break
-
-					const cc = (rec[COL.country] ?? "").trim()
+			for await (const rec of rows as AsyncIterable<string[]>) {
+				if (opts.signal?.aborted) break
 
-					if (!cc) continue
+				if (opts.limit !== undefined && emitted >= opts.limit) break
 
-					if (opts.country && cc !== opts.country) continue
+				const cc = (rec[COL.country] ?? "").trim()
 
-					const postcode = (rec[COL.postcode] ?? "").trim()
-					const locality = (rec[COL.place] ?? "").trim()
+				if (!cc) continue
 
-					if (!postcode || !locality) continue
-					const region = (rec[COL.admin1Name] ?? "").trim()
+				if (opts.country && cc !== opts.country) continue
 
-					// Postcode-first (international) variants. Skip the region variant when admin1 just
-					// repeats the place (common for city-states / micro-admin) to avoid "X X" noise.
-					const variants: Array<{ slot: string; comp: CanonicalRow["components"]; raw: string }> = [
-						{ slot: "pl", comp: { postcode, locality }, raw: `${postcode} ${locality}` },
-					]
+				const postcode = (rec[COL.postcode] ?? "").trim()
+				const locality = (rec[COL.place] ?? "").trim()
 
-					if (region && region.toLowerCase() !== locality.toLowerCase()) {
-						variants.push({
-							slot: "plr",
-							comp: { postcode, locality, region },
-							raw: `${postcode} ${locality}, ${region}`,
-						})
-					}
-
-					for (const v of variants) {
-						if (opts.limit !== undefined && emitted >= opts.limit) break
-						const aligned = reconcileComponents(v.comp, v.raw)
+				if (!postcode || !locality) continue
+				const region = (rec[COL.admin1Name] ?? "").trim()
 
-						if (Object.keys(aligned).length < 2) continue
+				// Postcode-first (international) variants. Skip the region variant when admin1 just
+				// repeats the place (common for city-states / micro-admin) to avoid "X X" noise.
+				const variants: Array<{ slot: string; comp: CanonicalRow["components"]; raw: string }> = [
+					{ slot: "pl", comp: { postcode, locality }, raw: `${postcode} ${locality}` },
+				]
 
-						yield {
-							raw: v.raw,
-							components: aligned,
-							country: cc,
-							source: GEONAMES_POSTAL_ADAPTER_ID,
-							source_id: `${stableSourceID(GEONAMES_POSTAL_ADAPTER_ID, aligned)}-${v.slot}`,
-							corpus_version: "",
-							license: GEONAMES_POSTAL_DEFAULT_LICENSE,
-						}
+				if (region && region.toLowerCase() !== locality.toLowerCase()) {
+					variants.push({
+						slot: "plr",
+						comp: { postcode, locality, region },
+						raw: `${postcode} ${locality}, ${region}`,
+					})
+				}
 
-						emitted++
+				for (const v of variants) {
+					if (opts.limit !== undefined && emitted >= opts.limit) break
+					const aligned = reconcileComponents(v.comp, v.raw)
+
+					if (Object.keys(aligned).length < 2) continue
+
+					yield {
+						raw: v.raw,
+						components: aligned,
+						country: cc,
+						source: GEONAMES_POSTAL_ADAPTER_ID,
+						source_id: `${stableSourceID(GEONAMES_POSTAL_ADAPTER_ID, aligned)}-${v.slot}`,
+						corpus_version: "",
+						license: GEONAMES_POSTAL_DEFAULT_LICENSE,
 					}
+
+					emitted++
 				}
-			} finally {
-				stream.destroy()
 			}
 		},
 	}

package/src/adapters/gnaf/adapter.ts

@@ -28,6 +28,7 @@
  *   line). Open G-NAF licence — attribute "Geoscape Australia".
  */
 
+import { tryParsingJSON } from "@mailwoman/core/objects"
 import { TextSpliterator } from "spliterator"
 
 import { stableSourceID } from "../../adapter.ts"
@@ -87,7 +88,7 @@ export function createGNAFAdapter(): CorpusAdapter {
 
 			// Input is the assembled component JSONL (one tuple per line). TextSpliterator auto-disposes on
 			// loop completion and on an early `break` (abort / limit), so the old explicit handle teardown is
-			// gone; JSON.parse tolerates a trailing CR on CRLF sources and the `!line.trim()` guard skips blanks.
+			// gone; the parse tolerates a trailing CR on CRLF sources and the `!line.trim()` guard skips blanks.
 			// The render order rotates (i % 3), matching v1.9.1's rerender.
 			for await (const line of TextSpliterator.fromAsync(opts.inputPath)) {
 				if (opts.signal?.aborted) break
@@ -96,13 +97,9 @@ export function createGNAFAdapter(): CorpusAdapter {
 
 				if (!line.trim()) continue
 
-				let t: GNAFTuple
+				const t = tryParsingJSON<GNAFTuple>(line)
 
-				try {
-					t = JSON.parse(line) as GNAFTuple
-				} catch {
-					continue
-				}
+				if (t === null) continue
 
 				if (!t.house_number || !t.street || !t.locality || !t.postcode) continue
 

package/src/adapters/gnaf/assemble.ts

@@ -30,7 +30,8 @@ import { createWriteStream } from "node:fs"
 import { readdir, readFile } from "node:fs/promises"
 import { join } from "node:path"
 
-import { PSVSpliterator } from "spliterator"
+import { tryParsingJSON } from "@mailwoman/core/objects"
+import { PSVSpliterator, TextSpliterator } from "spliterator"
 
 export interface GNAFAssembleOptions {
 	/**
@@ -109,19 +110,14 @@ async function loadMap<V>(paths: string[], keyCol: string, pick: (r: Row) => V):
  */
 async function loadHoldout(path: string): Promise<Set<string>> {
 	const keys = new Set<string>()
-	const text = await readFile(path, "utf8")
 
-	for (const line of text.split("\n")) {
+	for await (const line of TextSpliterator.fromAsync(path)) {
 		if (!line.trim()) continue
 
-		try {
-			const c = (JSON.parse(line) as { components?: Record<string, string> }).components
+		const c = tryParsingJSON<{ components?: Record<string, string> }>(line)?.components
 
-			if (c?.street && c?.locality && c?.postcode) {
-				keys.add(gnafHoldoutKey(c.street, c.locality, c.postcode))
-			}
-		} catch {
-			/* skip malformed */
+		if (c?.street && c?.locality && c?.postcode) {
+			keys.add(gnafHoldoutKey(c.street, c.locality, c.postcode))
 		}
 	}