@mailwoman/corpus 10.0.0 → 10.1.0

package/lib/pl/tools/fetch/emuia.ts

@@ -0,0 +1,360 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ * Harvests Poland's INSPIRE Addresses (AD) theme into the GML file that
+ * `#pl/adapters/emuia/adapter` reads.
+ *
+ * Główny Urząd Geodezji i Kartografii publishes the Państwowy Rejestr Granic through MapServer at
+ * {@linkcode PL_EMUIA_WFS}. Its dataset record states one condition of use in `otherConstraints`,
+ * `Brak warunków dostępu i użytkowania` — no conditions for access and use — which the
+ * address-source register elected. No license instrument is named, so the publisher's own words are
+ * the label, and that statement grants the reproduction a paged harvest performs.
+ *
+ * `#tools/fetch/wfs-harvest` owns the page read, the appending, the manifest and the resumption.
+ * What is particular to Poland is five measurements, taken on 2026-10-02:
+ *
+ * 1. `ms:AD.Address` is the only feature type the service publishes, and the payload is the Polish
+ *    register's own schema with every address value inline, so the harvest takes that one type and
+ *    resolves no reference.
+ * 2. The service serves GML and no JSON. Its `GetFeature` `outputFormat` parameter advertises four
+ *    values — `application/gml+xml; version=3.2`, `text/xml; subtype=gml/3.2.1`, `text/xml;
+ *    subtype=gml/3.1.1` and `text/xml; subtype=gml/2.1.2` — and answers with
+ *    `text/xml; subtype="gml/3.2.1"`.
+ * 3. A page holds at most 1,000 features whatever `count` asks for. `count=5000` answers
+ *    `numberReturned="1000"`, and the capabilities document states `CountDefault` as 1000. The page
+ *    size is therefore the service's cap rather than a choice, and a full harvest is one request per
+ *    thousand features.
+ * 4. The service states no count of its own. `resultType=hits` answers `numberMatched="1000"` both
+ *    bare and at `startIndex=1`, which is that same cap, and a feature page answers
+ *    `numberMatched="unknown"`. `readCheckedWFSFeatureCount` proves a reported count against a page
+ *    of the type, and a count equal to the page cap passes that check because no page can exceed the
+ *    cap — a 10-feature probe agrees with 1000. `statedFeatureCount` refuses a count equal to the
+ *    advertised `CountDefault` for that reason, so this service is harvested with no count and the
+ *    harvest ends on the first page that returns no features. The size is read from the service when
+ *    a caller asks for it, by `countWFSFeaturesByPaging`, and no count is written into this file.
+ * 5. The service honors a sort. `ImplementsSorting` is `TRUE`, `sortBy=ms:id` answers HTTP 200 and
+ *    `sortBy=ms:id D` returns the register's last rows first, which proves the parameter is applied.
+ *    `PagingIsTransactionSafe` is `FALSE`, which is the service stating that a paged sequence may
+ *    shift under edits made while it is being read. The sort bounds that shift to the rows whose
+ *    `ms:id` changed rather than leaving the whole sequence unordered.
+ *
+ * A measurement by paging rests on monotone presence: that an index holding a feature implies every
+ * smaller index holds one. A WFS offers no such guarantee, and a bisection over a service where it
+ * fails reports the first gap rather than the extent. The figure is therefore reported with the date
+ * it was taken, never stored as a constant: the register recorded 8,625,921 on 2026-10-01, and on
+ * 2026-10-02 `startIndex=8626950` returned one feature while `startIndex=8626951` returned none, so
+ * the service then held 8,626,951. That is 1,030 more than the day before, which is ordinary
+ * business for a municipal address register.
+ *
+ * At 1,000 features per page and 1,607,180 bytes per page, a full harvest at that size is 8,627
+ * requests and about 13.9 GB.
+ *
+ * The harvest assembles one GML document rather than one file per page, because the adapter opens
+ * `opts.inputPath` as a single markup stream. The first page's root tag opens the file with its
+ * namespace declarations kept and its per-page `numberReturned`, `numberMatched` and `timeStamp`
+ * dropped, since those describe one page and the manifest records them per page. The closing tag is
+ * written when the harvest reaches the end of the type, so a partial harvest is an unclosed document
+ * — which the adapter's scanner still reads member by member, and which a resumed run appends to
+ * after truncating back to the last page boundary.
+ */
+
+import { countWFSFeaturesByPaging, readCheckedWFSFeatureCount, type APIClient } from "@mailwoman/core/api"
+import type { PathBuilderLike } from "path-ts"
+
+import type { BaseFetchOptions, FetchSummary } from "#tools/fetch/download"
+import { readWFSCapabilities, type WFSCapabilities } from "#tools/fetch/inspire-addresses"
+import {
+	collectionOpeningTag,
+	harvestPagedWFS,
+	runWFSHarvest,
+	readWFSMarkupPage,
+	rootContent,
+	statedFeatureCount,
+	type FeatureCountStatement,
+	type HarvestedPayload,
+	type WFSHarvestManifest,
+} from "#tools/fetch/wfs-harvest"
+
+/**
+ * The service this module harvests.
+ */
+export const PL_EMUIA_WFS = "https://mapy.geoportal.gov.pl/wss/service/INSPIRE/Addresses"
+
+/**
+ * The one feature type the service publishes, spelled as its capabilities document spells it.
+ */
+export const PL_EMUIA_TYPE_NAME = "ms:AD.Address"
+
+/**
+ * The output format the harvest asks for, which is the first the service advertises.
+ */
+export const PL_EMUIA_OUTPUT_FORMAT = "application/gml+xml; version=3.2"
+
+/**
+ * The property the pages are ordered by.
+ */
+export const PL_EMUIA_SORT_BY = "ms:id"
+
+/**
+ * Features per page.
+ *
+ * The service's own cap rather than a choice: `count=5000` answers with 1,000 features,
+ * and the capabilities document states `CountDefault` as 1000.
+ */
+export const PL_EMUIA_PAGE_SIZE = 1000
+
+/**
+ * The file the adapter's `inputPath` points at, inside the harvest directory.
+ */
+export const PL_EMUIA_HARVEST_FILE = "address.gml"
+
+/**
+ * The XML declaration the assembled document opens with.
+ *
+ * The service's own pages declare UTF-8, and the harvest is written as UTF-8.
+ */
+const XML_DECLARATION = '<?xml version="1.0" encoding="UTF-8"?>\n'
+
+/**
+ * The adapter slug this module fetches for, and the directory it writes under.
+ */
+const SLUG = "emuia"
+
+/**
+ * Names the service in every refusal this module raises.
+ */
+const CONTEXT = "pl emuia wfs"
+
+/**
+ * The terms the address-source register elected for this publisher.
+ */
+const LICENSE = "Brak warunków dostępu i użytkowania"
+
+/**
+ * The spacing between requests.
+ *
+ * The service answers a 1,000-feature page in about 2 seconds and a page at a deep `startIndex`
+ * in about 6, so its own latency already spaces a serial harvest further apart than this.
+ * The interval is the ceiling a run is held to rather than the rate it achieves, and one
+ * request per second against a government host whose terms state no rate is the ceiling chosen.
+ */
+const MIN_REQUEST_INTERVAL_MS = 1000
+
+export interface HarvestEMUiAOptions {
+	/**
+	 * Where the harvest is written.
+	 *
+	 * The adapter reads {@linkcode PL_EMUIA_HARVEST_FILE} inside it.
+	 */
+	outputDir: PathBuilderLike
+	/**
+	 * Features per page, capped at {@linkcode PL_EMUIA_PAGE_SIZE} because the service caps it there.
+	 */
+	pageSize?: number
+	/**
+	 * Stop once the manifest holds this many pages, for a probe rather than a full harvest.
+	 */
+	maxPages?: number
+	/**
+	 * Measure the service's extent by paging before the harvest starts.
+	 *
+	 * Off by default.
+	 * The measurement costs about 2·log2(n) requests — 51 for a register of this size — and the
+	 * harvest does not need it: paging to the first empty page reads the type whole either way.
+	 *
+	 * It buys a denominator for the progress lines and a figure for the manifest,
+	 * and it rests on the monotone-presence assumption this module's header states.
+	 */
+	measureCount?: boolean
+	signal?: AbortSignal
+	report?: (line: string) => void
+}
+
+/**
+ * The count the service states, with how it was obtained.
+ *
+ * The service states none that can be used, so this reports why rather than
+ * carrying its page cap forward as a count.
+ * A caller that asked for {@linkcode HarvestEMUiAOptions.measureCount} gets the
+ * paged measurement instead, with the requests it cost.
+ */
+export async function readEMUiAFeatureCount(
+	client: Pick<APIClient, "fetch">,
+	options: { measureCount?: boolean; pageCap: number | null }
+): Promise<FeatureCountStatement> {
+	const stated = statedFeatureCount(
+		await readCheckedWFSFeatureCount(client, {
+			wfsURL: PL_EMUIA_WFS,
+			typeNames: PL_EMUIA_TYPE_NAME,
+			context: CONTEXT,
+		}),
+		options.pageCap
+	)
+
+	if (stated.count !== null) return stated
+
+	if (!options.measureCount) {
+		return {
+			count: null,
+			because: `${stated.because}, and the harvest ends on the first page that returns no features`,
+		}
+	}
+
+	const measured = await countWFSFeaturesByPaging(client, {
+		wfsURL: PL_EMUIA_WFS,
+		typeNames: PL_EMUIA_TYPE_NAME,
+		outputFormat: PL_EMUIA_OUTPUT_FORMAT,
+		context: CONTEXT,
+	})
+
+	return {
+		count: measured.count,
+		because: `${stated.because}, so the extent was measured by paging in ${measured.requests} requests, ${measured.confirmed ? "confirmed by a page straddling the last index" : "unconfirmed by the straddling page, which returned fewer features than the count implies"}, and the measurement assumes that an index holding a feature implies every smaller index holds one`,
+	}
+}
+
+/**
+ * What the service states about itself, with the three claims this harvest depends on checked.
+ *
+ * The type name and the output format are read from the document rather than taken
+ * from this file's constants, so a service that stops publishing either raises here
+ * instead of producing a harvest of something else.
+ *
+ * @throws When the service publishes no Addresses type, does not advertise the GML
+ * format the adapter reads, or does not advertise result paging.
+ */
+export async function readEMUiACapabilities(client: Pick<APIClient, "fetch">): Promise<WFSCapabilities> {
+	const capabilities = await readWFSCapabilities(client, { wfsURL: PL_EMUIA_WFS, context: CONTEXT })
+
+	if (!capabilities.typeNames.Address) {
+		throw new Error(
+			`${CONTEXT}: the capabilities document publishes no Addresses feature type, so ${PL_EMUIA_TYPE_NAME} could not be confirmed`
+		)
+	}
+
+	if (!capabilities.outputFormats.includes(PL_EMUIA_OUTPUT_FORMAT)) {
+		throw new Error(
+			`${CONTEXT}: the service does not advertise ${PL_EMUIA_OUTPUT_FORMAT}, which is the format the adapter reads — it advertises ${capabilities.outputFormats.join(", ")}`
+		)
+	}
+
+	if (!capabilities.supportsPaging) {
+		throw new Error(
+			`${CONTEXT}: the service does not advertise ImplementsResultPaging, and such a service answers every page with the first, so a paged harvest would store one page repeated`
+		)
+	}
+
+	return capabilities
+}
+
+/**
+ * Harvests the service into `options.outputDir` and writes the manifest beside the data file.
+ *
+ * @returns The manifest as written.
+ */
+export async function harvestEMUiAPL(
+	client: Pick<APIClient, "fetch">,
+	options: HarvestEMUiAOptions
+): Promise<WFSHarvestManifest> {
+	const capabilities = await readEMUiACapabilities(client)
+	const typeName = capabilities.typeNames.Address ?? PL_EMUIA_TYPE_NAME
+
+	const featureCount = await readEMUiAFeatureCount(client, {
+		measureCount: options.measureCount,
+		pageCap: capabilities.countDefault,
+	})
+
+	options.report?.(`  Feature count: ${featureCount.count ?? "not stated"} — ${featureCount.because}`)
+
+	return await harvestPagedWFS({
+		context: CONTEXT,
+		source: SLUG,
+		outputDir: options.outputDir,
+		filename: PL_EMUIA_HARVEST_FILE,
+		request: {
+			wfsURL: PL_EMUIA_WFS,
+			typeName,
+			outputFormat: PL_EMUIA_OUTPUT_FORMAT,
+			sortBy: PL_EMUIA_SORT_BY,
+		},
+		license: LICENSE,
+		// The elected statement names no attribution clause.
+		// Crediting GUGiK stays good practice.
+		attribution: "",
+		featureCount,
+		pageSize: Math.min(options.pageSize ?? PL_EMUIA_PAGE_SIZE, PL_EMUIA_PAGE_SIZE),
+		maxPages: options.maxPages,
+		signal: options.signal,
+		report: options.report,
+		readPage: async ({ startIndex, count }): Promise<HarvestedPayload> => {
+			const page = await readWFSMarkupPage(client, {
+				wfsURL: PL_EMUIA_WFS,
+				context: CONTEXT,
+				params: {
+					typeNames: typeName,
+					outputFormat: PL_EMUIA_OUTPUT_FORMAT,
+					sortBy: PL_EMUIA_SORT_BY,
+					count: String(count),
+					startIndex: String(startIndex),
+				},
+			})
+
+			return {
+				payload: rootContent(page.body, page.root, CONTEXT),
+				header: `${XML_DECLARATION}${collectionOpeningTag(page.root)}`,
+				footer: `</${page.root.name}>\n`,
+				numberReturned: page.numberReturned,
+				numberMatched: page.numberMatched,
+				retrievedAt: page.timeStamp,
+			}
+		},
+	})
+}
+
+export type FetchEMUiAPLOptions = BaseFetchOptions &
+	Pick<HarvestEMUiAOptions, "maxPages" | "measureCount" | "pageSize" | "signal"> & {
+		/**
+		 * An injected client, for a test that supplies its own transport.
+		 */
+		client?: Pick<APIClient, "fetch">
+	}
+
+/**
+ * Harvests Poland's addresses under `<outRoot>/emuia/`, for `mailwoman corpus fetch emuia-pl`.
+ *
+ * Re-runnable: a complete harvest whose file still hashes to the manifest's digest makes
+ * no request, and an interrupted one resumes at the page after the last that reached disk.
+ */
+export async function fetchEMUiAPL(
+	options: FetchEMUiAPLOptions,
+	report?: (line: string) => void
+): Promise<FetchSummary> {
+	// The service caps a page at 1,000, so a larger request is answered with 1,000 either way
+	// and the manifest records what was asked for rather than what arrived.
+	const pageSize = Math.min(options.pageSize ?? PL_EMUIA_PAGE_SIZE, PL_EMUIA_PAGE_SIZE)
+
+	return await runWFSHarvest(
+		{
+			slug: SLUG,
+			outRoot: options.outRoot,
+			filename: PL_EMUIA_HARVEST_FILE,
+			expect: { wfsURL: PL_EMUIA_WFS, sortBy: PL_EMUIA_SORT_BY, pageSize },
+			displayName: "pl-emuia",
+			minRequestIntervalMs: MIN_REQUEST_INTERVAL_MS,
+			client: options.client,
+			maxPages: options.maxPages,
+			harvest: async (client) =>
+				await harvestEMUiAPL(client, {
+					outputDir: options.outRoot(SLUG),
+					pageSize,
+					maxPages: options.maxPages,
+					measureCount: options.measureCount,
+					signal: options.signal,
+					report,
+				}),
+		},
+		report
+	)
+}

