@mailwoman/corpus 7.2.0 → 7.2.1

package/src/adapters/gnaf/assemble.ts

@@ -0,0 +1,200 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Assemble a sampled, component-labeled Australian address set from G-NAF (the Geocoded National
+ *   Address File — Geoscape Australia, Open G-NAF licence; any derived artifact must attribute
+ *   "Geoscape Australia"). G-NAF is a relational PSV distribution (~16.9M addresses);
+ *   reconstructing a street address joins three tables — ADDRESS_DETAIL (number, postcode, the
+ *   PIDs) → STREET_LOCALITY (street name + type) → LOCALITY (suburb). State is the per-file prefix
+ *   (ACT/NSW/…).
+ *
+ *   Streaming + in-memory join via the house {@link PSVSpliterator} (pipe-separated; `mode: "object"`
+ *   keys each row by its header) — NOT raw `read_csv` SQL, which a flat-file join doesn't need and
+ *   which the #183–190 cleanup retired. The two lookup tables (STREET_LOCALITY ~765k rows, LOCALITY
+ *   ~16k) fit as Maps; ADDRESS_DETAIL is streamed once and reservoir-sampled, so memory stays
+ *   bounded (the OOM lesson from the Overture ingest).
+ *
+ *   No coordinates: the output feeds the PARSER ({@link ../gnaf/adapter}, #208) — teaching the model
+ *   AU's postcode-first / house-number-last word order, the gap `scripts/eval/au-order-probe.ts`
+ *   pinned (65%→87% if the parse were order-robust). The parser needs the address string +
+ *   component labels, not lat/lon.
+ *
+ *   Output: component tuples as JSONL, consumed by the `gnaf` corpus adapter (which renders them in
+ *   multiple orders + the corpus aligner BIO-labels them). An optional held-out eval set is
+ *   excluded by (street, locality, postcode) so the training shard never overlaps the benchmark.
+ */
+
+import { createWriteStream } from "node:fs"
+import { readdir, readFile } from "node:fs/promises"
+import { join } from "node:path"
+
+import { PSVSpliterator } from "spliterator"
+
+export interface GNAFAssembleOptions {
+	/** G-NAF `Standard` directory (holds the per-state `*_psv.psv` tables). */
+	standardDir: string
+	/** Target sample size (uniform reservoir → population-proportional across states). */
+	sampleSize: number
+	/** Output JSONL path. */
+	out: string
+	/**
+	 * Optional held-out eval JSONL (rows with a `components` field) — its (street,locality,postcode) are excluded.
+	 */
+	holdoutPath?: string
+	/** Progress sink (the CLI passes a setter). */
+	onProgress?: (message: string) => void
+}
+
+export interface GNAFAssembleResult {
+	written: number
+	seen: number
+	heldOut: number
+	byState: Record<string, number>
+}
+
+/** UPPERCASE → Title Case, preserving intra-word apostrophes/hyphens (O'Brien, Coff's Harbour). */
+export function titlecase(s: string): string {
+	return s
+		.toLowerCase()
+		.replace(/(^|[\s'\-/])([a-z])/g, (_m, p: string, c: string) => p + c.toUpperCase())
+		.trim()
+}
+
+/** Holdout/dedup key: a street within a locality+postcode (house-number-agnostic — conservative). */
+export function gnafHoldoutKey(street: string, locality: string, postcode: string): string {
+	return `${street}|${locality}|${postcode}`.toLowerCase()
+}
+
+type Row = Record<string, string | number | undefined>
+async function* psvObjects(path: string): AsyncIterable<Row> {
+	yield* PSVSpliterator.fromAsync(path, { mode: "object", header: true }) as AsyncIterable<Row>
+}
+
+/** Load a small lookup table fully into a Map keyed by `keyCol`. */
+async function loadMap<V>(paths: string[], keyCol: string, pick: (r: Row) => V): Promise<Map<string, V>> {
+	const m = new Map<string, V>()
+
+	for (const p of paths) {
+		for await (const r of psvObjects(p)) {
+			const k = r[keyCol]
+
+			if (k != null && k !== "") {
+				m.set(String(k), pick(r))
+			}
+		}
+	}
+
+	return m
+}
+
+/** Build the held-out key set from an eval JSONL whose rows carry a `components` object. */
+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")) {
+		if (!line.trim()) continue
+
+		try {
+			const c = (JSON.parse(line) as { components?: Record<string, string> }).components
+
+			if (c?.street && c?.locality && c?.postcode) {
+				keys.add(gnafHoldoutKey(c.street, c.locality, c.postcode))
+			}
+		} catch {
+			/* skip malformed */
+		}
+	}
+
+	return keys
+}
+
+export async function assembleGNAF(opts: GNAFAssembleOptions): Promise<GNAFAssembleResult> {
+	const progress = opts.onProgress ?? (() => {})
+	const files = await readdir(opts.standardDir)
+	const pick = (re: RegExp, exclude?: RegExp) =>
+		files.filter((f) => re.test(f) && !(exclude && exclude.test(f))).map((f) => join(opts.standardDir, f))
+
+	// `*_LOCALITY_psv.psv` also globs `*_STREET_LOCALITY_psv.psv` — exclude the latter explicitly.
+	const streetPaths = pick(/_STREET_LOCALITY_psv\.psv$/)
+	const localityPaths = pick(/_LOCALITY_psv\.psv$/, /_STREET_LOCALITY_psv\.psv$/)
+	const addressPaths = pick(/_ADDRESS_DETAIL_psv\.psv$/)
+
+	const holdout = opts.holdoutPath ? await loadHoldout(opts.holdoutPath) : new Set<string>()
+
+	if (opts.holdoutPath) {
+		progress(`held-out eval keys: ${holdout.size}`)
+	}
+
+	progress(`loading STREET_LOCALITY (${streetPaths.length} files) + LOCALITY (${localityPaths.length})…`)
+	const streetMap = await loadMap(streetPaths, "STREET_LOCALITY_PID", (r) => ({
+		name: String(r.STREET_NAME ?? ""),
+		type: String(r.STREET_TYPE_CODE ?? ""),
+		suffix: String(r.STREET_SUFFIX_CODE ?? ""),
+	}))
+	const localityMap = await loadMap(localityPaths, "LOCALITY_PID", (r) => String(r.LOCALITY_NAME ?? ""))
+	progress(`streets=${streetMap.size.toLocaleString()} localities=${localityMap.size.toLocaleString()}`)
+
+	const reservoir: Array<{ house_number: string; street: string; locality: string; region: string; postcode: string }> =
+		[]
+	let seen = 0
+	let heldOut = 0
+
+	for (const p of addressPaths) {
+		const state = (p.match(/\/([A-Z]+)_ADDRESS_DETAIL/) ?? [])[1] ?? ""
+
+		for await (const r of psvObjects(p)) {
+			const numberFirst = String(r.NUMBER_FIRST ?? "")
+
+			if (!numberFirst || r.DATE_RETIRED || !r.POSTCODE) continue
+			const st = streetMap.get(String(r.STREET_LOCALITY_PID ?? ""))
+			const suburbRaw = localityMap.get(String(r.LOCALITY_PID ?? ""))
+
+			if (!st?.name || !suburbRaw) continue
+			const street = `${titlecase(st.name)} ${titlecase(st.type)}${st.suffix ? " " + titlecase(st.suffix) : ""}`.trim()
+			const locality = titlecase(suburbRaw)
+			const postcode = String(r.POSTCODE)
+
+			if (holdout.has(gnafHoldoutKey(street, locality, postcode))) {
+				heldOut++
+				continue
+			}
+			let house = numberFirst + (r.NUMBER_FIRST_SUFFIX ? String(r.NUMBER_FIRST_SUFFIX) : "")
+
+			if (r.NUMBER_LAST) {
+				house = `${house}-${String(r.NUMBER_LAST)}`
+			}
+
+			if (r.FLAT_NUMBER) {
+				house = `${String(r.FLAT_NUMBER)}/${house}`
+			}
+			const tuple = { house_number: house, street, locality, region: state, postcode }
+			seen++
+
+			if (reservoir.length < opts.sampleSize) {
+				reservoir.push(tuple)
+			} else {
+				const j = Math.floor(Math.random() * seen)
+
+				if (j < opts.sampleSize) {
+					reservoir[j] = tuple
+				}
+			}
+		}
+		progress(`${state}: ${seen.toLocaleString()} valid joinable seen`)
+	}
+
+	const out = createWriteStream(opts.out)
+	const byState: Record<string, number> = {}
+
+	for (const t of reservoir) {
+		out.write(JSON.stringify(t) + "\n")
+		byState[t.region] = (byState[t.region] ?? 0) + 1
+	}
+	await new Promise<void>((res) => out.end(res))
+	progress(`wrote ${reservoir.length.toLocaleString()} tuples → ${opts.out}`)
+
+	return { written: reservoir.length, seen, heldOut, byState }
+}

package/src/adapters/index.ts

@@ -0,0 +1,135 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Adapter registry bootstrap.
+ *
+ *   Importing this module registers every built-in adapter with `defaultAdapterRegistry`. The CLI
+ *   (`commands/corpus/list.tsx`, `commands/corpus/run.tsx`) imports it once at startup.
+ *
+ *   Adapters under construction live in their own subdirectories (`./wof-admin-json/`, `./ban/`, ...)
+ *   and are added to the `BUILTIN_ADAPTERS` list here as they come online. Tests that need a
+ *   pristine registry should construct their own `InMemoryAdapterRegistry` instead of mutating the
+ *   default.
+ *
+ *   The WOF adapters export their canonical ids — `wof-admin` and `wof-postalcode` — so existing
+ *   `mailwoman corpus build` callsites do not need to change despite the Phase 1.5.1 SQLite →
+ *   JSON-bundle pivot (`./wof-admin-json/` and `./wof-postalcode-json/` directories hold the
+ *   implementations; the registered ids are unchanged).
+ */
+
+import { defaultAdapterRegistry } from "../adapter.ts"
+import type { CorpusAdapter } from "../types.ts"
+import { banAdapter } from "./ban/adapter.ts"
+import { fccBdcAdapter } from "./fcc-bdc/adapter.ts"
+import { geonamesPostalAdapter } from "./geonames-postal/adapter.ts"
+import { geonamesAdapter } from "./geonames/adapter.ts"
+import { gnafAdapter } from "./gnaf/adapter.ts"
+import { openaddressesAdapter } from "./openaddresses/adapter.ts"
+import { overtureAdapter } from "./overture/adapter.ts"
+import { stateHiSchoolsAdapter } from "./state-hi-schools/adapter.ts"
+import { stateIaContractorsAdapter } from "./state-ia-contractors/adapter.ts"
+import { stateNyNotariesAdapter } from "./state-ny-notaries/adapter.ts"
+import { stateTxNotariesAdapter } from "./state-tx-notaries/adapter.ts"
+import { tigerAdapter } from "./tiger/adapter.ts"
+import { usgovHrsaFqhcAdapter } from "./usgov-hrsa-fqhc/adapter.ts"
+import { usgovImlsPlsAdapter } from "./usgov-imls-pls/adapter.ts"
+import { usgovIrsBmfAdapter } from "./usgov-irs-bmf/adapter.ts"
+import { usgovNADAdapter } from "./usgov-nad/adapter.ts"
+import { usgovNPPESAdapter } from "./usgov-nppes/adapter.ts"
+import { wofAdminAdapter } from "./wof-admin-json/adapter.ts"
+import { wofPostalcodeAdapter } from "./wof-postalcode-json/adapter.ts"
+
+/**
+ * Built-in adapters. Order is significant: `corpus build` iterates this list to drive every adapter in turn.
+ * Coarse-first (admin → postcode), then street-level (BAN FR, TIGER US, OpenAddresses global), then adversarial-source
+ * (FCC BDC US, HRSA FQHC US).
+ *
+ * The `usgov-samhsa-treatment-locator` adapter is intentionally absent from this list — the SAMHSA Open Data Foundry
+ * bulk CSV the adapter was written against is no longer publicly distributed (see issue #33, 2026-05-17 investigation).
+ * The factory + named export remain available so the adapter can be hand-registered if an operator obtains a compatible
+ * CSV (FOIA, partner channel, upstream restoration). Re-add it here once a stable public source returns.
+ */
+export const BUILTIN_ADAPTERS: readonly CorpusAdapter[] = [
+	wofAdminAdapter,
+	wofPostalcodeAdapter,
+	geonamesAdapter,
+	geonamesPostalAdapter,
+	banAdapter,
+	tigerAdapter,
+	openaddressesAdapter,
+	overtureAdapter,
+	gnafAdapter,
+	fccBdcAdapter,
+	usgovHrsaFqhcAdapter,
+	usgovNPPESAdapter,
+	usgovNADAdapter,
+	usgovImlsPlsAdapter,
+	usgovIrsBmfAdapter,
+	stateIaContractorsAdapter,
+	stateTxNotariesAdapter,
+	stateNyNotariesAdapter,
+	stateHiSchoolsAdapter,
+]
+
+for (const adapter of BUILTIN_ADAPTERS) {
+	if (!defaultAdapterRegistry.get(adapter.id)) {
+		defaultAdapterRegistry.register(adapter)
+	}
+}
+
+export { BAN_ADAPTER_ID, banAdapter } from "./ban/adapter.ts"
+export { FCC_BDC_ADAPTER_ID, FCC_BDC_DEFAULT_LICENSE, fccBdcAdapter } from "./fcc-bdc/adapter.ts"
+export {
+	GEONAMES_POSTAL_ADAPTER_ID,
+	GEONAMES_POSTAL_DEFAULT_LICENSE,
+	geonamesPostalAdapter,
+} from "./geonames-postal/adapter.ts"
+export { GEONAMES_ADAPTER_ID, GEONAMES_DEFAULT_LICENSE, geonamesAdapter } from "./geonames/adapter.ts"
+export {
+	OPENADDRESSES_ADAPTER_ID,
+	OPENADDRESSES_DEFAULT_LICENSE,
+	openaddressesAdapter,
+} from "./openaddresses/adapter.ts"
+export {
+	STATE_HI_SCHOOLS_ADAPTER_ID,
+	STATE_HI_SCHOOLS_DEFAULT_LICENSE,
+	stateHiSchoolsAdapter,
+} from "./state-hi-schools/adapter.ts"
+export {
+	STATE_IA_CONTRACTORS_ADAPTER_ID,
+	STATE_IA_CONTRACTORS_DEFAULT_LICENSE,
+	stateIaContractorsAdapter,
+} from "./state-ia-contractors/adapter.ts"
+export {
+	STATE_NY_NOTARIES_ADAPTER_ID,
+	STATE_NY_NOTARIES_DEFAULT_LICENSE,
+	stateNyNotariesAdapter,
+} from "./state-ny-notaries/adapter.ts"
+export {
+	STATE_TX_NOTARIES_ADAPTER_ID,
+	STATE_TX_NOTARIES_DEFAULT_LICENSE,
+	stateTxNotariesAdapter,
+} from "./state-tx-notaries/adapter.ts"
+export { TIGER_ADAPTER_ID, TIGER_DEFAULT_LICENSE, tigerAdapter } from "./tiger/adapter.ts"
+export {
+	USGOV_HRSA_FQHC_ADAPTER_ID,
+	USGOV_HRSA_FQHC_DEFAULT_LICENSE,
+	usgovHrsaFqhcAdapter,
+} from "./usgov-hrsa-fqhc/adapter.ts"
+export {
+	USGOV_IMLS_PLS_ADAPTER_ID,
+	USGOV_IMLS_PLS_DEFAULT_LICENSE,
+	usgovImlsPlsAdapter,
+} from "./usgov-imls-pls/adapter.ts"
+export { USGOV_IRS_BMF_ADAPTER_ID, USGOV_IRS_BMF_DEFAULT_LICENSE, usgovIrsBmfAdapter } from "./usgov-irs-bmf/adapter.ts"
+export { USGOV_NAD_ADAPTER_ID, USGOV_NAD_DEFAULT_LICENSE, usgovNADAdapter } from "./usgov-nad/adapter.ts"
+export { USGOV_NPPES_ADAPTER_ID, USGOV_NPPES_DEFAULT_LICENSE, usgovNPPESAdapter } from "./usgov-nppes/adapter.ts"
+export {
+	USGOV_SAMHSA_ADAPTER_ID,
+	USGOV_SAMHSA_DEFAULT_LICENSE,
+	usgovSamhsaTreatmentLocatorAdapter,
+} from "./usgov-samhsa-treatment-locator/adapter.ts"
+export { WOF_ADMIN_ADAPTER_ID, wofAdminAdapter } from "./wof-admin-json/adapter.ts"
+export { WOF_POSTALCODE_ADAPTER_ID, wofPostalcodeAdapter } from "./wof-postalcode-json/adapter.ts"

package/src/adapters/openaddresses/adapter.ts

@@ -0,0 +1,237 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   `openaddresses`: Line-delimited GeoJSON adapter for openaddresses.io exports.
+ *
+ *   OpenAddresses publishes country-partitioned address dumps as either CSV or line-delimited GeoJSON
+ *   (one `Feature` per line, also called ND-GeoJSON / GeoJSONL). This adapter consumes the
+ *   line-delimited GeoJSON shape — it streams cleanly without holding the file in memory, which
+ *   matters for the multi-gigabyte national dumps (e.g. `us-northeast.geojsonl`, ~20M rows).
+ *
+ *   The collection aggregates **hundreds** of underlying sources with **per-source licenses** (city
+ *   open-data portals, county GIS departments, state DOTs). The adapter therefore prefers the
+ *   per-row `LICENSE` property when present and falls back to the configured `defaultLicense`. The
+ *   propagated license travels with each `CanonicalRow` so downstream code can stratify, exclude,
+ *   or re-attribute by license at training time.
+ *
+ *   Country must be explicit (`opts.country` REQUIRED): OpenAddresses files are organized by country
+ *   but the row-level data doesn't include a country code, so the adapter refuses to run without
+ *   one. This matches how a `mailwoman corpus build` invocation pins each file to a country via the
+ *   inputs JSON.
+ *
+ *   Properties consumed (per the canonical OpenAddresses schema; both UPPERCASE and lowercase
+ *   variants are accepted because legacy dumps used UPPERCASE):
+ *
+ *   | Property | ComponentTag | | ------------- |
+ *   -------------------------------------------------------------- | | `number` | `house_number` |
+ *   | `street` | `street` | | `unit` | `unit` (if non-empty) | | `city` | `locality` | | `region` |
+ *   `region` (state code for US, province for CA, etc.) | | `postcode` | `postcode` | | `LICENSE` |
+ *   per-row `license` override | | `hash` / `id` | `source_id` (prefer `hash`; fall back to `id`;
+ *   then synthesize)|
+ *
+ *   `district` is intentionally NOT mapped — for US data it carries borough or county and would
+ *   inflate alignment quarantine because postal addresses don't include it. Phase 6+ may revisit
+ *   for non-US locales where district names DO appear on the envelope.
+ */
+
+import { TextSpliterator } from "spliterator"
+
+import { stableSourceID } from "../../adapter.ts"
+import { formatAddress, reconcileComponents } from "../../format.ts"
+import { SHARE_ALIKE_PATTERN } from "../../license.ts"
+import type { AdapterOptions, CanonicalRow, CorpusAdapter } from "../../types.ts"
+
+export const OPENADDRESSES_ADAPTER_ID = "openaddresses"
+export const OPENADDRESSES_DEFAULT_LICENSE = "CC-BY-4.0"
+
+/**
+ * Subset of OpenAddresses Feature properties the adapter inspects. The runtime accepts UPPERCASE or lowercase keys;
+ * this interface documents the canonical lowercase form after normalization.
+ */
+interface OaProperties {
+	hash?: string
+	id?: string
+	number?: string
+	street?: string
+	unit?: string
+	city?: string
+	district?: string
+	region?: string
+	postcode?: string
+	license?: string
+}
+
+/** Return a lowercase-keyed view of a Feature's properties so case variants both work. */
+function normalizeProperties(raw: unknown): OaProperties {
+	if (!raw || typeof raw !== "object") return {}
+	const out: Record<string, string> = {}
+
+	for (const [k, v] of Object.entries(raw as Record<string, unknown>)) {
+		if (typeof v === "string") {
+			out[k.toLowerCase()] = v
+		} else if (typeof v === "number") {
+			out[k.toLowerCase()] = String(v)
+		}
+	}
+
+	return out as OaProperties
+}
+
+/** Parse a single ND-GeoJSON line; return null for blanks, comments, or non-Feature shapes. */
+function parseFeatureLine(line: string): OaProperties | null {
+	const trimmed = line.trim()
+
+	if (!trimmed || trimmed.startsWith("#")) return null
+	let parsed: unknown
+
+	try {
+		parsed = JSON.parse(trimmed)
+	} catch {
+		return null
+	}
+
+	if (!parsed || typeof parsed !== "object") return null
+	const obj = parsed as { type?: string; properties?: unknown }
+
+	if (obj.type !== "Feature") return null
+
+	return normalizeProperties(obj.properties)
+}
+
+export interface OpenaddressesAdapterOptions {
+	/**
+	 * Per-row license used when a Feature lacks an explicit `LICENSE` property. Defaults to `CC-BY-4.0` — the most common
+	 * license across the OpenAddresses collection. Override per dump via the runner's adapter-options passthrough.
+	 */
+	defaultLicense?: string
+
+	/**
+	 * Per-adapter share-alike drop. Default **true** (include) as of 2026-06-19: exclusion is a deliberate BUILD-level
+	 * act (`buildCorpus({ excludeLicenses })` / `--exclude-share-alike`), NOT a silent adapter default (#26 — "purposely
+	 * exclude, don't opt in to include"). Set false only for an explicit adapter-scoped drop; the build-level
+	 * `--exclude-share-alike` is the normal path.
+	 */
+	allowShareAlike?: boolean
+}
+
+/**
+ * Build an OpenAddresses adapter. The optional `defaultLicense` lets callers stamp a non-default fallback for dumps
+ * known to carry a single license throughout (e.g. a PDDL-only state slice).
+ */
+export function createOpenaddressesAdapter(opts: OpenaddressesAdapterOptions = {}): CorpusAdapter {
+	const defaultLicense = opts.defaultLicense ?? OPENADDRESSES_DEFAULT_LICENSE
+	const allowShareAlike = opts.allowShareAlike ?? true
+
+	return {
+		id: OPENADDRESSES_ADAPTER_ID,
+		defaultLicense,
+		description: "OpenAddresses (global): line-delimited GeoJSON dumps with per-row licenses.",
+
+		async *rows(adapterOpts: AdapterOptions): AsyncIterable<CanonicalRow> {
+			if (!adapterOpts.country) {
+				throw new Error(
+					"openaddresses adapter: --country is required (OpenAddresses files are country-partitioned but rows lack a country field)"
+				)
+			}
+			const country = adapterOpts.country
+
+			// TextSpliterator streams string lines (parseFeatureLine keeps tolerating blank/`#`/
+			// malformed lines by returning null); passing the path string lets the lib own + dispose
+			// the file handle, including on an early `break`.
+			const lines = TextSpliterator.fromAsync(adapterOpts.inputPath)
+
+			let emitted = 0
+			let shareAlikeBlocked = 0
+
+			try {
+				for await (const line of lines) {
+					if (adapterOpts.signal?.aborted) break
+
+					if (adapterOpts.limit !== undefined && emitted >= adapterOpts.limit) break
+
+					const props = parseFeatureLine(line)
+
+					if (!props) continue
+
+					const houseNumber = props.number?.trim() ?? ""
+					const street = props.street?.trim() ?? ""
+					const unit = props.unit?.trim() ?? ""
+					const city = props.city?.trim() ?? ""
+					const region = props.region?.trim() ?? ""
+					const postcode = props.postcode?.trim() ?? ""
+
+					// A row is only useful if it has, at minimum, a street + (postcode OR locality).
+					// Pure point-only rows would land in quarantine anyway.
+					if (!street) continue
+
+					if (!city && !postcode) continue
+
+					const license = (props.license?.trim() || defaultLicense).trim()
+
+					if (!allowShareAlike && SHARE_ALIKE_PATTERN.test(license)) {
+						shareAlikeBlocked++
+						continue
+					}
+
+					const components: CanonicalRow["components"] = {}
+
+					if (houseNumber) {
+						components.house_number = houseNumber
+					}
+
+					if (street) {
+						components.street = street
+					}
+
+					if (unit) {
+						components.unit = unit
+					}
+
+					if (city) {
+						components.locality = city
+					}
+
+					if (region) {
+						components.region = region
+					}
+
+					if (postcode) {
+						components.postcode = postcode
+					}
+
+					const raw = formatAddress(components, country, { separator: ", " })
+
+					if (!raw) continue
+
+					const aligned = reconcileComponents(components, raw)
+
+					if (Object.keys(aligned).length === 0) continue
+
+					const sourceIDSeed = props.hash?.trim() || props.id?.trim()
+					const sourceID = sourceIDSeed
+						? `${OPENADDRESSES_ADAPTER_ID}-${sourceIDSeed}`
+						: stableSourceID(OPENADDRESSES_ADAPTER_ID, aligned)
+
+					yield {
+						raw,
+						components: aligned,
+						country,
+						source: OPENADDRESSES_ADAPTER_ID,
+						source_id: sourceID,
+						corpus_version: "",
+						license,
+					}
+					emitted++
+				}
+			} finally {
+				if (shareAlikeBlocked > 0) {
+					process.stderr.write(`  openaddresses: ${shareAlikeBlocked} share-alike rows dropped, ${emitted} kept\n`)
+				}
+			}
+		},
+	}
+}
+
+export const openaddressesAdapter = createOpenaddressesAdapter()