@workerstack/database 0.21.0 → 0.22.1

package/src/formats/iso3166-1.ts

@@ -0,0 +1,78 @@
+// Written by `bun scripts/registries.ts` from the pinned release below: edit the script, not this file.
+// Debian iso-codes v4.20.1: https://salsa.debian.org/iso-codes-team/iso-codes/-/raw/v4.20.1/data/iso_3166-1.json
+// the alpha-2 and alpha-3 code of every officially assigned country
+
+// lookup-table: the 249 codes, one line per first letter, read by isIso3166Alpha2
+const ALPHA_2: ReadonlySet<string> = /* @__PURE__ */ new Set(
+	/* @__PURE__ */ `AD AE AF AG AI AL AM AO AQ AR AS AT AU AW AX AZ
+BA BB BD BE BF BG BH BI BJ BL BM BN BO BQ BR BS BT BV BW BY BZ
+CA CC CD CF CG CH CI CK CL CM CN CO CR CU CV CW CX CY CZ
+DE DJ DK DM DO DZ
+EC EE EG EH ER ES ET
+FI FJ FK FM FO FR
+GA GB GD GE GF GG GH GI GL GM GN GP GQ GR GS GT GU GW GY
+HK HM HN HR HT HU
+ID IE IL IM IN IO IQ IR IS IT
+JE JM JO JP
+KE KG KH KI KM KN KP KR KW KY KZ
+LA LB LC LI LK LR LS LT LU LV LY
+MA MC MD ME MF MG MH MK ML MM MN MO MP MQ MR MS MT MU MV MW MX MY MZ
+NA NC NE NF NG NI NL NO NP NR NU NZ
+OM
+PA PE PF PG PH PK PL PM PN PR PS PT PW PY
+QA
+RE RO RS RU RW
+SA SB SC SD SE SG SH SI SJ SK SL SM SN SO SR SS ST SV SX SY SZ
+TC TD TF TG TH TJ TK TL TM TN TO TR TT TV TW TZ
+UA UG UM US UY UZ
+VA VC VE VG VI VN VU
+WF WS
+YE YT
+ZA ZM ZW`.split(/\s/u),
+)
+
+// lookup-table: the 249 codes, one line per first letter, read by isIso3166Alpha3
+const ALPHA_3: ReadonlySet<string> = /* @__PURE__ */ new Set(
+	/* @__PURE__ */ `ABW AFG AGO AIA ALA ALB AND ARE ARG ARM ASM ATA ATF ATG AUS AUT AZE
+BDI BEL BEN BES BFA BGD BGR BHR BHS BIH BLM BLR BLZ BMU BOL BRA BRB BRN BTN BVT BWA
+CAF CAN CCK CHE CHL CHN CIV CMR COD COG COK COL COM CPV CRI CUB CUW CXR CYM CYP CZE
+DEU DJI DMA DNK DOM DZA
+ECU EGY ERI ESH ESP EST ETH
+FIN FJI FLK FRA FRO FSM
+GAB GBR GEO GGY GHA GIB GIN GLP GMB GNB GNQ GRC GRD GRL GTM GUF GUM GUY
+HKG HMD HND HRV HTI HUN
+IDN IMN IND IOT IRL IRN IRQ ISL ISR ITA
+JAM JEY JOR JPN
+KAZ KEN KGZ KHM KIR KNA KOR KWT
+LAO LBN LBR LBY LCA LIE LKA LSO LTU LUX LVA
+MAC MAF MAR MCO MDA MDG MDV MEX MHL MKD MLI MLT MMR MNE MNG MNP MOZ MRT MSR MTQ MUS MWI MYS MYT
+NAM NCL NER NFK NGA NIC NIU NLD NOR NPL NRU NZL
+OMN
+PAK PAN PCN PER PHL PLW PNG POL PRI PRK PRT PRY PSE PYF
+QAT
+REU ROU RUS RWA
+SAU SDN SEN SGP SGS SHN SJM SLB SLE SLV SMR SOM SPM SRB SSD STP SUR SVK SVN SWE SWZ SXM SYC SYR
+TCA TCD TGO THA TJK TKL TKM TLS TON TTO TUN TUR TUV TWN TZA
+UGA UKR UMI URY USA UZB
+VAT VCT VEN VGB VIR VNM VUT
+WLF WSM
+YEM
+ZAF ZMB ZWE`.split(/\s/u),
+)
+
+/**
+ * Whether `value` is an officially assigned ISO 3166-1 alpha-2 country code, exactly as written: uppercase, such as
+ * HR or GB (UK is reserved, not assigned). The codes are those of Debian iso-codes v4.20.1. Any string is taken;
+ * this never throws.
+ */
+export function isIso3166Alpha2(value: string): boolean {
+	return ALPHA_2.has(value)
+}
+
+/**
+ * Whether `value` is an officially assigned ISO 3166-1 alpha-3 country code, exactly as written: uppercase, such as
+ * HRV or GBR. The codes are those of Debian iso-codes v4.20.1. Any string is taken; this never throws.
+ */
+export function isIso3166Alpha3(value: string): boolean {
+	return ALPHA_3.has(value)
+}

