@mailwoman/corpus 10.0.0 → 10.2.0

package/lib/recipes/venue.ts

@@ -0,0 +1,347 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   `venue` recipe. A real venue name written as the whole query, and the same name followed by a
+ *   locality drawn from the country's admin tuples. The rows teach the model that
+ *   `Manchester Art Gallery` is a venue rather than a locality and a region, which the venue-head
+ *   prior in `@mailwoman/neural` also asserts, so the model and the prior agree.
+ *
+ *   Venue names come from the Overture place-names Parquet file the venue-head table is built
+ *   from, which holds `name`, `category` and `country` for every place at confidence 0.85 or
+ *   higher. The file has no locality column, so the locality row joins a name to a tuple of the
+ *   same country and asserts no fact about where the venue stands, so its surface is
+ *   `SurfaceOrigin.Composed`. The bare row is the publisher's own string, so its surface is
+ *   `SurfaceOrigin.Attested`.
+ *
+ *   A bare row needs a name of two or more words. A one-word name such as `Blackwell` or `Roadside`
+ *   is written as a bare query only beside a locality, because a lone unknown word is the shape of a
+ *   bare locality and a row that labels it `venue` would teach against bare-locality recall.
+ *
+ *   A name that equals a locality of the country's tuples, or whose written row is an input on a
+ *   gauntlet board, is refused.
+ */
+
+import { dataRootPath } from "@mailwoman/core/data-root"
+import { mulberry32 as makeMulberry32 } from "@mailwoman/core/utils"
+import { venueHeadLexicon } from "@mailwoman/poi-taxonomy/venue-heads"
+import type { PathBuilderLike } from "path-ts"
+
+import { normalizeGauntletSurface, readGauntletInputs } from "#gauntlet-inputs"
+import { type DisposableDuckDB, escapeSQLString, openDuckDB } from "#parquet/duckdb"
+import {
+	alignAndWrite,
+	readTuples,
+	recipeSourceID,
+	type CorpusRecipe,
+	type RecipeTuple,
+	type WriteRecipeLine,
+} from "#recipes/scaffold"
+import { defaultRecipeSource } from "#recipes/sources"
+import { SourceRegister } from "#registers"
+import { countryToLocale } from "#synthesizers/utils"
+import { SurfaceOrigin } from "#types"
+
+/**
+ * The Overture release the venue-head table is built from, so the two read one name population.
+ */
+export const DEFAULT_VENUE_NAMES: PathBuilderLike = dataRootPath(
+	"overture",
+	"2026-09-23.1",
+	"place-names",
+	"names.parquet"
+)
+
+/**
+ * Venue names drawn per country when `--count` is absent.
+ */
+export const DEFAULT_NAMES_PER_COUNTRY = 20_000
+
+/**
+ * Share of locality rows that also carry the region when `--venue-region-fraction` is absent.
+ */
+export const DEFAULT_REGION_FRACTION = 0.5
+
+/**
+ * The two written shapes.
+ */
+export const VenueTemplate = {
+	/**
+	 * The venue name as the whole query.
+	 */
+	Bare: "venue-bare",
+	/**
+	 * The venue name, a comma, and a locality of the same country.
+	 */
+	Locality: "venue-locality",
+} as const
+
+/**
+ * One of {@linkcode VenueTemplate}.
+ */
+export type VenueTemplate = (typeof VenueTemplate)[keyof typeof VenueTemplate]
+
+const LICENSE =
+	"CDLA-Permissive-2.0 — Overture Maps places names; the locality comes from CC-BY / public-domain admin tuples"
+
+const BARE_PROVENANCE = {
+	register: SourceRegister.Overture,
+	surface: SurfaceOrigin.Attested,
+	// The names file has no record id column.
+	baseSourceID: null,
+}
+
+const LOCALITY_PROVENANCE = {
+	register: SourceRegister.Overture,
+	surface: SurfaceOrigin.Composed,
+	baseSourceID: null,
+}
+
+/**
+ * A head lookup for one country, the shape `venueHeadLexicon` returns.
+ */
+export interface VenueHeadSuffixLookup {
+	suffix(word: string): number | null
+}
+
+const SPACELESS_SCRIPT_RE = /^[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Thai}]+$/u
+
+/**
+ * Characters a spaceless-script name needs before it is written as a bare query.
+ *
+ * A two-character name such as `東京` is the length of a city name, and the head the table recognizes is
+ * the name's last character, so a name shorter than this is a head with one character of stem.
+ */
+export const MIN_SPACELESS_BARE_CHARACTERS = 3
+
+/**
+ * Whether a name may be written as the whole query.
+ *
+ * In a spaced script the name needs two or more words, and at least one word
+ * with a letter, so `24 7` and `A1` stay out.
+ * In a script written without spaces a name is one word, so it qualifies when it has three or more
+ * characters and ends in a venue head the table holds for the country, as `国立西洋美術館` ends in `館`.
+ *
+ * A spaceless name the table does not recognize is written beside a locality only.
+ */
+export function isBareVenueName(name: string, heads?: VenueHeadSuffixLookup): boolean {
+	const words = name.trim().split(/\s+/u)
+
+	if (words.length >= 2) return words.some((word) => /\p{L}{2,}/u.test(word))
+
+	const word = words[0]!
+
+	return (
+		Boolean(heads) &&
+		[...word].length >= MIN_SPACELESS_BARE_CHARACTERS &&
+		SPACELESS_SCRIPT_RE.test(word) &&
+		heads!.suffix(word) !== null
+	)
+}
+
+/**
+ * The comparison key for a name against the country's localities.
+ */
+export function venueNameKey(name: string): string {
+	return name.normalize("NFC").trim().toLowerCase().replaceAll(/\s+/gu, " ")
+}
+
+/**
+ * Admin tuples grouped by country, with the locality set each country's names are checked against.
+ */
+export interface CountryTuples {
+	tuples: RecipeTuple[]
+	localities: Set<string>
+}
+
+/**
+ * The ISO 3166-1 alpha-2 code of a tuple's country.
+ *
+ * `corpus tuples` writes the code under `cc` and the display name under `country`.
+ * Older tuples files write the code under `country`.
+ * A tuple with neither form returns `null`.
+ */
+export function tupleCountryCode(tuple: RecipeTuple): string | null {
+	for (const value of [tuple.cc, tuple.country]) {
+		if (typeof value === "string" && /^[A-Za-z]{2}$/u.test(value.trim())) return value.trim().toUpperCase()
+	}
+
+	return null
+}
+
+/**
+ * Groups the admin tuples by country and keeps those with a locality.
+ */
+export async function groupTuplesByCountry(input: PathBuilderLike): Promise<Map<string, CountryTuples>> {
+	const byCountry = new Map<string, CountryTuples>()
+
+	for await (const tuple of readTuples(input)) {
+		const country = tupleCountryCode(tuple)
+
+		if (!country || !tuple.locality) continue
+		let entry = byCountry.get(country)
+
+		if (!entry) {
+			entry = { tuples: [], localities: new Set() }
+			byCountry.set(country, entry)
+		}
+
+		entry.tuples.push(tuple)
+		entry.localities.add(venueNameKey(tuple.locality))
+	}
+
+	return byCountry
+}
+
+/**
+ * Reads up to `limit` distinct names of one country from the Overture names file.
+ *
+ * The order is a hash of the name and the seed, so one seed draws one sample and a second seed another.
+ */
+export async function readVenueNames(
+	db: DisposableDuckDB,
+	venueNames: PathBuilderLike,
+	country: string,
+	limit: number,
+	seed: number
+): Promise<string[]> {
+	const result = await db.runAndReadAll(
+		`SELECT DISTINCT name FROM read_parquet('${escapeSQLString(String(venueNames))}')
+		WHERE country = '${escapeSQLString(country)}' AND name IS NOT NULL AND length(trim(name)) >= 3
+		ORDER BY hash(name, ${Math.floor(seed)}) LIMIT ${Math.floor(limit)}`
+	)
+
+	return result.getRows().map((row) => String(row[0]))
+}
+
+interface EmitContext {
+	write: WriteRecipeLine
+	source: { bare: string; locality: string }
+	boardInputs: ReadonlySet<string>
+	random: () => number
+	stats: { emitted: number; skipped: number; contaminated: number }
+}
+
+function emit(
+	context: EmitContext,
+	raw: string,
+	components: Record<string, string>,
+	country: string,
+	template: VenueTemplate,
+	idParts: Record<string, string | undefined>
+): void {
+	if (context.boardInputs.has(normalizeGauntletSurface(raw))) {
+		context.stats.contaminated++
+
+		return
+	}
+
+	const source = template === VenueTemplate.Bare ? context.source.bare : context.source.locality
+
+	const ok = alignAndWrite(
+		context.write,
+		{
+			raw,
+			components,
+			country,
+			locale: countryToLocale(country),
+			source,
+			source_id: recipeSourceID(source, { ...idParts, template }),
+			corpus_version: "0.12.0",
+			license: LICENSE,
+		},
+		template,
+		template === VenueTemplate.Bare ? BARE_PROVENANCE : LOCALITY_PROVENANCE
+	)
+
+	if (ok) {
+		context.stats.emitted++
+	} else {
+		context.stats.skipped++
+	}
+}
+
+/**
+ * Recipe registered with the corpus builder.
+ *
+ * `--input` supplies locality, region and country tuples, and every country
+ * in it with venue names is covered.
+ * `--count` caps the names drawn per country.
+ * `--venue-names` points at the Overture names file.
+ */
+export const venueRecipe: CorpusRecipe = {
+	name: "venue",
+	description: "A real venue name as the whole query, and the name beside a locality of its country",
+	mode: "tuples",
+	options: [
+		{ flag: "--venue-names <parquet>", description: `Overture place-names file (default ${DEFAULT_VENUE_NAMES})` },
+		{ flag: "--count <n>", description: `venue names per country (default ${DEFAULT_NAMES_PER_COUNTRY})` },
+		{
+			flag: "--venue-region-fraction <share>",
+			description: `locality rows that also carry the region (default ${DEFAULT_REGION_FRACTION})`,
+		},
+	],
+	async run(opts, write) {
+		if (!opts.input) throw new Error("venue recipe requires --input <tuples.jsonl>")
+		const random = makeMulberry32(opts.seed)
+		const venueNames = opts.venueNames ?? DEFAULT_VENUE_NAMES
+		const perCountry = opts.count ?? DEFAULT_NAMES_PER_COUNTRY
+		const regionFraction = opts.venueRegionFraction ?? DEFAULT_REGION_FRACTION
+		const byCountry = await groupTuplesByCountry(opts.input)
+		const boardInputs = await readGauntletInputs()
+
+		const context: EmitContext = {
+			write,
+			source: {
+				bare: opts.sourceName ? `${opts.sourceName}-bare` : defaultRecipeSource("synth-venue-bare"),
+				locality: opts.sourceName ? `${opts.sourceName}-locality` : defaultRecipeSource("synth-venue-locality"),
+			},
+			boardInputs,
+			random,
+			stats: { emitted: 0, skipped: 0, contaminated: 0 },
+		}
+
+		let read = 0
+
+		using db = await openDuckDB({ threads: 4 })
+
+		for (const [country, { tuples, localities }] of byCountry) {
+			const names = await readVenueNames(db, venueNames, country, perCountry, opts.seed)
+			const heads = venueHeadLexicon(country)
+
+			for (const name of names) {
+				read++
+
+				if (localities.has(venueNameKey(name))) {
+					context.stats.skipped++
+
+					continue
+				}
+
+				const tuple = tuples[Math.floor(random() * tuples.length)]!
+				const locality = tuple.locality!
+				const withRegion = Boolean(tuple.region) && random() < regionFraction
+				const components: Record<string, string> = { venue: name, locality }
+				let raw = `${name}, ${locality}`
+
+				if (withRegion) {
+					components.region = tuple.region!
+					raw = `${raw}, ${tuple.region}`
+				}
+
+				emit(context, raw, components, country, VenueTemplate.Locality, {
+					name,
+					locality,
+					region: withRegion ? tuple.region : undefined,
+				})
+
+				if (isBareVenueName(name, heads)) {
+					emit(context, name, { venue: name }, country, VenueTemplate.Bare, { name })
+				}
+			}
+		}
+
+		return { read, ...context.stats }
+	},
+}

