@mailwoman/corpus 7.1.0 → 7.2.1

package/src/adapters/state-ia-contractors/adapter.ts

@@ -0,0 +1,148 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   `state-ia-contractors`: Iowa Active Construction Contractor Registrations CSV consumer.
+ *
+ *   Iowa Workforce Development publishes a public registry of active construction contractors. Each
+ *   row carries a business name, street address, city/state/zip, and contact info.
+ *
+ *   The adapter consumes the CSV the operator pre-downloads via `fetch-state-sources.ts`.
+ *
+ *   Output: one row per contractor with `venue` (business name) and address quad `(house_number,
+ *   street, locality, region, postcode)`.
+ *
+ *   License: stamped `"Public Domain"` per Iowa state government open-data terms.
+ */
+
+import { createReadStream } from "node:fs"
+
+import { parse as csvParse } from "csv-parse"
+
+import { stableSourceID } from "../../adapter.ts"
+import { lookupStateAbbreviation } from "../../codex/us-fips-state.ts"
+import { reconcileComponents } from "../../format.ts"
+import type { AdapterOptions, CanonicalRow, CorpusAdapter } from "../../types.ts"
+
+export const STATE_IA_CONTRACTORS_ADAPTER_ID = "state-ia-contractors"
+export const STATE_IA_CONTRACTORS_DEFAULT_LICENSE = "Public Domain"
+
+const HOUSE_NUMBER_PREFIX = /^(\d+(?:-\d+)?[A-Za-z]?)\s+(.+)$/
+
+interface IaContractorRow {
+	"Registration #": string
+	"Business Name": string
+	"Address 1": string
+	"Address 2": string
+	City: string
+	State: string
+	"Zip Code": string
+	"First Name": string
+	"Last Name": string
+}
+
+function splitAddress(address: string): { house_number?: string; street: string } | null {
+	const trimmed = address.trim()
+
+	if (!trimmed) return null
+	const m = HOUSE_NUMBER_PREFIX.exec(trimmed)
+
+	if (m) return { house_number: m[1], street: m[2]!.trim() }
+
+	return { street: trimmed }
+}
+
+export function createStateIaContractorsAdapter(): CorpusAdapter {
+	return {
+		id: STATE_IA_CONTRACTORS_ADAPTER_ID,
+		defaultLicense: STATE_IA_CONTRACTORS_DEFAULT_LICENSE,
+		description:
+			"Iowa Active Construction Contractor Registrations — business name + full street address (public-domain).",
+
+		async *rows(opts: AdapterOptions): AsyncIterable<CanonicalRow> {
+			if (opts.country && opts.country !== "US") {
+				throw new Error(`state-ia-contractors adapter: only US supported, got country=${opts.country}`)
+			}
+
+			const stream = createReadStream(opts.inputPath, { encoding: "utf8" })
+			const parser = stream.pipe(
+				csvParse({
+					columns: true,
+					skip_empty_lines: true,
+					relax_quotes: true,
+					relax_column_count: true,
+				})
+			)
+
+			let emitted = 0
+
+			try {
+				for await (const record of parser as AsyncIterable<IaContractorRow>) {
+					if (opts.signal?.aborted) break
+
+					if (opts.limit !== undefined && emitted >= opts.limit) break
+
+					const businessName = (record["Business Name"] ?? "").trim()
+					const address1 = (record["Address 1"] ?? "").trim()
+					const address2 = (record["Address 2"] ?? "").trim()
+					const city = (record.City ?? "").trim()
+					const stateAbbr = (record.State ?? "").trim()
+					const zip = (record["Zip Code"] ?? "").trim()
+
+					if (!city || !zip) continue
+
+					const state = lookupStateAbbreviation(stateAbbr)
+
+					if (!state) continue
+
+					const fullAddress = [address1, address2].filter(Boolean).join(" ")
+					const split = splitAddress(fullAddress)
+
+					if (!split) continue
+
+					const venue = businessName || undefined
+
+					const components: CanonicalRow["components"] = {
+						...(venue ? { venue } : {}),
+						...(split.house_number ? { house_number: split.house_number } : {}),
+						street: split.street,
+						locality: city,
+						region: state.abbreviation,
+						postcode: zip,
+					}
+
+					const streetPart = [split.house_number, split.street].filter(Boolean).join(" ").trim()
+					const raw = [venue, streetPart, [city, [stateAbbr, zip].filter(Boolean).join(" ")].filter(Boolean).join(", ")]
+						.filter(Boolean)
+						.join(", ")
+
+					const aligned = reconcileComponents(components, raw)
+
+					if (Object.keys(aligned).length <= 2) continue
+
+					const regNum = (record["Registration #"] ?? "").trim()
+					const sourceID = regNum
+						? `${STATE_IA_CONTRACTORS_ADAPTER_ID}-${regNum}`
+						: stableSourceID(STATE_IA_CONTRACTORS_ADAPTER_ID, aligned)
+
+					yield {
+						raw,
+						components: aligned,
+						country: "US",
+						locale: "en-US",
+						source: STATE_IA_CONTRACTORS_ADAPTER_ID,
+						source_id: sourceID,
+						corpus_version: "",
+						license: STATE_IA_CONTRACTORS_DEFAULT_LICENSE,
+					}
+					emitted++
+				}
+			} finally {
+				stream.destroy()
+			}
+		},
+	}
+}
+
+export const stateIaContractorsAdapter = createStateIaContractorsAdapter()