package/src/formats/iso4217.ts

@@ -0,0 +1,42 @@
+// Written by `bun scripts/registries.ts` from the pinned release below: edit the script, not this file.
+// ISO 4217 list one as SIX published it on 2026-09-17: https://www.six-group.com/dam/download/financial-information/data-center/iso-currrency/lists/list-one.xml
+// the distinct alphabetic codes
+
+// lookup-table: the 178 alphabetic codes of the 2026-09-17 list, one line per first letter, read by isIso4217
+const CODES: ReadonlySet<string> = /* @__PURE__ */ new Set(
+	/* @__PURE__ */ `AED AFN ALL AMD AOA ARS AUD AWG AZN
+BAM BBD BDT BHD BIF BMD BND BOB BOV BRL BSD BTN BWP BYN BZD
+CAD CDF CHE CHF CHW CLF CLP CNY COP COU CRC CUP CVE CZK
+DJF DKK DOP DZD
+EGP ERN ETB EUR
+FJD FKP
+GBP GEL GHS GIP GMD GNF GTQ GYD
+HKD HNL HTG HUF
+IDR ILS INR IQD IRR ISK
+JMD JOD JPY
+KES KGS KHR KMF KPW KRW KWD KYD KZT
+LAK LBP LKR LRD LSL LYD
+MAD MDL MGA MKD MMK MNT MOP MRU MUR MVR MWK MXN MXV MYR MZN
+NAD NGN NIO NOK NPR NZD
+OMR
+PAB PEN PGK PHP PKR PLN PYG
+QAR
+RON RSD RUB RWF
+SAR SBD SCR SDG SEK SGD SHP SLE SOS SRD SSP STN SVC SYP SZL
+THB TJS TMT TND TOP TRY TTD TWD TZS
+UAH UGX USD USN UYI UYU UYW UZS
+VED VES VND VUV
+WST
+XAD XAF XAG XAU XBA XBB XBC XBD XCD XCG XDR XOF XPD XPF XPT XSU XTS XUA XXX
+YER
+ZAR ZMW ZWG`.split(/\s/u),
+)
+
+/**
+ * Whether `value` is a current ISO 4217 alphabetic currency code, exactly as written: uppercase, such as EUR or USD.
+ * The codes are those of the list published 2026-09-17, fund and precious metal codes such as XAU included;
+ * a withdrawn code such as HRK is not one. Any string is taken; this never throws.
+ */
+export function isIso4217(value: string): boolean {
+	return CODES.has(value)
+}

package/src/formats/iso639-1.ts

