@workerstack/database 0.22.0 → 0.23.0

package/src/cli/migrate.ts

@@ -1,7 +1,7 @@
 /** `comb migrate`: init, diff, check, apply, baseline and status. */
 import fs from "node:fs"
 import path from "node:path"
-import { parseArgs, refuseFurther } from "./args.ts"
+import { parseArgs, refuseFurther, usageOf } from "./args.ts"
 import { binOf } from "../migrate/core/optional-peer.ts"
 import { declaredFts, ftsSql } from "./comb-config.ts"
 import {
@@ -14,7 +14,8 @@ import {
 } from "./drizzle-dialect.ts"
 import { migrateApply, needPeers } from "./migrate-apply.ts"
 import { type MigrateTarget, refuseBlank, refuseNoDir, resolveMigrateTarget } from "./migrate-target.ts"
-import { CliError, type CliContext } from "./output.ts"
+import { refusePathName } from "./file-path.ts"
+import { CliError, type CliContext, ShowHelp } from "./output.ts"
 import { scratchDir } from "../migrate/core/cleanup.ts"
 
 const DRIZZLE_CONFIG = `import { defineConfig } from "drizzle-kit"
@@ -100,10 +101,12 @@ function migrateInit(argv: readonly string[], io: CliContext): void {
  * database's dialect, directory and drizzle config come from it; without, it is SQLite in
  * ./atlas-migrations.
  */
-async function migrateDiff(argv: readonly string[], io: CliContext): Promise<void> {
+async function runDiff(argv: readonly string[], io: CliContext): Promise<void> {
 	const args = parseArgs(argv, "migrate diff")
 	/* parseArgs refuses a diff that names no database */
 	const [db, name] = args.positionals as [string, (string | undefined)?]
+	/* Atlas makes the file's name from it: a path would land outside the directory, or nowhere */
+	if (name !== undefined) refusePathName(name, "Migration name", usageOf("migrate diff"))
 	const env = args.options["env"] as string | undefined
 	const { d1, expected, exported, fts, migrationsDir, pg, provider, target } = await diffTarget(db, env, io)
 	/* a diff starts a missing directory, and refuses a file before anything runs */
@@ -229,7 +232,26 @@ function reportDrift(db: string, files: readonly string[], io: CliContext): neve
 		io.out(`-- ${path.basename(file)}`)
 		io.out(fs.readFileSync(file, "utf8"))
 	}
-	throw new CliError(`${db} has drifted from its migrations: comb migrate diff ${db} would write the SQL above`)
+	throw new Drifted(`${db} has drifted from its migrations: comb migrate diff ${db} would write the SQL above`)
+}
+
+/** A dry run's refusal for drift, which exits 1 */
+class Drifted extends CliError {}
+
+/**
+ * `migrate diff`. A dry run is a drift gate, so it exits 1 for drift alone, and 2 for every failure
+ * that kept it from checking, the argv's own refusal among them: --dry-run is read from argv, as
+ * the CLI reads --json, so that refusal knows it is a dry run's
+ */
+async function migrateDiff(argv: readonly string[], io: CliContext): Promise<void> {
+	if (!argv.includes("--dry-run")) return runDiff(argv, io)
+	try {
+		await runDiff(argv, io)
+	} catch (error) {
+		if (error instanceof Drifted || error instanceof ShowHelp) throw error
+		/* an Error: comb throws only Errors, and a config's load wraps whatever the config throws (migrate/config.ts) */
+		throw new CliError((error as Error).message, 2, { cause: error })
+	}
 }
 
 export async function cmdMigrate(argv: readonly string[], io: CliContext, help: string): Promise<void> {

package/src/formats/bcp47.ts

@@ -0,0 +1,12 @@
+import { formatTakes } from "./catalog.ts"
+
+/**
+ * Whether `value` is a well-formed BCP 47 language tag, RFC 5646 §2.1's Language-Tag, exactly as
+ * written: a langtag such as zh-Hant-TW or es-419, a private-use tag such as x-private, or a
+ * grandfathered tag such as i-klingon. It takes what a `format: "bcp47"` column takes before its
+ * trim, from the same grammar: it never trims or folds case, so " en" is no tag. A value that is no
+ * string at runtime is refused, and this never throws.
+ */
+export function isBcp47(value: string): boolean {
+	return typeof value === "string" && formatTakes("bcp47", value)
+}

package/src/formats/catalog.ts

@@ -98,13 +98,28 @@ const LOWERCASE: Transforms = ["trim", "lowercase"]
 const UPPERCASE: Transforms = ["trim", "uppercase"]
 
 /*
- * RFC 5646 §2.1's langtag: language (with up to three extlangs), script, region, variants, extensions
- * and private use, each class case-insensitive; a grandfathered tag is no langtag
+ * RFC 5646 §2.1's Language-Tag, each class case-insensitive: a langtag (language with up to three
+ * extlangs, script, region, variants, extensions and private use), a private-use tag alone, or an
+ * irregular grandfathered tag; the regular grandfathered tags, such as zh-min-nan, are langtags
  */
 const LANGUAGE = "(?:[A-Za-z]{2,3}(?:-[A-Za-z]{3}){0,3}|[A-Za-z]{4,8})"
 const VARIANTS = "(?:-(?:[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*"
 const EXTENSIONS = "(?:-[0-9A-WYZa-wyz](?:-[A-Za-z0-9]{2,8})+)*"
-const LANGTAG = `${LANGUAGE}(?:-[A-Za-z]{4})?(?:-(?:[A-Za-z]{2}|[0-9]{3}))?${VARIANTS}${EXTENSIONS}(?:-[Xx](?:-[A-Za-z0-9]{1,8})+)?`
+const PRIVATE_USE = "[Xx](?:-[A-Za-z0-9]{1,8})+"
+const LANGTAG = `${LANGUAGE}(?:-[A-Za-z]{4})?(?:-(?:[A-Za-z]{2}|[0-9]{3}))?${VARIANTS}${EXTENSIONS}(?:-${PRIVATE_USE})?`
+/* RFC 5646 §2.1's irregular grandfathered tags, which match no langtag */
+const IRREGULAR =
+	"en-GB-oed i-ami i-bnn i-default i-enochian i-hak i-klingon i-lux i-mingo i-navajo i-pwn i-tao i-tay i-tsu sgn-BE-FR sgn-BE-NL sgn-CH-DE"
+
+/** `tag` with each letter a class of its two cases, as the rest of the grammar reads them */
+const anyCase = (tag: string): string =>
+	tag.replace(/[A-Za-z]/gu, (letter) => `[${letter.toUpperCase()}${letter.toLowerCase()}]`)
+
+/** RFC 5646 §2.1's Language-Tag, anchored: langtag / privateuse / grandfathered */
+function languageTagSource(): string {
+	const grandfathered = IRREGULAR.split(" ").map(anyCase).join("|")
+	return `^(?:${LANGTAG}|${PRIVATE_USE}|${grandfathered})$`
+}
 
 /* semver.org 2.0.0's version pattern, its groups non-capturing */
 const NUMBER = "(?:0|[1-9][0-9]*)"
@@ -194,7 +209,15 @@ function specs(): { readonly [F in TextFormat]: FormatSpec } {
 	return {
 		base64url: spec(["RFC 4648 §5 base64url, unpadded", UNPADDED, 0, null, TRIM, null, "dGVzdA"]),
 		/* RFC 5646 §4.4.1's 35 is the buffer an implementation must hold, not a cap on a tag */
-		bcp47: spec(["BCP 47 language tag, RFC 5646 §2.1 well-formed", `^${LANGTAG}$`, 2, null, TRIM, null, "zh-Hant-TW"]),
+		bcp47: spec([
+			"BCP 47 language tag, RFC 5646 §2.1 well-formed",
+			languageTagSource(),
+			2,
+			null,
+			TRIM,
+			null,
+			"zh-Hant-TW",
+		]),
 		e164: spec(["ITU-T E.164 phone number, + and up to 15 digits", "^\\+[1-9][0-9]{1,14}$", 3, 16, TRIM, null, PHONE]),
 		"iana-time-zone": spec(["IANA time zone name, tzdata 2026f", ZONE_NAME, 1, 64, TRIM, "isIanaTimeZone", ZONE]),
 		ip: spec([ADDRESS, `^(?:${ipv4}|${ipv6})$`, 2, 45, LOWERCASE, null, IPV6]),

package/src/index.ts

@@ -1,4 +1,5 @@
 export { isCidr } from "./cidr.ts"
+export { isBcp47 } from "./formats/bcp47.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"

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 {

package/src/migrate/core/d1-engine-child.mjs

@@ -9,10 +9,12 @@
  * Then each file as wrangler sends it, the file and the history row it appends, through wrangler's
  * `splitSqlQuery`, in one batch. D1 resolves a function in a trigger body, a view or a generated
  * column only when a statement uses it, so EXPLAIN then compiles each view, and each table's INSERT,
- * UPDATE and DELETE, the file made or changed. What D1 refuses comes back in D1's own words.
+ * UPDATE and DELETE, the file made or changed; a view takes only the writes its INSTEAD OF triggers fire
+ * on (trigger-write.mjs). What D1 refuses comes back in D1's own words.
  */
 import { readFileSync } from "node:fs"
 import { pathToFileURL } from "node:url"
+import { EVENTS, quote, triggerEvent, writeOf } from "./trigger-write.mjs"
 
 /**
  * @typedef {{ all(): Promise<{ results?: Array<Record<string, unknown>> | undefined }> }} D1Statement
@@ -27,9 +29,6 @@ import { pathToFileURL } from "node:url"
  * @typedef {import("./d1-engine-child.d.mts").ProofResult} ProofResult
  */
 
-/** @param {string} name */
-const quote = (name) => `"${name.replaceAll('"', '""')}"`
-
 /**
  * D1's own words for a failure: the cause wrangler's client wraps, when there is one
  * @param {unknown} error
@@ -87,7 +86,8 @@ async function isRowTable(db, table) {
  * @returns {Promise<string[]>}
  */
 async function probes(db, before) {
-	const changed = [...(await master(db))].filter(([key, object]) => before.get(key)?.sql !== object.sql)
+	const after = [...(await master(db))]
+	const changed = after.filter(([key, object]) => before.get(key)?.sql !== object.sql)
 	const views = changed.filter(([, object]) => object.type === "view").map(([, object]) => object.table)
 	const tables = new Set(changed.filter(([, object]) => object.type === "trigger").map(([, object]) => object.table))
 	for (const [, object] of changed)
@@ -96,16 +96,32 @@ async function probes(db, before) {
 	const writes = []
 	for (const table of tables) {
 		const { results = [] } = await db.prepare(`PRAGMA table_xinfo(${quote(table)})`).all()
-		const columns = results.filter((row) => row["hidden"] === 0).map((row) => quote(String(row["name"])))
-		writes.push(
-			`EXPLAIN INSERT INTO ${quote(table)} DEFAULT VALUES`,
-			`EXPLAIN UPDATE ${quote(table)} SET ${columns.map((column) => `${column} = ${column}`).join(", ")}`,
-			`EXPLAIN DELETE FROM ${quote(table)}`,
-		)
+		const columns = results.filter((row) => row["hidden"] === 0).map((row) => String(row["name"]))
+		for (const event of eventsOf(after, table)) writes.push(`EXPLAIN ${writeOf(table, event, columns)}`)
 	}
 	return [...views.map((view) => `EXPLAIN SELECT * FROM ${quote(view)}`), ...writes]
 }
 
+/**
+ * `name` as SQLite compares names, ASCII letters folded alone: a trigger's tbl_name is spelled as its ON clause was
+ * @param {string} name
+ */
+const fold = (name) => name.replace(/[A-Z]/g, (letter) => letter.toLowerCase())
+
+/**
+ * The writes `table` takes in the schema `objects`: a table every one, a view each its triggers fire on
+ * @param {ReadonlyArray<[string, SchemaObject]>} objects
+ * @param {string} table
+ */
+function eventsOf(objects, table) {
+	const on = objects.filter(([, object]) => fold(object.table) === fold(table))
+	if (!on.some(([, object]) => object.type === "view")) return EVENTS
+	const fired = new Set(
+		on.filter(([, object]) => object.type === "trigger").map(([, object]) => triggerEvent(object.sql)),
+	)
+	return EVENTS.filter((event) => fired.has(event))
+}
+
 /**
  * The scratch D1 a proof runs on: what it holds is replayed on a fresh one when workerd crashes,
  * which a disconnect shows ("other side closed"), not a D1 error

package/src/migrate/core/d1-history.ts

@@ -15,7 +15,7 @@ import { executeAll } from "../drivers/d1.ts"
 import { lockedOut } from "../drivers/d1-lock.ts"
 import { assertLocalExists, type D1Target, localMissing, type ReadConfig, resolveBinding } from "./d1-binding.ts"
 import { d1Files, refuseSwallowing } from "./d1-files.ts"
-import { applyFailure, wranglerError } from "./d1-wrangler-error.ts"
+import { refuseUnlike } from "./d1-wrangler-error.ts"
 import { D1_HASH_INTENT_TABLE, D1_HASH_TABLE, DRIZZLE_HISTORY_TABLE } from "./d1-history-tables.ts"
 import {
 	type Hashed,
@@ -37,8 +37,9 @@ import { orphanMessage } from "./history-match.ts"
 import { generateMigrationHash, migrationHashes } from "./parse.ts"
 import { proveOnD1 } from "./d1-engine.ts"
 import { planApply } from "./plan-apply.ts"
-import { runPeer } from "./process.ts"
+import { type RunResult, runPeer } from "./process.ts"
 import { Refused } from "./refused.ts"
+import { whileStoppable } from "./stopped.ts"
 
 /** The files `__drizzle_migrations` records that the migrations table does not */
 function recordedByDrizzle(
@@ -129,27 +130,6 @@ async function appliedAfter(
 	}
 }
 
-/** Refuse a failed run, or one whose table gained (`added`) other than the `names` checked, naming a file never checked */
-function refuseUnlike(
-	ran: { code: number; stderr: string; stdout: string },
-	{ added, locked, names, table }: { added: string[]; locked: boolean; names: string[]; table: string },
-): void {
-	const unchecked = added.filter((name) => !names.includes(name))
-	const rest = names.filter((name) => !added.includes(name))
-	const also =
-		unchecked.length === 0
-			? ""
-			: `; wrangler also applied ${unchecked.join(", ")}, which comb never checked and holds no hash for: check each against git, then run comb migrate baseline <db> --hashes`
-	const now = { applied: added, pending: rest }
-	if (ran.code !== 0) throw new Refused(`wrangler d1 migrations apply failed: ${applyFailure(ran, locked)}${also}`, now)
-	if (unchecked.length > 0 || rest.length > 0) {
-		throw new Refused(
-			`wrangler recorded ${added.join(", ") || "nothing"} in ${table}, where comb checked ${names.join(", ")}; wrangler said: ${wranglerError(ran)}${also}`,
-			now,
-		)
-	}
-}
-
 type D1Apply = {
 	approve(migration: ParsedMigration): Promise<Approval>
 	/** only check: apply nothing */
@@ -158,6 +138,25 @@ type D1Apply = {
 	read: ReadConfig
 }
 
+/**
+ * wrangler's apply of `names`, each announced first. A stop signal ends its run, and the table then
+ * says which of them it recorded (stopped.ts)
+ */
+async function wranglerApply(
+	target: D1Target,
+	{ print, read }: D1Apply,
+	{ names, table }: { names: string[]; table: string },
+): Promise<RunResult> {
+	for (const name of names) print(`Apply: ${name}`)
+	const found = async () => {
+		const recorded = await appliedAfter(target, read, { names, ok: false, table })
+		return { applied: names.filter((name) => recorded.has(name)), pending: names.filter((name) => !recorded.has(name)) }
+	}
+	return whileStoppable({ names, print, read: found }, () =>
+		runPeer(target.exec, target.wrangler)(["d1", "migrations", "apply", target.name, ...target.flags], { input: "" }),
+	)
+}
+
 /** Check the pending migrations and, unless only checking, apply them through wrangler; returns them */
 async function applyD1(target: D1Target, options: D1Apply): Promise<string[]> {
 	const { applied, hasIntents, marks, settle, table } = await history(options.read, target, {
@@ -193,9 +192,7 @@ async function applyD1(target: D1Target, options: D1Apply): Promise<string[]> {
 	/* the intents go first: a lost record then fails before wrangler applies anything */
 	const hashed = pending.map(({ migration, name }) => ({ hash: migration.hash, marked: true, name }))
 	await target.conn.batch([...settleStatements(settle, hasIntents, marks), ...intentStatements(hashed)])
-	for (const name of names) options.print(`Apply: ${name}`)
-	const apply = ["d1", "migrations", "apply", target.name, ...target.flags]
-	const ran = await runPeer(target.exec, target.wrangler)(apply, { input: "" })
+	const ran = await wranglerApply(target, options, { names, table })
 	/* asked before anything else runs, while the lock that failed the apply is most likely still held */
 	const locked = ran.code !== 0 && target.flags.includes("--local") && (await lockedOut(ran, target.held))
 	const after = await appliedAfter(target, options.read, { names, ok: ran.code === 0, table })

package/src/migrate/core/d1-wrangler-error.ts

@@ -1,7 +1,9 @@
 /**
- * What a failed `wrangler d1 migrations apply` says, read for the refusal comb gives.
+ * What a failed `wrangler d1 migrations apply` says, read for the refusal comb gives, and the refusal
+ * of a run whose table records other than the files comb checked.
  */
 import { LOCKER } from "../drivers/d1-lock.ts"
+import { Refused } from "./refused.ts"
 
 type Ran = { stderr: string; stdout: string }
 
@@ -23,3 +25,24 @@ export function applyFailure(ran: Ran, locked: boolean): string {
 		? `the local D1 database was locked by ${LOCKER} while wrangler applied: let it finish and rerun`
 		: wranglerError(ran)
 }
+
+/** Refuse a failed run, or one whose table gained (`added`) other than the `names` checked, naming a file never checked */
+export function refuseUnlike(
+	ran: { code: number; stderr: string; stdout: string },
+	{ added, locked, names, table }: { added: string[]; locked: boolean; names: string[]; table: string },
+): void {
+	const unchecked = added.filter((name) => !names.includes(name))
+	const rest = names.filter((name) => !added.includes(name))
+	const also =
+		unchecked.length === 0
+			? ""
+			: `; wrangler also applied ${unchecked.join(", ")}, which comb never checked and holds no hash for: check each against git, then run comb migrate baseline <db> --hashes`
+	const now = { applied: added, pending: rest }
+	if (ran.code !== 0) throw new Refused(`wrangler d1 migrations apply failed: ${applyFailure(ran, locked)}${also}`, now)
+	if (unchecked.length > 0 || rest.length > 0) {
+		throw new Refused(
+			`wrangler recorded ${added.join(", ") || "nothing"} in ${table}, where comb checked ${names.join(", ")}; wrangler said: ${wranglerError(ran)}${also}`,
+			now,
+		)
+	}
+}