@mailwoman/corpus 10.0.0 → 10.1.0

package/lib/build/align.ts

@@ -0,0 +1,364 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ * @file The align phase reads each adapter's canonical rows and applies license and register refusals.
+ *   It expands synthesis and aligns each row. It then routes the result to a split or quarantine.
+ *
+ *   The phase appends to four files. It writes a checkpoint at each adapter boundary, allowing an interrupted
+ *   build to resume at the next adapter without aligning earlier adapters again.
+ */
+
+import { openWriteStream, type WriteStream } from "@mailwoman/core/fs/streams"
+import { truncateFile } from "@mailwoman/core/fs/writers"
+import { sha256Hex } from "@mailwoman/core/hash"
+import { stringifyJSON } from "@mailwoman/core/json"
+import type { PathBuilder } from "path-ts"
+
+import {
+	ALIGN_OUTPUTS,
+	readAlignCheckpoint,
+	writeAlignCheckpoint,
+	type AlignCheckpoint,
+	type AlignOutputName,
+	type AlignSettings,
+} from "#build/checkpoint"
+import { createIneligibilityReader } from "#build/eligibility"
+import { streamJSONL } from "#build/rows"
+import type { BuildProfile, BuildStage } from "#build/types"
+import { $public } from "#env"
+import { flushStream, once, type AdapterRunManifest } from "#runner"
+import { defaultAugmentationsForCountry, synthesizeRow } from "#synthesizers/utils"
+import type { CanonicalRow } from "#types"
+import { alignRow } from "#utils/align"
+import {
+	createLicenseVerdictCache,
+	type LicensePolicy,
+	type LicenseRefusalKind,
+	type LicenseVerdictCache,
+} from "#utils/license"
+import { splitForRow, type CountryHoldout, type SplitName } from "#utils/split"
+
+export interface AlignPhaseOptions {
+	/**
+	 * The adapter runs to align, in the order their rows enter the output files.
+	 */
+	adapterRuns: readonly AdapterRunManifest[]
+
+	corpusVersion: string
+	synthesize: boolean
+	profile: BuildProfile
+	licensePolicy: LicensePolicy
+	excludeLicenses: readonly RegExp[]
+	holdouts: Record<string, CountryHoldout>
+
+	/**
+	 * Each register source's ingest-eligibility reasons, or `null` under the exploratory profile.
+	 */
+	eligibility: ReadonlyMap<string, readonly string[]> | null
+
+	labeledPaths: Record<SplitName, PathBuilder>
+	quarantinePath: PathBuilder
+	checkpointPath: PathBuilder
+
+	onProgress?: (stage: BuildStage, message: string) => void
+}
+
+/**
+ * The counts produced by the align phase.
+ *
+ * The build uses them in its manifest and frozen source record.
+ */
+export interface AlignPhaseResult {
+	aligned: number
+	quarantined: number
+	counts: Record<SplitName, number>
+	licenseCounts: Map<string, number>
+	refusedByKind: Map<LicenseRefusalKind, number>
+	/**
+	 * Rows the license policy refused, counted per `source`.
+	 *
+	 * A source here contributed zero rows to the corpus whatever its adapter reported writing, which is
+	 * the distinction between a source present in corpus provenance and one present in model provenance.
+	 */
+	refusedBySource: Map<string, number>
+	excludedByLicense: number
+	admittedUnresolved: number
+	excludedByEligibility: number
+	rowsBySource: Map<string, { rows: number; license: string }>
+	ineligibleSources: Map<string, readonly string[]>
+
+	/**
+	 * The license cache used by this phase.
+	 *
+	 * Its `refusedValues()` method returns every value it refused.
+	 */
+	licenses: LicenseVerdictCache
+}
+
+/**
+ * The mutable state of one align run.
+ * The checkpoint restores and records this state.
+ */
+interface AlignTally {
+	aligned: number
+	quarantined: number
+	excludedByLicense: number
+	admittedUnresolved: number
+	excludedByEligibility: number
+}
+
+/**
+ * Return each output to the length the checkpoint recorded.
+ *
+ * Whatever the interrupted adapter wrote past the boundary is discarded, because the checkpoint's
+ * accumulators do not count those rows and the split manifests are computed from the accumulators.
+ */
+async function restoreOutputs(checkpoint: AlignCheckpoint, paths: Record<AlignOutputName, PathBuilder>): Promise<void> {
+	for (const name of ALIGN_OUTPUTS) {
+		await truncateFile(paths[name], checkpoint.offsets[name])
+	}
+}
+
+/**
+ * Restore the accumulators a checkpoint recorded into this run's containers.
+ */
+function restoreTally(checkpoint: AlignCheckpoint, result: AlignPhaseResult): AlignTally {
+	for (const name of ["train", "val", "test"] as const) {
+		result.counts[name] = checkpoint.counts[name]
+	}
+
+	for (const [license, count] of Object.entries(checkpoint.license_counts)) {
+		result.licenseCounts.set(license, count)
+	}
+
+	for (const [kind, count] of Object.entries(checkpoint.refused_by_kind)) {
+		result.refusedByKind.set(kind as LicenseRefusalKind, count)
+	}
+
+	for (const [source, count] of Object.entries(checkpoint.refused_by_source)) {
+		result.refusedBySource.set(source, count)
+	}
+
+	for (const [source, contributed] of Object.entries(checkpoint.rows_by_source)) {
+		result.rowsBySource.set(source, contributed)
+	}
+
+	return {
+		aligned: checkpoint.aligned,
+		quarantined: checkpoint.quarantined,
+		excludedByLicense: checkpoint.excluded_by_license,
+		admittedUnresolved: checkpoint.admitted_unresolved_license_rows,
+		excludedByEligibility: checkpoint.excluded_by_eligibility,
+	}
+}
+
+/**
+ * Align every adapter run's rows into the four output files, writing a checkpoint at each adapter boundary.
+ */
+export async function runAlignPhase(opts: AlignPhaseOptions): Promise<AlignPhaseResult> {
+	const ineligibility = createIneligibilityReader(opts.eligibility)
+	const licenses = createLicenseVerdictCache(opts.licensePolicy, opts.excludeLicenses)
+
+	const result: AlignPhaseResult = {
+		aligned: 0,
+		quarantined: 0,
+		counts: { train: 0, val: 0, test: 0 },
+		licenseCounts: new Map(),
+		refusedByKind: new Map(),
+		excludedByLicense: 0,
+		admittedUnresolved: 0,
+		excludedByEligibility: 0,
+		refusedBySource: new Map(),
+		rowsBySource: new Map(),
+		ineligibleSources: ineligibility.refused,
+		licenses,
+	}
+
+	const settings: AlignSettings = {
+		corpus_version: opts.corpusVersion,
+		synthesize: opts.synthesize,
+		license_policy: opts.licensePolicy,
+		exclude_licenses: opts.excludeLicenses.map((pattern) => pattern.source).toSorted(),
+		profile: opts.profile,
+		holdout_digest: sha256Hex(stringifyJSON(opts.holdouts)),
+	}
+
+	const paths: Record<AlignOutputName, PathBuilder> = { ...opts.labeledPaths, quarantine: opts.quarantinePath }
+
+	const checkpoint =
+		$public.MAILWOMAN_RESUME === "1"
+			? await readAlignCheckpoint(opts.checkpointPath, {
+					settings,
+					adapterOrder: opts.adapterRuns.map((run) => run.adapter_id),
+				})
+			: null
+
+	let tally: AlignTally = {
+		aligned: 0,
+		quarantined: 0,
+		excludedByLicense: 0,
+		admittedUnresolved: 0,
+		excludedByEligibility: 0,
+	}
+
+	if (checkpoint) {
+		await restoreOutputs(checkpoint, paths)
+		tally = restoreTally(checkpoint, result)
+
+		opts.onProgress?.(
+			"align",
+			`resumed align after ${checkpoint.completed_adapters.join(", ")} ` +
+				`(${tally.aligned.toLocaleString()} aligned rows)`
+		)
+	}
+
+	// `a` rather than the default `w` on a resume, because the files hold the rows the checkpoint counted.
+	const flags = checkpoint ? "a" : "w"
+
+	const streams: Record<AlignOutputName, WriteStream> = {
+		train: openWriteStream(paths.train, { encoding: "utf8", flags }),
+		val: openWriteStream(paths.val, { encoding: "utf8", flags }),
+		test: openWriteStream(paths.test, { encoding: "utf8", flags }),
+		quarantine: openWriteStream(paths.quarantine, { encoding: "utf8", flags }),
+	}
+
+	const offsets: Record<AlignOutputName, number> = checkpoint
+		? { ...checkpoint.offsets }
+		: { train: 0, val: 0, test: 0, quarantine: 0 }
+
+	const writeLine = (name: AlignOutputName, line: string): void => {
+		offsets[name] += Buffer.byteLength(line, "utf8")
+		streams[name].write(line)
+	}
+
+	const quarantine = (row: CanonicalRow, reason: string): void => {
+		writeLine("quarantine", `${stringifyJSON({ row, reason })}\n`)
+	}
+
+	const completed = checkpoint ? [...checkpoint.completed_adapters] : []
+
+	for (const adapterRun of opts.adapterRuns) {
+		if (completed.includes(adapterRun.adapter_id)) continue
+
+		opts.onProgress?.("align", `aligning ${adapterRun.adapter_id}`)
+
+		for await (const row of streamJSONL<CanonicalRow>(adapterRun.jsonl_path)) {
+			result.licenseCounts.set(row.license, (result.licenseCounts.get(row.license) ?? 0) + 1)
+
+			// The license count is incremented before the drop, so the manifest's license set
+			// reflects what the corpus contained and `excluded_by_license` what was removed.
+			const verdict = licenses.read(row.license)
+
+			if (verdict.refusal) {
+				tally.excludedByLicense++
+				result.refusedByKind.set(verdict.refusal, (result.refusedByKind.get(verdict.refusal) ?? 0) + 1)
+
+				// Counted per source as well as per refusal kind, because an adapter's own
+				// `written` count records what it emitted rather than what entered the corpus.
+				// A source refused here contributed no row, and model provenance generated from
+				// `adapters[].written` alone would credit it with rows it did not supply.
+				result.refusedBySource.set(row.source, (result.refusedBySource.get(row.source) ?? 0) + 1)
+
+				continue
+			}
+
+			// An admitted row whose license resolves to no expression entered with
+			// unknown obligations rather than with none.
+			// The manifest states the count so a consumer can tell the two apart.
+			if (!verdict.resolved) {
+				tally.admittedUnresolved++
+			}
+
+			// Eligibility runs before augmentation: a synthetic row inherits its ancestor's `source`,
+			// so refusing the ancestor here refuses everything fanned from it.
+			const ineligible = ineligibility.read(row)
+
+			if (ineligible) {
+				tally.excludedByEligibility++
+
+				quarantine(row, `source-ineligible:${ineligible.join("; ")}`)
+
+				continue
+			}
+
+			// Counted after both refusals, so the frozen manifest records what a source
+			// contributed rather than what it offered.
+			const contributed = result.rowsBySource.get(row.source)
+
+			result.rowsBySource.set(row.source, { rows: (contributed?.rows ?? 0) + 1, license: row.license })
+
+			const fanned: CanonicalRow[] = [row]
+
+			if (opts.synthesize) {
+				for (const aug of synthesizeRow(row, defaultAugmentationsForCountry(row.country))) {
+					fanned.push(aug)
+				}
+			}
+
+			for (const r of fanned) {
+				let aligned: ReturnType<typeof alignRow>
+
+				try {
+					aligned = alignRow(r)
+				} catch (error) {
+					// No single row may crash a multi-hour build.
+					// An unknown throw is quarantined as `align-threw`, and a rise in
+					// that reason's count is a finding.
+					quarantine(r, `align-threw:${(error as Error).message.slice(0, 160)}`)
+
+					tally.quarantined++
+
+					continue
+				}
+
+				if (aligned.kind === "labeled") {
+					const split = splitForRow(aligned.row, opts.holdouts)
+
+					writeLine(split, `${stringifyJSON(aligned.row)}\n`)
+
+					result.counts[split]++
+
+					tally.aligned++
+				} else {
+					quarantine(r, aligned.row.reason)
+
+					tally.quarantined++
+				}
+			}
+		}
+
+		// The checkpoint is written at the adapter boundary, after the bytes it counts have reached disk.
+		// Mid-adapter recovery is unavailable.
+		// The largest adapter takes about twenty minutes to align.
+		// A row offset inside one adapter's file would still require replaying that adapter's synthesis.
+		await Promise.all(ALIGN_OUTPUTS.map((name) => flushStream(streams[name])))
+
+		completed.push(adapterRun.adapter_id)
+
+		await writeAlignCheckpoint(opts.checkpointPath, {
+			settings,
+			completed_adapters: [...completed],
+			offsets: { ...offsets },
+			counts: { ...result.counts },
+			aligned: tally.aligned,
+			quarantined: tally.quarantined,
+			license_counts: Object.fromEntries(result.licenseCounts),
+			refused_by_kind: Object.fromEntries(result.refusedByKind),
+			refused_by_source: Object.fromEntries(result.refusedBySource),
+			excluded_by_license: tally.excludedByLicense,
+			admitted_unresolved_license_rows: tally.admittedUnresolved,
+			excluded_by_eligibility: tally.excludedByEligibility,
+			rows_by_source: Object.fromEntries(result.rowsBySource),
+			written_at: new Date().toISOString(),
+		})
+	}
+
+	for (const stream of Object.values(streams)) {
+		stream.end()
+	}
+
+	await Promise.all(Object.values(streams).map((stream) => once(stream, "close")))
+
+	return { ...result, ...tally }
+}