package/src/adapters/state-ny-notaries/adapter.ts

@@ -0,0 +1,169 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   `state-ny-notaries`: New York Commissioned Notaries CSV consumer.
+ *
+ *   The New York Department of State publishes a registry of commissioned notaries public. Each row
+ *   optionally carries a business name and business address (~1-5% fill rate).
+ *
+ *   The adapter consumes the CSV the operator pre-downloads via `fetch-state-sources.ts`. Column
+ *   names match the data.ny.gov export header (note: some columns have leading spaces).
+ *
+ *   License: stamped `"Public Domain"` per New York state government open-data terms.
+ */
+
+import { createReadStream } from "node:fs"
+
+import { parse as csvParse } from "csv-parse"
+
+import { stableSourceID } from "../../adapter.ts"
+import { lookupStateAbbreviation } from "../../codex/us-fips-state.ts"
+import { reconcileComponents } from "../../format.ts"
+import type { AdapterOptions, CanonicalRow, CorpusAdapter } from "../../types.ts"
+
+export const STATE_NY_NOTARIES_ADAPTER_ID = "state-ny-notaries"
+export const STATE_NY_NOTARIES_DEFAULT_LICENSE = "Public Domain"
+
+const HOUSE_NUMBER_PREFIX = /^(\d+(?:-\d+)?[A-Za-z]?)\s+(.+)$/
+
+interface NyNotaryRow {
+	"Commission Holder Name": string
+	"Commission Number (UID)": string
+	"Business Name (if available)": string
+	"Business Address 1 (if available)": string
+	"Business Address 2 (if available)": string
+	" Business City (if available)": string
+	"Business State (if available)": string
+	"Business Zip (if available)": string
+	"Commissioned County": string
+}
+
+function splitAddress(address: string): { house_number?: string; street: string } | null {
+	const trimmed = address.trim()
+
+	if (!trimmed) return null
+	const m = HOUSE_NUMBER_PREFIX.exec(trimmed)
+
+	if (m) return { house_number: m[1], street: m[2]!.trim() }
+
+	return { street: trimmed }
+}
+
+const RAW_NY_COLUMNS = [
+	"Commission Holder Name",
+	"Commission Number (UID)",
+	"Business Name (if available)",
+	"Business Address 1 (if available)",
+	"Business Address 2 (if available)",
+	" Business City (if available)",
+	"Business State (if available)",
+	"Business Zip (if available)",
+	"Commissioned County",
+] as const
+
+export function createStateNyNotariesAdapter(): CorpusAdapter {
+	return {
+		id: STATE_NY_NOTARIES_ADAPTER_ID,
+		defaultLicense: STATE_NY_NOTARIES_DEFAULT_LICENSE,
+		description: "New York Commissioned Notaries — name + optional business address (public-domain).",
+
+		async *rows(opts: AdapterOptions): AsyncIterable<CanonicalRow> {
+			if (opts.country && opts.country !== "US") {
+				throw new Error(`state-ny-notaries adapter: only US supported, got country=${opts.country}`)
+			}
+
+			const stream = createReadStream(opts.inputPath, { encoding: "utf8" })
+			const parser = stream.pipe(
+				csvParse({
+					columns: true,
+					skip_empty_lines: true,
+					relax_quotes: true,
+					relax_column_count: true,
+				})
+			)
+
+			let emitted = 0
+
+			try {
+				for await (const rawRecord of parser as AsyncIterable<Record<string, string>>) {
+					if (opts.signal?.aborted) break
+
+					if (opts.limit !== undefined && emitted >= opts.limit) break
+
+					// NY CSV has columns with leading spaces, so we normalize by trimming keys.
+					const record: Record<string, string> = {}
+
+					for (const key of Object.keys(rawRecord)) {
+						record[key.trim()] = rawRecord[key] ?? ""
+					}
+
+					const holderName = (record["Commission Holder Name"] ?? "").trim()
+					const businessName = (record["Business Name (if available)"] ?? "").trim()
+					const address1 = (record["Business Address 1 (if available)"] ?? "").trim()
+					const address2 = (record["Business Address 2 (if available)"] ?? "").trim()
+					const city = (record["Business City (if available)"] ?? "").trim()
+					const stateAbbr = (record["Business State (if available)"] ?? "").trim()
+					const zip = (record["Business Zip (if available)"] ?? "").trim()
+					const county = (record["Commissioned County"] ?? "").trim()
+
+					if (!city || !stateAbbr || !zip) continue
+
+					if (!address1 && !address2) continue
+
+					const state = lookupStateAbbreviation(stateAbbr)
+
+					if (!state) continue
+
+					const fullAddress = [address1, address2].filter(Boolean).join(" ")
+					const split = splitAddress(fullAddress)
+
+					if (!split) continue
+
+					const venue = businessName || holderName || undefined
+
+					const components: CanonicalRow["components"] = {
+						...(venue ? { venue } : {}),
+						...(split.house_number ? { house_number: split.house_number } : {}),
+						street: split.street,
+						locality: city,
+						region: state.abbreviation,
+						postcode: zip,
+						...(county ? { subregion: county } : {}),
+					}
+
+					const streetPart = [split.house_number, split.street].filter(Boolean).join(" ").trim()
+					const raw = [venue, streetPart, [city, [stateAbbr, zip].filter(Boolean).join(" ")].filter(Boolean).join(", ")]
+						.filter(Boolean)
+						.join(", ")
+
+					const aligned = reconcileComponents(components, raw)
+
+					if (Object.keys(aligned).length <= 2) continue
+
+					const commNum = (record["Commission Number (UID)"] ?? "").trim()
+					const sourceID = commNum
+						? `${STATE_NY_NOTARIES_ADAPTER_ID}-${commNum}`
+						: stableSourceID(STATE_NY_NOTARIES_ADAPTER_ID, aligned)
+
+					yield {
+						raw,
+						components: aligned,
+						country: "US",
+						locale: "en-US",
+						source: STATE_NY_NOTARIES_ADAPTER_ID,
+						source_id: sourceID,
+						corpus_version: "",
+						license: STATE_NY_NOTARIES_DEFAULT_LICENSE,
+					}
+					emitted++
+				}
+			} finally {
+				stream.destroy()
+			}
+		},
+	}
+}
+
+export const stateNyNotariesAdapter = createStateNyNotariesAdapter()

