@mailwoman/corpus 9.1.0 → 9.2.0

package/src/shard-recipes/index.ts

@@ -9,6 +9,7 @@
  */
 
 import { anchorAbsorptionRecipe } from "./anchor-absorption.ts"
+import { bareCountryRecipe } from "./bare-country.ts"
 import { boundaryStressRecipe } from "./boundary-stress.ts"
 import { countryBalancedRecipe } from "./country-balanced.ts"
 import { czPcFirstPrepositionRecipe } from "./cz-pcfirst-preposition.ts"
@@ -27,12 +28,14 @@ import { noStreetLedRecipe } from "./no-street-led.ts"
 import { noStreetRecipe } from "./no-street.ts"
 import { poBoxCedexRecipe } from "./po-box-cedex.ts"
 import { poBoxRecipe } from "./po-box.ts"
+import { reviewedPostcodeTailRecipe } from "./reviewed-postcode-tail.ts"
 import type { ShardRecipe } from "./scaffold.ts"
 import { siBareVillageRecipe } from "./si-bare-village.ts"
 import { streetAffixRecipe, suffixBoundaryRecipe } from "./street-affix.ts"
 import { streetBareRecipe } from "./street-bare.ts"
 import { streetRecipe } from "./street.ts"
 import { subVenueRecipe } from "./sub-venue.ts"
+import { trailingRegionRecipe } from "./trailing-region.ts"
 import { unitRecipe } from "./unit.ts"
 
 export * from "./scaffold.ts"