package/lib/build/checkpoint.ts

@@ -0,0 +1,131 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ * @file The align phase's resume point. It records aligned adapters and each output's length at that moment.
+ *   It also records every accumulator used to compute the manifest.
+ *
+ *   The adapter phase recovers from its per-adapter `MANIFEST.json`. Align, split and parquet ran 6 h 35 min
+ *   of the 8 h 27 min `v0.7.0-de-holdout` build with no recovery point, because the four labeled streams are
+ *   truncated at open and every accumulator is a local. This file is what a resumed align phase reads
+ *   instead of starting over.
+ *
+ *   The phase is replayable only when the same rows produce the same output, so the checkpoint records the
+ *   settings that change alignment and refuses a resume under different ones. `align-determinism` in
+ *   `build.test.ts` compares four output digests across two builds over one intermediate directory.
+ */
+
+import { readLocalJSONFile, pathExists } from "@mailwoman/core/fs/readers"
+import { writeLocalJSONFile } from "@mailwoman/core/fs/writers"
+import { stringifyJSON } from "@mailwoman/core/json"
+import type { PathBuilderLike } from "path-ts"
+
+/**
+ * The four append-only outputs of the align phase, by the name in each file.
+ */
+export const ALIGN_OUTPUTS = ["train", "val", "test", "quarantine"] as const
+
+export type AlignOutputName = (typeof ALIGN_OUTPUTS)[number]
+
+/**
+ * The settings that change what the align phase writes for a given input row.
+ *
+ * A resume under different settings would mix two policies inside one output file,
+ * so the checkpoint records these and a mismatch refuses the resume rather than continuing.
+ */
+export interface AlignSettings {
+	corpus_version: string
+	synthesize: boolean
+	license_policy: string
+	exclude_licenses: readonly string[]
+	profile: string
+	holdout_digest: string
+}
+
+/**
+ * The align phase's state at an adapter boundary.
+ */
+export interface AlignCheckpoint {
+	settings: AlignSettings
+
+	/**
+	 * Adapter ids whose rows are already in the four outputs, in the order they were aligned.
+	 *
+	 * A resume requires this to be a prefix of the current run's adapter order.
+	 * Alignment appends, so a different order would place a later adapter's rows
+	 * before an earlier one's and change every split file's contents.
+	 */
+	completed_adapters: string[]
+
+	/**
+	 * Byte length of each output at the checkpoint, after its writes were flushed.
+	 *
+	 * A resumed build shortens each file to this length.
+	 * The shortening discards whatever the interrupted adapter wrote past the boundary.
+	 */
+	offsets: Record<AlignOutputName, number>
+
+	counts: Record<"train" | "val" | "test", number>
+	aligned: number
+	quarantined: number
+	license_counts: Record<string, number>
+	refused_by_kind: Record<string, number>
+	/**
+	 * Rows the license policy refused, counted per `source`, so a resumed build carries the tally
+	 * rather than restarting it at zero and understating the refusal in its manifest.
+	 */
+	refused_by_source: Record<string, number>
+	excluded_by_license: number
+	admitted_unresolved_license_rows: number
+	excluded_by_eligibility: number
+	rows_by_source: Record<string, { rows: number; license: string }>
+	written_at: string
+}
+
+/**
+ * Read the align checkpoint, or return `null` when the build has not reached one.
+ *
+ * @throws When the checkpoint describes different settings, or an adapter order
+ * the current run does not begin with.
+ * Both cases would append this run's rows to a file written under different rules.
+ * The resulting corpus could report a row count that later readers accept.
+ */
+export async function readAlignCheckpoint(
+	path: PathBuilderLike,
+	expected: { settings: AlignSettings; adapterOrder: readonly string[] }
+): Promise<AlignCheckpoint | null> {
+	if (!(await pathExists(path))) return null
+
+	const checkpoint = await readLocalJSONFile<AlignCheckpoint>(path)
+	const found = stringifyJSON(checkpoint.settings)
+	const wanted = stringifyJSON(expected.settings)
+
+	if (found !== wanted) {
+		throw new Error(
+			`resume refused: ${path.toString()} was written under ${found} and this build runs under ${wanted}. ` +
+				`Delete the intermediate directory's labeled and quarantine files together with this checkpoint to ` +
+				`align from the start.`
+		)
+	}
+
+	const prefix = expected.adapterOrder.slice(0, checkpoint.completed_adapters.length)
+
+	if (stringifyJSON(prefix) !== stringifyJSON(checkpoint.completed_adapters)) {
+		throw new Error(
+			`resume refused: ${path.toString()} recorded ${stringifyJSON(checkpoint.completed_adapters)} as aligned ` +
+				`and this build's adapter order begins ${stringifyJSON(prefix)}. Alignment appends, so the rows would ` +
+				`land in a different order than the recorded offsets describe.`
+		)
+	}
+
+	return checkpoint
+}
+
+/**
+ * Write the align checkpoint.
+ *
+ * The caller flushes the four outputs before calling this, so every byte the offsets count is on disk.
+ */
+export function writeAlignCheckpoint(path: PathBuilderLike, checkpoint: AlignCheckpoint): Promise<void> {
+	return writeLocalJSONFile(checkpoint, path).then(() => undefined)
+}