@@ -0,0 +1,41 @@
+// Written by `bun scripts/registries.ts` from the pinned release below: edit the script, not this file.
+// Debian iso-codes v4.20.1: https://salsa.debian.org/iso-codes-team/iso-codes/-/raw/v4.20.1/data/iso_639-2.json
+// the two-letter code of every ISO 639-2 language that has one, which is ISO 639-1
+
+// lookup-table: the 183 two-letter language codes, one line per first letter, read by isIso639Alpha2
+const CODES: ReadonlySet<string> = /* @__PURE__ */ new Set(
+	/* @__PURE__ */ `aa ab ae af ak am an ar as av ay az
+ba be bg bi bm bn bo br bs
+ca ce ch co cr cs cu cv cy
+da de dv dz
+ee el en eo es et eu
+fa ff fi fj fo fr fy
+ga gd gl gn gu gv
+ha he hi ho hr ht hu hy hz
+ia id ie ig ii ik io is it iu
+ja jv
+ka kg ki kj kk kl km kn ko kr ks ku kv kw ky
+la lb lg li ln lo lt lu lv
+mg mh mi mk ml mn mr ms mt my
+na nb nd ne ng nl nn no nr nv ny
+oc oj om or os
+pa pi pl ps pt
+qu
+rm rn ro ru rw
+sa sc sd se sg si sk sl sm sn so sq sr ss st su sv sw
+ta te tg th ti tk tl tn to tr ts tt tw ty
+ug uk ur uz
+ve vi vo
+wa wo
+xh
+yi yo
+za zh zu`.split(/\s/u),
+)
+
+/**
+ * Whether `value` is an ISO 639-1 two-letter language code, exactly as written: lowercase, such as hr or en. The
+ * codes are those of Debian iso-codes v4.20.1. Any string is taken; this never throws.
+ */
+export function isIso639Alpha2(value: string): boolean {
+	return CODES.has(value)
+}

package/src/formats/uts35.ts

@@ -0,0 +1,143 @@
+// Written by `bun scripts/registries.ts` from the pinned release below: edit the script, not this file.
+// Unicode CLDR release-49:
+//   https://raw.githubusercontent.com/unicode-org/cldr/release-49/common/bcp47/calendar.xml
+//   https://raw.githubusercontent.com/unicode-org/cldr/release-49/common/bcp47/measure.xml
+//   https://raw.githubusercontent.com/unicode-org/cldr/release-49/common/bcp47/number.xml
+
+/** The 18 values of the `ca` (calendar) key of a Unicode locale extension, deprecated ones dropped. */
+export const CALENDARS: readonly string[] = [
+	"buddhist",
+	"chinese",
+	"coptic",
+	"dangi",
+	"ethioaa",
+	"ethiopic",
+	"gregory",
+	"hebrew",
+	"indian",
+	"islamic",
+	"islamic-civil",
+	"islamic-rgsa",
+	"islamic-tbla",
+	"islamic-umalqura",
+	"iso8601",
+	"japanese",
+	"persian",
+	"roc",
+]
+
+/** The 7 values of the `fw` (first day of the week) key of a Unicode locale extension, deprecated ones dropped. */
+export const FIRST_DAYS: readonly string[] = ["fri", "mon", "sat", "sun", "thu", "tue", "wed"]
+
+/** The 6 values of the `hc` (hour cycle) key of a Unicode locale extension, deprecated ones dropped. */
+export const HOUR_CYCLES: readonly string[] = ["c12", "c24", "h11", "h12", "h23", "h24"]
+
+/** The 3 values of the `ms` (measurement system) key of a Unicode locale extension, deprecated ones dropped. */
+export const MEASUREMENT_SYSTEMS: readonly string[] = ["metric", "uksystem", "ussystem"]
+
+/** The 3 values of the `mu` (temperature unit) key of a Unicode locale extension, deprecated ones dropped. */
+export const MEASUREMENT_UNITS: readonly string[] = ["celsius", "fahrenhe", "kelvin"]
+
+/** The 100 values of the `nu` (numbering system) key of a Unicode locale extension, deprecated ones dropped. */
+export const NUMBERING_SYSTEMS: readonly string[] = [
+	"adlm",
+	"ahom",
+	"arab",
+	"arabext",
+	"armn",
+	"armnlow",
+	"bali",
+	"beng",
+	"bhks",
+	"brah",
+	"cakm",
+	"cham",
+	"cyrl",
+	"deva",
+	"diak",
+	"ethi",
+	"finance",
+	"fullwide",
+	"gara",
+	"geor",
+	"gong",
+	"gonm",
+	"grek",
+	"greklow",
+	"gujr",
+	"gukh",
+	"guru",
+	"hanidays",
+	"hanidec",
+	"hans",
+	"hansfin",
+	"hant",
+	"hantfin",
+	"hebr",
+	"hmng",
+	"hmnp",
+	"java",
+	"jpan",
+	"jpanfin",
+	"jpanyear",
+	"kali",
+	"kawi",
+	"khmr",
+	"knda",
+	"krai",
+	"lana",
+	"lanatham",
+	"laoo",
+	"latn",
+	"lepc",
+	"limb",
+	"mathbold",
+	"mathdbl",
+	"mathmono",
+	"mathsanb",
+	"mathsans",
+	"mlym",
+	"modi",
+	"mong",
+	"mroo",
+	"mtei",
+	"mymr",
+	"mymrepka",
+	"mymrpao",
+	"mymrshan",
+	"mymrtlng",
+	"nagm",
+	"native",
+	"newa",
+	"nkoo",
+	"olck",
+	"onao",
+	"orya",
+	"osma",
+	"outlined",
+	"rohg",
+	"roman",
+	"romanlow",
+	"saur",
+	"segment",
+	"shrd",
+	"sind",
+	"sinh",
+	"sora",
+	"sund",
+	"sunu",
+	"takr",
+	"talu",
+	"taml",
+	"tamldec",
+	"telu",
+	"thai",
+	"tibt",
+	"tirh",
+	"tnsa",
+	"tols",
+	"traditio",
+	"vaii",
+	"wara",
+	"wcho",
+]

