@devdogsuga/devtools 0.1.51-next.551 → 0.1.51-next.552

package/README.md

@@ -127,7 +127,14 @@ How it works, in short:
   needs `--yes`. It then regenerates the types (and leaves them alone when nothing changed and they are current).
   On a hosted project, a machine with no record (a second laptop, a deleted `supabase/migrations/`) first
   restores it from the project's own history table (`migration fetch --db-url`), so the diff is not taken
-  against an empty database.
+  against an empty database. The record belongs to one database (`.devtools/record.json` notes which, and which
+  files it has applied): another target's record is set aside and that database's own history is fetched, and a
+  migration written but never applied is pending, not applied; it is applied on the next sync, with the `--yes`
+  question for drops.
+- **What a member changed.** A column that looks renamed (missing here, an extra of the same type beside it) is
+  refused, not recreated empty. A difference in privileges on something that exists is applied as a GRANT of what
+  `supabase/schemas` grants and reported; privileges beyond that are not taken away. Functions are named with
+  their argument types, and a missing overload is recreated beside the member's own.
 - **Types are never committed.** `db types` writes them to the path in the config, which is git-ignored.
   The schema hash covers the sorted schema paths, their LF-normalised contents and the generator version (the
   pinned CLI, or supadart); CI uploads a `<product>-types-<hash>.tgz` asset to a rolling `generated-types`

package/dist/{cli-xAkuiAkl.js → cli-DfHsw0fp.js}