package/lib/{recipes/index.ts → recipes.ts}

@@ -3,9 +3,11 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   The synthetic-corpus SLICE RECIPE registry. Each recipe ({@link CorpusRecipe}) is what one legacy
- *   `build-*-slice.mjs` script used to be; the `mailwoman corpus slice <recipe>` command dispatches
- *   to them. A new slice is a new entry here, not a new script.
+ *   The recipe registry. A recipe derives rows from attested data; `recipes/sources.ts` records which
+ *   operation each one performs, and only the `invented-*` recipes compose a row with no real record
+ *   behind it. Each recipe ({@link CorpusRecipe}) is what one root-level
+ *   build script used to be. the `mailwoman corpus slice <recipe>` command dispatches to them. A new
+ *   recipe is a new entry here rather than a new script.
  */
 
 import { cnOrganizationalUnitsRecipe } from "#cn/recipes/organizational-units"
@@ -19,24 +21,25 @@ import { frOrderRecipe } from "#fr/recipes/order"
 import { localeRecipe } from "#international/recipes/locale"
 import { nlPostcodeRecipe } from "#nl/recipes/postcode"
 import { noFragmentRecipe } from "#no/recipes/fragment"
-import { noStreetRecipe } from "#no/recipes/street/index"
+import { noStreetRecipe } from "#no/recipes/street"
 import { noStreetLedRecipe } from "#no/recipes/street/led"
 import { anchorAbsorptionRecipe } from "#recipes/anchor-absorption"
 import { bareCountryRecipe } from "#recipes/bare/country"