package/src/index.ts

@@ -1,4 +1,9 @@
 export { isCidr } from "./cidr.ts"
+export type { IntegerFormat, TextFormat } from "./formats/catalog.ts"
+export { isIanaTimeZone } from "./formats/iana-time-zone.ts"
+export { isIso3166Alpha2, isIso3166Alpha3 } from "./formats/iso3166-1.ts"
+export { isIso4217 } from "./formats/iso4217.ts"
+export { isIso639Alpha2 } from "./formats/iso639-1.ts"
 export { jsonValue } from "./json-value.ts"
 export { CombError } from "./error.ts"
 export {

package/src/meta/column.ts

@@ -45,19 +45,32 @@ function combColumnMeta(column: unknown): CombColumnMeta | undefined {
 	return config?.[COMB_COLUMN] as CombColumnMeta | undefined
 }
 
-/** A c.enum's options as its column's record: the flags its constraints, the rest its state machine, none when it names no state */
+/** `record` without the keys set to undefined, as a key set to undefined is one left out */
+function defined(record: Readonly<Record<string, unknown>>): Record<string, unknown> {
+	return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined))
+}
+
+/**
+ * A c.enum's options as its column's record: its constraints (the flags, its `format`, and a `schema`
+ * a JavaScript caller passes, kept for codegen to refuse by name), the rest its state machine, none
+ * when it names no state
+ */
 function enumMeta(
 	values: readonly string[],
-	options: { nomutate?: boolean | undefined; private?: boolean | undefined; tenant?: boolean | undefined } = {},
+	options: {
+		format?: string | undefined
+		nomutate?: boolean | undefined
+		private?: boolean | undefined
+		schema?: unknown
+		tenant?: boolean | undefined
+	} = {},
 ): { [K in keyof CombColumnMeta]: CombColumnMeta[K] | undefined } {
-	const { nomutate, private: hidden, tenant, ...given } = options
-	const flags = { nomutate, private: hidden, tenant }
-	const flagged = Object.values(flags).some((flag) => flag !== undefined)
-	/* a state set to undefined is one left out */
-	const states = Object.fromEntries(Object.entries(given).filter(([, value]) => value !== undefined))
-	const whole = !flagged && Object.keys(states).length === Object.keys(options).length
+	const { format, nomutate, private: hidden, schema, tenant, ...rest } = options
+	const constraints = defined({ format, nomutate, private: hidden, schema, tenant })
+	const states = defined(rest)
+	const whole = Object.keys(constraints).length === 0 && Object.keys(states).length === Object.keys(options).length
 	return {
-		constraints: flagged ? flags : undefined,
+		constraints: Object.keys(constraints).length === 0 ? undefined : constraints,
 		kind: "enum",
 		/* a machine given alone is kept as the very object passed, as assertTransition takes it too */
 		states: Object.keys(states).length === 0 ? undefined : whole ? options : states,

package/src/migrate/core/apply.ts

@@ -6,8 +6,10 @@
  */
 import { chainText } from "../../error-chain.ts"
 import type { Connection } from "../types.ts"
+import { pastStop } from "./cleanup.ts"
 import { HASH_VERSION } from "./parse.ts"
 import { Refused } from "./refused.ts"
+import { whileStoppable } from "./stopped.ts"
 import { isTransient } from "./transient.ts"
 import { type RetryOptions, withRetry } from "./utils.ts"
 
@@ -24,19 +26,39 @@ const TABLE = `(
       hash_v INTEGER
     )`
 
-/** Whether a unique index of comb's history holds its hash alone, as comb's table did before 0.13 */
-export async function hashUnique(conn: Connection): Promise<boolean> {
+/** Whether a unique index of comb's history holds `column` alone */
+async function uniqueOn(conn: Connection, column: string): Promise<boolean> {
 	const list = await conn.execute("PRAGMA index_list(__drizzle_migrations)")
 	const unique = list.rows.filter((row) => Number(row[list.columns.indexOf("unique")]) === 1)
 	for (const index of unique) {
 		const name = String(index[list.columns.indexOf("name")])
 		const info = await conn.execute(`PRAGMA index_info("${name.replaceAll('"', '""')}")`)
 		const columns = info.rows.map((row) => String(row[info.columns.indexOf("name")]))
-		if (columns.length === 1 && columns[0] === "hash") return true
+		if (columns.length === 1 && columns[0] === column) return true
 	}
 	return false
 }
 
+/** Whether a unique index of comb's history holds its hash alone, as comb's table did before 0.13 */
+export const hashUnique = (conn: Connection): Promise<boolean> => uniqueOn(conn, "hash")
+
+/**
+ * A name recorded once, whoever made the table: a history drizzle's migrator made gains `name` by ALTER
+ * and no UNIQUE with it, so nothing would refuse a second run's record of a file the first applied.
+ * Refused, naming the files, when the history already holds one twice
+ */
+async function keepNameUnique(conn: Connection): Promise<void> {
+	if (await uniqueOn(conn, "name")) return
+	const twice = await conn.execute(
+		"SELECT name FROM __drizzle_migrations WHERE name IS NOT NULL GROUP BY name HAVING count(*) > 1 ORDER BY name",
+	)
+	if (twice.rows.length > 0)
+		throw new Error(
+			`__drizzle_migrations records ${twice.rows.map((row) => String(row[0])).join(", ")} more than once, so comb cannot keep a file from being recorded twice: delete the extra rows of each (keep the first), then run it again`,
+		)
+	await conn.execute("CREATE UNIQUE INDEX IF NOT EXISTS __drizzle_migrations_name ON __drizzle_migrations (name)")
+}
+
 /**
  * comb's history, made where it is missing, named from 0.11, and from a history before 0.13
  * rebuilt in one batch: every row and id kept, each row `renamed` lists taking its new name,
@@ -55,7 +77,7 @@ export async function ensureMigrationsTable(
 	/* a history 0.20 or earlier wrote gains it too, every row it holds left without it */
 	if (!has("hash_v")) await conn.execute("ALTER TABLE __drizzle_migrations ADD COLUMN hash_v INTEGER")
 	/* a history from before 0.13 holds each hash once: rebuilt, in one batch, with every row and id kept */
-	if (!(await hashUnique(conn))) return
+	if (!(await hashUnique(conn))) return keepNameUnique(conn)
 	/* a history made without AUTOINCREMENT has no counter; its largest id is where the new one starts */
 	const sequenced = await conn.execute("SELECT 1 FROM sqlite_master WHERE name = 'sqlite_sequence'")
 	const counted =
@@ -151,7 +173,8 @@ class Unconfirmed extends Error {}
  * record it wrote says it ran, so a retry reads the history first and runs nothing again.
  * When no read of `history` answers after a batch that failed transiently, the failure is an Unconfirmed.
  * The record goes first, so a batch whose file another run recorded while it waited for the lock
- * fails on the name at once and runs nothing; the history then says so, and it is that run's.
+ * fails on the name's unique index at once and runs nothing (ensureMigrationsTable keeps one on every
+ * history, whoever made the table); the history then says so, and it is that run's.
  * Returns who applied it.
  */
 export async function applyRecorded(
@@ -207,24 +230,42 @@ export async function applyEach(
 	{ history, print, retry }: ApplyOptions & { print: (line: string) => void },
 ): Promise<void> {
 	const names = migrations.map(({ filename }) => filename)
-	for (const [at, migration] of migrations.entries()) {
-		print(`Apply: ${migration.filename}`)
-		try {
-			const conn = await open()
+	/* the files that committed, and the batch under way, which a stop waits for: it commits or fails whole */
+	let done = 0
+	let batching: Promise<unknown> = Promise.resolve()
+	const read = async () => {
+		await batching.catch(() => {
+			// reason: a batch that failed committed nothing, which the count it left already says
+		})
+		return { applied: names.slice(0, done), pending: names.slice(done) }
+	}
+	await whileStoppable({ names, print, read }, async () => {
+		for (const [at, migration] of migrations.entries()) {
+			/* a stop parks the run here, whichever connection the next file would open */
+			await pastStop()
+			print(`Apply: ${migration.filename}`)
 			try {
-				if ((await applyRecorded(conn, migration, { history, retry })) === "another run")
-					print(`Skip (applied by another run): ${migration.filename}`)
-			} finally {
-				await conn.close()
+				const conn = await open()
+				try {
+					/* counted with the batch, so a stop that waited for it reads the count it made */
+					const batch = applyRecorded(conn, migration, { history, retry }).then((who) => {
+						done++
+						return who
+					})
+					batching = batch
+					if ((await batch) === "another run") print(`Skip (applied by another run): ${migration.filename}`)
+				} finally {
+					await conn.close()
+				}
+			} catch (error) {
+				const applied = names.slice(0, at)
+				if (applied.length > 0) print(`Applied before the failure: ${applied.join(", ")}`)
+				/* withRetry throws an Error, whatever the batch threw; so does a connection that would not open */
+				const message = (error as Error).message
+				if (error instanceof Unconfirmed)
+					throw new Refused(message, { applied, pending: names.slice(at + 1), unknown: [migration.filename] })
+				throw new Refused(message, { applied, pending: names.slice(at) })
 			}
-		} catch (error) {
-			const done = names.slice(0, at)
-			if (done.length > 0) print(`Applied before the failure: ${done.join(", ")}`)
-			/* withRetry throws an Error, whatever the batch threw; so does a connection that would not open */
-			const message = (error as Error).message
-			if (error instanceof Unconfirmed)
-				throw new Refused(message, { applied: done, pending: names.slice(at + 1), unknown: [migration.filename] })
-			throw new Refused(message, { applied: done, pending: names.slice(at) })
 		}
-	}
+	})
 }

package/src/migrate/core/atlas-apply-runs.ts

@@ -4,11 +4,11 @@
  * reading of a file proves what it leaves on its session: a trigger, a default, a DO block's EXECUTE
  * or code the target holds can each run a SET that outlives its COMMIT.
  */
-import { hold } from "./cleanup.ts"
 import { type Foreign, ownHistory } from "./atlas-foreign.ts"
 import { type AtlasFile, type AtlasStatus, checkHistory } from "./atlas-history.ts"
 import { APPLY_FORMAT, NON_LINEAR, reported } from "./atlas-report.ts"
 import { atlas, type AtlasCommand, atlasStatus } from "./atlas-status.ts"
+import { whileStoppable } from "./stopped.ts"
 
 /**
  * After an Atlas call that ran no file and said nothing, once this apply ran `applied`: done once
@@ -29,27 +29,17 @@ async function ranNothing(
 }
 
 /**
- * What SIGINT or SIGTERM runs once it stopped this apply's Atlas call and that call ended (cleanup.ts
- * runs a child's step before this one): the history read once more, and which approved
- * files it records and which it does not, printed; no further call starts, and the process then ends
- * by the signal
+ * The approved files the history records and those it does not, read once Atlas's call ended after a
+ * stop signal (cleanup.ts runs a child's step before this apply's): what stopped.ts reports
  */
-const stoppedBy =
+const found =
 	(options: AtlasCommand, copy: string, { approved, foreign }: { approved: ReadonlySet<string>; foreign: Foreign }) =>
-	async (signal: NodeJS.Signals): Promise<void> => {
-		try {
-			const { pending } = ownHistory(await atlasStatus(options, copy), foreign, copy)
-			const left = new Set(pending.map((file) => file.Name))
-			const [ran, not] = [
-				[...approved].filter((name) => !left.has(name)),
-				[...approved].filter((name) => left.has(name)),
-			]
-			options.print(
-				`Stopped by ${signal}: applied ${ran.join(", ") || "none"}; not applied ${not.join(", ") || "none"}`,
-			)
-		} catch (error) {
-			// reason: a history read that fails must not hide the stop: the line says what comb could not read, and the process still ends by the signal
-			options.print(`Stopped by ${signal}: comb could not read what was applied: ${(error as Error).message}`)
+	async (): Promise<{ applied: string[]; pending: string[] }> => {
+		const { pending } = ownHistory(await atlasStatus(options, copy), foreign, copy)
+		const left = new Set(pending.map((file) => file.Name))
+		return {
+			applied: [...approved].filter((name) => !left.has(name)),
+			pending: [...approved].filter((name) => left.has(name)),
 		}
 	}
 
@@ -67,12 +57,11 @@ async function applyRuns(
 	{ foreign, report, status }: { foreign: Foreign; report: Parameters<typeof checkHistory>[2]; status: AtlasStatus },
 ): Promise<string[]> {
 	const approved = new Set(status.pending.map((file) => file.Name))
-	const release = hold(stoppedBy(options, copy, { approved, foreign }))
-	try {
-		return await callEach(options, copy, { approved, foreign, report })
-	} finally {
-		release()
-	}
+	/* no further call starts, and the process then ends by the signal, after the report: a stop parks this loop */
+	return whileStoppable(
+		{ names: [...approved], print: options.print, read: found(options, copy, { approved, foreign }) },
+		() => callEach(options, copy, { approved, foreign, report }),
+	)
 }
 
 /** applyRuns' calls, each of the first file still pending, until every approved file ran */

package/src/migrate/core/cleanup.ts

@@ -1,6 +1,6 @@
 /**
  * comb's one cleanup rule: what a run makes outside itself (a scratch
- * directory, a replay database) is held here until the run lets it go, and SIGINT or SIGTERM runs
+ * directory, a replay database) is held here until the run lets it go, and a stop signal runs
  * every step still held before the process ends as the signal would. A scratch directory is named
  * for the process that made it, so a later run removes one a killed process left at once, by
  * whether that process still runs.
@@ -11,14 +11,25 @@ import fs from "node:fs"
 import os from "node:os"
 import path from "node:path"
 
-/** A step a signal runs, told which signal came */
-type Step = (signal: NodeJS.Signals) => unknown
+/**
+ * A step a signal runs, told which signal came and what the steps that ran before it returned, in
+ * that order: a step held first runs last, and reads what the steps held after it found out
+ */
+type Step = (signal: NodeJS.Signals, earlier: readonly unknown[]) => unknown
 
 // per-process-constant: what this process holds now
 const held = /* @__PURE__ */ new Set<Step>()
 
-/* the signals a held step runs on: a Ctrl-C, and what a supervisor, a container stop or a CI step timeout sends */
-const SIGNALS = ["SIGINT", "SIGTERM"] as const
+/**
+ * The signals a held step runs on: every one whose default action ends the process and that a
+ * terminal or a supervisor sends. A Ctrl-C (SIGINT), a Ctrl-\ (SIGQUIT), a container stop or a CI
+ * step timeout (SIGTERM), and a terminal's hangup, as an SSH drop sends it (SIGHUP): a child in a
+ * group of its own gets none of them from the terminal, so comb's forward is its only signal.
+ */
+export const STOP_SIGNALS = ["SIGHUP", "SIGINT", "SIGQUIT", "SIGTERM"] as const
+
+/** One of STOP_SIGNALS */
+export type StopSignal = (typeof STOP_SIGNALS)[number]
 
 // per-process-constant: the steps a signal is running, so a step's own work goes on while what it stops waits
 const inStep = /* @__PURE__ */ new AsyncLocalStorage<true>()
@@ -45,9 +56,10 @@ function newGate(): Gate {
 
 /** Every step, last held first, each once the one before ends: a child stops before the scratch it used goes */
 async function runSteps(steps: readonly Step[], signal: NodeJS.Signals): Promise<void> {
+	const returned: unknown[] = []
 	for (const step of steps.toReversed()) {
 		try {
-			await step(signal)
+			returned.push(await step(signal, [...returned]))
 		} catch {
 			// reason: one step that fails must not keep the rest from cleaning up; the process ends either way
 		}
@@ -77,7 +89,7 @@ function stop(signal: NodeJS.Signals): void {
 		gate = undefined
 		if (process.listenerCount(signal) > 1) return current.let()
 		/* both gone before the signal comes again, so it ends the process, and what waits for this stop waits on */
-		for (const each of SIGNALS) process.off(each, stop)
+		for (const each of STOP_SIGNALS) process.off(each, stop)
 		process.kill(process.pid, signal)
 	})
 }
@@ -101,11 +113,11 @@ export function pastStop(): Promise<void> {
 }
 
 /**
- * Hold `step` until the release this returns, so SIGINT and SIGTERM run it before the process ends.
+ * Hold `step` until the release this returns, so a stop signal runs it before the process ends.
  * The listener is read from the process, not remembered: a host that removed every listener gets it back.
  */
 export function hold(step: Step): () => void {
-	for (const signal of SIGNALS) if (!process.listeners(signal).includes(stop)) process.on(signal, stop)
+	for (const signal of STOP_SIGNALS) if (!process.listeners(signal).includes(stop)) process.on(signal, stop)
 	held.add(step)
 	return () => void held.delete(step)
 }
@@ -199,7 +211,7 @@ export type Scratch = { dir: string; remove(): void }
 
 /**
  * A new directory under the temp directory that only this user can open (0700), named `prefix`, this
- * process's pid and host mark, and removed by `remove`, or by SIGINT or SIGTERM before it. A
+ * process's pid and host mark, and removed by `remove`, or by a stop signal before it. A
  * process's first scratch of a prefix sweeps what killed runs left.
  */
 export function scratchDir(prefix: string): Scratch {