@@ -7307,10 +7307,15 @@ function postgresSession(dbUrl) {
 			const list = [...schemas];
 			const found = /* @__PURE__ */ new Set();
 			const functions = await sql`
-        select n.nspname as s, p.proname as n from pg_proc p
+        select n.nspname as s, p.proname as n,
+               oidvectortypes(p.proargtypes) as sig
+        from pg_proc p
         join pg_namespace n on n.oid = p.pronamespace
-        where n.nspname = any(${list})`;
-			for (const r of functions) found.add(`function:${r.s}.${r.n}`);
+        where n.nspname = any(${list}) and p.prokind in ('f', 'p')`;
+			for (const r of functions) {
+				found.add(`function:${r.s}.${r.n}`);
+				found.add(`signature:${r.s}.${r.n}(${r.sig})`);
+			}
 			const views = await sql`
         select n.nspname as s, c.relname as n from pg_class c
         join pg_namespace n on n.oid = c.relnamespace
@@ -7324,6 +7329,17 @@ function postgresSession(dbUrl) {
 			for (const r of triggers) found.add(`trigger:${r.s}.${r.t}:${r.n}`);
 			return found;
 		},
+		async columnTypes(schemas) {
+			const rows = await sql`
+        select n.nspname as s, c.relname as t, a.attname as c,
+               format_type(a.atttypid, a.atttypmod) as type
+        from pg_attribute a
+        join pg_class c on c.oid = a.attrelid
+        join pg_namespace n on n.oid = c.relnamespace
+        where n.nspname = any(${[...schemas]}) and c.relkind in ('r', 'p', 'f')
+          and a.attnum > 0 and not a.attisdropped`;
+			return new Map(rows.map((r) => [`${r.s}.${r.t}.${r.c}`, r.type]));
+		},
 		async exec(text) {
 			await sql.begin(async (tx) => {
 				await tx.unsafe(text);
@@ -7678,6 +7694,110 @@ function qualified(name) {
 function shown(name) {
 	return parts(name).map((part) => `"${part}"`).join(".");
 }
+const TYPE_ALIASES = {
+	int: "integer",
+	int4: "integer",
+	int8: "bigint",
+	int2: "smallint",
+	bool: "boolean",
+	float8: "double precision",
+	float4: "real",
+	varchar: "character varying",
+	bpchar: "character",
+	timestamptz: "timestamp with time zone",
+	timetz: "time with time zone",
+	decimal: "numeric"
+};
+/** `Int4[ ]`, `pg_catalog.text`, `"text"` -> a comparable spelling. */
+function normalizeType(type) {
+	let t = type.trim().replace(/\s+/g, " ").toLowerCase();
+	const array = /(\s*\[\d*\])+$/.exec(t)?.[0] ?? "";
+	t = t.slice(0, t.length - array.length);
+	t = t.replace(/^pg_catalog\./, "").replace(/"/g, "");
+	t = t.replace(/\s*\(.*\)$/, (m) => m.replace(/\s+/g, ""));
+	const base = /^([a-z0-9_ ]+?)(\(.*\))?$/.exec(t);
+	const head = base?.[1]?.trim() ?? t;
+	const tail = base?.[2] ?? "";
+	return `${TYPE_ALIASES[head] ?? head}${tail}${array.replace(/\s/g, "")}`;
+}
+/** The text inside the first balanced parentheses of `text`, or null. */
+function balanced(text) {
+	const start = text.indexOf("(");
+	if (start === -1) return null;
+	let depth = 0;
+	let quote = null;
+	for (let i = start; i < text.length; i++) {
+		const ch = text[i];
+		if (quote) {
+			if (ch === quote) quote = null;
+		} else if (ch === "'" || ch === "\"") quote = ch;
+		else if (ch === "(") depth++;
+		else if (ch === ")" && --depth === 0) return text.slice(start + 1, i);
+	}
+	return null;
+}
+const MULTIWORD_HEADS = /* @__PURE__ */ new Set([
+	"double",
+	"timestamp",
+	"time",
+	"character",
+	"bit",
+	"national",
+	"interval"
+]);
+/**
+* The argument types of a function's parameter list, as the database spells
+* them: `a int, OUT b text, c text DEFAULT 'x'` -> `(integer, text)`.
+*/
+function signatureOf(argList) {
+	const types = [];
+	for (let arg of splitTopLevel(argList)) {
+		if (/^(OUT|TABLE)\b/i.test(arg)) continue;
+		arg = arg.replace(/^(?:IN\s+OUT|INOUT|IN|VARIADIC)\s+/i, "");
+		const dflt = /\s+DEFAULT\s|\s*=\s*/i.exec(arg);
+		if (dflt) arg = arg.slice(0, dflt.index);
+		arg = arg.trim();
+		const named = new RegExp(`^(${IDENT})\\s+(.+)$`, "s").exec(arg);
+		let type = arg;
+		if (named) {
+			const head = named[1].toLowerCase();
+			const second = named[2].split(/[\s(]/)[0].toLowerCase();
+			if (!(MULTIWORD_HEADS.has(head) && (/^(precision|with|without|varying)$/.test(second) || named[2].startsWith("(")))) type = named[2];
+		}
+		types.push(normalizeType(type));
+	}
+	return `(${types.join(", ")})`;
+}
+/** Normalizes the `function:s.n(types)` spelling the database reports. */
+function normalizeKeySignature(types) {
+	return signatureOf(types);
+}
+/** Reads what a GRANT or REVOKE is on. */
+function privilegeOf(text, revoke) {
+	const on = new RegExp(String.raw`\bON\s+(?:(TABLE|SEQUENCE|FUNCTION|PROCEDURE|SCHEMA|TYPE|DOMAIN)\s+)?(${QNAME})(\s*\(.*\))?\s+(?:FROM|TO)\s+(.+)$`, "is").exec(text);
+	const base = {
+		sql: text,
+		revoke,
+		targets: [],
+		base: "",
+		object: null,
+		from: ""
+	};
+	if (!on) return base;
+	const kind = (on[1] ?? "").toUpperCase();
+	const name = on[2];
+	const isFunction = kind === "FUNCTION" || kind === "PROCEDURE";
+	const sig = isFunction ? signatureOf(balanced(on[3] ?? "") ?? "") : "";
+	const object = `${qualified(name)}${sig}`;
+	const columns = isFunction ? [] : [...text.slice(0, on.index).matchAll(/\(([^)]*)\)/g)].flatMap((m) => m[1].split(",").map((c) => parts(c)[0]).filter((c) => Boolean(c)));
+	return {
+		...base,
+		base: object,
+		targets: columns.length > 0 ? columns.map((c) => `${object}.${c}`) : [object],
+		object: `privileges on ${isFunction ? "function " : ""}${shown(name)}${sig}`,
+		from: on[4].replace(/"/g, "")
+	};
+}
 const CREATE_KINDS = {
 	SCHEMA: "schema",
 	TABLE: "table",
@@ -7696,14 +7816,18 @@ const WORD = (word) => new RegExp(`^${word}\\b`, "i");
 * database has (for `CREATE OR REPLACE`, which reads the same whether the
 * object is missing or merely different).
 */
-function classifyDiff(sql, existing) {
+function classifyDiff(sql, existing, columnTypes = /* @__PURE__ */ new Map()) {
+	const signatures = /* @__PURE__ */ new Set();
+	for (const key of existing) {
+		const m = /^signature:(.*?)\((.*)\)$/.exec(key);
+		if (m) signatures.add(`${m[1]}${normalizeKeySignature(m[2])}`);
+	}
 	const creates = [];
 	const drops = [];
 	const conflicts = /* @__PURE__ */ new Map();
 	const extras = [];
 	const preamble = [];
 	const privileges = [];
-	let sawRevoke = false;
 	const conflict = (object, why) => {
 		const set = conflicts.get(object) ?? /* @__PURE__ */ new Set();
 		set.add(why);
@@ -7715,24 +7839,11 @@ function classifyDiff(sql, existing) {
 			preamble.push(statement);
 			continue;
 		}
-		if (WORD("GRANT").test(text)) {
+		if (WORD("GRANT").test(text) || WORD("REVOKE").test(text)) {
+			const p = privilegeOf(text, WORD("REVOKE").test(text));
 			privileges.push({
-				sql: statement,
-				target: null,
-				finding: null
-			});
-			continue;
-		}
-		if (WORD("REVOKE").test(text)) {
-			sawRevoke = true;
-			const on = new RegExp(String.raw`\bON\s+(?:(?:TABLE|SEQUENCE|FUNCTION|SCHEMA|TYPE|DOMAIN)\s+)?(${QNAME})(?:\s*\([^)]*\))?\s+FROM\s+(.+)$`, "i").exec(text);
-			privileges.push({
-				sql: statement,
-				target: on ? qualified(on[1]) : "",
-				finding: {
-					object: on ? `privileges on ${shown(on[1])}` : "privileges",
-					detail: on ? `granted to ${on[2].replace(/"/g, "")} beyond (or instead of) what supabase/schemas grants` : "differ from what supabase/schemas grants"
-				}
+				...p,
+				sql: statement
 			});
 			continue;
 		}
@@ -7753,12 +7864,17 @@ function classifyDiff(sql, existing) {
 				const noun = kindWord === "POLICY" ? "policy" : "trigger";
 				key = `${noun}:${table}:${parts(name).at(-1)}`;
 				label = `${noun} ${shown(name)} on ${on ? shown(on[1]) : "?"}`;
+			} else if (kindWord === "FUNCTION" || kindWord === "PROCEDURE") {
+				const sig = signatureOf(balanced(rest) ?? "");
+				key = `function:${qualified(name)}${sig}`;
+				label = `function ${shown(name)}${sig}`;
 			} else {
 				const kind = CREATE_KINDS[kindWord] ?? kindWord.toLowerCase();
 				key = `${kind}:${qualified(name)}`;
 				label = `${kind} ${shown(name)}`;
 			}
-			if (replace && existing.has(key)) conflict(label, "its definition differs from supabase/schemas");
+			const exists = key.startsWith("function:") ? signatures.has(key.slice(9)) || signatures.size === 0 && existing.has(`function:${qualified(name)}`) : existing.has(key);
+			if (replace && exists) conflict(label, "its definition differs from supabase/schemas");
 			else creates.push({
 				key,
 				sql: statement,
@@ -7788,6 +7904,15 @@ function classifyDiff(sql, existing) {
 						detail: "not in supabase/schemas"
 					}
 				});
+			} else if (kindWord === "FUNCTION" || kindWord === "PROCEDURE") {
+				const sig = signatureOf(balanced(rest) ?? "");
+				drops.push({
+					key: `function:${qualified(name)}${sig}`,
+					finding: {
+						object: `function ${shown(name)}${sig}`,
+						detail: "not in supabase/schemas"
+					}
+				});
 			} else {
 				const kind = CREATE_KINDS[kindWord] ?? kindWord.toLowerCase();
 				drops.push({
@@ -7822,23 +7947,51 @@ function classifyDiff(sql, existing) {
 		}
 		conflict(text.slice(0, 80), "a difference devtools does not know how to classify, so it will not touch it");
 	}
-	const created = new Set(creates.map((c) => c.key));
-	const dropped = new Set(drops.map((d) => d.key));
-	const restoring = creates.filter((c) => !dropped.has(c.key));
-	for (const d of drops) if (created.has(d.key)) conflict(d.finding.object, "it is defined differently from supabase/schemas");
+	const renamedCreates = /* @__PURE__ */ new Set();
+	const renamedDrops = /* @__PURE__ */ new Set();
+	for (const c of creates) {
+		if (!c.column) continue;
+		const from = drops.find((d) => {
+			if (!d.column || renamedDrops.has(d)) return false;
+			if (d.column.table !== c.column.table) return false;
+			const type = columnTypes.get(`${d.column.table}.${d.column.name}`);
+			return type !== void 0 && normalizeType(type) === c.column.type;
+		});
+		if (!from) continue;
+		renamedCreates.add(c);
+		renamedDrops.add(from);
+		conflict(c.label, `supabase/schemas has it, and your database has ${from.finding.object} of the same type (${c.column.type}); that looks like a rename, so devtools will not add an empty column beside it. If you renamed it on purpose, rename it in supabase/schemas too; otherwise rename it back`);
+	}
+	const skipped = new Set([...renamedCreates].map((c) => c.key.slice(7)));
+	const liveCreates = creates.filter((c) => !renamedCreates.has(c));
+	const liveDrops = drops.filter((d) => !renamedDrops.has(d));
+	const created = new Set(liveCreates.map((c) => c.key));
+	const dropped = new Set(liveDrops.map((d) => d.key));
+	const restoring = liveCreates.filter((c) => !dropped.has(c.key));
+	for (const d of liveDrops) if (created.has(d.key)) conflict(d.finding.object, "it is defined differently from supabase/schemas");
 	else extras.push(d.finding);
-	const newNames = new Set(restoring.map((c) => c.key).filter((key) => !/^(index|policy|trigger|column|constraint|rls)/.test(key)).map((key) => key.slice(key.indexOf(":") + 1)));
+	const newNames = new Set(restoring.map((c) => c.key).filter((key) => !/^(index|policy|trigger|constraint|rls)/.test(key)).map((key) => key.slice(key.indexOf(":") + 1)));
 	const tail = [];
-	let grants = 0;
-	for (const p of privileges) if (p.target === null) {
-		tail.push(p.sql);
-		grants++;
-	} else if (newNames.has(p.target)) tail.push(p.sql);
-	else if (p.finding) extras.push(p.finding);
+	const regranted = /* @__PURE__ */ new Set();
+	const revokes = [];
+	for (const p of privileges) {
+		if (p.targets.length > 0 && p.targets.every((t) => skipped.has(t))) continue;
+		if (p.targets.length > 0 && (newNames.has(p.base) || p.targets.every((t) => newNames.has(t)))) tail.push(p.sql);
+		else if (!p.revoke) {
+			tail.push(p.sql);
+			regranted.add(p.object ?? "privileges");
+		} else revokes.push(p);
+	}
+	for (const p of revokes) {
+		if (p.object && regranted.has(p.object)) continue;
+		extras.push({
+			object: p.object ?? "privileges",
+			detail: p.object ? `granted to ${p.from} beyond (or instead of) what supabase/schemas grants` : "differ from what supabase/schemas grants"
+		});
+	}
 	const restore = [];
-	const restored = restoring.map((c) => c.label);
-	if (restoring.length > 0 || grants > 0) restore.push(...preamble, ...restoring.map((c) => c.sql), ...tail);
-	if (restoring.length === 0 && grants > 0 && !sawRevoke) restored.push("privileges");
+	const restored = [...restoring.map((c) => c.label), ...regranted];
+	if (restoring.length > 0 || tail.length > 0) restore.push(...preamble, ...restoring.map((c) => c.sql), ...tail);
 	return {
 		restore,
 		restored,
@@ -7861,12 +8014,19 @@ function dedupe(findings) {
 function classifyTableAction(table, t, action, ctx) {
 	const sql = `ALTER TABLE ${table} ${action}`;
 	let m;
-	if (m = new RegExp(String.raw`^ADD\s+COLUMN\s+(?:IF\s+NOT\s+EXISTS\s+)?(${IDENT})`, "i").exec(action)) ctx.creates.push({
-		key: `column:${t}.${parts(m[1])[0]}`,
-		sql,
-		label: `column ${shown(table)}.${shown(m[1])}`
-	});
-	else if (m = new RegExp(String.raw`^ADD\s+CONSTRAINT\s+(${IDENT})`, "i").exec(action)) ctx.creates.push({
+	if (m = new RegExp(String.raw`^ADD\s+COLUMN\s+(?:IF\s+NOT\s+EXISTS\s+)?(${IDENT})`, "i").exec(action)) {
+		const typeText = action.slice(m[0].length).trim().split(/\s+(?:DEFAULT|NOT\s+NULL|NULL|GENERATED|CONSTRAINT|REFERENCES|CHECK|COLLATE|UNIQUE|PRIMARY)\b/i)[0];
+		ctx.creates.push({
+			key: `column:${t}.${parts(m[1])[0]}`,
+			sql,
+			label: `column ${shown(table)}.${shown(m[1])}`,
+			column: {
+				table: t,
+				name: parts(m[1])[0],
+				type: normalizeType(typeText)
+			}
+		});
+	} else if (m = new RegExp(String.raw`^ADD\s+CONSTRAINT\s+(${IDENT})`, "i").exec(action)) ctx.creates.push({
 		key: `constraint:${t}.${parts(m[1])[0]}`,
 		sql,
 		label: `constraint ${shown(m[1])} on ${shown(table)}`
@@ -7876,6 +8036,10 @@ function classifyTableAction(table, t, action, ctx) {
 		finding: {
 			object: `column ${shown(table)}.${shown(m[1])}`,
 			detail: "not in supabase/schemas"
+		},
+		column: {
+			table: t,
+			name: parts(m[1])[0]
 		}
 	});
 	else if (m = new RegExp(String.raw`^DROP\s+CONSTRAINT\s+(?:IF\s+EXISTS\s+)?(${IDENT})`, "i").exec(action)) ctx.drops.push({
@@ -7966,6 +8130,65 @@ const NOTHING = {
 	extras: [],
 	compared: false
 };
+function recordFile(product) {
+	return join(product.root, ".devtools", "record.json");
+}
+function pendingDir(product) {
+	return join(product.root, ".devtools", "pending");
+}
+function readRecord(product) {
+	try {
+		const raw = JSON.parse(readFileSync(recordFile(product), "utf8"));
+		return typeof raw.target === "string" && Array.isArray(raw.applied) ? {
+			target: raw.target,
+			applied: raw.applied.map(String)
+		} : null;
+	} catch {
+		return null;
+	}
+}
+function writeRecord(product, target, files) {
+	mkdirSync(dirname(recordFile(product)), { recursive: true });
+	const record = {
+		target: targetKey(target),
+		applied: files.map(versionOf)
+	};
+	writeFileSync(recordFile(product), JSON.stringify(record, null, 2) + "\n");
+}
+/** `local`, or `hosted:<project ref>` (never the password). */
+function targetKey(target) {
+	if (target.kind === "local") return "local";
+	try {
+		const url = new URL(target.dbUrl);
+		const user = decodeURIComponent(url.username);
+		return `hosted:${(user.includes(".") ? user.split(".").slice(1).join(".") : "") || url.hostname}`;
+	} catch {
+		return "hosted";
+	}
+}
+/** The migrations the target has applied (null: no history table); throws if it cannot be reached. */
+async function probe(open, target, redact) {
+	let session;
+	try {
+		session = open(target.dbUrl);
+		return await session.appliedMigrations();
+	} catch (err) {
+		throw new SyncError("Could not connect to the database to compare it with supabase/schemas, so nothing was changed, and the database was not checked against supabase/schemas. Fix the connection (is the database running, is the password right?) and run `devtools db sync` again.", redact(err.message));
+	} finally {
+		await session?.close().catch(() => void 0);
+	}
+}
+/** Puts back migrations a sync that was killed had set aside. */
+function restorePending(product) {
+	const dir = pendingDir(product);
+	if (!existsSync(dir)) return;
+	mkdirSync(product.paths.migrationsDir, { recursive: true });
+	for (const file of readdirSync(dir)) {
+		const back = join(product.paths.migrationsDir, file);
+		if (existsSync(back)) rmSync(join(dir, file));
+		else renameSync(join(dir, file), back);
+	}
+}
 /** `20261011120000` from `20261011120000_devtools_sync.sql`. */
 function versionOf(file) {
 	return file.split("_")[0] ?? file;
@@ -8047,34 +8270,56 @@ function listFindings(findings) {
 */
 async function reconcileLive(product, cli, target, run, options, log, warn, redact) {
 	const files = migrationFiles(product.paths.migrationsDir);
-	if (!options.open || files.length === 0) return NOTHING;
+	if (!options.open || files.length === 0) return {
+		...NOTHING,
+		pending: []
+	};
 	const { schemas } = product.config.supabase;
 	let session;
 	let ledger;
 	let existing;
+	let columnTypes;
 	try {
 		session = options.open(target.dbUrl);
 		ledger = await session.appliedMigrations();
 		existing = await session.existingObjects(schemas);
+		columnTypes = await session.columnTypes(schemas);
 	} catch (err) {
 		await session?.close().catch(() => void 0);
 		throw new SyncError("Could not connect to the database to compare it with supabase/schemas, so nothing was changed, and the database was not checked against supabase/schemas. Fix the connection (is the database running, is the password right?) and run `devtools db sync` again.", redact(err.message));
 	}
+	const record = readRecord(product);
+	const noted = record?.target === targetKey(target) ? record.applied : null;
+	const known = /* @__PURE__ */ new Set([...ledger ?? [], ...noted ?? []]);
+	const everythingApplied = ledger === null && noted === null;
+	const isApplied = (file) => everythingApplied || known.has(versionOf(file));
+	const appliedFiles = files.filter(isApplied);
+	const pending = files.filter((file) => !isApplied(file));
+	if (appliedFiles.length === 0) {
+		await session.close().catch(() => void 0);
+		return {
+			...NOTHING,
+			pending
+		};
+	}
+	const aside = pendingDir(product);
+	if (pending.length > 0) mkdirSync(aside, { recursive: true });
+	for (const file of pending) renameSync(join(product.paths.migrationsDir, file), join(aside, file));
 	try {
-		const drift = classifyDiff(await liveDiff(product, cli, target, run, log, redact), existing);
+		const drift = classifyDiff(await liveDiff(product, cli, target, run, log, redact), existing, columnTypes);
 		if (drift.extras.length > 0 && !options.strict) warn(`Your database has ${drift.extras.length} thing${drift.extras.length === 1 ? "" : "s"} that supabase/schemas does not define. They are left as they are:\n${listFindings(drift.extras)}\n${cleanupHint(target)}`);
 		if (drift.conflicts.length > 0) throw new SyncError(`Your database defines ${drift.conflicts.length} thing${drift.conflicts.length === 1 ? "" : "s"} differently from supabase/schemas. devtools will not change them for you, and nothing was changed.`, `${listFindings(drift.conflicts)}\nIf the database is right, edit supabase/schemas to match it. If the schema files are right, ${target.kind === "local" ? "run `devtools db sync --rebuild` (it wipes your development database), then `devtools dev-data`" : "reset the project from its dashboard (Database > Settings), then run `devtools db sync` and `devtools dev-data`"}.`);
 		if (options.strict && drift.extras.length > 0) throw new SyncError(`--strict: your database has ${drift.extras.length} thing${drift.extras.length === 1 ? "" : "s"} that supabase/schemas does not define. Nothing was changed or deleted.`, `${listFindings(drift.extras)}\n${cleanupHint(target)}`);
 		if (drift.restore.length > 0) {
-			if (drift.restored.length > 0) log(`Your database is missing ${summarize(drift.restored)}; creating ${drift.restored.length === 1 ? "it" : "them"} again from supabase/schemas. Nothing that already exists is changed.`);
+			if (drift.restored.length > 0) log(`Your database is missing ${summarize(drift.restored)}; creating ${drift.restored.length === 1 ? "it" : "them"} again from supabase/schemas. Nothing that already exists is changed.${drift.restored.some((label) => label.startsWith("privileges on")) ? " For the privileges, what supabase/schemas grants was granted again; privileges beyond that were not taken away." : ""}`);
 			try {
 				await session.exec(drift.restore.join(";\n") + ";");
 			} catch (err) {
 				throw new SyncError("Could not recreate what the database is missing; nothing was changed.", `${redact(err.message)}\n${target.kind === "local" ? "`devtools db sync --rebuild` starts over (it wipes your development database)." : "Reset the project from its dashboard (Database > Settings), then run `devtools db sync`."}`);
 			}
 		}
-		const known = new Set(ledger ?? []);
-		const unlisted = files.map(versionOf).filter((version) => !known.has(version));
+		const listed = new Set(ledger ?? []);
+		const unlisted = appliedFiles.map(versionOf).filter((version) => !listed.has(version));
 		if (unlisted.length > 0) {
 			if (ledger === null) log("The database has no migration history table; recreating it from the local record.");
 			const repaired = await run(cli.command, [
@@ -8092,9 +8337,14 @@ async function reconcileLive(product, cli, target, run, options, log, warn, reda
 		return {
 			restored: drift.restored,
 			extras: drift.extras,
-			compared: true
+			compared: true,
+			pending
 		};
 	} finally {
+		for (const file of pending) {
+			const from = join(aside, file);
+			if (existsSync(from)) renameSync(from, join(product.paths.migrationsDir, file));
+		}
 		await session.close().catch(() => void 0);
 	}
 }
@@ -8119,17 +8369,23 @@ async function dbSync(product, cli, target, run, options) {
 		...cli.prefix,
 		"migration",
 		"fetch",
-		"--db-url",
-		target.dbUrl
+		...target.kind === "local" ? ["--local"] : ["--db-url", target.dbUrl]
 	];
-	const needsRecord = target.kind === "hosted" && migrationFiles(migrationsDir).length === 0;
+	const key = targetKey(target);
+	const owner = readRecord(product)?.target;
+	const foreign = owner !== void 0 && owner !== key && migrationFiles(migrationsDir).length > 0;
+	let needsRecord = migrationFiles(migrationsDir).length === 0 && (target.kind === "hosted" || owner !== void 0 && owner !== key) || foreign;
 	if (options.dryRun) {
-		if (needsRecord) log(`Would run: ${cliLine(cli, [
+		if (needsRecord) log(`Would run: ${cliLine(cli, target.kind === "local" ? [
+			"migration",
+			"fetch",
+			"--local"
+		] : [
 			"migration",
 			"fetch",
 			"--db-url",
 			"<DB_URL>"
-		])} (this machine has no record of what the project has had applied)`);
+		])} (this machine has no record of what ${target.kind === "local" ? "the local stack" : "the project"} has had applied)`);
 		if (options.open) log(`Would run: ${cliLine(cli, liveDiffArgs(product, target).map((arg) => arg === target.dbUrl ? "<DB_URL>" : arg))} (and recreate anything the database is missing; extras are only listed)`);
 		log(`Would run: ${cliLine(cli, generateArgs.slice(cli.prefix.length))}`);
 		log(target.kind === "local" ? `Would run: ${cliLine(cli, [
@@ -8150,12 +8406,22 @@ async function dbSync(product, cli, target, run, options) {
 			...NOTHING
 		};
 	}
+	restorePending(product);
+	if (!needsRecord && target.kind === "local" && options.open && migrationFiles(migrationsDir).length === 0) needsRecord = (await probe(options.open, target, redact) ?? []).length > 0;
+	if (foreign) {
+		log(`supabase/migrations holds the record of another database (${owner}); this sync is for ${key}, so that record is set aside and this database's own history is used.`);
+		forgetMigrations(product);
+	}
 	if (needsRecord) {
 		const fetched = await run(cli.command, fetchArgs, { cwd: product.root });
+		if (fetched.code !== 0 && options.open) await probe(options.open, target, redact);
 		const restoredFiles = migrationFiles(migrationsDir).length;
-		if (fetched.code === 0 && restoredFiles > 0) log(`Restored ${restoredFiles} applied migration${restoredFiles === 1 ? "" : "s"} from the project's history.`);
+		if (fetched.code === 0 && restoredFiles > 0) {
+			log(`Restored ${restoredFiles} applied migration${restoredFiles === 1 ? "" : "s"} from ${target.kind === "local" ? "the local stack's" : "the project's"} history.`);
+			writeRecord(product, target, migrationFiles(migrationsDir));
+		}
 	}
-	const live = await reconcileLive(product, cli, target, run, options, log, warn, redact);
+	const { pending, ...live } = await reconcileLive(product, cli, target, run, options, log, warn, redact);
 	const restoredSomething = live.restored.length > 0;
 	const before = new Set(migrationFiles(migrationsDir));
 	let generated = await run(cli.command, generateArgs, { cwd: product.root });
@@ -8165,11 +8431,13 @@ async function dbSync(product, cli, target, run, options) {
 	}
 	if (generated.code !== 0) throw new SyncError(isContainerFailure(generated) ? "Could not diff the schema: Docker is needed for the shadow database. Start Docker and try again." : "Could not diff the schema against what this database has had applied.", redact(generated.stderr || generated.stdout));
 	const created = migrationFiles(migrationsDir).filter((f) => !before.has(f));
-	if (created.length === 0) {
+	const toApply = [...pending, ...created].sort();
+	if (toApply.length === 0) {
 		if (live.compared && !restoredSomething) {
 			const n = live.extras.length;
 			log(n === 0 ? "The database already matches supabase/schemas." : `The database matches supabase/schemas, with ${n} extra thing${n === 1 ? "" : "s"} listed above that it does not define.`);
 		}
+		writeRecord(product, target, migrationFiles(migrationsDir));
 		return {
 			migration: null,
 			applied: restoredSomething,
@@ -8177,8 +8445,8 @@ async function dbSync(product, cli, target, run, options) {
 			...live
 		};
 	}
-	const migration = created[created.length - 1];
-	const sql = readFileSync(join(migrationsDir, migration), "utf8");
+	const migration = toApply[toApply.length - 1];
+	const sql = toApply.map((file) => readFileSync(join(migrationsDir, file), "utf8")).join("\n");
 	const destructive = destructiveStatements(sql);
 	if (destructive.length > 0 && !options.yes) {
 		if (!(options.confirmDestructive ? await options.confirmDestructive(sql, destructive) : false)) {
@@ -8186,7 +8454,7 @@ async function dbSync(product, cli, target, run, options) {
 			throw new SyncError(`The change drops data in your development database (${destructive.length} statement${destructive.length === 1 ? "" : "s"}). Re-run with --yes to allow it.`, destructive.join(";\n"));
 		}
 	}
-	log(`Applying ${migration}`);
+	log(`Applying ${toApply.join(", ")}`);
 	const applyArgs = target.kind === "local" ? [
 		...cli.prefix,
 		"migration",
@@ -8205,6 +8473,7 @@ async function dbSync(product, cli, target, run, options) {
 		for (const file of created) rmSync(join(migrationsDir, file));
 		throw new SyncError("The change did not apply. Your schema files may not be valid SQL, or the database has drifted from what devtools recorded (`devtools db sync --rebuild` starts over).", redact(applied.stderr || applied.stdout));
 	}
+	writeRecord(product, target, migrationFiles(migrationsDir));
 	return {
 		migration,
 		applied: true,
@@ -8219,6 +8488,11 @@ function isContainerFailure(result) {
 function forgetMigrations(product) {
 	const files = migrationFiles(product.paths.migrationsDir);
 	for (const file of files) rmSync(join(product.paths.migrationsDir, file));
+	rmSync(recordFile(product), { force: true });
+	rmSync(pendingDir(product), {
+		recursive: true,
+		force: true
+	});
 	return files;
 }
 //#endregion

package/dist/launch.js

@@ -183,7 +183,7 @@ async function startStack() {
 * post-tier-resolution path.
 */
 async function dispatch(argv) {
-	const { main } = await import("./cli-xAkuiAkl.js");
+	const { main } = await import("./cli-DfHsw0fp.js");
 	try {
 		await main(argv);
 	} catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devdogsuga/devtools",
-  "version": "0.1.51-next.551",
+  "version": "0.1.51-next.552",
   "private": false,
   "type": "module",
   "description": "Contributor CLI for DevDogs repositories (the platform monorepo, DogDays, DogPack): the real tools with the session's tier filled in, `setup`, `db sync`, `db types`, `dev-data`, a menu over them, the checks CI runs, and the `with-env` launcher. Ships built JS; run via `pnpm devtools` in a product repo, `pnpm dlx @devdogsuga/devtools` (or the `devtools` bin once installed) from inside a clone.",
@@ -46,9 +46,9 @@
     "eslint": "^9.39.5",
     "tsdown": "^0.23.0",
     "vitest": "^4.1.11",
+    "@devdogsuga/config": "0.1.4-next.526",
     "@devdogsuga/cli-core": "0.0.0",
-    "@devdogsuga/sdk": "0.1.0",
-    "@devdogsuga/config": "0.1.4-next.526"
+    "@devdogsuga/sdk": "0.1.0"
   },
   "scripts": {
     "build": "tsdown && node scripts/write-build-info.mjs && node ../../scripts/check-bundle-imports.mjs",