package/src/adapters/state-tx-notaries/adapter.ts

@@ -0,0 +1,160 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   `state-tx-notaries`: Texas Notary Public Commissions CSV consumer.
+ *
+ *   The Texas Secretary of State publishes a registry of commissioned notaries public. Each row
+ *   optionally carries a mailing address in free-form text (often multi-line with embedded
+ *   city/state/zip). Address fill rate is ~5-10%.
+ *
+ *   The adapter parses the embedded `Address` field for city/state/zip using a trailing `"CITY, ST
+ *   ZIP"` pattern.
+ *
+ *   License: stamped `"Public Domain"` per Texas state government open-data terms.
+ */
+
+import { createReadStream } from "node:fs"
+
+import { parse as csvParse } from "csv-parse"
+
+import { stableSourceID } from "../../adapter.ts"
+import { lookupStateAbbreviation } from "../../codex/us-fips-state.ts"
+import { reconcileComponents } from "../../format.ts"
+import type { AdapterOptions, CanonicalRow, CorpusAdapter } from "../../types.ts"
+
+export const STATE_TX_NOTARIES_ADAPTER_ID = "state-tx-notaries"
+export const STATE_TX_NOTARIES_DEFAULT_LICENSE = "Public Domain"
+
+const HOUSE_NUMBER_PREFIX = /^(\d+(?:-\d+)?[A-Za-z]?)\s+(.+)$/
+
+/** Match trailing "CITY, ST ZIP" or "CITY, ST" at the end of an address line. */
+const CITY_STATE_ZIP_SUFFIX = /[,]?\s*([^,]+),\s*([A-Z]{2})\s*(\d{5}(?:-\d{4})?)?\s*$/i
+
+interface TxNotaryRow {
+	"Notary ID": string
+	"First Name": string
+	"Last Name": string
+	Address: string
+}
+
+function splitAddress(address: string): { house_number?: string; street: string } | null {
+	const trimmed = address.trim()
+
+	if (!trimmed) return null
+	const m = HOUSE_NUMBER_PREFIX.exec(trimmed)
+
+	if (m) return { house_number: m[1], street: m[2]!.trim() }
+
+	return { street: trimmed }
+}
+
+export function createStateTxNotariesAdapter(): CorpusAdapter {
+	return {
+		id: STATE_TX_NOTARIES_ADAPTER_ID,
+		defaultLicense: STATE_TX_NOTARIES_DEFAULT_LICENSE,
+		description:
+			"Texas Notary Public Commissions — name + mailing address with embedded city/state/zip (public-domain).",
+
+		async *rows(opts: AdapterOptions): AsyncIterable<CanonicalRow> {
+			if (opts.country && opts.country !== "US") {
+				throw new Error(`state-tx-notaries adapter: only US supported, got country=${opts.country}`)
+			}
+
+			const stream = createReadStream(opts.inputPath, { encoding: "utf8" })
+			const parser = stream.pipe(
+				csvParse({
+					columns: true,
+					skip_empty_lines: true,
+					relax_quotes: true,
+					relax_column_count: true,
+				})
+			)
+
+			let emitted = 0
+
+			try {
+				for await (const record of parser as AsyncIterable<TxNotaryRow>) {
+					if (opts.signal?.aborted) break
+
+					if (opts.limit !== undefined && emitted >= opts.limit) break
+
+					const rawAddress = (record.Address ?? "").trim()
+
+					if (!rawAddress) continue
+
+					const firstName = (record["First Name"] ?? "").trim()
+					const lastName = (record["Last Name"] ?? "").trim()
+					const notaryID = (record["Notary ID"] ?? "").trim()
+
+					// Parse embedded city/state/zip from the trailing portion of the address.
+					// Addresses look like: "1215 MCMILLAN DR\nCEDAR HILL, TX 75104"
+					const addrSingleLine = rawAddress.replace(/\n/g, ", ")
+					const cszMatch = CITY_STATE_ZIP_SUFFIX.exec(addrSingleLine)
+
+					if (!cszMatch) continue
+
+					const city = (cszMatch[1] ?? "").trim()
+					const stateAbbr = (cszMatch[2] ?? "").trim()
+					const zip = (cszMatch[3] ?? "").trim()
+
+					if (!city || !stateAbbr) continue
+
+					const state = lookupStateAbbreviation(stateAbbr)
+
+					if (!state) continue
+
+					// Extract the street portion (everything before the city/state/zip)
+					const streetPortion = addrSingleLine.slice(0, cszMatch.index).replace(/,\s*$/, "").trim()
+
+					if (!streetPortion) continue
+
+					const split = splitAddress(streetPortion)
+
+					if (!split) continue
+
+					const venue = [firstName, lastName].filter(Boolean).join(" ") || undefined
+
+					const components: CanonicalRow["components"] = {
+						...(venue ? { venue } : {}),
+						...(split.house_number ? { house_number: split.house_number } : {}),
+						street: split.street,
+						locality: city,
+						region: state.abbreviation,
+						...(zip ? { postcode: zip } : {}),
+					}
+
+					const streetPart = [split.house_number, split.street].filter(Boolean).join(" ").trim()
+					const raw = [venue, streetPart, [city, [stateAbbr, zip].filter(Boolean).join(" ")].filter(Boolean).join(", ")]
+						.filter(Boolean)
+						.join(", ")
+
+					const aligned = reconcileComponents(components, raw)
+
+					if (Object.keys(aligned).length <= 2) continue
+
+					const sourceID = notaryID
+						? `${STATE_TX_NOTARIES_ADAPTER_ID}-${notaryID}`
+						: stableSourceID(STATE_TX_NOTARIES_ADAPTER_ID, aligned)
+
+					yield {
+						raw,
+						components: aligned,
+						country: "US",
+						locale: "en-US",
+						source: STATE_TX_NOTARIES_ADAPTER_ID,
+						source_id: sourceID,
+						corpus_version: "",
+						license: STATE_TX_NOTARIES_DEFAULT_LICENSE,
+					}
+					emitted++
+				}
+			} finally {
+				stream.destroy()
+			}
+		},
+	}
+}
+
+export const stateTxNotariesAdapter = createStateTxNotariesAdapter()