package/lib/build/eligibility.ts

@@ -0,0 +1,96 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ * @file What the address-source register records about a row's source, read once per build.
+ */
+
+import { stringifyJSON } from "@mailwoman/core/json"
+
+import { ingestEligibilityProblems, readAddressSourceRegister, type LicenseDecision } from "#source-register"
+import type { CanonicalRow } from "#types"
+
+/**
+ * The key a row is looked up under: the adapter that emitted it and the jurisdiction it describes.
+ *
+ * The register scopes a source to one publisher in one jurisdiction,
+ * so an adapter id alone cannot address a record.
+ * One adapter serves several: `ban` emits eleven jurisdictions from one schema
+ * and each is its own source under its own license decision.
+ */
+export function sourceEligibilityKey(adapterID: string, iso2: string): string {
+	return `${adapterID}:${iso2.toUpperCase()}`
+}
+
+/**
+ * Every register source's ingest-eligibility reasons, keyed by the adapter
+ * and jurisdiction of the rows that carry it.
+ *
+ * A source declaring no `adapterID` is absent from the map, because no adapter emits it
+ * and no row can arrive under it.
+ * An empty array is the only value a caller may read as permission.
+ * An absent key is refused rather than admitted.
+ */
+export async function readSourceEligibility(): Promise<ReadonlyMap<string, readonly string[]>> {
+	const register = await readAddressSourceRegister()
+	const keyed = new Map<string, readonly string[]>()
+
+	for (const source of register.sources) {
+		if (source.adapterID === undefined) continue
+
+		keyed.set(sourceEligibilityKey(source.adapterID, source.iso2), ingestEligibilityProblems(source, register))
+	}
+
+	return keyed
+}
+
+/**
+ * The register's license decisions keyed by the label in a row.
+ *
+ * An unmatched adapter label records a `null` decision rather than inventing one.
+ */
+export async function readRegisterDecisions(): Promise<ReadonlyMap<string, LicenseDecision>> {
+	const register = await readAddressSourceRegister()
+
+	return new Map(register.licenses.map((decision) => [decision.licenseID, decision]))
+}
+
+/**
+ * Reads why a row's source may be refused from a release-eligible corpus.
+ * Records each refused source.
+ *
+ * `refused` accumulates as rows arrive.
+ * The build manifest reports the collected values.
+ *
+ * A build whose `eligibility` is `null` runs under the exploratory profile and every row reads eligible.
+ */
+export function createIneligibilityReader(eligibility: ReadonlyMap<string, readonly string[]> | null): {
+	refused: Map<string, readonly string[]>
+	read: (row: CanonicalRow) => readonly string[] | null
+} {
+	const refused = new Map<string, readonly string[]>()
+
+	return {
+		refused,
+		read: (row) => {
+			if (!eligibility) return null
+
+			const key = sourceEligibilityKey(row.source, row.country)
+			const cached = refused.get(key)
+
+			if (cached) return cached
+
+			const problems = eligibility.get(key) ?? [
+				`no register source declares ${stringifyJSON(row.source)} as its adapter in ${stringifyJSON(row.country)}, ` +
+					"so this row's publication has not been reviewed. Set `adapterID` on the source in " +
+					"`source-resolutions.json` once a review has elected it.",
+			]
+
+			if (!problems.length) return null
+
+			refused.set(key, problems)
+
+			return problems
+		},
+	}
+}

