@mailwoman/corpus 10.6.0 → 10.7.0

package/lib/im/adapters/land-registry/adapter.ts

@@ -0,0 +1,340 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ * `landregistry-im`: the property addresses of the Isle of Man Land Registry's land transactions, which the
+ * Isle of Man Government publishes on gov.im as one CSV of every registered sale since 2000.
+ *
+ * Each row is a sale, so one property appears once per sale. The adapter emits each distinct address
+ * once, comparing the emitted components case-folded and keeping the first. It reads only the address
+ * columns and never the price or date columns.
+ *
+ * `SubUnit_Name` is the flat or apartment (`Flat 2`, `Apartment 5`), `House_Number` the door number,
+ * `House_Name` the house's given name (`Ballacain Farm`) or the building's (`Spectrum Apartments`),
+ * `Street_Name` the street, `Locality` the estate or village inside the town, and `Town` the post town.
+ * The IM layout prints no region, so `Parish_` is not read.
+ *
+ * The register also records sales of land that has no postal address. Such a row describes the land
+ * (`Field North Of Ballawhannel Farm`, `Parcel Of Land`, `Land Adjacent To Mostyn Ville`) in place of
+ * naming a property, and the adapter refuses it, as it refuses a garage, a parking space or a substation
+ * sold on its own.
+ *
+ * The Isle of Man Government publishes the dataset under the Isle of Man Open Government Licence, which
+ * requires the attribution statement below. Every row records that license.
+ */
+
+import { formatAddressRow } from "@mailwoman/codex/address/format"
+import { matchCountryPostcode } from "@mailwoman/codex/postcode/country-formats"
+import { readLocalBuffer } from "@mailwoman/core/fs/readers"
+import { resolvePath } from "path-ts"
+import { CSVSpliterator } from "spliterator"
+
+import { UnsupportedCountryError } from "#adapters/errors"
+import { stableSourceIDFromParts } from "#adapters/source-id"
+import { SourceRegister } from "#registers"
+import {
+	AddressRole,
+	type AdapterOptions,
+	type CanonicalRow,
+	type CorpusAdapter,
+	countDropped,
+	SurfaceOrigin,
+} from "#types"
+
+/**
+ * Registry id for this adapter, stamped into every row it emits.
+ */
+export const LANDREGISTRY_IM_ADAPTER_ID = "landregistry-im"
+
+/**
+ * The Isle of Man Open Government Licence, whose version the dataset page does not state.
+ * It has no SPDX identifier.
+ */
+export const LANDREGISTRY_IM_LICENSE = "LicenseRef-IM-OGL"
+
+/**
+ * The attribution statement the license requires.
+ */
+export const LANDREGISTRY_IM_ATTRIBUTION =
+	"Contains public sector information licensed under the Isle of Man Open Government Licence"
+
+/**
+ * Every jurisdiction this adapter emits, checked against a caller's `--country`.
+ */
+export const LANDREGISTRY_IM_COUNTRIES: readonly string[] = ["IM"]
+
+/**
+ * The address columns the adapter reads from the land transactions CSV.
+ * The price and date columns are not read.
+ */
+export interface IsleOfManLandTransactionRecord {
+	SubUnit_Name: string
+	House_Number: string
+	House_Name: string
+	Street_Name: string
+	Locality: string
+	Town: string
+	Postcode: string
+}
+
+function present(value: string | undefined): string | null {
+	const trimmed = value?.replaceAll(/\s+/gu, " ").trim() ?? ""
+
+	return trimmed || null
+}
+
+/**
+ * A value that describes a piece of land rather than naming a property: it opens with the kind
+ * of land (`Land`, `Plot Of Land`, `Field Number 111277`, `Part Of The Estate`, `25.2 Acres Of Land`)
+ * or places it against another property (`Abutting`, `Adjacent To`, `Rear Of`, `Known As`).
+ */
+const LAND_DESCRIPTION =
+	/^(?:(?:a|the)\s+)?(?:lands?|plots?|parcels?|fields?|part|strip|portion|[\d.]+\s+acres?)\b|\b(?:abutting|adjacent|adjoining|adjoins|rear\s+off?|part\s+of|known\s+as|formerly|situate|being\s+part|close\s+to|near|nr)\b/iu
+
+/**
+ * In a flat or house name, a land word anywhere marks a description
+ * (`Riverside Cottage And Land`, `Two Fields At`, `Agricultural Land`),
+ * where in a street or locality it may be part of the name.
+ */
+const LAND_WORD = /\b(?:lands?|fields?|plots?|acres?)\b/iu
+
+/**
+ * A value that describes a structure or a share sold apart from any dwelling,
+ * which has no postal address of its own.
+ */
+const NOT_A_PREMISE =
+	/^(?:(?:a|the)\s+)?(?:garages?|lock[- ]?ups?|stores?|car\s+park(?:ing)?|forecourt|roadway|access\s+roads?|lane)\b|\b(?:site|substation|reservoir|parking|driveway|pumping\s+station|private\s+(?:roadway|road|drive|lane|access)|(?:common|shared|landscaped)\s+areas?|share\s+(?:in|of))\b/iu
+
+/**
+ * A house name that joins two properties (`Gorse Cottage And Willow Cottage`, `"Hawarden" And "Far End"`)
+ * records a sale of several premises at once.
+ */
+const SEVERAL_PROPERTIES = /\band\b|&/iu
+
+/**
+ * A house name that opens with a door number (`15 Godred Court`) holds a number
+ * and a secondary street rather than a property name.
+ */
+const LEADING_NUMBER = /^\d/u
+
+/**
+ * The flat designators `SubUnit_Name` holds that a single dwelling is written with.
+ */
+const UNIT_DESIGNATOR =
+	/^(?:(?:flat|apartment|apt\.?|unit|penthouse|suite|studio|maisonette)\s*[A-Z]?\d+[A-Z]?|(?:garden|basement|ground\s+floor|first\s+floor|top\s+floor|upper|lower)\s+(?:flat|apartment))$/iu
+
+/**
+ * A door number, with an optional letter, or a range of two.
+ */
+const HOUSE_NUMBER = /^\d+[A-Z]?(?:\s*-\s*\d+[A-Z]?)?$/iu
+
+/**
+ * A second-line value that is a thoroughfare (`Main Road`, `Off Clifton Drive`) rather than a place.
+ */
+const THOROUGHFARE =
+	/^off\b|\b(?:road|street|lane|avenue|drive|promenade|terrace|crescent|quay|way|close|parade|square)$/iu
+
+/**
+ * Maps one record onto the components the corpus asserts, or returns null when the row is refused.
+ *
+ * Each refusal and each dropped component increments its reason in `dropped`.
+ */
+export function componentsForIsleOfManLandTransactionRecord(
+	record: IsleOfManLandTransactionRecord,
+	dropped?: Pick<AdapterOptions, "dropped">
+): CanonicalRow["components"] | null {
+	const tally = dropped ?? {}
+	const subunit = present(record.SubUnit_Name)
+	const name = present(record.House_Name)
+	const street = present(record.Street_Name)
+	const dependent = present(record.Locality)
+
+	if (
+		[subunit, name, street, dependent].some((value) => value && LAND_DESCRIPTION.test(value)) ||
+		[subunit, name].some((value) => value && LAND_WORD.test(value))
+	) {
+		countDropped(tally, "row:land-parcel-description")
+
+		return null
+	}
+
+	if ([subunit, name].some((value) => value && NOT_A_PREMISE.test(value))) {
+		countDropped(tally, "row:not-a-premise")
+
+		return null
+	}
+
+	if (name && SEVERAL_PROPERTIES.test(name)) {
+		countDropped(tally, "row:several-properties")
+
+		return null
+	}
+
+	if (!street) {
+		countDropped(tally, "row:no-street")
+
+		return null
+	}
+
+	const components: CanonicalRow["components"] = { street }
+	const number = present(record.House_Number)
+
+	if (number && HOUSE_NUMBER.test(number)) {
+		components.house_number = number.replaceAll(/\s*-\s*/gu, "-")
+	} else if (number) {
+		// `9/11`, `3 & 5` and `Unit 4` name several doors or a unit rather than one door number.
+		countDropped(tally, "component:house_number:not-one-number")
+	}
+
+	if (subunit && UNIT_DESIGNATOR.test(subunit)) {
+		components.unit = subunit
+	} else if (subunit) {
+		// `Apartment 4 and Garage 4` and a bare `7` do not name one dwelling the layout can print.
+		countDropped(tally, "component:unit:not-a-unit-designator")
+	}
+
+	if (name && UNIT_DESIGNATOR.test(name)) {
+		// A flat recorded in the house-name column (`Apartment 9`) is the unit when the unit column is empty.
+		if (components.unit) {
+			countDropped(tally, "component:venue:unit-designator")
+		} else {
+			components.unit = name
+		}
+	} else if (name && LEADING_NUMBER.test(name)) {
+		countDropped(tally, "component:venue:holds-a-number")
+	} else if (name && /\p{L}{3}/u.test(name)) {
+		components.venue = name
+	} else if (name) {
+		countDropped(tally, "component:venue:code")
+	}
+
+	if (!components.house_number && !components.venue) {
+		countDropped(tally, "row:no-house-number-or-name")
+
+		return null
+	}
+
+	const town = present(record.Town)
+
+	if (town) {
+		components.locality = town
+	}
+
+	if (dependent && THOROUGHFARE.test(dependent)) {
+		countDropped(tally, "component:dependent_locality:thoroughfare")
+	} else if (dependent && dependent.toLowerCase() === town?.toLowerCase()) {
+		countDropped(tally, "component:dependent_locality:repeats-locality")
+	} else if (dependent) {
+		components.dependent_locality = dependent
+	}
+
+	const postcode = present(record.Postcode)?.toUpperCase()
+	const matched = postcode ? matchCountryPostcode(postcode, "IM") : null
+
+	if (matched) {
+		components.postcode = matched
+	} else if (postcode) {
+		countDropped(tally, "component:postcode:not-country-format")
+	}
+
+	if (!components.locality && !components.postcode) {
+		countDropped(tally, "row:no-locality-or-postcode")
+
+		return null
+	}
+
+	return components
+}
+
+/**
+ * The case-folded key two sales of one property share.
+ */
+function addressKey(components: CanonicalRow["components"]): string {
+	return Object.keys(components)
+		.toSorted()
+		.map((tag) => `${tag}=${components[tag as keyof typeof components]?.toLowerCase() ?? ""}`)
+		.join("\u001F")
+}
+
+export function createIsleOfManLandRegistryAdapter(): CorpusAdapter {
+	return {
+		id: LANDREGISTRY_IM_ADAPTER_ID,
+		defaultLicense: LANDREGISTRY_IM_LICENSE,
+		addressRole: AddressRole.Premise,
+		register: SourceRegister.IsleOfManLandTransactions,
+		surface: SurfaceOrigin.Rendered,
+		description: "Isle of Man Land Registry land transactions (gov.im): the addresses of registered property sales.",
+
+		async *rows(opts: AdapterOptions): AsyncIterable<CanonicalRow> {
+			if (opts.country && !LANDREGISTRY_IM_COUNTRIES.includes(opts.country)) {
+				throw new UnsupportedCountryError(LANDREGISTRY_IM_ADAPTER_ID, LANDREGISTRY_IM_COUNTRIES, opts.country)
+			}
+
+			// The file is 4 MB, so it is decoded whole.
+			// The BOM would otherwise prefix the first header.
+			const text = (await readLocalBuffer(resolvePath(opts.inputPath))).toString("utf8").replace(/^/u, "")
+
+			const records = CSVSpliterator.from<IsleOfManLandTransactionRecord>(Buffer.from(text, "utf8"), {
+				normalizeKeys: false,
+			})
+
+			const seen = new Set<string>()
+			let emitted = 0
+
+			for (const record of records) {
+				if (opts.signal?.aborted) return
+
+				if (opts.limit !== undefined && emitted >= opts.limit) return
+
+				const components = componentsForIsleOfManLandTransactionRecord(record, opts)
+
+				if (!components) continue
+
+				const key = addressKey(components)
+
+				if (seen.has(key)) {
+					countDropped(opts, "row:repeat-sale")
+
+					continue
+				}
+
+				seen.add(key)
+
+				const rendered = formatAddressRow(components, "IM", { singleLine: true })
+
+				if (!rendered) {
+					countDropped(opts, "row:render-failed")
+
+					continue
+				}
+
+				for (const tag of rendered.unplaced) {
+					countDropped(opts, `component:${tag}:not-rendered`)
+				}
+
+				const { raw, components: aligned } = rendered
+
+				yield {
+					raw,
+					components: aligned,
+					country: "IM",
+					locale: "en-IM",
+					source: LANDREGISTRY_IM_ADAPTER_ID,
+					// The file carries no record id or coordinates, and the dedupe above leaves
+					// one row per distinct address, so the components identify the row.
+					source_id: stableSourceIDFromParts(LANDREGISTRY_IM_ADAPTER_ID, aligned),
+					corpus_version: "",
+					license: LANDREGISTRY_IM_LICENSE,
+				}
+
+				emitted++
+			}
+		},
+	}
+}
+
+/**
+ * The configured adapter instance registered with the corpus builder.
+ */
+export const isleOfManLandRegistryAdapter = createIsleOfManLandRegistryAdapter()