package/lib/recipes/anchor-absorption.ts

@@ -3,26 +3,29 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   `anchor-absorption` slice recipe (#220/#723, Probe A1) — self-generates `--count` rows from
- *   {@link synthesizeAnchorAbsorptionRow}'s 6-slice mix (CASE-H / CASE-P-us-rural / CASE-P-de /
- *   anchor-fp / locale-ambig / standard), aligns each to BIO, and emits a labeled JSONL. The
- *   LEADING 5-digit on CASE-H/anchor-fp/locale-ambig is sampled from the REAL US ZIPs in the
- *   postcode-anchor lookup, so the shaped-painted anchor fires on it exactly as inference does —
- *   teaching the model to OVERRIDE a present anchor from context. Ported from
- *   scripts/build-anchor-absorption-slice.mjs.
+ *   `anchor-absorption` recipe, a self-generated `--count`-row source built from
+ *   {@link synthesizeAnchorAbsorptionRow}'s six-template mix (case-H / case-P-us-rural / case-P-de /
+ *   anchor-fp / locale-ambig / standard), aligned to BIO and emitted as a labeled jsonl. The
+ *   leading 5-digit on case-H/anchor-fp/locale-ambig is sampled from the real US ZIPs in the
+ *   postcode-anchor lookup, so the shaped-painted anchor fires on it exactly as inference does.
  */
 
 import { dataRootPath } from "@mailwoman/core/data-root"
 import { readLocalJSONFile } from "@mailwoman/core/fs/readers"