-import { barePostcodeRecipe } from "#recipes/bare/postcode/index"
+import { barePostcodeRecipe } from "#recipes/bare/postcode"
 import { boundaryStressRecipe } from "#recipes/boundary-stress"
 import { countryBalancedRecipe } from "#recipes/country-balanced"
 import { houseVenueRecipe } from "#recipes/house-venue"
 import { intersectionRecipe } from "#recipes/intersection"
+import { poBoxRecipe } from "#recipes/po/box"
 import { poBoxCedexRecipe } from "#recipes/po/box/cedex"
-import { poBoxRecipe } from "#recipes/po/box/index"
 import type { CorpusRecipe } from "#recipes/scaffold"
 import { streetRecipe } from "#recipes/street"
 import { streetAffixRecipe, suffixBoundaryRecipe } from "#recipes/street/affix"
 import { streetBareRecipe } from "#recipes/street/bare"
-import { subVenueRecipe } from "#recipes/sub/venue/index"
+import { subVenueRecipe } from "#recipes/sub/venue"
 import { trailingRegionRecipe } from "#recipes/trailing-region"
 import { unitRecipe } from "#recipes/unit"
+import { venueRecipe } from "#recipes/venue"
 import { sgRegisterRecipe } from "#sg/recipes/register"
 import { siBareVillageRecipe } from "#si/recipes/bare-village"
 import { bdRegisterRecipe, pkRegisterRecipe } from "#south-asia/recipes/register"
