@mailwoman/corpus 9.0.0 → 9.2.0

package/src/adapters/wof-json-rows.ts

@@ -0,0 +1,79 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ * @file Deterministic canonical-row emission shared by WOF GeoJSON adapters.
+ */
+
+import type { ComponentTag } from "@mailwoman/core/types"
+import { formatAddress, reconcileComponents } from "@mailwoman/formatter"
+
+import type { AdapterOptions, CanonicalRow } from "#types"
+import type { WOFRecord } from "#utils"
+
+export interface WOFVariantSpec {
+	suffix: string
+	components: Partial<Record<ComponentTag, string>>
+}
+
+interface EmitWOFJSONRowsOptions {
+	records: ReadonlyMap<number, WOFRecord>
+	ancestry: ReadonlyMap<number, WOFRecord[]>
+	adapterOptions: AdapterOptions
+	adapterID: string
+	localeByCountry: Readonly<Record<string, string>>
+	shouldEmit?: (record: WOFRecord) => boolean
+	nameSlotsFor: (record: WOFRecord) => Array<{ key: string; value: string }>
+	variantsFor: (record: WOFRecord, ancestry: WOFRecord[], selfName: string) => WOFVariantSpec[]
+}
+
+/**
+ * Emit aligned rows in WOF-id order, enforcing the adapter limit across all name and hierarchy variants.
+ */
+export function* emitWOFJSONRows(options: EmitWOFJSONRowsOptions): Generator<CanonicalRow> {
+	const {
+		records,
+		ancestry,
+		adapterOptions,
+		adapterID,
+		localeByCountry,
+		shouldEmit = () => true,
+		nameSlotsFor,
+		variantsFor,
+	} = options
+
+	let emitted = 0
+
+	for (const id of [...records.keys()].toSorted((a, b) => a - b)) {
+		if (adapterOptions.signal?.aborted) return
+		const record = records.get(id)!
+
+		if (!shouldEmit(record)) continue
+
+		for (const slot of nameSlotsFor(record)) {
+			for (const variant of variantsFor(record, ancestry.get(id) ?? [], slot.value)) {
+				if (adapterOptions.limit !== undefined && emitted >= adapterOptions.limit) return
+
+				const raw = formatAddress(variant.components, record.country, { separator: ", " })
+
+				if (!raw) continue
+				const components = reconcileComponents(variant.components, raw)
+
+				if (!Object.keys(components).length) continue
+
+				yield {
+					raw,
+					components,
+					country: record.country,
+					locale: localeByCountry[record.country],
+					source: adapterID,
+					source_id: `${adapterID}-${record.id}-${slot.key}-${variant.suffix}`,
+					corpus_version: "",
+					license: "CC0-1.0",
+				}
+
+				emitted++
+			}
+		}
+	}
+}

package/src/adapters/wof-postalcode-json/adapter.ts

@@ -40,9 +40,10 @@
 import type { WhosOnFirstPlacetype } from "@mailwoman/core/resources/whosonfirst"
 import type { ComponentTag } from "@mailwoman/core/types"
 
-import { formatAddress, reconcileComponents } from "../../format.ts"
-import type { AdapterOptions, CanonicalRow, CorpusAdapter } from "../../types.ts"
-import { buildAncestryIndex, normalizeNameKey, walkFeatures, type WOFRecord } from "../../wof-json.ts"
+import type { AdapterOptions, CanonicalRow, CorpusAdapter } from "#types"
+import { buildAncestryIndex, normalizeNameKey, walkFeatures, type WOFRecord } from "#utils"
+
+import { emitWOFJSONRows, type WOFVariantSpec } from "../wof-json-rows.ts"
 
 const COUNTRY_DISPLAY_NAME: Record<string, string> = {
 	US: "United States of America",
@@ -71,16 +72,11 @@ function placetypeToTag(placetype: WhosOnFirstPlacetype | string): ComponentTag
 	}
 }
 
-interface VariantSpec {
-	suffix: string
-	components: Partial<Record<ComponentTag, string>>
-}
-
 /**
  * Compute hierarchy variants for a postcode record. `selfName` is the postcode surface form (canonical `wof:name` for
  * the `default` slot, a `name:*` localized variant otherwise).
  */