package/lib/build/heap.ts

@@ -0,0 +1,53 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ * @file The heap a build needs before a resident-record adapter may run.
+ */
+
+/**
+ * Adapter ids whose run holds every source record resident before yielding a row.
+ *
+ * Both WOF adapters build a `Map` of the whole dataset and then sort its keys,
+ * so peak memory is a property of the source rather than of `limit`.
+ * Measured 2026-09-26: `wof-admin` peaks at 14,020 MiB.
+ * Both in one process peak at 14,883 MiB.
+ */
+const RESIDENT_RECORD_ADAPTERS: ReadonlySet<string> = new Set(["wof-admin", "wof-postalcode"])
+
+/**
+ * The heap a build needs before a resident-record adapter may run, in bytes.
+ *
+ * At Node's 4 GB default both WOF adapters abort with SIGABRT, `wof-admin` at 4,085 MB after 722 seconds.
+ * The floor sits under the measured 14,883 MiB peak by enough to admit a 16 GB cap
+ * and refuse the 4 GB default.
+ */
+export const RESIDENT_ADAPTER_HEAP_FLOOR_BYTES = 15 * 1024 * 1024 * 1024
+
+/**
+ * Refuses a build whose heap cannot hold a resident-record adapter's dataset.
+ *
+ * The failure this replaces is a SIGABRT twelve minutes into an eight-hour build.
+ * That abort reports no cause and loses the adapter phase.
+ * A startup read of the limit costs one call.
+ *
+ * The `corpus build` command calls this rather than `buildCorpus`, because this package's
+ * own tests run `wof-admin` against a five-kilobyte fixture at the default heap.
+ *
+ * @throws When a resident-record adapter is configured and the heap limit is under the floor.
+ */
+export function assertHeapForAdapters(adapterIDs: readonly string[], heapLimitBytes: number): void {
+	const resident = adapterIDs.filter((id) => RESIDENT_RECORD_ADAPTERS.has(id))
+
+	if (!resident.length || heapLimitBytes >= RESIDENT_ADAPTER_HEAP_FLOOR_BYTES) return
+
+	const gib = (bytes: number): string => `${(bytes / 1024 / 1024 / 1024).toFixed(1)} GiB`
+
+	throw new Error(
+		`corpus build: the heap limit is ${gib(heapLimitBytes)} and ${resident.join(", ")} ` +
+			`${resident.length === 1 ? "holds" : "hold"} every source record resident. That peaked at 14,883 MiB ` +
+			`on 2026-09-26. Re-run with NODE_OPTIONS="--max-old-space-size=20480", or leave ` +
+			`${resident.join(", ")} out of --inputs. Under ${gib(RESIDENT_ADAPTER_HEAP_FLOOR_BYTES)} the run aborts ` +
+			`with SIGABRT partway through the adapter phase.`
+	)
+}