@mailwoman/corpus 9.2.0 → 9.3.0

package/lib/tools/sub-venue/head-nouns.ts

@@ -0,0 +1,245 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   @file Head-noun derivation for the sub-venue lexicon — proposing the ADDRESSED form of a designator
+ *   from the encyclopaedic label a vocabulary source carries.
+ *
+ *   Wikidata's label for a concept is the encyclopaedic name (`terminal aeroportuaria`, `letištní
+ *   terminál`, `havalimanı terminali`), while the addressed form is the bare head (`Terminal`,
+ *   `Terminál`, `Terminali`). Nothing can promote the encyclopaedic form, so the head has to be
+ *   extracted before the curation pass has anything to decide about — that gap is why the first wave of
+ *   this table shipped 1,014 uncurated surfaces.
+ *
+ *   Everything derived lands `curated: false`. A derivation is a HYPOTHESIS about what the addressed
+ *   form is; a locale's own data is what confirms or kills it.
+ */
+
+import { isPresent } from "@mailwoman/core/objects"
+
+import type { SubVenueSurface } from "#tools/sub-venue/table"
+
+/**
+ * Diacritic-flattened ASCII fold, for comparing a Slavic or Turkish inflection against its Latin root.
+ *
+ * Deliberately `\p{Diacritic}` rather than `@mailwoman/normalize/fold`'s `stripCombiningMarks` (`\p{M}`): the two
+ * classes diverge outside plain diacritics, and {@link HEAD_NOUN_PREFIX_FLOOR} was calibrated against this exact fold.
+ */
+function asciiFold(text: string): string {
+	return text
+		.normalize("NFD")
+		.replaceAll(/\p{Diacritic}/gu, "")
+		.toLowerCase()
+}
+
+/**
+ * How many leading characters two ASCII-folded forms must share for one to count as the other's inflection.
+ *
+ * Five, or the id's own length when that is shorter (`hall`, `gate`, `wing`, `pier` are four). Measured against the
+ * committed Wikidata pull: at five, `terminal`/`terminál`/`terminale`/`terminali`/`terminála`/`terminalo` are all
+ * accepted for `terminal` while `campo` and `campws` are both rejected for `campus` (they share four). At six the
+ * Spanish `satélite` is lost; at four, Italian `campo` is admitted and it means FIELD.
+ */
+const HEAD_NOUN_PREFIX_FLOOR = 5
+
+/**
+ * The shortest substring a non-Latin head-noun candidate may be. Two: `航站` and `터미널` are both real, `楼` alone is
+ * "building" and would fire on every Chinese building name.
+ */
+const NON_LATIN_HEAD_MIN_LENGTH = 2
+
+/**
+ * How many head-noun candidates one non-Latin record+language group may contribute. Six — enough to carry `ターミナル`,
+ * `ターミナルビル` and `旅客ターミナル` together, capped because the substring lattice of a nine-character label is large and, ranked
+ * by attesting-surface count, nothing past the sixth has more than the minimum two.
+ */
+const NON_LATIN_HEAD_CANDIDATE_CAP = 6
+
+/**
+ * Latin-script test — the scripts an ASCII-folded prefix comparison against a Latin designator id can work on.
+ */
+const LATIN_PHRASE = /^[\p{Script=Latin}\d\s\p{P}]+$/u
+
+/**
+ * The scripts the shared-substring derivation is allowed to run on: Han, Hiragana, Katakana, Hangul.
+ *
+ * NARROWER than "not Latin", and the narrowing was earned. Run over every non-Latin phrase in the table, the derivation
+ * produced 90 fragments of Cyrillic, Greek, Arabic, Thai, Burmese and Tamil words — `сгра`, `град`, `κτίρ`,
+ * `ิ่งก่อสร้า` — because those languages have exactly one surface per concept and the only substrings shared inside a
+ * group are pieces of one word. Every one of them was unusable, and none could ever be counted: `poi.db` is four
+ * countries and this wave's extracts are GB, DE, FR, ES and JP, so nothing in reach attests a Thai or Burmese surface.
+ * Deriving a candidate no available source can confirm is not a hypothesis, it is table weight.
+ */
+const SHARED_SUBSTRING_SCRIPT = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u
+
+/**
+ * Derive the HEAD NOUN of every multi-part surface, so `terminal aeroportuaria` contributes the form anyone actually
+ * writes on an envelope.
+ *
+ * The problem this solves is the whole reason wave 1 shipped 1,014 uncurated surfaces: Wikidata's label for a concept
+ * is the ENCYCLOPAEDIC name (`terminal aeroportuaria`, `letištní terminál`, `havalimanı terminali`), while the
+ * addressed form is the bare head (`Terminal`, `Terminál`, `Terminali`). Nothing can promote the encyclopaedic form, so
+ * the head has to be extracted before the curation pass has anything to decide about.
+ *
+ * Two derivations, because the table holds two kinds of writing:
+ *
+ * - **Latin script — the COGNATE test.** A token is the head when its ASCII fold shares {@link HEAD_NOUN_PREFIX_FLOOR}
+ *   leading characters with the designator's own canonical id. Nothing subtler survived contact with the data: an
+ *   earlier version matched a token against any SINGLE-TOKEN surface of the record, and because Dutch `universiteit` is
+ *   a one-token surface of `campus`, it derived `universitario`, `universitaire`, `üniversite` and twenty more as head
+ *   nouns of `campus`. Those are the MODIFIER half of the label, and admitting them would have taught the harvest to
+ *   read "Ciudad Universitaria" as sub-venue structure.
+ * - **Non-Latin script — the SHARED-SUBSTRING test.** The cognate test cannot reach a script the id is not written in,
+ *   and for Han and Kana a token split finds nothing at all. So every substring of length ≥
+ *   {@link NON_LATIN_HEAD_MIN_LENGTH} occurring in at least two DISTINCT surfaces of the same record and primary
+ *   language becomes a candidate, ranked by how many surfaces carry it. Japanese yields `ターミナル` (in all five `ja`
+ *   terminal labels) ahead of `ターミナルビル` (three); Chinese yields `航站`, `航站楼`, `航站樓`. Where the script DOES space its
+ *   words (Korean, Greek, Cyrillic) a candidate must be a whole token, so `공항 터미널` ∩ `공항터미널` gives `터미널` and never a
+ *   fragment.
+ *
+ * The non-Latin branch deliberately emits SEVERAL candidates instead of picking one. Choosing between `航站` and `航站楼`
+ * from Wikidata alone is guesswork; the Japan extract answers it by counting, and the promotion ledger records which
+ * count won. Everything derived lands `curated: false` — the derivation is a hypothesis about what the addressed form
+ * is, and a locale's own data is what confirms or kills it.
+ */
+export function deriveHeadNounSurfaces(surfaces: readonly SubVenueSurface[]): SubVenueSurface[] {
+	const derived = new Map<string, SubVenueSurface>()
+	const seen = new Set(surfaces.map((s) => `${s.phrase}\0${s.recordID}\0${s.lang}`))
+
+	const emit = (phrase: string, from: SubVenueSurface): void => {
+		if (phrase === from.phrase) return
+
+		const key = `${phrase}\0${from.recordID}\0${from.lang}`
+
+		if (seen.has(key) || derived.has(key)) return
+
+		derived.set(key, {
+			phrase,
+			recordID: from.recordID,
+			recordKind: from.recordKind,
+			lang: from.lang,
+			region: "",
+			source: "derived:head-noun",
+			curated: false,
+			observations: 0,
+			context: {},
+		})
+	}
+
+	// ── Spacing scripts: prefix-match a token against a single-token surface of the same record ──────
+	// Latin script: a token that is a cognate of the designator's own canonical id.
+	for (const surface of surfaces) {
+		if (!LATIN_PHRASE.test(surface.phrase)) continue
+
+		const parts = surface.phrase.split(/[^\p{L}\p{N}]+/u).filter(isPresent)
+
+		if (parts.length < 2) continue
+
+		const root = asciiFold(surface.recordID)
+		const floor = Math.min(HEAD_NOUN_PREFIX_FLOOR, root.length)
+
+		for (const part of parts) {
+			const folded = asciiFold(part)
+
+			if (folded.length >= floor && commonPrefixLength(folded, root) >= floor) {
+				emit(part, surface)
+			}
+		}
+	}
+
+	// Non-Latin script: substrings shared by two or more surfaces of the same record + language.
+	const groups = new Map<string, Set<string>>()
+
+	for (const surface of surfaces) {
+		if (!SHARED_SUBSTRING_SCRIPT.test(surface.phrase)) continue
+
+		// Group `zh`, `zh-cn`, `zh-hant` together: they are writing systems for one vocabulary, and the
+		// simplified/traditional pair is exactly the evidence a shared substring needs.
+		const key = `${surface.recordID} ${surface.lang.split(/[-_]/u)[0]!}`
+		const pool = groups.get(key) ?? new Set<string>()
+		pool.add(surface.phrase)
+		groups.set(key, pool)
+	}
+
+	const candidatesByGroup = new Map<string, string[]>()
+
+	for (const [key, pool] of groups) {
+		if (pool.size < 2) continue
+		candidatesByGroup.set(key, sharedSubstringCandidates(pool))
+	}
+
+	for (const surface of surfaces) {
+		if (!SHARED_SUBSTRING_SCRIPT.test(surface.phrase)) continue
+
+		const key = `${surface.recordID} ${surface.lang.split(/[-_]/u)[0]!}`
+
+		for (const candidate of candidatesByGroup.get(key) ?? []) {
+			if (surface.phrase.includes(candidate)) {
+				emit(candidate, surface)
+			}
+		}
+	}
+
+	return [...derived.values()]
+}
+
+/**
+ * Length of the shared leading run of two strings.
+ */
+function commonPrefixLength(a: string, b: string): number {
+	const limit = Math.min(a.length, b.length)
+	let i = 0
+
+	while (i < limit && a[i] === b[i]) {
+		i++
+	}
+
+	return i
+}
+
+/**
+ * Substrings occurring in at least two DISTINCT members of `pool`, ranked by that count and then by length, capped at
+ * {@link NON_LATIN_HEAD_CANDIDATE_CAP}.
+ *
+ * A candidate never spans whitespace, and in a pool whose members contain whitespace a candidate must be a whole token
+ * of some member. That is what keeps Korean `공항 터미널` from contributing a fragment straddling the space.
+ *
+ * MAXIMAL candidates only: one contained in a longer candidate carried by the SAME number of surfaces is dropped, since
+ * counting can never separate the two. Every one of `ターミナル`'s five ja labels also contains `ターミ`, `ターミナ` and `ミナル`, so
+ * without this the group contributes four indistinguishable candidates and the Japan harvest returns four identical
+ * counts. `航站` survives next to `航站楼` because six surfaces carry it against that one's two.
+ */
+function sharedSubstringCandidates(pool: ReadonlySet<string>): string[] {
+	const phrases = [...pool]
+	const spaced = phrases.some((phrase) => /\s/u.test(phrase))
+	const tokens = spaced ? new Set(phrases.flatMap((phrase) => phrase.split(/\s+/u).filter(isPresent))) : null
+	const counts = new Map<string, number>()
+
+	for (const phrase of phrases) {
+		const local = new Set<string>()
+
+		for (let length = NON_LATIN_HEAD_MIN_LENGTH; length <= phrase.length; length++) {
+			for (let start = 0; start + length <= phrase.length; start++) {
+				const candidate = phrase.slice(start, start + length)
+
+				if (/\s/u.test(candidate)) continue
+				local.add(candidate)
+			}
+		}
+
+		for (const candidate of local) {
+			counts.set(candidate, (counts.get(candidate) ?? 0) + 1)
+		}
+	}
+
+	const kept = [...counts].filter(([candidate, count]) => count >= 2 && (!tokens || tokens.has(candidate)))
+
+	return kept
+		.filter(([candidate, count]) =>
+			kept.every(([other, otherCount]) => other === candidate || otherCount !== count || !other.includes(candidate))
+		)
+		.toSorted((a, b) => b[1] - a[1] || b[0].length - a[0].length || a[0].localeCompare(b[0]))
+		.slice(0, NON_LATIN_HEAD_CANDIDATE_CAP)
+		.map(([candidate]) => candidate)
+}

package/lib/tools/sub-venue/surfaces.ts

@@ -0,0 +1,95 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   @file Surface-form primitives for the sub-venue lexicon: the normalizer every phrase passes
+ *   through, the phrase → record index built over the surfaces accumulated so far, and the operator
+ *   that decides whether a feature's name contains a known designator.
+ *
+ *   The two matching rules here are script-conditional, and both narrowings are required — see
+ *   {@link NON_SPACING_SCRIPT} and {@link nameContainsSurfaces}.
+ */
+
+import type { SubVenueSurface } from "#tools/sub-venue/table"
+
+/**
+ * Scripts whose case is meaningful to fold. Everything else is left as written — see {@link SubVenueSurface.phrase}.
+ */
+const CASE_FOLDING_SCRIPT = /^[\p{Script=Latin}\p{Script=Cyrillic}\p{Script=Greek}\d\s\p{P}]+$/u
+
+/**
+ * Scripts written without spaces between words, where a token split cannot find a designator and a SUBSTRING test is
+ * the correct operator. Han, Hiragana, Katakana; Hangul is excluded because Korean does space its words.
+ *
+ * The Germanic-compound argument that keeps {@link nameContainsSurfaces} token-bounded for Latin script does not
+ * transfer here — there is no `-gate`/`-hall` street-name suffix class in Japanese, and `第1ターミナル` is unreachable by any
+ * token split. Measured on the Japan extract: see the harvest counts in `corpus/data/PROVENANCE.md`.
+ */
+const NON_SPACING_SCRIPT = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/u
+
+/**
+ * Normalize a surface for the table: trim, collapse internal whitespace, and lowercase ONLY when the string is entirely
+ * in a bicameral script. `ターミナルビル` and `航站楼` pass through untouched; `Flughafenterminal` folds.
+ */
+export function normalizeSurface(text: string): string {
+	const trimmed = text.trim().replaceAll(/\s+/gu, " ")
+
+	return CASE_FOLDING_SCRIPT.test(trimmed) ? trimmed.toLowerCase() : trimmed
+}
+
+/**
+ * A phrase → record index, keyed on the normalized phrase. Built by {@link buildSurfaceIndex} from the surfaces present
+ * before the harvest runs, and the reason a matched phrase can be attributed to the record it actually names.
+ */
+export type SurfaceIndex = ReadonlyMap<string, { recordID: string; recordKind: "designator" | "modifier" }>
+
+/**
+ * Index the surfaces accumulated so far by phrase. First writer wins, so a seed record beats a Wikidata alias that
+ * happens to collide — `terminal` stays the `terminal` designator even though it is also an Italian alias for it.
+ */
+export function buildSurfaceIndex(surfaces: readonly SubVenueSurface[]): SurfaceIndex {
+	const index = new Map<string, { recordID: string; recordKind: "designator" | "modifier" }>()
+
+	for (const surface of surfaces) {
+		if (index.has(surface.phrase)) continue
+		index.set(surface.phrase, { recordID: surface.recordID, recordKind: surface.recordKind })
+	}
+
+	return index
+}
+
+/**
+ * Every known phrase found in `name`, as whole-token runs for spacing scripts and as substrings for non-spacing ones.
+ *
+ * Token-boundary matching for Latin script, not substring: `Nordterminal` is a real German compound in which `terminal`
+ * is a suffix, and a substring test would also fire on `Terminalstraße`. The compound case is a genuine miss and it is
+ * the right miss — admitting suffix matches would fire on every `-hall`/`-gate` compound in Germanic and Nordic street
+ * naming, which is exactly the confound class `Briggate`/`Kirkgate` represents.
+ *
+ * For Han/Kana names that rule finds nothing at all, because the script has no word boundaries: `第1ターミナル` splits into
+ * one token that matches no surface. There the LONGEST known substring is the correct operator, and the compound
+ * objection does not transfer — Japanese has no `-gate` street-name suffix class.
+ */
+export function nameContainsSurfaces(name: string, index: SurfaceIndex): string[] {
+	const normalized = normalizeSurface(name)
+	const hits = new Set<string>()
+
+	for (const token of normalized.split(/[\s,()/]+/u)) {
+		const stripped = token.replaceAll(/^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu, "")
+
+		if (stripped && index.has(stripped)) {
+			hits.add(stripped)
+		}
+	}
+
+	if (NON_SPACING_SCRIPT.test(normalized)) {
+		for (const [phrase] of index) {
+			if (NON_SPACING_SCRIPT.test(phrase) && normalized.includes(phrase)) {
+				hits.add(phrase)
+			}
+		}
+	}
+
+	return [...hits]
+}

package/lib/tools/sub-venue/table.ts

@@ -0,0 +1,281 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   @file The sub-venue lexicon's record schema and the shipped vocabulary it is seeded from — the
+ *   emitted artifact's shape plus the designator, modifier and Wikidata-concept tables every build
+ *   starts out holding.
+ *
+ *   The shape follows `@mailwoman/poi-taxonomy`'s `taxonomy.json` idiom exactly — typed records plus a
+ *   FLAT phrase array keyed back to a record id, which is what makes a longest-match phrase index cheap
+ *   to build over it. {@link SubVenueSurface} is this table's `SynonymEntry`.
+ *
+ *   The seeds DUPLICATE `neural/venue-structure.ts` knowingly: `@mailwoman/corpus` does not depend on
+ *   `@mailwoman/neural` (the dependency runs the other way for the training path, and pulling
+ *   onnxruntime into a corpus build to read three string arrays would be absurd), so the shipped
+ *   vocabulary is re-declared here. That is a drift surface and it is stated rather than hidden —
+ *   `sub-venue-lexicon.test.ts` pins the seed's contents literally, so a change in either place fails a
+ *   test rather than passing silently.
+ */
+
+import type { SubVenuePromotion } from "#tools/sub-venue-promotions"
+
+/**
+ * This table's own data version. Bump when the source vintages or the build semantics change.
+ *
+ * `0.2.0` — wave 2: per-region attestation, the phrase-attribution fix (finding 3 above), derived head nouns, the
+ * Overture source, and the `promotions[]` receipts section.
+ */
+export const SUBVENUE_LEXICON_VERSION = "0.2.0"
+
+/**
+ * Which side of the containment relation a designator names. Mirrors `@mailwoman/osm/sdk`'s `SubVenueTier`; re-declared
+ * for the same dependency-direction reason as the seed.
+ */
+export const LexiconTier = {
+	SubVenue: "subvenue",
+	Venue: "venue",
+} as const
+
+export type LexiconTier = (typeof LexiconTier)[keyof typeof LexiconTier]
+
+/**
+ * One designator record — a venue-interior (or containing-venue) structural noun.
+ */
+export interface SubVenueDesignator {
+	/**
+	 * Canonical id, lowercase English. Matches `neural/venue-structure.ts`'s `VENUE_STRUCTURE_DESIGNATORS` wherever the
+	 * two overlap.
+	 */
+	id: string
+	tier: LexiconTier
+	/**
+	 * Whether this designator may be preceded by a {@link SubVenueModifier} — the `North Terminal` shape.
+	 *
+	 * A SUBSET, and the exclusions are required: `gate` and `building` form ordinary STREET names in exactly this shape
+	 * ("East Gate" is a real GB street, "Building Society Place" is a real street), so admitting them turns a correct
+	 * street parse into a sub-venue one. Setting this true means claiming no street is named `<modifier> <id>`. Check
+	 * before you do.
+	 */
+	modifierEligible: boolean
+	/**
+	 * Whether the shipped span proposer already recognizes this designator. `false` means the lexicon proposes it and
+	 * nothing consumes it yet.
+	 */
+	shipped: boolean
+	/**
+	 * Where the term comes from, one entry per attesting source: `wof:placetype`, `osm:aeroway=terminal`,
+	 * `wikidata:Q849706`, `overture:airport_terminal`. Sorted, so a regenerate is stable.
+	 */
+	provenance: string[]
+}
+
+/**
+ * One positional modifier — the `North`/`Upper`/`Main` half of `North Terminal`.
+ */
+export interface SubVenueModifier {
+	id: string
+	shipped: boolean
+	provenance: string[]
+}
+
+/**
+ * One surface form: a phrase, the record it names, and where it was attested.
+ *
+ * This is the table's `SynonymEntry` — the flat array a phrase index is built over.
+ */
+export interface SubVenueSurface {
+	/**
+	 * The phrase, lowercased for Latin-script languages and left as written otherwise — case-folding is meaningless for
+	 * Han and Kana, which the script guard excludes.
+	 *
+	 * It does NOT exclude Turkish: `İ` (U+0130) is `\p{Script=Latin}`, so the guard admits it and `toLowerCase` folds it
+	 * to `i` plus a combining dot above. A Turkish surface therefore round-trips through a form its own locale would not
+	 * write. Nothing shipped depends on that today; a Turkish designator would.
+	 */
+	phrase: string
+	/**
+	 * The {@link SubVenueDesignator.id} or {@link SubVenueModifier.id} this phrase is a surface of.
+	 */
+	recordID: string
+	/**
+	 * Which record table `recordID` points into.
+	 */
+	recordKind: "designator" | "modifier"
+	/**
+	 * BCP-47-ish language subtag as the source wrote it (`en`, `ja`, `zh-Hant`, `pt-BR`), or `und` when the source gave
+	 * an untagged default name.
+	 */
+	lang: string
+	/**
+	 * ISO 3166-1 alpha-2 of the DATA the phrase was attested in, `""` for vocabulary sources that attest a term's
+	 * existence rather than its use anywhere. This is the axis promotion is decided on: `hall` is attested 3,274 times in
+	 * `GB` and every promotion of it lives or dies on a per-region census, never a global one.
+	 */
+	region: string
+	/**
+	 * `wikidata:label`, `wikidata:alt`, `osm:name`, `osm:name:<lang>`, `overture:name`, `derived:head-noun`, or `seed`.
+	 */
+	source: string
+	/**
+	 * Whether a human has approved this surface for parsing use IN ITS REGION. Everything machine-derived starts `false`
+	 * and is flipped only by a matching {@link SubVenuePromotion}. A consumer that gates a parse MUST filter on this — see
+	 * `sub-venue-lexicon.ts`'s module docstring for what a promotion decides and why it is per-locale.
+	 */
+	curated: boolean
+	/**
+	 * How many source features attested this exact phrase, when the source counts (OSM, Overture). `0` for vocabulary
+	 * sources, which attest a term's EXISTENCE rather than its frequency.
+	 */
+	observations: number
+	/**
+	 * The rule-assigned designator of the FEATURES that carried this phrase, with a count each — `platform:3205
+	 * campus:49` for GB's `hall`. Empty for vocabulary sources.
+	 *
+	 * This is the confound axis. A `hall` on a `platform` row is a British bus stop named after a village hall; a `hall`
+	 * on a `terminal` row is a real German departure hall. Without it, a surface's `observations` count is a magnitude
+	 * with no sign — see the repo's "meaning of zero" rule, which applies just as hard to a large number.
+	 */
+	context: Record<string, number>
+}
+
+/**
+ * The measured shape of a designator's identifier half — what follows `Gate`/`Terminal` in real data.
+ *
+ * Derived from OSM `ref` values, NOT from names, and that is why the artifact has a section for it at all. Every one of
+ * Berlin's 26 `aeroway=gate` features is unnamed and carries only a `ref`: `13`, `6`, `0/1`, `14/15`, `16-18`. So `Gate
+ * A12` is a RENDERING (`<designator> <ref>`) rather than a string anyone has written down, and a slice that wants to
+ * generate the designator+identifier form needs the identifier DISTRIBUTION, not a list of phrases.
+ */
+export interface IdentifierShape {
+	designatorID: string
+	/**
+	 * ISO 3166-1 alpha-2 of the extract this distribution was measured in. Per-region because the shapes differ: GB gates
+	 * are 70% bare digits, Japanese platform refs are overwhelmingly bare digits with a different range, and a slice that
+	 * generates `Gate <ref>` for a French address should sample France's distribution.
+	 */
+	region: string
+	/**
+	 * A coarse class: `digit` (`5`), `letter` (`B`), `letter-digit` (`A12`), `digit-letter` (`2F`), `range` (`16-18`,
+	 * `0/1`), or `other`.
+	 */
+	shape: string
+	observations: number
+	/**
+	 * Up to eight real values, sorted, so a slice author can see what the class actually contains.
+	 */
+	examples: string[]
+}
+
+/**
+ * One input source's provenance, copied off its fetch manifest.
+ */
+export interface SubVenueLexiconSource {
+	id: string
+	origin: string
+	license: string
+	retrieved: string
+	rows: number
+}
+
+/**
+ * The committed table.
+ */
+export interface SubVenueLexiconTable {
+	version: string
+	sources: SubVenueLexiconSource[]
+	designators: SubVenueDesignator[]
+	modifiers: SubVenueModifier[]
+	surfaces: SubVenueSurface[]
+	identifierShapes: IdentifierShape[]
+	/**
+	 * Every curation decision taken against this table, promotion AND rejection, each with the census that backs it. A
+	 * rejection is as required as a promotion: it is what stops the next reader re-proposing `hall` for en-GB.
+	 */
+	promotions: SubVenuePromotion[]
+}
+
+/**
+ * The vocabulary that already ships in `neural/venue-structure.ts`, re-declared. See the module docstring for why this
+ * duplication exists.
+ *
+ * `tier` is added here (the shipped list has no such field): the seven WOF placetypes plus `terminal`/`gate` are all
+ * venue-INTERIOR, except `campus` and `building`, which name a whole venue as often as a part of one. They are marked
+ * `subvenue` anyway, because that is the role the span proposer uses them in — `Building 43, Googleplex` is a unit
+ * inside a venue.
+ */
+export const SHIPPED_DESIGNATOR_SEED: ReadonlyArray<{
+	id: string
+	modifierEligible: boolean
+	provenance: string[]
+}> = [
+	{ id: "arcade", modifierEligible: true, provenance: ["wof:placetype"] },
+	{ id: "building", modifierEligible: false, provenance: ["wof:placetype"] },
+	{ id: "campus", modifierEligible: true, provenance: ["wof:placetype"] },
+	{ id: "concourse", modifierEligible: true, provenance: ["wof:placetype"] },
+	{ id: "enclosure", modifierEligible: false, provenance: ["wof:placetype"] },
+	{ id: "gate", modifierEligible: false, provenance: ["osm:aeroway=gate"] },
+	{ id: "installation", modifierEligible: false, provenance: ["wof:placetype"] },
+	{ id: "terminal", modifierEligible: true, provenance: ["osm:aeroway=terminal"] },
+	{ id: "wing", modifierEligible: true, provenance: ["wof:placetype"] },
+]
+
+/**
+ * The shipped positional modifiers, re-declared from `neural/venue-structure.ts`'s `VENUE_STRUCTURE_MODIFIERS`.
+ */
+export const SHIPPED_MODIFIER_SEED: readonly string[] = [
+	"central",
+	"east",
+	"front",
+	"inner",
+	"lower",
+	"main",
+	"north",
+	"outer",
+	"rear",
+	"south",
+	"upper",
+	"west",
+]
+
+/**
+ * Designators the lexicon ADDS beyond what ships, each with the source that attests it.
+ *
+ * `platform`, `station` and `airport` come from the OSM extractor's rule table and are the rail/aviation venue-side
+ * vocabulary the corpus line needs. `hall` and `satellite` come from Wikidata concepts and from
+ * `wof-osm-placetype-map.mdx`'s own "plausible additions" note, which lists `hall` explicitly. `pier` joins them in
+ * wave 2 on 282 Overture attestations in the `pier` category plus 162 in the GB extract — the corpus task names `Pier
+ * C` as a target shape, so the record has to exist before a slice can generate it.
+ *
+ * None is `modifierEligible`: that claim needs a confound board per term AND per locale, and `sub-venue-promotions.ts`
+ * is where those live. A promotion marks a SURFACE usable; it does not widen the modifier grammar.
+ */
+export const PROPOSED_DESIGNATORS: ReadonlyArray<{
+	id: string
+	tier: LexiconTier
+	provenance: string[]
+}> = [
+	{ id: "airport", tier: LexiconTier.Venue, provenance: ["osm:aeroway=aerodrome"] },
+	{ id: "hall", tier: LexiconTier.SubVenue, provenance: ["wikidata:Q240854"] },
+	{ id: "pier", tier: LexiconTier.SubVenue, provenance: ["overture:pier"] },
+	{ id: "platform", tier: LexiconTier.SubVenue, provenance: ["osm:public_transport=platform", "osm:railway=platform"] },
+	{ id: "satellite", tier: LexiconTier.SubVenue, provenance: ["wikidata:Q15990706"] },
+	{ id: "station", tier: LexiconTier.Venue, provenance: ["osm:railway=station"] },
+]
+
+/**
+ * `designatorID` → Wikidata QID, mirroring `fetch/wikidata-subvenue.ts`'s `SUBVENUE_CONCEPTS`. Re-declared here so the
+ * builder stays a pure function over PARSED input rather than reaching into a fetch module for a constant; the test
+ * pins the two against each other.
+ */
+export const CONCEPT_QIDS: Readonly<Record<string, string>> = {
+	terminal: "Q849706",
+	gate: "Q247739",
+	concourse: "Q862212",
+	campus: "Q209465",
+	building: "Q41176",
+	arcade: "Q186637",
+	hall: "Q240854",
+	satellite: "Q15990706",
+}