package/lib/international/recipes/locale.ts

@@ -9,6 +9,7 @@
 
 import { COUNTRY_SURFACE_FORMS } from "@mailwoman/codex/country"
 import { dataRootPath } from "@mailwoman/core/data-root"
+import { pathExists } from "@mailwoman/core/fs/readers/stat"
 import { openReadStream } from "@mailwoman/core/fs/streams"
 import { readZipEntry } from "@mailwoman/core/fs/zip"
 import { stringifyJSON } from "@mailwoman/core/json"
@@ -16,10 +17,12 @@ import { isPresent } from "@mailwoman/core/objects"
 import { sample } from "@mailwoman/core/random"
 import { mulberry32 as makeMulberry32 } from "@mailwoman/core/utils"
 import type { PathBuilderLike } from "path-ts"
-import { CSVSpliterator } from "spliterator"
+import { CSVSpliterator, JSONSpliterator } from "spliterator"
 
 import { stableSourceID } from "#adapters/source-id"
+import { GB_OS_OPEN_ADAPTER_ID, gbOSOpenCanonicalRowsPath } from "#gb/adapters/os-open/adapter"
 import { openConstituentCountryReader } from "#gb/constituent-country"
+import { readCountyOfPostcode } from "#gb/county"
 import type { CorpusRecipe } from "#recipes/scaffold"
 import { defaultRecipeSource } from "#recipes/sources"
 import { SourceRegister } from "#registers"