+import { stringifyJSON } from "@mailwoman/core/json"
 import { makeLcg } from "@mailwoman/core/utils"
 import type { PathBuilderLike } from "path-ts"
 
-import { sliceSourceID, type CorpusRecipe } from "#recipes/scaffold"
+import { recipeSourceID, type CorpusRecipe } from "#recipes/scaffold"
+import { defaultRecipeSource } from "#recipes/sources"
 import { synthesizeAnchorAbsorptionRow } from "#synthesizers/anchor-absorption"
+import { SurfaceOrigin } from "#types"
 import { alignRow } from "#utils"
+
 /**
- * The leading-5-digit source: the real US ZIPs in the postcode anchor's pilot lookup. Resolved through the data-root
- * helper (the lab default is `$MAILWOMAN_DATA_ROOT`), never re-hardcoded.
+ * The leading-5-digit source: the real US ZIPs in the postcode anchor's pilot lookup.
+ *
+ * Resolved through the data-root helper (the lab default is `$MAILWOMAN_DATA_ROOT`), never re-hardcoded.
  */
 const ANCHOR_LOOKUP = dataRootPath("anchor", "pilot-anchor-lookup.json")
 
@@ -43,17 +46,18 @@ async function loadRealUsZips(path: PathBuilderLike): Promise<string[]> {
 }
 
 /**
- * Slice recipe registered with the corpus builder — see the file header for the parse behaviour it exists to exercise,
- * and `description` below for the surface form it generates.
+ * Recipe registered with the corpus builder.
+ *
+ * See the file header for the parse behavior it exercises.
+ * See `description` below for the generated surface form.
  */
 export const anchorAbsorptionRecipe: CorpusRecipe = {
 	name: "anchor-absorption",
-	description: "Anchor-absorption counter-augmentation (#220/#723): 6-slice mix → synthesizeAnchorAbsorptionRow",
+	description: "Anchor-absorption counter-augmentation (#220/#723): six-template mix → synthesizeAnchorAbsorptionRow",
 	mode: "generate",
 	async run(opts, write) {
-		// Emit PRNG: the legacy build-anchor-absorption-slice.mjs seeded an LCG (lcg(opts.seed)).
 		const random = makeLcg(opts.seed)
-		const source = opts.sourceName ?? "synth-anchor-absorption"
+		const source = opts.sourceName ?? defaultRecipeSource("synth-anchor-absorption")
 		const count = opts.count ?? 50_000
 		const realZips = await loadRealUsZips(ANCHOR_LOOKUP)
 
@@ -67,14 +71,13 @@ export const anchorAbsorptionRecipe: CorpusRecipe = {
 			const synth = synthesizeAnchorAbsorptionRow({ random, realZips })
 			const country = synth.locale.split("-")[1]
 
-			// "en-US" -> "US", "de-DE" -> "DE"
 			const canonical = {
 				raw: synth.raw,
 				components: synth.components,
 				country,
 				locale: synth.locale,
 				source,
-				source_id: sliceSourceID(source, { v: String(i) }),
+				source_id: recipeSourceID(source, { v: String(i) }),
 			}
 
 			const aligned = alignRow(canonical as Parameters<typeof alignRow>[0])
@@ -86,7 +89,15 @@ export const anchorAbsorptionRecipe: CorpusRecipe = {
 			}
 
 			write(
-				JSON.stringify({ ...aligned.row, synth_method: "anchor-absorption", synth_template: synth.template }) + "\n"
+				stringifyJSON({
+					...aligned.row,
+					recipe: "anchor-absorption",
+					template: synth.template,
+					// The components are drawn from weighted template tables rather than read from a
+					// register, so the row teaches the absorption shape and names no published address.
+					register: null,
+					surface: SurfaceOrigin.Invented,
+				})
 			)
 
 			written++
@@ -94,7 +105,7 @@ export const anchorAbsorptionRecipe: CorpusRecipe = {
 		}
 
 		console.error(`\nwrote ${written} rows (${quarantined} quarantined)`)
-		console.error("  by slice:", JSON.stringify(byTemplate))
+		console.error("  by template:", stringifyJSON(byTemplate))
 
 		return { emitted: written, skipped: quarantined }
 	},

package/lib/recipes/bare/country.ts

@@ -1,35 +1,27 @@
-/**
- * @copyright Sister Software
- * @license AGPL-3.0
- * @author Teffen Ellis, et al.
- *
- *   `bare-country` — the country name as the WHOLE query. Addresses almost never consist of one bare
- *   country name, so the class is out of the model's training distribution and the tag is a coin
- *   flip: measured on the 2026-08-13 panel, France/Germany/United States/New Zealand parsed
- *   `country` while Japan/China/Nigeria/Australia/Deutschland parsed `locality`. The retrieval-side
- *   bare-country race (#1651) covers the answer either way; this slice closes the PARSE half so the
- *   tag itself is right.
- *
- *   Source is the codex country table — every ISO canonical English name plus the curated surface
- *   forms (endonyms and long-form names). The 2–3 letter CODES are deliberately excluded: a bare
- *   `JP` or `GER` is an abbreviation register with its own ambiguity surface (`IN`, `DE`, `TO` are
- *   English words), and teaching it here would be an unmeasured claim. Case augmentation is the
- *   loader's job, as everywhere.
- */
-
 import { COUNTRY_SURFACE_FORMS, CountryNames, matchCountry } from "@mailwoman/codex/country"
 import { mulberry32 as makeMulberry32 } from "@mailwoman/core/utils"
 
-import { alignAndWrite, type CorpusRecipe, sliceSourceID } from "#recipes/scaffold"
+import { alignAndWrite, type CorpusRecipe, recipeSourceID } from "#recipes/scaffold"
+import { defaultRecipeSource } from "#recipes/sources"
+import { SourceRegister } from "#registers"
+import { SurfaceOrigin } from "#types"
+
 /**
- * Surfaces shorter than this are the code register (`JP`, `GER`), not a name — excluded (see the module doc).
+ * Resolved once, because `source_id` includes the source as its prefix and a pair
+ * that disagreed would name a source no row of this output declares.
  */
+const BARE_COUNTRY_SOURCE = defaultRecipeSource("synth-bare-country")
+
+const BARE_COUNTRY_PROVENANCE = {
+	register: SourceRegister.Codex,
+	surface: SurfaceOrigin.Attested,
+	// The codex table is the record.
+	// Its rows have no `source_id` of their own.
+	baseSourceID: null,
+}
+
 const MIN_NAME_LENGTH = 4
 
-/**
- * Every (surface, iso2) pair the slice emits: the ISO canonical names plus each country's curated surface forms,
- * deduplicated on the surface string (a form shared across countries — none known — would keep its first bearer).
- */
 function* bareCountrySurfaces(): Generator<{ surface: string; iso2: string }> {
 	const seen = new Set<string>()
 
@@ -52,15 +44,15 @@ function* bareCountrySurfaces(): Generator<{ surface: string; iso2: string }> {
 }
 
 /**
- * Slice recipe registered with the corpus builder — see the file header for the parse behaviour it exists to exercise,
- * and `description` below for the surface form it generates.
+ * Generates queries that consist only of a country name, drawn from ISO names
+ * and curated surface forms of at least four characters, with no country codes.
  */
 export const bareCountryRecipe: CorpusRecipe = {
 	name: "bare-country",
-	description: "The country name as the whole query (#1651 parse half): ISO names + curated endonyms, no codes",
+	description:
+		"Emits a country name as the whole query, drawn from ISO names and curated endonyms but never from country codes",
 	mode: "generate",
 	async run(opts, write) {
-		// Seeded for parity with the other recipes; the surfaces themselves drive the content.
 		makeMulberry32(opts.seed)
 		let read = 0
 		let emitted = 0
@@ -70,20 +62,20 @@ export const bareCountryRecipe: CorpusRecipe = {
 			read++
 
 			const components: Record<string, string> = { country: surface }
-			const source_id = sliceSourceID("synth-bare-country", { country: surface, cc: iso2, v: String(read) })
+			const source_id = recipeSourceID(BARE_COUNTRY_SOURCE, { country: surface, cc: iso2, v: String(read) })
 
 			const canonical = {
 				raw: surface,
 				components,
 				country: iso2,
 				locale: "und",
-				source: "synth-bare-country",
+				source: BARE_COUNTRY_SOURCE,
 				source_id,
 				corpus_version: "0.11.0",
 				license: "Synthetic — bare-country; surfaces from the codex country table (ISO 3166 + curated forms)",
 			}
 
-			if (alignAndWrite(write, canonical, "bare-country")) {
+			if (alignAndWrite(write, canonical, "bare-country", BARE_COUNTRY_PROVENANCE)) {
 				emitted++
 			} else {
 				skipped++

package/lib/recipes/bare/postcode/eval.ts

@@ -5,7 +5,7 @@
  *
  *   Reserved bare-postcode capability cases. These strings are excluded from every country in the
  *   training recipe and are read only by evaluation. Reservation is by normalized input string,
- *   because `NNN NN` is shared by CZ, SK, SE and GR; excluding a Czech row alone could still train
+ *   because `NNN NN` is shared by CZ, SK, SE and GR. excluding only a Czech row could still train
  *   the model on the identical Swedish input.
  */