@@ -82,23 +85,24 @@ const RECIPES: readonly CorpusRecipe[] = [
 	boundaryStressRecipe,
 	anchorAbsorptionRecipe,
 	subVenueRecipe,
+	venueRecipe,
 ]
 
 /**
  * Recipe name → recipe.
  */
-export const SLICE_RECIPES: ReadonlyMap<string, CorpusRecipe> = new Map(RECIPES.map((r) => [r.name, r]))
+export const RECIPES_BY_NAME: ReadonlyMap<string, CorpusRecipe> = new Map(RECIPES.map((r) => [r.name, r]))
 
 /**
  * Look up a recipe by its `<recipe>` name.
  */
-export function getSliceRecipe(name: string): CorpusRecipe | undefined {
-	return SLICE_RECIPES.get(name)
+export function getRecipe(name: string): CorpusRecipe | null {
+	return RECIPES_BY_NAME.get(name) ?? null
 }
 
 /**
  * All recipes (for `--list` / help).
  */
-export function listSliceRecipes(): readonly CorpusRecipe[] {
+export function listRecipes(): readonly CorpusRecipe[] {
 	return RECIPES
 }

package/lib/registers.ts

@@ -0,0 +1,280 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Stable ids for the publications that corpus rows come from.
+ */
+
+/**
+ * The publications this repository reads, keyed by stable id.
+ *
+ * A row's `source` identifies the adapter or recipe that emitted it.
+ * A row's `register` identifies the publication behind its record.
+ * That publication determines the governing terms.
+ *
+ * Built corpora store these ids on every row, so an existing id must never change.
+ *
+ * An aggregator such as OpenAddresses or Overture is recorded as itself,
+ * because its per-record upstream and terms vary.
+ */
+export const SourceRegister = {
+	/**
+	 * OpenAddresses, an aggregator over national and municipal address registers.
+	 */
+	OpenAddresses: "openaddresses",
+	/**
+	 * Overture Maps addresses, an aggregator whose rows include a per-record source and license.
+	 */
+	Overture: "overture",
+	/**
+	 * Who's On First, the gazetteer of places and postal codes.
+	 */
+	WhosOnFirst: "whos-on-first",
+	/**
+	 * OpenStreetMap.
+	 */
+	OpenStreetMap: "openstreetmap",
+	/**
+	 * GeoNames, the place-name gazetteer.
+	 */
+	GeoNames: "geonames",
+	/**
+	 * GeoNames postal-code tables, published separately from the place gazetteer.
+	 */
+	GeoNamesPostal: "geonames-postal",
+	/**
+	 * France's Base Adresse Nationale.
+	 */
+	BaseAdresseNationale: "fr-ban",
+	/**
+	 * Kartverket's `Matrikkelen - Adresse`, the Norwegian cadastre's address table.
+	 *
+	 * The prefix is the publisher's own country, as `fr-ban`'s is, and the dataset
+	 * covers Svalbard beside the mainland.
+	 */
+	MatrikkelenAdresse: "no-matrikkelen-adresse",
+	/**
+	 * The INSPIRE Addresses theme of the Czech Office for Surveying, Mapping and Cadastre.
+	 *
+	 * ČÚZK publishes one zipped GML per municipality, 6,258 of them, through an ATOM service.
+	 */
+	CuzkInspireAddresses: "cz-cuzk-inspire-addresses",
+	/**
+	 * Suomen ympäristökeskus' Ryhti built-environment system.
+	 *
+	 * Its building address data covers Åland's sixteen municipalities beside the
+	 * Finnish mainland in one national file.
+	 *
+	 * The prefix is the publisher's own country, as `fr-ban`'s is.
+	 */
+	RyhtiBuildingAddress: "fi-ryhti-building-address",
+	/**
+	 * Klimadatastyrelsen's INSPIRE Addresses theme for Denmark, published as a GeoPackage.
+	 *
+	 * One address is a join across five tables rather than a row.
+	 */
+	DKInspireAddresses: "dk-inspire-addresses",
+	/**
+	 * Estonia's Aadressiandmete süsteem, served as the INSPIRE Addresses theme by Maa- ja Ruumiamet.
+	 *
+	 * The tail is the system the theme is served out of.
+	 */
+	EstoniaADS: "ee-ads-aadress",
+	/**
+	 * The municipal EMUiA address registers, reaching the INSPIRE Addresses theme through
+	 * the Państwowy Rejestr Granic and served by Główny Urząd Geodezji i Kartografii.
+	 */
+	PolandEMUiA: "pl-emuia-adresy",
+	/**
+	 * The INSPIRE Addresses theme of agentschap Digitaal Vlaanderen.
+	 *
+	 * Coverage is the Flemish Region rather than Belgium.
+	 * Brussels and Wallonia publish the theme through their own services,
+	 * so a Belgian build reads three registers.
+	 */
+	VlaanderenInspireAddresses: "be-vlaanderen-inspire-ad",
+	/**
+	 * The INSPIRE Addresses theme of the Service public de Wallonie, out of its ICAR register.
+	 *
+	 * Coverage is the Walloon Region.
+	 * Flanders and Brussels publish the theme through their own services,
+	 * so a Belgian build reads three registers.
+	 */
+	WallonieInspireAddresses: "be-wallonie-inspire-ad",
+	/**
+	 * The INSPIRE Addresses theme of the Brussels Regional Informatics Center, out of UrbIS.
+	 *
+	 * Coverage is the Brussels-Capital Region.
+	 * The address-source register holds no row for this publisher, so no license is elected
+	 * and `createIneligibilityReader` refuses every row the adapter emits.
+	 *
+	 * The id exists so the adapter can name its publication once a row is written.
+	 */
+	BrusselsInspireAddresses: "be-brussels-inspire-ad",
+	/**
+	 * The INSPIRE Addresses theme of Kadaster, the Dutch cadastre.
+	 *
+	 * One ATOM entry serves the whole country as a single gzipped GML.
+	 */
+	KadasterInspireAddresses: "nl-kadaster-inspire-ad",
+	/**
+	 * The INSPIRE Addresses theme the Ministerstvo vnútra Slovenskej republiky serves
+	 * out of the national address register, as a paged WFS 2.0.
+	 */
+	SlovakiaInspireAddresses: "sk-minv-inspire-ad",
+	/**
+	 * The INSPIRE Addresses theme of the Dirección General del Catastro.
+	 *
+	 * Coverage is Spain outside the foral cadastres: 52 of the 55 entries in the national
+	 * ATOM feed, one province feed each, listing one zipped GML per municipality.
+	 * The other three entries link the publications below.
+	 *
+	 * Each of those states its own terms.
+	 * Spain therefore needs four registers.
+	 */
+	CatastroInspireAddresses: "es-catastro-inspire-ad",
+	/**
+	 * The INSPIRE Addresses theme of the Diputación Foral de Bizkaia.
+	 *
+	 * Coverage is the province of Bizkaia, as 112 municipality archives.
+	 * The archives hold addresses only, and the features they reference are served
+	 * by the publisher's WFS rather than by the ATOM feed.
+	 */
+	BizkaiaInspireAddresses: "es-bizkaia-inspire-ad",
+	/**
+	 * The INSPIRE Addresses theme of the Diputación Foral de Gipuzkoa.
+	 *
+	 * One ATOM entry serves the whole province as a single zipped GML.
+	 */
+	GipuzkoaInspireAddresses: "es-gipuzkoa-inspire-ad",
+	/**
+	 * The INSPIRE Addresses theme of the Gobierno de Navarra.
+	 *
+	 * The province is split across 272 zipped GML partitions, each titled
+	 * `Address Navarra` The title states no municipality.
+	 */
+	NavarraInspireAddresses: "es-navarra-inspire-ad",
+	/**
+	 * BD-Adresses, the georeferenced address file the Administration du cadastre et de
+	 * la topographie publishes for Luxembourg through `data.public.lu`.
+	 *
+	 * The publisher describes it as a subset of the national register of localities and streets,
+	 * enriched with coordinates, so the publication is narrower than that register.
+	 */
+	BDAdresses: "lu-act-bd-adresses",
+	/**
+	 * The OCDS release Autorità Nazionale Anticorruzione publishes for Italy's National Database
+	 * of Public Contracts, reached through the Open Contracting Partnership's Data Registry.
+	 *
+	 * Every address in the release belongs to a contracting authority or a paying office,
+	 * because the `supplier` role holds no address object.
+	 */
+	ANACContracts: "it-anac-ocds-contracts",
+	/**
+	 * Romania's school network, the Ministry of Education's list of every education unit and its address.
+	 */
+	ReteaScolara: "ro-edu-retea-scolara",
+	/**
+	 * FINESS, the health ministry's register of health and social establishments,
+	 * read from its establishment extract on data.gouv.fr.
+	 */
+	FINESS: "fr-finess",
+	/**
+	 * The education ministry's Annuaire de l'éducation, the directory of schools and education offices.
+	 */
+	AnnuaireEducation: "fr-annuaire-education",
+	/**
+	 * The CORDIS organization files for the participants in the EU's research framework programmes
+	 * (FP7, Horizon 2020, Horizon Europe), published by the Publications Office of the European Union.
+	 *
+	 * Each address is the one a participating legal entity registered with the participant register.
+	 */
+	CORDISParticipants: "eu-cordis-participants",
+	/**
+	 * Latvia's State Address Register (Valsts adrešu reģistrs), the open data Valsts zemes
+	 * dienests publishes as the data.gov.lv dataset `varis-atvertie-dati`.
+	 */
+	VARIS: "lv-varis",
+	/**
+	 * GLEIF's Level 1 LEI golden copy: the legal and headquarters addresses of every LEI holder.
+	 */
+	GLEIFGoldenCopy: "gleif-lei-golden-copy",
+	/**
+	 * HM Land Registry Price Paid Data, England and Wales.
+	 */
+	LandRegistryPricePaid: "gb-hm-land-registry-ppd",
+	/**
+	 * Australia's Geocoded National Address File.
+	 */
+	GNAF: "au-gnaf",
+	/**
+	 * The United States Census Bureau's TIGER/Line road and address-range files.
+	 */
+	CensusTIGER: "us-census-tiger",
+	/**
+	 * The National Address Database, published by the US Department of Transportation.
+	 */
+	NationalAddressDatabase: "us-dot-nad",
+	/**
+	 * The FCC Broadband Data Collection location fabric.
+	 */
+	FCCBroadbandData: "us-fcc-bdc",
+	/**
+	 * The National Plan and Provider Enumeration System.
+	 */
+	NPPES: "us-nppes",
+	/**
+	 * HRSA's Federally Qualified Health Center file.
+	 */
+	HRSAHealthCenters: "us-hrsa-fqhc",
+	/**
+	 * The IMLS Public Libraries Survey.
+	 */
+	IMLSPublicLibraries: "us-imls-pls",
+	/**
+	 * The IRS Business Master File of tax-exempt organizations.
+	 */
+	IRSBusinessMasterFile: "us-irs-bmf",
+	/**
+	 * SAMHSA's behavioral health treatment services locator.
+	 */
+	SAMHSATreatmentLocator: "us-samhsa-treatment-locator",
+	/**
+	 * Hawaii Department of Education's school directory.
+	 */
+	HawaiiSchools: "us-hi-doe-schools",
+	/**
+	 * New York State's notary public register.
+	 */
+	NewYorkNotaries: "us-ny-notaries",
+	/**
+	 * Texas's notary public register.
+	 */
+	TexasNotaries: "us-tx-notaries",
+	/**
+	 * Iowa's Active Construction Contractor Registrations.
+	 */
+	IowaContractors: "us-ia-contractor-registrations",
+	/**
+	 * This repository's curated codex tables, such as country names, address layouts and postcode formats.
+	 */
+	Codex: "mailwoman-codex",
+	/**
+	 * Facts that a person read from a publisher and recorded here by hand.
+	 *
+	 * The reviewed file records the publisher.
+	 */
+	ReviewedByHand: "mailwoman-reviewed",
+	/**
+	 * A tuple extract under `$MAILWOMAN_DATA_ROOT/corpus/tuples/` whose upstream publication is unknown.
+	 *
+	 * A recipe whose tuples record their upstream passes that register instead.
+	 */
+	DerivedTuples: "mailwoman-derived-tuples",
+} as const
+
+/**
+ * One of the {@link SourceRegister} ids.
+ */
+export type SourceRegister = (typeof SourceRegister)[keyof typeof SourceRegister]