@@ -28,12 +31,26 @@ import { SurfaceOrigin } from "#types"
 import { alignRow } from "#utils"
 
 /**
- * One source file: either a CSV member of a ZIP (`zip` and `csv`) or an extracted CSV (`path`).
+ * One source file: a CSV member of a ZIP (`zip` and `csv`), an extracted CSV (`path`),
+ * or an adapter's canonical rows (`canonicalRows`).
  */
 export interface LocalePart {
 	zip?: PathBuilderLike
 	csv?: string
 	path?: PathBuilderLike
+	/**
+	 * An adapter's `canonical.jsonl`, read in place of a CSV.
+	 *
+	 * Each row's `components` supplies the house number, street, locality and postcode.
+	 * Every row must carry {@linkcode LocalePart.canonicalSource} as its `source`.
+	 */
+	canonicalRows?: PathBuilderLike
+	/**
+	 * The `source` every row of {@linkcode LocalePart.canonicalRows} must carry.
+	 *
+	 * A row from any other source throws, so a file another adapter wrote is never read as this one.
+	 */
+	canonicalSource?: string
 	region?: string
 	/**
 	 * Maps the district column to locality and the city column to dependent locality.
@@ -51,9 +68,32 @@ export interface LocalePart {
 	/**
 	 * Opens a reader that answers the row's region from its postcode, replacing the region column.
 	 *
-	 * A GB part answers the constituent country this way, and its county column is not read.
+	 * A GB part answers the county or the constituent country this way.
 	 */
-	regionOfPostcode?: () => (postcode: string) => string | null
+	regionOfPostcode?: () => Promise<(postcode: string) => string | null>
+}
+
+/**
+ * The share of GB postcodes whose rows label the county `region`, out of five.
+ *
+ * The other postcodes' rows label the constituent country, which Who's On First
+ * records as a `macroregion` under the United Kingdom.
+ */
+const GB_COUNTY_REGION_FIFTHS = 4
+
+/**
+ * Whether a GB postcode's rows label the county rather than the constituent country.
+ *
+ * The choice is a function of the postcode alone, so a rebuild makes the same choice for every row.
+ */
+function gbPostcodeTakesCounty(postcode: string): boolean {
+	let sum = 0
+
+	for (const char of postcode) {
+		sum += char.codePointAt(0)!
+	}
+
+	return sum % 5 < GB_COUNTY_REGION_FIFTHS
 }
 
 /**
@@ -70,6 +110,12 @@ export interface LocaleCountrySource {
 	 * The corpus version written to each row.
 	 */
 	corpusVersion: string