package/src/adapters/synth-po-box/adapter.ts

@@ -0,0 +1,197 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   `synth-po-box`: PO box / PMB / Apartado / BP synthesizer adapter.
+ *
+ *   Consumes a JSONL stream of (locality, region, postcode, country) tuples — typically extracted
+ *   from existing corpus output (TIGER/NAD/BAN/WOF) — and emits synthetic PO box training rows. See
+ *   `../../synthesize-po-box.ts` for the per-locale templates and number-noise logic.
+ *
+ *   Why an adapter and not an augmenter:
+ *
+ *   - Per USPS Pub 28 / DMM 508, a PO box delivery line is mutually exclusive with a street line.
+ *       Synthesizing PO boxes by mutating a street row would teach the model an invalid pattern.
+ *       The clean shape is: read just (locality, region, postcode, country) and produce a fresh
+ *       PO-box-shaped row.
+ *   - Per-DeepSeek (3-turn consult, 2026-05-28): PMB rows that COMBINE a street line with a PMB number
+ *       ARE valid (CMRA addresses). Those are produced when `pmbRatio > 0` AND the input tuple
+ *       carries a `street` field.
+ */
+
+import { TextSpliterator } from "spliterator"
+
+import { stableSourceID } from "../../adapter.ts"
+import {
+	countryToLocale,
+	REGION_OPTIONAL_LOCALES,
+	synthesizeMilitaryPoBoxRow,
+	synthesizePoBoxRow,
+	type PoBoxBaseTuple,
+} from "../../synthesize-po-box.ts"
+import type { AdapterOptions, CanonicalRow, CorpusAdapter } from "../../types.ts"
+
+export const SYNTH_PO_BOX_ADAPTER_ID = "synth-po-box"
+export const SYNTH_PO_BOX_LICENSE = "Synthetic — derived from CC-BY / public-domain input tuples"
+
+export interface PoBoxInputRow extends PoBoxBaseTuple {
+	street?: string
+	houseNumber?: string
+}
+
+export interface SynthPoBoxAdapterOptions {
+	/**
+	 * How many PO box variants to emit per input tuple. Each variant picks a different leader (and possibly a different
+	 * number / noise level). Default 1.
+	 */
+	variantsPerInput?: number
+	/**
+	 * Probability (0..1) of emitting a PMB-with-street variant when both the input has a street and the locale supports
+	 * PMB. Default 0.15.
+	 */
+	pmbRatio?: number
+	/**
+	 * Deterministic seed for reproducible synthesis. Default Date.now().
+	 */
+	seed?: number
+	/**
+	 * Probability (0..1), evaluated per input tuple, of ALSO emitting one US military/diplomatic PO-box row
+	 * (`PSC/CMR/Unit <id> Box <box>, APO/FPO/DPO AA/AE/AP <zip>`, #517). These rows are self-contained — they draw no
+	 * field from the input tuple, so military volume scales with the input stream size. Default 0 (off) — the adapter's
+	 * contract is "one row per input"; the corpus build recipe opts in to seed the rare-but-real military class without
+	 * changing the default.
+	 */
+	militaryRatio?: number
+}
+
+function makeRandom(seed: number): () => number {
+	let s = seed
+
+	return () => {
+		s = (s * 1664525 + 1013904223) % 4294967296
+
+		return s / 4294967296
+	}
+}
+
+export function createSynthPoBoxAdapter(opts: SynthPoBoxAdapterOptions = {}): CorpusAdapter {
+	const variantsPerInput = opts.variantsPerInput ?? 1
+	const pmbRatio = opts.pmbRatio ?? 0.15
+	const militaryRatio = opts.militaryRatio ?? 0
+
+	return {
+		id: SYNTH_PO_BOX_ADAPTER_ID,
+		defaultLicense: SYNTH_PO_BOX_LICENSE,
+		description:
+			"Synthetic PO box / PMB / Apartado / Boîte Postale rows. Consumes JSONL of (locality, region, postcode, country) tuples and emits locale-appropriate PO box variants.",
+
+		async *rows(options: AdapterOptions): AsyncIterable<CanonicalRow> {
+			const random = makeRandom(opts.seed ?? Date.now())
+
+			// TextSpliterator streams string lines; the per-line try/catch below keeps this reader
+			// tolerant of malformed rows (skipped++), so TextSpliterator + explicit JSON.parse — not
+			// JSONSpliterator, which would throw on the first bad line.
+			const lines = TextSpliterator.fromAsync(options.inputPath)
+
+			let emitted = 0
+			let skipped = 0
+			let militarySeq = 0
+
+			for await (const line of lines) {
+				if (options.signal?.aborted) break
+
+				if (options.limit !== undefined && emitted >= options.limit) break
+
+				const trimmed = line.trim()
+
+				if (!trimmed) continue
+
+				let input: PoBoxInputRow
+
+				try {
+					input = JSON.parse(trimmed) as PoBoxInputRow
+				} catch {
+					skipped++
+					continue
+				}
+
+				// Region is required EXCEPT for region-less locales (NZ: `Private Bag 12, Auckland 1010`
+				// has no region token, #517). synthesizePoBoxRow handles region absence; the guard just
+				// must not discard those tuples as "missing region".
+				const regionOptional = input.country ? REGION_OPTIONAL_LOCALES.has(countryToLocale(input.country)) : false
+
+				if (!input.locality || !input.postcode || !input.country || (!input.region && !regionOptional)) {
+					skipped++
+					continue
+				}
+
+				if (options.country && options.country !== input.country) continue
+
+				for (let v = 0; v < variantsPerInput; v++) {
+					const synth = synthesizePoBoxRow(input, { random, pmbRatio })
+
+					if (!synth) continue
+
+					// Include `v` in dependent_locality slot to vary the digest across variants;
+					// stableSourceID only accepts ComponentTag keys.
+					const sourceID = stableSourceID(SYNTH_PO_BOX_ADAPTER_ID, {
+						locality: `${input.locality}#${v}`,
+						region: input.region,
+						postcode: input.postcode,
+						country: input.country,
+					})
+
+					yield {
+						raw: synth.raw,
+						components: synth.components,
+						country: input.country,
+						locale: synth.locale,
+						source: SYNTH_PO_BOX_ADAPTER_ID,
+						source_id: sourceID,
+						corpus_version: "",
+						license: SYNTH_PO_BOX_LICENSE,
+					}
+					emitted++
+
+					if (options.limit !== undefined && emitted >= options.limit) break
+				}
+
+				// US military/diplomatic PO-box rows (#517): self-contained — draw nothing from the input
+				// tuple — emitted per input line with probability `militaryRatio` (off by default, so the
+				// default random stream and output are byte-identical). Military volume scales with the
+				// stream rather than the US-tuple count. US-only: suppressed under a non-US country filter
+				// and counted against `limit` like any other row.
+				const militaryAllowed = !options.country || options.country === "US"
+
+				if (
+					militaryRatio > 0 &&
+					militaryAllowed &&
+					(options.limit === undefined || emitted < options.limit) &&
+					random() < militaryRatio
+				) {
+					const mil = synthesizeMilitaryPoBoxRow({ random })
+					const sourceID = stableSourceID(SYNTH_PO_BOX_ADAPTER_ID, {
+						po_box: `${mil.components.po_box}#mil${militarySeq++}`,
+						locality: mil.components.locality!,
+						region: mil.components.region!,
+						postcode: mil.components.postcode!,
+					})
+					yield {
+						raw: mil.raw,
+						components: mil.components,
+						country: "US",
+						locale: mil.locale,
+						source: SYNTH_PO_BOX_ADAPTER_ID,
+						source_id: sourceID,
+						corpus_version: "",
+						license: SYNTH_PO_BOX_LICENSE,
+					}
+					emitted++
+				}
+			}
+		},
+	}
+}
+
+export const synthPoBoxAdapter = createSynthPoBoxAdapter()