@@ -41,6 +44,9 @@ export * from "./scaffold.ts"
  * Every registered recipe, in display order.
  */
 const RECIPES: readonly ShardRecipe[] = [
+	bareCountryRecipe,
+	trailingRegionRecipe,
+	reviewedPostcodeTailRecipe,
 	streetRecipe,
 	streetBareRecipe,
 	streetAffixRecipe,

package/src/shard-recipes/intersection.ts

@@ -34,16 +34,17 @@
  *   - `$MAILWOMAN_DATA_ROOT/oa-cache/us__il__cook.zip` (ZIP→city tails)
  */
 
-import { existsSync, readFileSync, writeFileSync } from "node:fs"
+import { existsSync, writeFileSync } from "node:fs"
 
 import type { DuckDBConnection } from "@duckdb/node-api"
 import type { ComponentTag } from "@mailwoman/core/types"
 import { dataRootPath, repoRootPath } from "@mailwoman/core/utils"
-import { stableSourceID } from "@mailwoman/corpus/adapters/utils"
-import type { CanonicalRow, LabeledRow } from "@mailwoman/corpus/types"
-import { alignRow } from "@mailwoman/corpus/utils"
 import { JSONSpliterator } from "spliterator"
 
+import { stableSourceID } from "#adapters/utils"
+import type { CanonicalRow, LabeledRow } from "#types"
+import { alignRow } from "#utils"
+
 import { makeMulberry32, readZippedCSVRecords, type ShardRecipe } from "./scaffold.ts"
 
 interface County {

package/src/shard-recipes/locale.ts

@@ -29,16 +29,14 @@ import { createReadStream } from "node:fs"
 
 import { COUNTRY_SURFACE_FORMS } from "@mailwoman/codex/country"
 import { readZipEntry } from "@mailwoman/core/fs/zip"
+import { isPresent } from "@mailwoman/core/objects"
 import { dataRootPath } from "@mailwoman/core/utils"
-import { stableSourceID } from "@mailwoman/corpus/adapters/utils"
-import {
-	type LocaleBaseTuple,
-	type SynthesizedLocaleRow,
-	synthesizeLocaleRow,
-} from "@mailwoman/corpus/synthesizers/german"
-import { alignRow } from "@mailwoman/corpus/utils"
 import { CSVSpliterator } from "spliterator"
 
+import { stableSourceID } from "#adapters/utils"
+import { type LocaleBaseTuple, type SynthesizedLocaleRow, synthesizeLocaleRow } from "#synthesizers/german"
+import { alignRow } from "#utils"
+
 import { makeMulberry32, type ShardRecipe } from "./scaffold.ts"
 
 /**
@@ -296,7 +294,7 @@ export async function readTuples(part: LocalePart, rng: () => number): Promise<L
 			// pre-joined STREET column, so `cols.tipoVial === -1` and this is a no-op there.
 			const street =
 				cols.tipoVial >= 0
-					? [get(cells, cols.tipoVial), get(cells, cols.street)].filter(Boolean).join(" ")
+					? [get(cells, cols.tipoVial), get(cells, cols.street)].filter(isPresent).join(" ")
 					: get(cells, cols.street)
 
 			const rawCity = get(cells, cols.city)

package/src/shard-recipes/no-street.ts

@@ -10,7 +10,7 @@
  *   scripts/build-no-street-shard.mjs.
  */
 
-import { synthesizeNoStreetRow, type NoStreetBaseTuple } from "@mailwoman/corpus/synthesizers/no-street"
+import { synthesizeNoStreetRow, type NoStreetBaseTuple } from "#synthesizers/no-street"
 
 import { alignAndWrite, makeLcg, readTuples, shardSourceID, type ShardRecipe } from "./scaffold.ts"
 

package/src/shard-recipes/po-box-cedex.ts

@@ -39,14 +39,15 @@ import { isNZDeliveryService, isNZPostcode } from "@mailwoman/codex/nz"
 import { isPOBox } from "@mailwoman/codex/us"
 import { readZipEntry } from "@mailwoman/core/fs/zip"
 import { dataRootPath } from "@mailwoman/core/utils"
+import { TextSpliterator, TSVSpliterator } from "spliterator"
+
 import {
 	maybeNoisifyBoxNumber,
 	PO_BOX_LOCALE_TEMPLATES,
 	synthesizeMilitaryPoBoxRow,
 	type LocaleTemplate,
-} from "@mailwoman/corpus/synthesizers/po-box"
-import { alignRow } from "@mailwoman/corpus/utils"
-import { TextSpliterator, TSVSpliterator } from "spliterator"
+} from "#synthesizers/po-box"
+import { alignRow } from "#utils"
 
 import {
 	makeMulberry32,

package/src/shard-recipes/po-box.ts

@@ -9,11 +9,7 @@
  *   scripts/build-po-box-shard.mjs.
  */
 
-import {
-	synthesizeMilitaryPoBoxRow,
-	synthesizePoBoxRow,
-	type PoBoxBaseTuple,
-} from "@mailwoman/corpus/synthesizers/po-box"
+import { synthesizeMilitaryPoBoxRow, synthesizePoBoxRow, type PoBoxBaseTuple } from "#synthesizers/po-box"
 
 import { alignAndWrite, makeLcg, readTuples, shardSourceID, type ShardRecipe } from "./scaffold.ts"
 

package/src/shard-recipes/reviewed-postcode-tail.ts

@@ -0,0 +1,189 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   A bounded, reviewed source for Venezuela's `locality postcode, region` convention (#1821).
+ *   Bulk sources yielded zero Venezuelan tuples, so this recipe reads four reviewed facts and applies
+ *   only transformations that do not create another postcode-to-place join.
+ */
+
+import { readFileSync } from "node:fs"
+import { fileURLToPath } from "node:url"
+
+import { parseJSONStrict } from "@mailwoman/core/objects"
+
+import { alignAndWrite, type ShardRecipe, shardSourceID } from "./scaffold.ts"
+
+/**
+ * A separate sampler bucket so a receipt measures these reviewed after-locality rows and no other postcode placement.
+ */
+export const REVIEWED_POSTCODE_TAIL_SOURCE = "synth-reviewed-postcode-tail"
+
+/**
+ * The four postcode-to-place facts reviewed for #1821 and committed in the package data file.
+ */
+const REVIEWED_TUPLE_COUNT = 4
+
+interface ReviewedTupleProvenance {
+	publisher: string
+	url: string
+	retrievedAt: string
+	reviewStatus: "reviewed"
+	sourceLicenseNote: string
+}
+
+export interface ReviewedPostcodeTuple {
+	id: string
+	locality: string
+	postcode: string
+	region: string
+	country: "Venezuela"
+	cc: "VE"
+	locale: "es-VE"
+	postcodePlacement: "after_locality"
+	provenance: ReviewedTupleProvenance
+}
+
+interface ReviewedPostcodeTupleFile {
+	version: string
+	reviewedAt: string
+	tuples: ReviewedPostcodeTuple[]
+}
+
+type VariantID =
+	| "canonical-country"
+	| "canonical-no-country"
+	| "comma-free"
+	| "uppercase"
+	| "left-context"
+	| "accent-folded"
+
+interface Variant {
+	id: VariantID
+	raw: string
+	components: Record<string, string>
+}
+
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/
+
+export function defaultReviewedPostcodeTuplePath(): string {
+	return fileURLToPath(import.meta.resolve("@mailwoman/corpus/data/reviewed-ve-postcode-tuples.json"))
+}
+
+export function readReviewedPostcodeTuples(path = defaultReviewedPostcodeTuplePath()): ReviewedPostcodeTuple[] {
+	const document = parseJSONStrict<ReviewedPostcodeTupleFile>(readFileSync(path, "utf8"))
+
+	if (!document.version || !ISO_DATE.test(document.reviewedAt) || document.tuples.length !== REVIEWED_TUPLE_COUNT) {
+		throw new Error("reviewed postcode tuple file must declare a version, review date, and exactly four tuples")
+	}
+
+	const ids = new Set<string>()
+	const facts = new Set<string>()
+
+	for (const tuple of document.tuples) {
+		const provenance = tuple.provenance
+		const fact = `${tuple.locality}\u0000${tuple.postcode}\u0000${tuple.region}`
+
+		if (
+			!tuple.id ||
+			!tuple.locality ||
+			!tuple.postcode ||
+			!tuple.region ||
+			tuple.country !== "Venezuela" ||
+			tuple.cc !== "VE" ||
+			tuple.locale !== "es-VE" ||
+			tuple.postcodePlacement !== "after_locality" ||
+			!provenance?.publisher ||
+			!URL.canParse(provenance.url) ||
+			!ISO_DATE.test(provenance.retrievedAt) ||
+			provenance.reviewStatus !== "reviewed" ||
+			!provenance.sourceLicenseNote
+		) {
+			throw new Error(`invalid reviewed postcode tuple: ${tuple.id || "<missing id>"}`)
+		}
+
+		if (ids.has(tuple.id) || facts.has(fact)) throw new Error(`duplicate reviewed postcode tuple: ${tuple.id}`)
+		ids.add(tuple.id)
+		facts.add(fact)
+	}
+
+	return document.tuples
+}
+
+const foldAccents = (value: string): string => value.normalize("NFD").replaceAll(/\p{M}/gu, "").normalize("NFC")
+
+export function reviewedPostcodeTailVariants(tuple: ReviewedPostcodeTuple): Variant[] {
+	const tail = `${tuple.locality} ${tuple.postcode}, ${tuple.region}`
+	const withCountry = `${tail}, ${tuple.country}`
+	const base = { locality: tuple.locality, postcode: tuple.postcode, region: tuple.region, country: tuple.country }
+	const upper = Object.fromEntries(Object.entries(base).map(([key, value]) => [key, value.toUpperCase()]))
+
+	const variants: Variant[] = [
+		{ id: "canonical-country", raw: withCountry, components: base },
+		{
+			id: "canonical-no-country",
+			raw: tail,
+			components: { locality: tuple.locality, postcode: tuple.postcode, region: tuple.region },
+		},
+		{ id: "comma-free", raw: `${tuple.locality} ${tuple.postcode} ${tuple.region} ${tuple.country}`, components: base },
+		{ id: "uppercase", raw: withCountry.toUpperCase(), components: upper },
+		{
+			id: "left-context",
+			raw: `Comercio Ejemplo, Calle Principal, ${withCountry}`,
+			components: { venue: "Comercio Ejemplo", street: "Calle Principal", ...base },
+		},
+	]
+
+	const foldedLocality = foldAccents(tuple.locality)
+	const foldedRegion = foldAccents(tuple.region)
+
+	if (foldedLocality !== tuple.locality || foldedRegion !== tuple.region) {
+		variants.push({
+			id: "accent-folded",
+			raw: `${foldedLocality} ${tuple.postcode}, ${foldedRegion}, ${tuple.country}`,
+			components: { locality: foldedLocality, postcode: tuple.postcode, region: foldedRegion, country: tuple.country },
+		})
+	}
+
+	return variants
+}
+
+/**
+ * Emit bounded surface variants of the committed reviewed facts without constructing another geographic join.
+ */
+export const reviewedPostcodeTailRecipe: ShardRecipe = {
+	name: "reviewed-postcode-tail",
+	description: "Reviewed Venezuela locality-postcode-region tails with bounded surface variants",
+	mode: "generate",
+	async run(opts, write) {
+		const tuples = readReviewedPostcodeTuples(opts.input)
+		let emitted = 0
+		let skipped = 0
+
+		for (const tuple of tuples) {
+			for (const variant of reviewedPostcodeTailVariants(tuple)) {
+				const sourceID = shardSourceID(REVIEWED_POSTCODE_TAIL_SOURCE, { tuple: tuple.id, variant: variant.id })
+
+				const canonical = {
+					raw: variant.raw,
+					components: variant.components,
+					country: tuple.cc,
+					locale: tuple.locale,
+					source: REVIEWED_POSTCODE_TAIL_SOURCE,
+					source_id: sourceID,
+					corpus_version: "0.11.0",
+					license: `Synthetic rendering of reviewed postal facts — ${tuple.provenance.publisher}; source terms recorded in reviewed-ve-postcode-tuples.json`,
+				}
+
+				if (alignAndWrite(write, canonical, "reviewed-postcode-tail", tuple.id)) {
+					emitted++
+				} else {
+					skipped++
+				}
+			}
+		}
+
+		return { read: tuples.length, emitted, skipped }
+	},
+}

package/src/shard-recipes/scaffold.ts

@@ -13,29 +13,60 @@ import { existsSync } from "node:fs"
 
 import { readZipEntry } from "@mailwoman/core/fs/zip"
 import { tryParsingJSON } from "@mailwoman/core/objects"
-import { stableSourceID } from "@mailwoman/corpus/adapters/utils"
-import { alignRow } from "@mailwoman/corpus/utils"
 import type { PathBuilderLike } from "path-ts"
 import type { AsyncChunkIterator, AsyncDataResource } from "spliterator"
 import { AsyncSequence, CSVSpliterator } from "spliterator"
 
+import { stableSourceIDFromParts } from "#adapters/utils"
+import { alignRow } from "#utils"
+
 /**
- * {@link stableSourceID}, but accepting arbitrary disambiguator keys (e.g. a variant index `v`) that aren't
- * `ComponentTag`s. `stableSourceID` sorts + hashes EVERY key it's given, so passing extra keys is how the legacy
- * builders kept per-variant ids unique — the strict typing is just too narrow for that. Centralizes the one cast.
+ * {@link stableSourceIDFromParts} under the name the recipes use: arbitrary disambiguator keys (e.g. a variant index
+ * `v`) that aren't `ComponentTag`s, which is how the legacy builders kept per-variant ids unique.
  */
 export function shardSourceID(adapterID: string, parts: Record<string, string | undefined>): string {
-	return stableSourceID(adapterID, parts as unknown as Parameters<typeof stableSourceID>[1])
+	return stableSourceIDFromParts(adapterID, parts)
 }
 
+/**
+ * Where a country's convention writes the postcode inside the `«locality», «region»[, «country»]` admin tail.
+ *
+ * Load-bearing rather than cosmetic: the same digits change TAG with position. Measured on the shipped model,
+ * `Heladería Frappé Manía, Avenida Country Club, Barcelona 6001, Anzoátegui, Venezuela` tags `6001` as `house_number`
+ * and loses the locality into the street, while the identical row written `… 6001 Barcelona, Anzoátegui, Venezuela`
+ * tags it `postcode` and recovers `locality: Barcelona`. So a shard emitting one placement teaches one family of
+ * countries.
+ *
+ * Each is attested by a gauntlet board row, which is the bar for adding another:
+ *
+ * - `leading` — `«postcode» «locality», «region»`. `Rua da Praia, 15, 8600-315 Lagos, Algarve, Portugal`
+ *   (`pt_structured`). The default, and what every tuple written before this field existed means.
+ * - `after_locality` — `«locality» «postcode», «region»`. `…, Barcelona 6001, Anzoátegui, Venezuela`
+ *   (`ve_city_postcode_trailing_state`).
+ * - `after_region` — `«locality», «region» «postcode»`. `12 MG Road, Indiranagar, Bengaluru, Karnataka 560038, India`
+ *   (`in_structured`).
+ */
+export type PostcodePlacement = "leading" | "after_locality" | "after_region"
+
 /**
  * A (locality, region, postcode, country) source tuple — the input to tuples-mode recipes.
  */
 export interface ShardTuple {
 	locality?: string
+	/**
+	 * The segment before the locality, when the source has one. A shard whose every row BEGINS with the locality teaches
+	 * that the first named segment is the locality, which flips the model's default — measured on the v4.8.0 candidate,
+	 * where `Ye Three Lords, 27 Minories, London EC3N 1DE` came back `locality: "Ye Three Lords"`.
+	 */
+	dependentLocality?: string
 	region?: string
 	postcode?: string
 	country?: string
+	/**
+	 * Defaults to `leading` when absent, which is what every tuple file written before this field existed means — so an
+	 * old tuples file produces byte-identical rows.
+	 */
+	postcodePlacement?: PostcodePlacement
 	[k: string]: unknown
 }
 
@@ -266,7 +297,7 @@ export interface ShardRecipeOpts {
 	 * `sub-venue`: the `poi.db` spatial layer, read for the en-US and fr-FR venue + confound pools (the two of poi.db's
 	 * four countries this shard has legs for). Default `$MAILWOMAN_DATA_ROOT/poi/poi.db`.
 	 */
-	poiDb?: string
+	poiDB?: string
 	/**
 	 * `sub-venue`: GB/US/FR address-context tuples JSONL. Default the house-venue v3 tuples
 	 * (`$MAILWOMAN_DATA_ROOT/corpus/intermediate/house-venue-tuples-v3.jsonl`); DE and ES read OpenAddresses directly.

package/src/shard-recipes/street-affix.ts

@@ -38,9 +38,10 @@ import {
 } from "@mailwoman/codex/us"
 import type { ComponentTag } from "@mailwoman/core/types"
 import { dataRootPath } from "@mailwoman/core/utils"
-import { stableSourceID } from "@mailwoman/corpus/adapters/utils"
-import type { CanonicalRow } from "@mailwoman/corpus/types"
-import { alignRow } from "@mailwoman/corpus/utils"
+
+import { stableSourceID } from "#adapters/utils"
+import type { CanonicalRow } from "#types"
+import { alignRow } from "#utils"
 
 import { NAME_PRONE_US_SUFFIXES } from "../name-prone-us-suffixes.ts"
 import { makeMulberry32, readCSVRecords, readZippedCSVRecords, shardSourceID, type ShardRecipe } from "./scaffold.ts"

package/src/shard-recipes/street-bare.ts

@@ -17,9 +17,9 @@
  *   reproduces the legacy run byte-for-byte.
  */
 
-import { DEFAULT_US_BASES } from "@mailwoman/corpus/synthesizers/intersection"
-import { synthesizeStreetRow, type StreetBaseTuple } from "@mailwoman/corpus/synthesizers/street"
-import { alignRow } from "@mailwoman/corpus/utils"
+import { DEFAULT_US_BASES } from "#synthesizers/intersection"
+import { synthesizeStreetRow, type StreetBaseTuple } from "#synthesizers/street"
+import { alignRow } from "#utils"
 
 import { makeMulberry32, shardSourceID, type CanonicalShardRow, type ShardRecipe } from "./scaffold.ts"
 

package/src/shard-recipes/street.ts

@@ -7,8 +7,8 @@
  *   {@link synthesizeStreetRow} → aligned LabeledRow. Ported from scripts/build-street-shard.mjs.
  */
 
-import { stableSourceID } from "@mailwoman/corpus/adapters/utils"
-import { synthesizeStreetRow, type StreetBaseTuple } from "@mailwoman/corpus/synthesizers/street"
+import { stableSourceID } from "#adapters/utils"
+import { synthesizeStreetRow, type StreetBaseTuple } from "#synthesizers/street"
 
 import { alignAndWrite, makeLcg, readTuples, type ShardRecipe } from "./scaffold.ts"
 

package/src/shard-recipes/sub-venue-sources.ts

@@ -31,14 +31,15 @@ import { fileURLToPath } from "node:url"
 
 import { parseJSONStrict } from "@mailwoman/core/objects"
 import { dataRootPath } from "@mailwoman/core/utils"
-import type { LocaleBaseTuple } from "@mailwoman/corpus/synthesizers/german"
+
+import type { LocaleBaseTuple } from "#synthesizers/german"
 import {
 	classifyIdentifier,
 	readSubVenueJSONL,
 	type SubVenueLexiconTable,
 	SUBVENUE_PROMOTIONS,
 	type SubVenuePromotion,
-} from "@mailwoman/corpus/tools"
+} from "#tools"
 
 import { readTuples as readLocaleTuples, type LocalePart } from "./locale.ts"
 import { makeMulberry32, readTuples as readShardTuples } from "./scaffold.ts"
@@ -568,17 +569,6 @@ export const EMPTY_NAME_POOLS: NamePools = {
 	unpromotedShapes: [],
 }
 
-/**
- * An extract row, as `sub-venue-extract` writes it. `SubVenueHarvestRow` plus the `tier` the harvest does not need and
- * this recipe does: `venue` rows (station, airport, campus) fill the venue slot.
- */
-interface SubVenueExtractRow {
-	designatorID: string
-	tier?: string
-	name?: string | null
-	ref?: string | null
-}
-
 /**
  * What every pool reader needs to know about the leg it is reading for.
  */
@@ -602,7 +592,7 @@ function isLongerProperName(low: string, name: string, designatorPhrases: readon
  * Read one OSM extract and split it into name pools.
  */
 export function readExtractPools(path: string, query: PoolQuery): NamePools {
-	const rows = readSubVenueJSONL(path) as unknown as SubVenueExtractRow[]
+	const rows = readSubVenueJSONL(path)
 	const venues = new Set<string>()
 	const attested = new Set<string>()
 	const rejectedVenues = new Set<string>()

package/src/shard-recipes/sub-venue.ts

@@ -60,11 +60,13 @@
  *        `JP` key. The JP extract is harvested and ready; the leg belongs to the JP shard.
  */
 
+import { isPresent } from "@mailwoman/core/objects"
 import type { ComponentTag } from "@mailwoman/core/types"
 import { dataRootPath } from "@mailwoman/core/utils"
-import type { LocaleBaseTuple } from "@mailwoman/corpus/synthesizers/german"
-import type { SubVenueLexiconTable } from "@mailwoman/corpus/tools"
-import { alignRow } from "@mailwoman/corpus/utils"
+
+import type { LocaleBaseTuple } from "#synthesizers/german"
+import type { SubVenueLexiconTable } from "#tools"
+import { alignRow } from "#utils"
 
 import { makeMulberry32, shardSourceID, type ShardRecipe } from "./scaffold.ts"
 import {
@@ -374,7 +376,7 @@ export function renderGroups(
 
 	const raw = groups
 		.map((group) => group.map((piece) => fold(piece.text)).join(" "))
-		.filter(Boolean)
+		.filter(isPresent)
 		.join(separator)
 
 	const components: Partial<Record<ComponentTag, string>> = {}
@@ -826,13 +828,13 @@ function buildLegPools(
 	leg: SubVenueLeg,
 	query: PoolQuery,
 	contextByCountry: ReadonlyMap<string, LocaleBaseTuple[]>,
-	paths: { extractsDir: string; poiDb: string }
+	paths: { extractsDir: string; poiDB: string }
 ): LegPools {
 	const extractPools = leg.extract ? readExtractPools(`${paths.extractsDir}/${leg.extract}`, query) : EMPTY_NAME_POOLS
 
 	// poi.db holds four countries; only these two legs are inside it.
 	const poiPools =
-		leg.country === "US" || leg.country === "FR" ? readPOIPools(paths.poiDb, leg.country, query) : EMPTY_NAME_POOLS
+		leg.country === "US" || leg.country === "FR" ? readPOIPools(paths.poiDB, leg.country, query) : EMPTY_NAME_POOLS
 
 	const names = mergeNamePools(extractPools, poiPools)
 	let context = contextByCountry.get(leg.country) ?? []
@@ -906,7 +908,7 @@ export const subVenueRecipe: ShardRecipe = {
 		const count = opts.count
 		const negativeFraction = opts.negativeFraction ?? DEFAULT_NEGATIVE_FRACTION
 		const extractsDir = opts.extractsDir ?? dataRootPath("sub-venue", "extracts")
-		const poiDb = opts.poiDb ?? dataRootPath("poi", "poi.db")
+		const poiDB = opts.poiDB ?? dataRootPath("poi", "poi.db")
 		const tuplesPath = opts.subVenueTuples ?? dataRootPath("corpus", "intermediate", "house-venue-tuples-v3.jsonl")
 		const lexicon: SubVenueLexiconTable = readSubVenueLexicon(opts.lexicon ?? defaultLexiconPath())
 
@@ -937,7 +939,7 @@ export const subVenueRecipe: ShardRecipe = {
 				english: leg.english,
 			}
 
-			const pools = buildLegPools(leg, query, contextByCountry, { extractsDir, poiDb })
+			const pools = buildLegPools(leg, query, contextByCountry, { extractsDir, poiDB })
 
 			legPromoted.set(leg.locale, promoted)
 			legPools.set(leg.locale, pools)