-export function postcodeVariantsFor(row: WOFRecord, ancestry: WOFRecord[], selfName: string): VariantSpec[] {
+export function postcodeVariantsFor(row: WOFRecord, ancestry: WOFRecord[], selfName: string): WOFVariantSpec[] {
 	if (placetypeToTag(row.placetype) !== "postcode") return []
 
 	const locality = ancestry.find((a) => placetypeToTag(a.placetype) === "locality")
@@ -88,7 +84,7 @@ export function postcodeVariantsFor(row: WOFRecord, ancestry: WOFRecord[], selfN
 	const country = ancestry.find((a) => placetypeToTag(a.placetype) === "country")
 	const countryDisplay = COUNTRY_DISPLAY_NAME[row.country] ?? country?.name ?? row.country
 
-	const variants: VariantSpec[] = [{ suffix: "self", components: { postcode: selfName } }]
+	const variants: WOFVariantSpec[] = [{ suffix: "self", components: { postcode: selfName } }]
 
 	if (locality) {
 		variants.push({
@@ -167,46 +163,16 @@ export function createWOFPostalcodeAdapter(): CorpusAdapter {
 			const ancestry = buildAncestryIndex(byID)
 
 			// Pass 2: emit postcode rows only, sorted by id for determinism.
-			const ids = [...byID.keys()].toSorted((a, b) => a - b)
-			let emitted = 0
-
-			for (const id of ids) {
-				if (opts.signal?.aborted) return
-				const rec = byID.get(id)!
-
-				if (placetypeToTag(rec.placetype) !== "postcode") continue
-
-				const chain = ancestry.get(id) ?? []
-				const slots = nameSlotsFor(rec)
-
-				for (const slot of slots) {
-					const variants = postcodeVariantsFor(rec, chain, slot.value)
-
-					for (const variant of variants) {
-						if (opts.limit !== undefined && emitted >= opts.limit) return
-
-						const raw = formatAddress(variant.components, rec.country, { separator: ", " })
-
-						if (!raw) continue
-						const aligned = reconcileComponents(variant.components, raw)
-
-						if (!Object.keys(aligned).length) continue
-
-						yield {
-							raw,
-							components: aligned,
-							country: rec.country,
-							locale: LOCALE_BY_COUNTRY[rec.country],
-							source: WOF_POSTALCODE_ADAPTER_ID,
-							source_id: `${WOF_POSTALCODE_ADAPTER_ID}-${rec.id}-${slot.key}-${variant.suffix}`,
-							corpus_version: "",
-							license: "CC0-1.0",
-						}
-
-						emitted++
-					}
-				}
-			}
+			yield* emitWOFJSONRows({
+				records: byID,
+				ancestry,
+				adapterOptions: opts,
+				adapterID: WOF_POSTALCODE_ADAPTER_ID,
+				localeByCountry: LOCALE_BY_COUNTRY,
+				shouldEmit: (record) => placetypeToTag(record.placetype) === "postcode",
+				nameSlotsFor,
+				variantsFor: postcodeVariantsFor,
+			})
 		},
 	}
 }

package/src/build.ts

@@ -55,20 +55,20 @@ import { $public } from "@mailwoman/core/env"
 import { parseJSONStrict } from "@mailwoman/core/objects"
 import { JSONSpliterator } from "spliterator"
 
-import { defaultAdapterRegistry } from "./adapter.ts"
-import { alignRow } from "./align.ts"
-import { licenseExcluded } from "./license.ts"
-import { writeShards, type ShardManifest } from "./parquet.ts"
-import { runAdapter, type AdapterRunManifest } from "./runner.ts"
+import { defaultAdapterRegistry } from "#adapters/utils"
+import { runAdapter, type AdapterRunManifest } from "#runner"
+import { defaultAugmentationsForCountry, synthesizeRow } from "#synthesizers/utils"
+import type { AdapterOptions, CanonicalRow, CorpusAdapter, LabeledRow } from "#types"
+import { alignRow } from "#utils/align"
+import { licenseExcluded } from "#utils/license"
+import { writeShards, type ShardManifest } from "#utils/parquet"
 import {
 	defaultHoldouts,
 	splitForRow,
 	writeSplitManifestsFromLabeledFiles,
 	type SplitManifest,
 	type SplitName,
-} from "./split.ts"
-import { defaultAugmentationsForCountry, synthesizeRow } from "./synthesize.ts"
-import type { AdapterOptions, CanonicalRow, CorpusAdapter, LabeledRow } from "./types.ts"
+} from "#utils/split"
 
 /**
  * Stage tags surfaced to `onProgress`.

package/src/index.ts

@@ -4,25 +4,11 @@
  * @author Teffen Ellis, et al.
  */
 
-export * from "./adapter.ts"
+export * from "./adapters/utils/index.ts"
 export * from "./adapters/gnaf/assemble.ts"
 export * from "./adapters/index.ts"
-export * from "./align.ts"
 export * from "./build.ts"
-export * from "./format.ts"
-export * from "./golden.ts"
-export * from "./parquet.ts"
-export * from "./parquet-wrapper/index.ts"
 export * from "./runner.ts"
+export * from "./parquet-wrapper/index.ts"
 export * from "./shard-recipes/index.ts"
-export * from "./split.ts"
-export * from "./synthesize-anchor-absorption.ts"
-export * from "./synthesize-german.ts"
-export * from "./synthesize-house-venue.ts"
-export * from "./synthesize-intersection.ts"
-export * from "./synthesize-no-street.ts"
-export * from "./synthesize-po-box.ts"
-export * from "./synthesize-street.ts"
-export * from "./synthesize.ts"
-export * from "./tokenize.ts"
-export * from "./types.ts"
+export * from "#types"

package/src/name-prone-us-suffixes.ts

@@ -0,0 +1,12 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ * Re-export shim: the name-prone set moved to `@mailwoman/codex/us` (data in
+ * `codex/us/street-suffix.json`, 2026-08-10) so the golden relabel flags, the #1569 shard
+ * recipe, AND the Python relabel pass (via the `gazetteer affix-relabel` v2 lexicon) all read
+ * one record. Import from `@mailwoman/codex/us` in new code.
+ */
+
+export { NAME_PRONE_US_SUFFIXES } from "@mailwoman/codex/us"

package/src/parquet-wrapper/reader.ts

@@ -67,6 +67,15 @@ export class ParquetReader<T extends ParquetRecordLike> extends BaseParquetReade
 	 * caller wanting the whole record should use.
 	 */
 	public async *project<K extends keyof T>(...columns: K[]): AsyncGenerator<Pick<T, K>, void, unknown> {
+		const missing = columns.filter((column) => !Object.hasOwn(this.schema.schema, column))
+
+		if (missing.length) {
+			throw new Error(
+				`Parquet projection requested column${missing.length === 1 ? "" : "s"} absent from the file schema: ` +
+					missing.map(String).join(", ")
+			)
+		}
+
 		const cursor = this.getCursor(columns.map((column) => [column as string]))
 
 		for (;;) {

package/src/runner.ts

@@ -31,8 +31,8 @@ import { createWriteStream, type WriteStream } from "node:fs"
 import { mkdir, writeFile } from "node:fs/promises"
 import { dirname, join } from "node:path"
 
-import { canonicalDedupKey, streamingSha256, type AdapterRegistry, type StreamingHasher } from "./adapter.ts"
-import type { AdapterOptions, CanonicalRow, CorpusAdapter } from "./types.ts"
+import { canonicalDedupKey, streamingSha256, type AdapterRegistry, type StreamingHasher } from "#adapters/utils"
+import type { AdapterOptions, CanonicalRow, CorpusAdapter } from "#types"
 
 /**
  * Snapshot of the runner's state, emitted on every progress tick.

package/src/shard-recipes/anchor-absorption.ts

@@ -17,10 +17,10 @@ import { readFileSync } from "node:fs"
 import { parseJSONStrict } from "@mailwoman/core/objects"
 import { dataRootPath } from "@mailwoman/core/utils"
 
-import { stableSourceID } from "../adapter.ts"
-import { alignRow } from "../align.ts"
-import { synthesizeAnchorAbsorptionRow } from "../synthesize-anchor-absorption.ts"
-import { makeLcg, type ShardRecipe } from "./scaffold.ts"
+import { synthesizeAnchorAbsorptionRow } from "#synthesizers/anchor-absorption"
+import { alignRow } from "#utils"
+
+import { makeLcg, shardSourceID, type ShardRecipe } from "./scaffold.ts"
 
 /**
  * The leading-5-digit source: the real US ZIPs in the postcode anchor's pilot lookup. Resolved through the data-root
@@ -76,7 +76,7 @@ export const anchorAbsorptionRecipe: ShardRecipe = {
 				country,
 				locale: synth.locale,
 				source,
-				source_id: stableSourceID(source, `${i}` as unknown as Parameters<typeof stableSourceID>[1]),
+				source_id: shardSourceID(source, { v: String(i) }),
 			}
 
 			const aligned = alignRow(canonical as Parameters<typeof alignRow>[0])

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

@@ -0,0 +1,95 @@
+/**
+ * @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 shard 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 { alignAndWrite, makeMulberry32, type ShardRecipe, shardSourceID } from "./scaffold.ts"
+
+/**
+ * Surfaces shorter than this are the code register (`JP`, `GER`), not a name — excluded (see the module doc).
+ */
+const MIN_NAME_LENGTH = 4
+
+/**
+ * Every (surface, iso2) pair the shard 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>()
+
+	for (const [iso2, forms] of Object.entries(COUNTRY_SURFACE_FORMS)) {
+		for (const surface of forms) {
+			if (surface.length < MIN_NAME_LENGTH || seen.has(surface)) continue
+			seen.add(surface)
+			yield { surface, iso2 }
+		}
+	}
+
+	for (const name of CountryNames) {
+		if (name.length < MIN_NAME_LENGTH || seen.has(name)) continue
+		const matched = matchCountry(name)
+
+		if (!matched) continue
+		seen.add(name)
+		yield { surface: name, iso2: matched.iso2 }
+	}
+}
+
+/**
+ * Shard 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.
+ */
+export const bareCountryRecipe: ShardRecipe = {
+	name: "bare-country",
+	description: "The country name as the whole query (#1651 parse half): ISO names + curated endonyms, no 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
+		let skipped = 0
+
+		for (const { surface, iso2 } of bareCountrySurfaces()) {
+			read++
+
+			const components: Record<string, string> = { country: surface }
+			const source_id = shardSourceID("synth-bare-country", { country: surface, cc: iso2, v: String(read) })
+
+			const canonical = {
+				raw: surface,
+				components,
+				country: iso2,
+				locale: "und",
+				source: "synth-bare-country",
+				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")) {
+				emitted++
+			} else {
+				skipped++
+			}
+		}
+
+		return { read, emitted, skipped }
+	},
+}

package/src/shard-recipes/boundary-stress.ts

@@ -12,8 +12,9 @@
  *   `synthesizeBoundaryStressRow` is NOT re-exported from the corpus index — imported directly here.
  */
 
-import { alignRow } from "../align.ts"
-import { type BoundaryStressTemplate, synthesizeBoundaryStressRow } from "../synthesize-boundary-stress.ts"
+import { type BoundaryStressTemplate, synthesizeBoundaryStressRow } from "#synthesizers/boundary-stress"
+import { alignRow } from "#utils"
+
 import { makeMulberry32, type ShardRecipe, shardSourceID } from "./scaffold.ts"
 
 /**

package/src/shard-recipes/country-balanced.ts

@@ -24,16 +24,16 @@
  *   legacy script used.
  */
 
-import { spawnSync } from "node:child_process"
-
 import { COUNTRY_SURFACE_FORMS, CountryNames } from "@mailwoman/codex/country"
+import { isPresent } from "@mailwoman/core/objects"
 import type { ComponentTag } from "@mailwoman/core/types"
 import { dataRootPath } from "@mailwoman/core/utils"
 
-import { stableSourceID } from "../adapter.ts"
-import { alignRow } from "../align.ts"
-import type { CanonicalRow } from "../types.ts"
-import { makeMulberry32, readCSVRecords, type ShardRecipe } from "./scaffold.ts"
+import { stableSourceID } from "#adapters/utils"
+import type { CanonicalRow } from "#types"
+import { alignRow } from "#utils"
+
+import { makeMulberry32, readZippedCSVRecords, type ShardRecipe } from "./scaffold.ts"
 
 // v2: the country TOKEN is decoupled from the skeleton's locale and drawn from a BROAD pool — every
 // ISO canonical name + every curated surface form (endonyms/abbrevs). Surface forms are over-weighted
@@ -154,26 +154,15 @@ interface CountryTuple {
 	order: string
 }
 
-function readTuples(source: CountrySource, limit: number): CountryTuple[] {
-	// countrywide extracts (FR/IT/NL) are GB-scale — cap the bytes with `head` (read ~8 lines per wanted
-	// tuple to survive dedup/skips) so the whole extract never has to be held in memory.
-	const maxLines = Math.max(limit * 8, 20_000) + 1
-
-	const r = spawnSync("bash", ["-c", `unzip -p "${source.zip}" "${source.csv}" | head -n ${maxLines}`], {
-		maxBuffer: 1024 * 1024 * 1024,
-		encoding: "buffer",
-	})
-
-	if (r.status !== 0) {
-		console.error(`  WARN: unzip failed for ${source.zip} (status ${r.status})`)
-
-		return []
-	}
-
+/**
+ * The countrywide extracts (FR/IT/NL) are GB-scale, so this reads only as far as `limit` distinct tuples: the `break`
+ * closes the reader, which releases the archive without inflating the rest of the member.
+ */
+async function readTuples(source: CountrySource, limit: number): Promise<CountryTuple[]> {
 	const tuples: CountryTuple[] = []
 	const seen = new Set<string>()
 
-	for (const row of readCSVRecords(r.stdout)) {
+	for await (const row of readZippedCSVRecords(source.zip, source.csv)) {
 		if (tuples.length >= limit) break
 
 		const street = row.street ?? "",
@@ -233,14 +222,14 @@ function renderCountry(
 	let body: string
 
 	if (order === "us") {
-		const regPc = [reg, pc].filter(Boolean).join(" ")
+		const regPc = [reg, pc].filter(isPresent).join(" ")
 		body = `${hn} ${street}, ${loc}${regPc ? ", " + regPc : ""}`
 	} else if (order === "fr") {
 		// French is NUMBER-street, postcode-city: "84 Route de la Fontaine, 75008 Paris".
-		body = `${hn} ${street}, ${[pc, loc].filter(Boolean).join(" ")}`
+		body = `${hn} ${street}, ${[pc, loc].filter(isPresent).join(" ")}`
 	} else {
 		// DE/IT/NL: street-number, postcode-city: "Pariser Platz 1, 10117 Berlin".
-		const pcCity = [pc, loc].filter(Boolean).join(" ")
+		const pcCity = [pc, loc].filter(isPresent).join(" ")
 		body = `${street} ${hn}, ${pcCity}`
 	}
 
@@ -449,7 +438,7 @@ export const countryBalancedRecipe: ShardRecipe = {
 		const pool: CountryTuple[] = []
 
 		for (const s of sources) {
-			const t = readTuples(s, perSource)
+			const t = await readTuples(s, perSource)
 
 			console.error(`  ${s.csv} (${s.iso2}): ${t.length} tuples`)
 

package/src/shard-recipes/cz-pcfirst-preposition.ts

@@ -16,6 +16,13 @@
 
 import { alignAndWrite, makeMulberry32, readTuples, type ShardRecipe, shardSourceID } from "./scaffold.ts"
 
+/**
+ * The order-cycle slot for the STREET-LESS form (`«city» «pc», Česko`) — the exact surface of the
+ * `cz-full-praha-100-00` board row, whose absence from the street-bearing orders was the v4.5.0 no-promote's measured
+ * gap.
+ */
+const STREETLESS_ORDER = 3
+
 /**
  * Shard 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.
@@ -44,27 +51,39 @@ export const czPcFirstPrepositionRecipe: ShardRecipe = {
 				continue
 			}
 
-			const order = read % 3
+			const order = read % 4
+			// The OFFICIAL Czech rendering spaces the PSČ as `NNN NN` ('512 44'); OpenAddresses stores it
+			// unspaced ('51244'), and a model trained only on the source form reads the spaced surface as
+			// house_number + garbage (the 'Praha 100 00' mangle). Alternate the two renderings so both
+			// orthographies are attested — the LABEL is the postcode either way.
+			const spaced = read % 2 === 0 && /^\d{5}$/.test(postcode)
+			const postcodeSurface = spaced ? `${postcode.slice(0, 3)} ${postcode.slice(3)}` : postcode
 			let raw: string
 
-			const components: Record<string, string> = {
-				street,
-				house_number: number,
-				postcode,
-				locality: city,
-			}
+			const components: Record<string, string> =
+				order === STREETLESS_ORDER
+					? { locality: city, postcode: postcodeSurface, country: "Česko" }
+					: { street, house_number: number, postcode: postcodeSurface, locality: city }
 
 			if (order === 0) {
-				raw = `${postcode} ${city}, ${street} ${number}`
+				raw = `${postcodeSurface} ${city}, ${street} ${number}`
 			} else if (order === 1) {
-				raw = `${street} ${number}, ${postcode} ${city}`
+				raw = `${street} ${number}, ${postcodeSurface} ${city}`
+			} else if (order === 2) {
+				raw = `${city}, ${postcodeSurface}, ${street} ${number}`
 			} else {
-				raw = `${city}, ${postcode}, ${street} ${number}`
+				// order === STREETLESS_ORDER: the street-less form — `«city» «pc», Česko` — the exact surface of the
+				// cz-full-praha-100-00 board row. The v4.5.0 no-promote receipt measured the gap: every
+				// prior order was street-bearing, so the model never saw a spaced PSČ beside a bare
+				// locality and mangled 'Praha 100 00, Czechia' into house_number spans. Street/number
+				// stay OUT of the components for this form (they are not in the surface).
+				raw = `${city} ${postcodeSurface}, Česko`
 			}
 
 			const source_id = shardSourceID("synth-cz-pcfirst-preposition", {
 				...components,
 				o: String(order),
+				s: spaced ? "1" : "0",
 				v: String(read),
 			})
 

package/src/shard-recipes/fr-admin-split.ts

@@ -32,11 +32,13 @@
 
 import { departementForCodePostal } from "@mailwoman/codex/fr"
 import type { ComponentTag } from "@mailwoman/core/types"
+import { tempRootPath } from "@mailwoman/core/utils"
 import { CSVSpliterator, Delimiters } from "spliterator"
 
-import { stableSourceID } from "../adapter.ts"
-import { alignRow } from "../align.ts"
-import type { CanonicalRow } from "../types.ts"
+import { stableSourceID } from "#adapters/utils"
+import type { CanonicalRow } from "#types"
+import { alignRow } from "#utils"
+
 import { makeMulberry32, type ShardRecipe } from "./scaffold.ts"
 
 /* oxlint-disable sister-software/no-unnamed-threshold -- the bare decimals below are weighted-sampler
@@ -45,7 +47,7 @@ import { makeMulberry32, type ShardRecipe } from "./scaffold.ts"
    would hide the distribution behind a wall of identifiers. Genuine thresholds in these files are
    extracted as named constants above. */
 
-const DEFAULT_COMMUNES = "/tmp/reg/fr-communes.tsv"
+const DEFAULT_COMMUNES = tempRootPath("reg", "fr-communes.tsv")
 const LICENSE = "BAN (Base Adresse Nationale) commune+postcode tuples, rendered admin-split — see ingest SOURCE"
 
 /**