+	/**
+	 * The dataset and terms the row's `license` names, before the rendering order.
+	 *
+	 * @defaultValue `OpenAddresses <CC> tuples`
+	 */
+	license?: string
 	/**
 	 * Replacement parts used when `--district-as-locality` is passed as true.
 	 */
@@ -161,19 +207,25 @@ const COUNTRY_SOURCES: Record<string, LocaleCountrySource> = {
 		parts: [{ path: dataRootPath("openaddresses", "extracted", "nz", "countrywide.csv"), districtAsLocality: true }],
 	},
 	GB: {
-		// Price Paid Data stores the postal town in `district` and an optional dependent locality in `city`.
-		source: defaultRecipeSource("synth-gb"),
-		register: SourceRegister.LandRegistryPricePaid,
+		// The `gb-os-open` adapter's rows: Code-Point Open postcodes joined to OS Open Roads and OS Open Names.
+		// `rendered-gb` read HM Land Registry Price Paid Data, whose address fields
+		// Royal Mail and Ordnance Survey license for non-commercial use only (#2635),
+		// so GB rows carry a source name of their own.
+		source: defaultRecipeSource("synth-gb-os-open"),
+		register: SourceRegister.OrdnanceSurveyOpenData,
 		corpusVersion: "0.9.9",
-		// The `REGION` column holds a county, so the constituent country is read from NSUL by postcode instead.
+		license: "OS OpenData GB tuples (OGL-UK-3.0)",
+		// The adapter's rows carry no region.
+		// The county comes from OS Open Names and the constituent country from NSUL, both by postcode.
 		parts: [
 			{
-				path: dataRootPath("ppd", "2026-07-22", "gb-tuples.csv"),
-				districtAsLocality: true,
-				regionOfPostcode: () => {
+				canonicalRows: gbOSOpenCanonicalRowsPath(),
+				canonicalSource: GB_OS_OPEN_ADAPTER_ID,
+				regionOfPostcode: async () => {
 					const countryOf = openConstituentCountryReader()
+					const countyOf = await readCountyOfPostcode()
 
-					return (postcode) => countryOf(postcode).name
+					return (postcode) => (gbPostcodeTakesCounty(postcode) && countyOf.get(postcode)) || countryOf(postcode).name
 				},
 			},
 		],
@@ -224,13 +276,102 @@ interface ColumnIndex {
 	tipoVial: number
 }
 
+/**
+ * One row of an adapter's `canonical.jsonl`, as far as the locale recipe reads it.
+ */
+interface CanonicalTupleRow {
+	source?: unknown
+	components?: Partial<Record<"house_number" | "street" | "locality" | "postcode", unknown>>
+}
+
+/**
+ * Reservoir-samples an adapter's canonical rows with Algorithm R, using `rng` for reproducibility.
+ *
+ * A row without a street or locality is skipped.
+ * A missing file throws rather than reading as an empty part.
+ *
+ * @throws When a row's `source` differs from `part.canonicalSource`.
+ */
+async function readCanonicalTuples(
+	part: LocalePart,
+	rows: PathBuilderLike,
+	rng: () => number
+): Promise<LocaleBaseTuple[]> {
+	if (!(await pathExists(rows))) {
+		throw new Error(
+			`${rows.toString()} is absent. Write it with \`mailwoman corpus run ${part.canonicalSource ?? "<adapter>"}\`.`
+		)
+	}
+
+	const reservoir: LocaleBaseTuple[] = []
+	const regionOf = await part.regionOfPostcode?.()
+	let seen = 0
+	let regionUnknown = 0
+
+	for await (const row of JSONSpliterator.fromAsync<CanonicalTupleRow>(rows)) {
+		if (part.canonicalSource && row.source !== part.canonicalSource) {
+			throw new Error(
+				`${rows.toString()} holds a row from source ${stringifyJSON(row.source)}; this part reads ${part.canonicalSource} rows only.`
+			)
+		}
+
+		const components = row.components ?? {}
+		const text = (value: unknown): string => (typeof value === "string" ? value.trim() : "")
+		const street = text(components.street)
+		const locality = text(components.locality)
+
+		if (!street || !locality) continue
+
+		const postcode = text(components.postcode)
+		let region = part.region ?? ""
+
+		if (regionOf) {
+			region = (postcode && regionOf(postcode)) || ""
+
+			if (!region) {
+				regionUnknown++
+			}
+		}
+
+		const tuple: LocaleBaseTuple = {
+			house_number: text(components.house_number),
+			street,
+			locality,
+			region,
+			postcode,
+		}
+
+		seen++
+
+		if (reservoir.length < RESERVOIR_CAP) {
+			reservoir.push(tuple)
+		} else {
+			const j = Math.floor(rng() * seen)
+
+			if (j < RESERVOIR_CAP) {
+				reservoir[j] = tuple
+			}
+		}
+	}
+
+	console.error(`  ${rows.toString()}: ${reservoir.length} sampled of ${seen} rows`)
+
+	if (regionOf) {
+		console.error(`  ${rows.toString()}: ${regionUnknown} rows have no region for their postcode`)
+	}
+
+	return reservoir
+}
+
 /**
  * Streams tuples from one part and reservoir-samples them with Algorithm R,
  * using `rng` for reproducibility.
  *
- * A read failure logs a warning and returns an empty list.
+ * @throws When the part cannot be read, naming the file.
  */
 export async function readTuples(part: LocalePart, rng: () => number): Promise<LocaleBaseTuple[]> {
+	if (part.canonicalRows) return readCanonicalTuples(part, part.canonicalRows, rng)
+
 	// The stream stays as bytes because CSVSpliterator decodes UTF-8 itself.
 	const input: NodeJS.ReadableStream | AsyncIterable<Uint8Array> = part.path
 		? openReadStream(part.path)
@@ -242,7 +383,7 @@ export async function readTuples(part: LocalePart, rng: () => number): Promise<L
 	let header: string[] | null = null
 	let seen = 0
 	let dropped = 0
-	const regionOf = part.regionOfPostcode?.()
+	const regionOf = await part.regionOfPostcode?.()
 	let regionUnknown = 0
 
 	try {
@@ -358,9 +499,12 @@ export async function readTuples(part: LocalePart, rng: () => number): Promise<L
 			}
 		}
 	} catch (error) {
-		console.error(`  WARN: read failed for ${part.path ?? part.zip}: ${(error as Error).message}`)
-
-		return []
+		// An unreadable part throws rather than reading as an empty one.
+		// The sub-venue recipe's DE leg once emitted zero rows behind a warning
+		// when `europe.zip` left the data root.
+		throw new Error(`${(part.path ?? part.zip)?.toString()} could not be read: ${(error as Error).message}`, {
+			cause: error,
+		})
 	}
 
 	console.error(`  ${part.path ?? part.csv}: ${reservoir.length} sampled of ${seen} rows (${dropped} city-noise drops)`)
@@ -421,7 +565,8 @@ export function resolveLocaleParts(countrySource: LocaleCountrySource, override:
  */
 export const localeRecipe: CorpusRecipe = {
 	name: "locale",
-	description: "Per-locale coverage rows (DE/FR/NL/IT/ES/NZ/GB) from real OA tuples, both orders → renderLocaleRow",
+	description:
+		"Per-locale coverage rows (DE/FR/NL/IT/ES/NZ/GB) from real OA tuples (OS OpenData for GB), both orders → renderLocaleRow",
 	mode: "generate",
 	options: [
 		{ flag: "--country <cc>", description: "Target country (DE|FR|NL|IT|ES|NZ|GB). Default DE" },
@@ -562,7 +707,7 @@ export const localeRecipe: CorpusRecipe = {
 				source,
 				source_id: sourceID,
 				corpus_version: countrySource.corpusVersion,
-				license: `OpenAddresses ${country} tuples, rendered ${order}-order — see ingest SOURCES`,
+				license: `${countrySource.license ?? `OpenAddresses ${country} tuples`}, rendered ${order}-order — see ingest SOURCES`,
 			}
 
 			const aligned = alignRow(canonical as Parameters<typeof alignRow>[0])