@rebasepro/server-postgres 0.24.0 → 0.24.1-canary.gcb918fc

package/dist/{rls-bootstrap-sql-_KNnjanK.js → rls-bootstrap-sql-RQUljnJ1.js}

@@ -1,31 +1,23 @@
 import { createRequire as __createRequire } from "module";
 __createRequire(import.meta.url);
-import { a as __toESM, i as __require, n as __commonJSMin, r as __exportAll, t as require___vite_browser_external } from "./__vite-browser-external-BnuHet1e.js";
-import { o as isRebaseIndexName } from "./collection-index-DdnsxiJ_.js";
-import { r as outWarn, t as out } from "./cli-output-CNdMql-L.js";
-import { t as chalk } from "./source-Br7L7GOI.js";
+import { a as __toESM, i as __require, n as __commonJSMin, r as __exportAll } from "./__vite-browser-external-BnuHet1e.js";
 import { LEGACY_RLS_SCHEMA, REBASE_SCHEMA } from "@rebasepro/types";
 import { sqlRows } from "@rebasepro/common";
-import fs from "fs";
-import path from "path";
+import process$1, { execArgv, execPath, hrtime, platform } from "node:process";
+import { constants } from "node:os";
+import tty from "node:tty";
 import { fileURLToPath } from "node:url";
 import { ChildProcess, execFile, spawn, spawnSync } from "node:child_process";
 import { StringDecoder } from "node:string_decoder";
 import { aborted, callbackify, debuglog, inspect, promisify, stripVTControlCharacters } from "node:util";
-import process$1, { execArgv, execPath, hrtime, platform } from "node:process";
-import tty from "node:tty";
-import path$1 from "node:path";
-import { execSync } from "child_process";
+import path from "node:path";
 import { scheduler, setImmediate, setTimeout } from "node:timers/promises";
-import { constants } from "node:os";
 import { EventEmitter, addAbortListener, on, once, setMaxListeners } from "node:events";
 import { serialize } from "node:v8";
 import { appendFileSync, createReadStream, createWriteStream, readFileSync, statSync, writeFileSync } from "node:fs";
 import { finished } from "node:stream/promises";
 import { Duplex, PassThrough, Readable, Transform, Writable, getDefaultHighWaterMark } from "node:stream";
 import { Buffer as Buffer$1 } from "node:buffer";
-import { createRequire } from "module";
-import { fileURLToPath as fileURLToPath$1, pathToFileURL } from "url";
 //#region src/utils/connection-string.ts
 /**
 * Connection-string rewrites for the tools Rebase shells out to.
@@ -851,7 +843,7 @@ var handleCommand = (filePath, rawArguments, rawOptions) => {
 var require_windows = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = isexe;
 	isexe.sync = sync;
-	var fs$3 = __require("fs");
+	var fs$2 = __require("fs");
 	function checkPathExt(path, options) {
 		var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
 		if (!pathext) return true;
@@ -868,12 +860,12 @@ var require_windows = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		return checkPathExt(path, options);
 	}
 	function isexe(path, options, cb) {
-		fs$3.stat(path, function(er, stat) {
+		fs$2.stat(path, function(er, stat) {
 			cb(er, er ? false : checkStat(stat, path, options));
 		});
 	}
 	function sync(path, options) {
-		return checkStat(fs$3.statSync(path), path, options);
+		return checkStat(fs$2.statSync(path), path, options);
 	}
 }));
 //#endregion
@@ -881,14 +873,14 @@ var require_windows = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 var require_mode = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = isexe;
 	isexe.sync = sync;
-	var fs$2 = __require("fs");
+	var fs$1 = __require("fs");
 	function isexe(path, options, cb) {
-		fs$2.stat(path, function(er, stat) {
+		fs$1.stat(path, function(er, stat) {
 			cb(er, er ? false : checkStat(stat, options));
 		});
 	}
 	function sync(path, options) {
-		return checkStat(fs$2.statSync(path), options);
+		return checkStat(fs$1.statSync(path), options);
 	}
 	function checkStat(stat, options) {
 		return stat.isFile() && checkMode(stat, options);
@@ -952,7 +944,7 @@ var require_isexe = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#region ../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js
 var require_which = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-	var path$4 = __require("path");
+	var path$3 = __require("path");
 	var COLON = isWindows ? ";" : ":";
 	var isexe = require_isexe();
 	var getNotFoundError = (cmd) => Object.assign(/* @__PURE__ */ new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -982,7 +974,7 @@ var require_which = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			if (i === pathEnv.length) return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
 			const ppRaw = pathEnv[i];
 			const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-			const pCmd = path$4.join(pathPart, cmd);
+			const pCmd = path$3.join(pathPart, cmd);
 			const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
 			resolve(subStep(p, i, 0));
 		});
@@ -1004,7 +996,7 @@ var require_which = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		for (let i = 0; i < pathEnv.length; i++) {
 			const ppRaw = pathEnv[i];
 			const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-			const pCmd = path$4.join(pathPart, cmd);
+			const pCmd = path$3.join(pathPart, cmd);
 			const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
 			for (let j = 0; j < pathExt.length; j++) {
 				const cur = p + pathExt[j];
@@ -1035,7 +1027,7 @@ var require_path_key = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js
 var require_resolveCommand = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var path$3 = __require("path");
+	var path$2 = __require("path");
 	var which = require_which();
 	var getPathKey = require_path_key();
 	function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -1050,12 +1042,12 @@ var require_resolveCommand = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 		try {
 			resolved = which.sync(parsed.command, {
 				path: env[getPathKey({ env })],
-				pathExt: withoutPathExt ? path$3.delimiter : void 0
+				pathExt: withoutPathExt ? path$2.delimiter : void 0
 			});
 		} catch (e) {} finally {
 			if (shouldSwitchCwd) process.chdir(cwd);
 		}
-		if (resolved) resolved = path$3.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+		if (resolved) resolved = path$2.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
 		return resolved;
 	}
 	function resolveCommand(parsed) {
@@ -1104,16 +1096,16 @@ var require_shebang_command = /* @__PURE__ */ __commonJSMin(((exports, module) =
 //#endregion
 //#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js
 var require_readShebang = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var fs$1 = __require("fs");
+	var fs = __require("fs");
 	var shebangCommand = require_shebang_command();
 	function readShebang(command) {
 		const size = 150;
 		const buffer = Buffer.alloc(size);
 		let fd;
 		try {
-			fd = fs$1.openSync(command, "r");
-			fs$1.readSync(fd, buffer, 0, size, 0);
-			fs$1.closeSync(fd);
+			fd = fs.openSync(command, "r");
+			fs.readSync(fd, buffer, 0, size, 0);
+			fs.closeSync(fd);
 		} catch (e) {}
 		return shebangCommand(buffer.toString());
 	}
@@ -1122,7 +1114,7 @@ var require_readShebang = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js
 var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var path$2 = __require("path");
+	var path$1 = __require("path");
 	var resolveCommand = require_resolveCommand();
 	var escape = require_escape();
 	var readShebang = require_readShebang();
@@ -1145,7 +1137,7 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		const needsShell = !isExecutableRegExp.test(commandFile);
 		if (parsed.options.forceShell || needsShell) {
 			const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-			parsed.command = path$2.normalize(parsed.command);
+			parsed.command = path$1.normalize(parsed.command);
 			parsed.command = escape.command(parsed.command);
 			parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
 			parsed.args = [
@@ -1254,33 +1246,33 @@ function toPath(urlOrPath) {
 }
 function traversePathUp(startPath) {
 	return { *[Symbol.iterator]() {
-		let currentPath = path$1.resolve(toPath(startPath));
+		let currentPath = path.resolve(toPath(startPath));
 		let previousPath;
 		while (previousPath !== currentPath) {
 			yield currentPath;
 			previousPath = currentPath;
-			currentPath = path$1.resolve(currentPath, "..");
+			currentPath = path.resolve(currentPath, "..");
 		}
 	} };
 }
 //#endregion
 //#region ../../node_modules/.pnpm/npm-run-path@6.0.0/node_modules/npm-run-path/index.js
 var npmRunPath = ({ cwd = process$1.cwd(), path: pathOption = process$1.env[pathKey()], preferLocal = true, execPath = process$1.execPath, addExecPath = true } = {}) => {
-	const cwdPath = path$1.resolve(toPath(cwd));
+	const cwdPath = path.resolve(toPath(cwd));
 	const result = [];
-	const pathParts = pathOption.split(path$1.delimiter);
+	const pathParts = pathOption.split(path.delimiter);
 	if (preferLocal) applyPreferLocal(result, pathParts, cwdPath);
 	if (addExecPath) applyExecPath(result, pathParts, execPath, cwdPath);
-	return pathOption === "" || pathOption === path$1.delimiter ? `${result.join(path$1.delimiter)}${pathOption}` : [...result, pathOption].join(path$1.delimiter);
+	return pathOption === "" || pathOption === path.delimiter ? `${result.join(path.delimiter)}${pathOption}` : [...result, pathOption].join(path.delimiter);
 };
 var applyPreferLocal = (result, pathParts, cwdPath) => {
 	for (const directory of traversePathUp(cwdPath)) {
-		const pathPart = path$1.join(directory, "node_modules/.bin");
+		const pathPart = path.join(directory, "node_modules/.bin");
 		if (!pathParts.includes(pathPart)) result.push(pathPart);
 	}
 };
 var applyExecPath = (result, pathParts, execPath, cwdPath) => {
-	const pathPart = path$1.resolve(cwdPath, toPath(execPath), "..");
+	const pathPart = path.resolve(cwdPath, toPath(execPath), "..");
 	if (!pathParts.includes(pathPart)) result.push(pathPart);
 };
 var npmRunPathEnv = ({ env = process$1.env, ...options } = {}) => {
@@ -2290,7 +2282,7 @@ var mapNode = ({ options }) => {
 var handleNodeOption = (file, commandArguments, { node: shouldHandleNode = false, nodePath = execPath, nodeOptions = execArgv.filter((nodeOption) => !nodeOption.startsWith("--inspect")), cwd, execPath: formerNodePath, ...options }) => {
 	if (formerNodePath !== void 0) throw new TypeError("The \"execPath\" option has been removed. Please use the \"nodePath\" option instead.");
 	const normalizedNodePath = safeNormalizeFileUrl(nodePath, "The \"nodePath\" option");
-	const resolvedNodePath = path$1.resolve(cwd, normalizedNodePath);
+	const resolvedNodePath = path.resolve(cwd, normalizedNodePath);
 	const newOptions = {
 		...options,
 		nodePath: resolvedNodePath,
@@ -2302,7 +2294,7 @@ var handleNodeOption = (file, commandArguments, { node: shouldHandleNode = false
 		commandArguments,
 		newOptions
 	];
-	if (path$1.basename(file, ".exe") === "node") throw new TypeError("When the \"node\" option is true, the first argument does not need to be \"node\".");
+	if (path.basename(file, ".exe") === "node") throw new TypeError("When the \"node\" option is true, the first argument does not need to be \"node\".");
 	return [
 		resolvedNodePath,
 		[
@@ -2386,7 +2378,7 @@ var serializeEncoding = (encoding) => typeof encoding === "string" ? `"${encodin
 //#region ../../node_modules/.pnpm/execa@9.6.1/node_modules/execa/lib/arguments/cwd.js
 var normalizeCwd = (cwd = getDefaultCwd()) => {
 	const cwdString = safeNormalizeFileUrl(cwd, "The \"cwd\" option");
-	return path$1.resolve(cwdString);
+	return path.resolve(cwdString);
 };
 var getDefaultCwd = () => {
 	try {
@@ -2424,7 +2416,7 @@ var normalizeOptions = (filePath, rawArguments, rawOptions) => {
 	options.killSignal = normalizeKillSignal(options.killSignal);
 	options.forceKillAfterDelay = normalizeForceKillAfterDelay(options.forceKillAfterDelay);
 	options.lines = options.lines.map((lines, fdNumber) => lines && !BINARY_ENCODINGS.has(options.encoding) && options.buffer[fdNumber]);
-	if (process$1.platform === "win32" && path$1.basename(file, ".exe") === "cmd") commandArguments.unshift("/q");
+	if (process$1.platform === "win32" && path.basename(file, ".exe") === "cmd") commandArguments.unshift("/q");
 	return {
 		file,
 		commandArguments,
@@ -6252,1231 +6244,6 @@ createExeca(mapNode);
 createExeca(mapScriptAsync, {}, deepScriptOptions, setScriptSync);
 var { sendMessage, getOneMessage, getEachMessage, getCancelSignal } = getIpcExport();
 //#endregion
-//#region src/schema/destructive-sql.ts
-var import___vite_browser_external = /* @__PURE__ */ __toESM(require___vite_browser_external(), 1);
-/**
-* Pure helpers that classify an Atlas declarative-apply plan as destructive
-* or not, and decide what `rebase db push` should do about it.
-*
-* `db push` runs `atlas schema apply` to make the live database match the
-* generated `schema.sql`. Removing a collection field compiles to
-* `DROP COLUMN`; renaming compiles to drop-then-add — either destroys data.
-* We first run the apply with `--dry-run` to obtain the planned SQL, scan it
-* here, and refuse to auto-approve anything destructive without an explicit
-* opt-in.
-*
-* A type change is a destructive plan that names no DROP. `ALTER COLUMN
-* "price" TYPE integer` rounds every 19.99 to 20, and `TYPE date` throws away
-* every timestamp's time of day, in a statement that reads like a routine
-* alter. So a type change is gated too, unless it is a widening every value
-* survives unchanged — which needs the column's current type, read from the
-* catalogue by the caller.
-*
-* A primary key change names no DROP of data either: `DROP CONSTRAINT
-* "<table>_pkey", ADD PRIMARY KEY ("id", "locale")` keeps every value and
-* gives every row a new address. It is gated like a drop.
-*
-* Everything in this file is side-effect free so it can be unit-tested
-* without Atlas or a database.
-*/
-/**
-* SQL fragments that destroy data or data-bearing objects. Matched
-* case-insensitively against each statement of the plan. `IF EXISTS` /
-* whitespace variations are tolerated by the regexes below.
-*/
-var DESTRUCTIVE_PATTERNS = [
-	{
-		label: "DROP TABLE",
-		re: /\bDROP\s+TABLE\b/i
-	},
-	{
-		label: "DROP COLUMN",
-		re: /\bDROP\s+COLUMN\b/i
-	},
-	{
-		label: "DROP SCHEMA",
-		re: /\bDROP\s+SCHEMA\b/i
-	},
-	{
-		label: "DROP VIEW",
-		re: /\bDROP\s+(MATERIALIZED\s+)?VIEW\b/i
-	},
-	{
-		label: "DROP TYPE",
-		re: /\bDROP\s+TYPE\b/i
-	},
-	{
-		label: "TRUNCATE",
-		re: /\bTRUNCATE\b/i
-	}
-];
-/**
-* Split a SQL script into individual statements, dropping blank lines and
-* `--` comment lines. Deliberately simple: Atlas emits one plain statement
-* per `;`, without string literals that contain semicolons in a schema DDL
-* plan, so a naive split is safe and keeps this dependency-free.
-*/
-function splitSqlStatements(sql) {
-	return sql.split("\n").filter((line) => !line.trim().startsWith("--")).join("\n").split(";").map((s) => s.trim()).filter((s) => s.length > 0);
-}
-/** `->`, the marker Atlas prints in front of the first line of every statement. */
-var PLAN_MARKER_RE = /^\s*->\s?/;
-/** `-------`, both the rule between sections and the one above a summary. */
-var PLAN_RULE_RE = /^\s*-{5,}\s*$/;
-/** `Planning migration statements (3 in total):` — and the count it announces. */
-var PLAN_HEADING_RE = /^Planning migration statements \((\d+) in total\):/m;
-/** What Atlas prints, and nothing else, when there is nothing to plan. */
-var PLAN_SYNCED_RE = /^\s*Schema is synced, no changes to be made\s*$/;
-/**
-* Read the statements out of whatever Atlas printed.
-*
-* `atlas schema apply --dry-run` does not print SQL. It prints a report, and
-* the same statements appear in it twice:
-*
-*     Planning migration statements (2 in total):
-*
-*       -- modify "people" table:
-*         -> ALTER TABLE "public"."people" ALTER COLUMN "rating" TYPE numeric(4,1);
-*       -- create "notes" table:
-*         -> CREATE TABLE "public"."notes" (
-*              "body" text NULL DEFAULT 'a;b',
-*              …
-*            );
-*
-*     -------------------------------------------
-*
-*     Analyzing planned statements (2 in total):
-*       …
-*     Running dry-run migration (2 statements in total):
-*       -- modify "people" table
-*         -> ALTER TABLE …;          ← the same statement, again
-*       -- ok (19µs)
-*
-* Splitting that on `;` is how the push gate went blind: the heading has no
-* `;` and does not start with `--`, so it became the first line of the first
-* statement, and an `ALTER TABLE` parse anchored at the start of a statement
-* read nothing — every narrowing type change applied without a prompt. Reading
-* both sections was a second bug, counting every destructive statement twice.
-*
-* So the report is read as a report: a statement is a `->` line and the lines
-* indented under it, up to the next `--` heading, `->`, blank line or rule;
-* only the first section that holds a `->` is read; and `;` plays no part,
-* because a default like `'a;b'` contains one.
-*
-* Plain SQL — a migration file, or an Atlas that printed SQL — has no `->`
-* and is split the old way.
-*/
-function readPlan(plan) {
-	if (PLAN_SYNCED_RE.test(plan)) return { statements: [] };
-	const lines = plan.split(/\r?\n/);
-	if (!lines.some((line) => PLAN_MARKER_RE.test(line))) return { statements: splitSqlStatements(plan) };
-	const heading = PLAN_HEADING_RE.exec(plan);
-	const statements = [];
-	let current = null;
-	const flush = () => {
-		if (current) statements.push(current.join("\n").trim().replace(/;\s*$/, "").trimEnd());
-		current = null;
-	};
-	for (const line of lines) {
-		if (PLAN_MARKER_RE.test(line)) {
-			flush();
-			current = [line.replace(PLAN_MARKER_RE, "")];
-			continue;
-		}
-		if (PLAN_RULE_RE.test(line) || /^\S/.test(line) && !line.startsWith("--")) {
-			flush();
-			if (statements.length > 0) break;
-			continue;
-		}
-		if (!current) continue;
-		if (line.trim() === "" || line.trim().startsWith("--")) {
-			flush();
-			continue;
-		}
-		current.push(line);
-	}
-	flush();
-	return {
-		statements,
-		announced: heading ? Number(heading[1]) : void 0
-	};
-}
-/**
-* The statements of an Atlas plan, each exactly once, without Atlas's
-* rendering and without the trailing `;`. See {@link readPlan} for the shape
-* it reads; `test/fixtures/atlas-dry-run/` holds real captures of it.
-*/
-function extractPlanStatements(plan) {
-	return readPlan(plan).statements;
-}
-/**
-* Every column of every ordinary table outside the system schemas, with its
-* type. What {@link detectDestructiveStatements} compares a planned type
-* change against; `format_type` because it carries the modifier (`(255)`,
-* `(10,2)`) that decides whether a change widens or narrows.
-*/
-var COLUMN_TYPES_SQL = `
-    SELECT n.nspname AS "schema",
-           c.relname AS "table",
-           a.attname AS "column",
-           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 c.relkind IN ('r', 'p')
-      AND a.attnum > 0
-      AND NOT a.attisdropped
-      AND n.nspname NOT IN ('pg_catalog', 'information_schema')
-      AND n.nspname NOT LIKE 'pg\\_%'
-`;
-/**
-* Scan an Atlas plan (the SQL printed by `schema apply --dry-run`) and return
-* the statements that would destroy data. An empty array means the plan is
-* safe to auto-approve.
-*
-* `columnTypes` is what the database holds now. A type change to a column it
-* does not list is flagged: not knowing what a column is means not knowing
-* whether the change keeps its values.
-*/
-function detectDestructiveStatements(planSql, columnTypes = []) {
-	const found = [];
-	const { statements, announced } = readPlan(planSql);
-	if (announced !== void 0 && announced !== statements.length) found.push({
-		statement: `Planning migration statements (${announced} in total)`,
-		kind: "UNREADABLE PLAN",
-		detail: `Atlas announced ${announced} statement(s) and ${statements.length} could be read — read the plan yourself before allowing it`
-	});
-	for (const statement of statements) {
-		const dropped = DESTRUCTIVE_PATTERNS.find(({ re }) => re.test(statement));
-		const rekeyed = describePrimaryKeyChange(statement);
-		const lossy = parseColumnTypeChanges(statement).map((change) => ({
-			change,
-			from: currentTypeOf(change, columnTypes)
-		})).filter(({ change, from }) => from === void 0 || !isLosslessTypeChange(from, change.to)).map(({ change, from }) => `"${change.column}" ${from ?? "(current type unknown)"} → ${change.to}`).join("; ");
-		const kind = dropped?.label ?? (rekeyed ? "PRIMARY KEY CHANGE" : lossy ? "ALTER COLUMN TYPE" : void 0);
-		if (!kind) continue;
-		const detail = [rekeyed, lossy].filter(Boolean).join("; ");
-		found.push(detail ? {
-			statement,
-			kind,
-			detail
-		} : {
-			statement,
-			kind
-		});
-	}
-	return found;
-}
-var IDENT = String.raw`(?:"(?:[^"]|"")+"|[A-Za-z_][A-Za-z0-9_$]*)`;
-var ALTER_TABLE_RE = new RegExp(String.raw`^ALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?(?:ONLY\s+)?(${IDENT})(?:\.(${IDENT}))?\s+([\s\S]*)$`, "i");
-var TYPE_CLAUSE_RE = new RegExp(String.raw`^ALTER\s+(?:COLUMN\s+)?(${IDENT})\s+(?:SET\s+DATA\s+)?TYPE\s+([\s\S]+)$`, "i");
-var unquote = (ident) => ident.startsWith("\"") ? ident.slice(1, -1).replace(/""/g, "\"") : ident;
-/**
-* Split an `ALTER TABLE`'s clause list on its top-level commas — the ones
-* outside parentheses and quotes, so `TYPE numeric(10, 2)` stays one clause.
-*/
-function splitClauses(body) {
-	const clauses = [];
-	let depth = 0;
-	let quote;
-	let start = 0;
-	for (let i = 0; i < body.length; i++) {
-		const ch = body[i];
-		if (quote) {
-			if (ch === quote) quote = void 0;
-		} else if (ch === "\"" || ch === "'") quote = ch;
-		else if (ch === "(") depth++;
-		else if (ch === ")") depth--;
-		else if (ch === "," && depth === 0) {
-			clauses.push(body.slice(start, i).trim());
-			start = i + 1;
-		}
-	}
-	clauses.push(body.slice(start).trim());
-	return clauses.filter((clause) => clause.length > 0);
-}
-/**
-* The statement from its `ALTER TABLE` on, wherever on a line that starts.
-*
-* {@link readPlan} hands over clean statements. This is the second line of
-* defence for text it could not clean — a rendering it does not know yet —
-* where a line of prose above the statement must not hide the statement, which
-* is exactly how an anchored match once read Atlas's whole plan as safe.
-*/
-function fromAlterTable(statement) {
-	const start = /(?:^|\n)[ \t]*(?:->[ \t]*)?(ALTER\s+TABLE\b)/i.exec(statement);
-	return start ? statement.slice(start.index + start[0].length - start[1].length).trim() : statement.trim();
-}
-/**
-* Every `ALTER COLUMN … [SET DATA] TYPE` in one statement. Atlas prints its
-* dry-run statements under a `-> ` marker and puts several clauses in one
-* `ALTER TABLE`, so both are handled.
-*/
-function parseColumnTypeChanges(statement) {
-	const table = ALTER_TABLE_RE.exec(fromAlterTable(statement));
-	if (!table) return [];
-	const [schema, name] = table[2] ? [unquote(table[1]), unquote(table[2])] : [void 0, unquote(table[1])];
-	const changes = [];
-	for (const clause of splitClauses(table[3])) {
-		const match = TYPE_CLAUSE_RE.exec(clause);
-		if (!match) continue;
-		const to = match[2].split(/\s+(?:USING|COLLATE)\s/i)[0].trim();
-		changes.push({
-			schema,
-			table: name,
-			column: unquote(match[1]),
-			to
-		});
-	}
-	return changes;
-}
-/** `ADD [CONSTRAINT "x"] PRIMARY KEY ("a", "b")`, one clause of an `ALTER TABLE`. */
-var ADD_PRIMARY_KEY_RE = new RegExp(String.raw`^ADD\s+(?:CONSTRAINT\s+${IDENT}\s+)?PRIMARY\s+KEY\b\s*(?:\(([^)]*)\))?`, "i");
-/** `DROP CONSTRAINT [IF EXISTS] "x"`, one clause of an `ALTER TABLE`. */
-var DROP_CONSTRAINT_RE = new RegExp(String.raw`^DROP\s+CONSTRAINT\s+(?:IF\s+EXISTS\s+)?(${IDENT})`, "i");
-/** What a row loses when the columns that address it change. */
-var ROW_ADDRESS_LOST = "every row's id changes, so anything that refers to a row by its id — a URL, a foreign key, an id stored elsewhere — stops finding it";
-/**
-* What an `ALTER TABLE` does to the table's primary key, in a sentence — or
-* `undefined` when it leaves the key alone.
-*
-* The key is a row's address: Rebase reads, links and routes every row by it.
-* Atlas plans a key change as `DROP CONSTRAINT "<table>_pkey", ADD PRIMARY KEY
-* (…)` — one routine-looking statement that names no DROP of data — so moving
-* a collection from `(id)` to `(id, locale)` re-keyed a populated table with
-* no prompt. A `CREATE TABLE`'s own `PRIMARY KEY` is not a change and is never
-* read here: only an `ALTER TABLE`'s clauses are. A dropped constraint counts
-* as the key when it carries Postgres's default name for one, `<table>_pkey`;
-* a key under another name is caught by the `ADD PRIMARY KEY` that replaces it.
-*/
-function describePrimaryKeyChange(statement) {
-	const alter = ALTER_TABLE_RE.exec(fromAlterTable(statement));
-	if (!alter) return void 0;
-	const table = alter[2] ? `${alter[1]}.${alter[2]}` : alter[1];
-	let added;
-	let dropped;
-	for (const clause of splitClauses(alter[3])) {
-		const add = ADD_PRIMARY_KEY_RE.exec(clause);
-		if (add) {
-			added = add[1] === void 0 ? "a new key" : `(${add[1].split(",").map((c) => c.trim()).join(", ")})`;
-			continue;
-		}
-		const drop = DROP_CONSTRAINT_RE.exec(clause);
-		if (drop && unquote(drop[1]).endsWith("_pkey")) dropped = drop[1];
-	}
-	if (added && dropped) return `${table} is re-keyed on ${added}: ${ROW_ADDRESS_LOST}`;
-	if (added) return `${table} gets the primary key ${added}: rows are addressed by it from now on, and the push fails if two rows share a value`;
-	if (dropped) return `${table} loses its primary key ${dropped}: ${ROW_ADDRESS_LOST}`;
-}
-/**
-* The column's current type. A table named without its schema matches in any
-* schema, but only when every match agrees — two same-named tables with
-* different types leave the answer unknown.
-*/
-function currentTypeOf(change, columnTypes) {
-	const types = new Set(columnTypes.filter((col) => col.table === change.table && col.column === change.column && (change.schema === void 0 || col.schema === change.schema)).map((col) => col.type));
-	return types.size === 1 ? [...types][0] : void 0;
-}
-/** Spellings of one type, mapped to one name. Anything absent compares verbatim. */
-var TYPE_ALIASES = {
-	"int": "integer",
-	"int4": "integer",
-	"int2": "smallint",
-	"int8": "bigint",
-	"character varying": "varchar",
-	"decimal": "numeric",
-	"timestamp without time zone": "timestamp",
-	"timestamp with time zone": "timestamptz",
-	"time without time zone": "time",
-	"time with time zone": "timetz",
-	"bool": "boolean",
-	"float4": "real",
-	"float8": "double precision",
-	"character": "bpchar",
-	"char": "bpchar"
-};
-/** Decimal digits each integer type holds, which is what a `numeric` must hold too. */
-var INTEGER_DIGITS = {
-	smallint: 5,
-	integer: 10,
-	bigint: 19
-};
-/** Types whose modifier is a fractional-seconds precision, 6 when absent. */
-var SECONDS_PRECISION = /* @__PURE__ */ new Set([
-	"timestamp",
-	"timestamptz",
-	"time",
-	"timetz"
-]);
-function parseType(raw) {
-	let text = raw.trim().replace(/\s+/g, " ");
-	let dims = 0;
-	for (let suffix = /\s*\[\d*\]$/.exec(text); suffix; suffix = /\s*\[\d*\]$/.exec(text)) {
-		dims++;
-		text = text.slice(0, suffix.index);
-	}
-	if (text.includes("\"")) return {
-		base: text,
-		dims
-	};
-	text = text.toLowerCase().replace(/^pg_catalog\./, "");
-	let args;
-	const modifier = /\(([^)]*)\)/.exec(text);
-	if (modifier) {
-		args = modifier[1].split(",").map((part) => Number(part.trim()));
-		text = `${text.slice(0, modifier.index)} ${text.slice(modifier.index + modifier[0].length)}`.replace(/\s+/g, " ").trim();
-	}
-	return {
-		base: TYPE_ALIASES[text] ?? text,
-		args,
-		dims
-	};
-}
-/** Does moving from one modifier to another, on the same type, keep every value? */
-function modifierWidens(base, from, to) {
-	if (JSON.stringify(from) === JSON.stringify(to)) return true;
-	if (base === "varchar") return to === void 0 || from !== void 0 && to[0] >= from[0];
-	if (base === "numeric") {
-		if (to === void 0) return true;
-		if (from === void 0) return false;
-		const [p1, s1 = 0] = from;
-		const [p2, s2 = 0] = to;
-		return s2 >= s1 && p2 - s2 >= p1 - s1;
-	}
-	if (SECONDS_PRECISION.has(base)) return (to?.[0] ?? 6) >= (from?.[0] ?? 6);
-	return false;
-}
-/**
-* Is `ALTER COLUMN … TYPE to` a widening, one that keeps every value exactly
-* as it was?
-*
-* Deliberately short. Everything not listed needs a confirmation, including
-* changes that are usually harmless: `timestamp` → `timestamptz` reads each
-* value in the session's time zone, `json` → `jsonb` drops duplicate keys,
-* `real` → `double precision` prints 0.1 as 0.100000001490116, and `integer` →
-* `text` keeps the digits but changes what the column is.
-*
-*  - the same type, with a modifier at least as wide (`varchar(100)` →
-*    `varchar(255)`, `numeric(10,2)` → `numeric(12,2)` or unbounded,
-*    `timestamptz(3)` → `timestamptz`);
-*  - `smallint` → `integer` → `bigint`, and any of them to a `numeric` with
-*    room for all their digits;
-*  - `varchar(n)` → `text`, and `text` → an unbounded `varchar`.
-*
-* Arrays follow their element type, and never gain or lose a dimension.
-*/
-function isLosslessTypeChange(from, to) {
-	const a = parseType(from);
-	const b = parseType(to);
-	if (a.dims !== b.dims) return false;
-	if (a.args?.some(Number.isNaN) || b.args?.some(Number.isNaN)) return false;
-	if (a.base === b.base) return modifierWidens(a.base, a.args, b.args);
-	const fromDigits = INTEGER_DIGITS[a.base];
-	if (fromDigits !== void 0) {
-		const toDigits = INTEGER_DIGITS[b.base];
-		if (toDigits !== void 0) return toDigits >= fromDigits;
-		if (b.base === "numeric") return b.args === void 0 || b.args[0] - (b.args[1] ?? 0) >= fromDigits;
-		return false;
-	}
-	if (a.base === "varchar" && b.base === "text") return true;
-	if (a.base === "text" && b.base === "varchar") return b.args === void 0;
-	return false;
-}
-/**
-* Decide how `db push` should proceed given the plan's destructiveness and
-* the invocation context.
-*
-*  - No destructive statements → `apply` (safe to auto-approve).
-*  - Destructive + `--allow-destructive` → `apply` (operator opted in).
-*  - Destructive + interactive TTY → `confirm` (prompt before applying).
-*  - Destructive + non-interactive → `refuse` (never silently drop data in
-*    CI / scripts / agents).
-*/
-function decidePushSafety(opts) {
-	if (opts.destructiveCount === 0) return "apply";
-	if (opts.allowDestructive) return "apply";
-	return opts.interactive ? "confirm" : "refuse";
-}
-//#endregion
-//#region src/module-dir.ts
-var moduleDir = path.dirname(fileURLToPath$1(import.meta.url));
-//#endregion
-//#region src/generated-sql.ts
-/**
-* Where `db push` and `db generate` put the SQL they render from the collections.
-*
-* Five files — `schema.sql` (Atlas's desired state), `policies.sql`,
-* `search.sql`, `vector.sql` and `triggers.sql` — and every one of them is
-* scratch. Both commands regenerate all five before reading any of them, and
-* nothing else reads them at all. They used to be written into `drizzle/`, beside
-* the migrations, and committed: a copy nobody read, which every collection
-* change rewrote in the diff and every two branches touching collections
-* conflicted on.
-*
-* Relative to the directory the command runs in (the backend), like the
-* migrations are.
-*/
-/** The directory, relative to the working directory. POSIX, because it is also a URL path. */
-var GENERATED_SQL_DIR = ".rebase/sql";
-/**
-* `schema.sql` as Atlas takes it. Relative on purpose, like the
-* `file://drizzle/migrations` beside it: Atlas joins the URL's host and path, so
-* `.rebase` is read as the first path segment, measured against the pinned 1.2.3.
-*/
-var DESIRED_STATE_URL = `file://${GENERATED_SQL_DIR}/schema.sql`;
-/** The files the DDL generator writes, all of them derived from the collections. */
-var GENERATED_SQL_FILES = [
-	"schema.sql",
-	"policies.sql",
-	"search.sql",
-	"vector.sql",
-	"triggers.sql"
-];
-/** The absolute directory, for the working directory the command runs in. */
-function generatedSqlDir(cwd = process.cwd()) {
-	return path.resolve(cwd, GENERATED_SQL_DIR);
-}
-/**
-* The first line of every file the generator writes, in every release that
-* wrote them into `drizzle/`. Matching it is what makes removing the old copy
-* safe: a file there under one of these names that does not open this way was
-* written by a person, and is left alone.
-*/
-var GENERATED_HEADER = /^-- This file (is auto-generated by the Rebase DDL generator|contains RLS policies generated by Rebase)\./;
-/**
-* Get the directory ready to be written, and retire the copies an older release
-* committed.
-*
-* The directory ignores itself, rather than relying on the project's
-* `.gitignore`: a scaffold ignores `.rebase/`, but a project created before it
-* did would otherwise start committing these files from their new home.
-*
-* The old copies in `drizzle/` are deleted, not left behind. Nothing writes them
-* any more, so from the first push after an upgrade they only fall further
-* behind — and a stale `policies.sql` in the repository is exactly what someone
-* reviewing the project's RLS would read.
-*
-* @returns the old files it removed, relative to the working directory.
-*/
-function prepareGeneratedSqlDir(cwd = process.cwd()) {
-	const dir = generatedSqlDir(cwd);
-	fs.mkdirSync(dir, { recursive: true });
-	const ignore = path.join(dir, ".gitignore");
-	if (!fs.existsSync(ignore)) fs.writeFileSync(ignore, "# Generated by `rebase db push` / `rebase db generate` from the collections.\n*\n");
-	const removed = [];
-	for (const name of GENERATED_SQL_FILES) {
-		const legacy = path.join(cwd, "drizzle", name);
-		if (!fs.existsSync(legacy)) continue;
-		const firstLine = fs.readFileSync(legacy, "utf-8").split("\n", 1)[0];
-		if (!GENERATED_HEADER.test(firstLine)) continue;
-		fs.rmSync(legacy);
-		removed.push(path.posix.join("drizzle", name));
-	}
-	return removed;
-}
-//#endregion
-//#region src/cli-helpers.ts
-/**
-* Which package manager installed this project, read off its lockfile.
-*
-* Every remedy for a blocked build script is package-manager specific, and
-* naming the wrong one is the same failure as naming none: `pnpm approve-builds`
-* is not a thing an npm user can run, and `pnpm.onlyBuiltDependencies` is a key
-* npm does not read. This existed as a pnpm-only message for long enough that
-* npm 12 — which blocks dependency lifecycle scripts by default, the way pnpm 10
-* does — could ship and leave every npm reader three unfollowable commands deep.
-*
-* The lockfile, not `npm_config_user_agent`: the question is how the project's
-* `node_modules` was built, not which binary happens to be invoking us. Walks up
-* because commands run from `backend/` in a scaffolded project, and the lockfile
-* is at the workspace root.
-*/
-function detectProjectPackageManager(startDir = process.cwd()) {
-	const lockfiles = [
-		["pnpm-lock.yaml", "pnpm"],
-		["bun.lock", "bun"],
-		["bun.lockb", "bun"],
-		["yarn.lock", "yarn"],
-		["package-lock.json", "npm"]
-	];
-	let dir = path.resolve(startDir);
-	while (true) {
-		for (const [file, manager] of lockfiles) if (fs.existsSync(path.join(dir, file))) return manager;
-		const parent = path.dirname(dir);
-		if (parent === dir) return "unknown";
-		dir = parent;
-	}
-}
-/**
-* How to let `@ariga/atlas` run its `preinstall`, in the reader's own package
-* manager.
-*
-* Returns the lines to print after "the binary is missing but the package is
-* installed". Kept next to {@link detectProjectPackageManager} so the two move
-* together, and returned rather than printed so it can be asserted on.
-*/
-function describeBuildScriptRemedy(packageName, manager = detectProjectPackageManager()) {
-	switch (manager) {
-		case "npm": return [
-			`    npm install-scripts approve ${packageName}`,
-			"",
-			"  or, to record it in the project (what `rebase init` scaffolds):",
-			"",
-			"    // package.json",
-			`    "allowScripts": { "${packageName}": true }`,
-			"",
-			"  Then re-run `npm install`."
-		];
-		case "yarn": return [
-			"    // .yarnrc.yml",
-			"    enableScripts: true",
-			"",
-			"  Then re-run `yarn install`."
-		];
-		case "bun": return [
-			"    // package.json",
-			`    "trustedDependencies": ["${packageName}"]`,
-			"",
-			"  Then re-run `bun install`."
-		];
-		default: return [
-			"    pnpm approve-builds",
-			"",
-			"  or, to record it in the project (what `rebase init` scaffolds):",
-			"",
-			"    // package.json",
-			`    "pnpm": { "onlyBuiltDependencies": ["${packageName}"] }`,
-			"",
-			"  Then re-run `pnpm install`."
-		];
-	}
-}
-/**
-* "Install again, from scratch", in the reader's own package manager.
-*
-* For the `bin-link-missing` state: the tree is half-written, and re-resolving
-* it is what recreates the `.bin` shim. `--force` on pnpm is what makes it
-* relink rather than decide the tree is already up to date.
-*/
-function describeReinstallCommand(manager = detectProjectPackageManager()) {
-	switch (manager) {
-		case "npm": return "rm -rf node_modules && npm install";
-		case "yarn": return "yarn install --force";
-		case "bun": return "rm -rf node_modules && bun install";
-		default: return "pnpm install --force";
-	}
-}
-/** `add <pkg>` as a dev dependency, in the reader's own package manager. */
-function describeDevAddCommand(packageName, manager = detectProjectPackageManager()) {
-	switch (manager) {
-		case "npm": return `npm install -D ${packageName}`;
-		case "yarn": return `yarn add -D ${packageName}`;
-		case "bun": return `bun add -d ${packageName}`;
-		default: return `pnpm add -D ${packageName}`;
-	}
-}
-/**
-* Where a package's own manifest lives, or null if it is not installed here.
-*
-* `package.json` rather than the package root: a package with an `exports` map
-* that omits `.` is unresolvable by name even when it is perfectly installed,
-* which would misreport it as absent.
-*/
-function resolvePackageManifest(packageName) {
-	const bases = [pathToFileURL(path.join(process.cwd(), "package.json")), pathToFileURL(path.join(moduleDir, "package.json"))];
-	for (const base of bases) try {
-		return createRequire(base).resolve(`${packageName}/package.json`);
-	} catch {}
-	return null;
-}
-/**
-* The binaries a package's own manifest declares, as absolute paths.
-*
-* `bin` is a string for a single binary named after the package, or a map.
-* Both forms appear in the wild and `@ariga/atlas` uses the map.
-*/
-function declaredBinaries(manifestPath) {
-	let manifest;
-	try {
-		manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
-	} catch {
-		return [];
-	}
-	const dir = path.dirname(manifestPath);
-	if (typeof manifest.bin === "string") return [path.resolve(dir, manifest.bin)];
-	if (manifest.bin && typeof manifest.bin === "object") return Object.values(manifest.bin).filter((target) => typeof target === "string").map((target) => path.resolve(dir, target));
-	return [];
-}
-function diagnoseMissingBin(packageName) {
-	const manifestPath = resolvePackageManifest(packageName);
-	if (!manifestPath) return "not-installed";
-	const binaries = declaredBinaries(manifestPath);
-	if (binaries.length === 0) return "build-script-blocked";
-	return binaries.some((file) => fs.existsSync(file)) ? "bin-link-missing" : "build-script-blocked";
-}
-function resolveLocalBin(binName) {
-	let dir = moduleDir;
-	while (true) {
-		const candidate = path.join(dir, "node_modules", ".bin", binName);
-		if (fs.existsSync(candidate)) return candidate;
-		const parent = path.dirname(dir);
-		if (parent === dir) break;
-		dir = parent;
-	}
-	let cwd = process.cwd();
-	while (true) {
-		const candidate = path.join(cwd, "node_modules", ".bin", binName);
-		if (fs.existsSync(candidate)) return candidate;
-		const parent = path.dirname(cwd);
-		if (parent === cwd) break;
-		cwd = parent;
-	}
-	try {
-		const globalPath = execSync(process.platform === "win32" ? `where ${binName}` : `which ${binName}`, { encoding: "utf-8" }).trim().split("\n")[0].trim();
-		if (globalPath && fs.existsSync(globalPath)) return globalPath;
-	} catch {}
-	return null;
-}
-async function getTableIncludesFromCollections(allCollections) {
-	const { getTableName, relationalCollections, resolveJunctionSpecs } = await import("@rebasepro/common");
-	const { isPostgresCollectionConfig } = await import("@rebasepro/types");
-	const collections = relationalCollections(allCollections);
-	const includes = [];
-	for (const col of collections) {
-		const tableName = getTableName(col);
-		const schema = isPostgresCollectionConfig(col) && col.schema ? col.schema : "public";
-		if (tableName) includes.push(`${schema}.${tableName}`);
-	}
-	for (const junction of resolveJunctionSpecs(collections).values()) includes.push(`${junction.schema}.${junction.table}`);
-	return Array.from(new Set(includes));
-}
-async function getTableIncludes(collectionsPath) {
-	return getTableIncludesFromCollections(await loadCollectionsForCli(collectionsPath));
-}
-/**
-* Load a project's collections the way the Atlas-facing commands need them.
-*
-* Deliberately forgiving — a file that fails to import is skipped rather than
-* fatal — because the callers use this to *narrow* what Atlas may touch, and a
-* hard failure here would block a push over an unrelated broken file. Callers
-* that cannot tolerate a partial answer (the table excludes, which fail closed)
-* check the result themselves.
-*/
-/** Paths this process has already complained about. See {@link loadCollectionsForCli}. */
-var warnedMissingCollectionsPaths = /* @__PURE__ */ new Set();
-async function loadCollectionsForCli(collectionsPath) {
-	const resolvedPath = path.resolve(collectionsPath);
-	const collections = [];
-	if (!fs.existsSync(resolvedPath) && !warnedMissingCollectionsPaths.has(resolvedPath)) {
-		warnedMissingCollectionsPaths.add(resolvedPath);
-		outWarn(chalk.yellow(`  ⚠  Collections path not found: "${collectionsPath}"\n     Resolved to: ${resolvedPath}\n     (relative to cwd: ${process.cwd()})\n     Pass an absolute path, or a path relative to where you run the command.`));
-	}
-	if (fs.existsSync(resolvedPath)) {
-		if (fs.statSync(resolvedPath).isDirectory()) {
-			const files = fs.readdirSync(resolvedPath);
-			for (const file of files) if ((file.endsWith(".ts") || file.endsWith(".js")) && !file.includes(".test.") && !file.endsWith(".d.ts") && file !== "index.ts" && file !== "index.js") try {
-				const module = await import(pathToFileURL(path.join(resolvedPath, file)).href);
-				if (module && module.default) collections.push(module.default);
-			} catch {}
-		}
-	}
-	return collections;
-}
-function getDevDatabaseUrl(databaseUrl) {
-	try {
-		const parsed = new URL(databaseUrl);
-		parsed.pathname = `/${parsed.pathname.slice(1)}_dev_diff`;
-		return parsed.toString();
-	} catch {
-		return databaseUrl + "_dev_diff";
-	}
-}
-/**
-* Create the scratch database Atlas plans against, and say so when we cannot.
-*
-* Atlas needs a `--dev-url` — an empty database it can build the desired state
-* in — and this makes `<db>_dev_diff` next to the real one. The whole body used
-* to be wrapped in an empty catch commented "Ignore, let Atlas handle
-* connection failures", and Atlas's version of handling it is `postgres:
-* querying system variables: pq: database "app_dev_diff" does not exist
-* (3D000)` — the symptom, four frames downstream of the cause, with the cause
-* thrown away.
-*
-* The cause is almost always `42501`: `CREATE DATABASE` is a privilege managed
-* providers do not grant, so this is the first thing a hosted user hits and the
-* one they can do least with.
-*
-* @returns whether the scratch database was created by *this* call — the only
-*          case in which dropping it afterwards is ours to do.
-*/
-async function ensureDevDatabaseExists(databaseUrl, devDatabaseUrl) {
-	let devDbName = "";
-	try {
-		const { Client } = await import("pg");
-		const parsed = new URL(databaseUrl);
-		devDbName = new URL(devDatabaseUrl).pathname.slice(1);
-		parsed.pathname = "/postgres";
-		const client = new Client({ connectionString: parsed.toString() });
-		await client.connect();
-		try {
-			if ((await client.query("SELECT 1 FROM pg_database WHERE datname = $1", [devDbName])).rowCount === 0) {
-				await client.query(`CREATE DATABASE "${devDbName}"`);
-				out(chalk.gray(`  ✓ Created validation database "${devDbName}"`));
-				return true;
-			}
-		} finally {
-			await client.end();
-		}
-	} catch (err) {
-		outWarn(describeDevDatabaseFailure(err, devDbName || "<db>_dev_diff"));
-	}
-	return false;
-}
-/**
-* What went wrong creating the scratch database, and what to do about it.
-*
-* Exported for its test: the `42501` branch is the one that matters and it
-* cannot be provoked without a non-superuser role.
-*/
-function describeDevDatabaseFailure(err, devDbName) {
-	const code = err?.code;
-	const message = err instanceof Error ? err.message : String(err);
-	const lines = [chalk.yellow(`  ⚠  Could not create the Atlas scratch database "${devDbName}": ${message}`)];
-	if (code === "42501") lines.push(chalk.gray(`     Atlas plans every change in a throwaway copy of the schema, and CREATE DATABASE
-     is a privilege most managed providers withhold. Two ways forward:
-       • GRANT the role CREATEDB:  ALTER ROLE "<role>" CREATEDB;
-       • or create it once by hand:  CREATE DATABASE "${devDbName}";`));
-	else lines.push(chalk.gray("     Atlas will fail next with `database \"" + devDbName + "\" does not exist (3D000)`, which is this."));
-	return lines.join("\n");
-}
-/**
-* Drop the scratch database again, after the command that needed it succeeded.
-*
-* It is a full copy of the schema — no rows, but every table, type and index —
-* and it was left behind per target forever. The only notice anyone got was
-* `rebase db branch prune` reporting "3 Atlas scratch database(s) left over
-* from db push", and on a provider that bills per database it is a silent cost.
-*
-* Deliberately NOT called on the failure path: after a failed push the scratch
-* database holds the state Atlas was planning against, which is the one thing
-* worth inspecting.
-*/
-async function dropDevDatabase(databaseUrl, devDatabaseUrl) {
-	try {
-		const { Client } = await import("pg");
-		const parsed = new URL(databaseUrl);
-		const devDbName = new URL(devDatabaseUrl).pathname.slice(1);
-		parsed.pathname = "/postgres";
-		const client = new Client({ connectionString: parsed.toString() });
-		await client.connect();
-		try {
-			await client.query(`DROP DATABASE IF EXISTS "${devDbName}"`);
-			out(chalk.gray(`  ✓ Removed validation database "${devDbName}"`));
-		} finally {
-			await client.end();
-		}
-	} catch (err) {
-		outWarn(chalk.gray(`  ⚠  Could not remove the Atlas scratch database: ${err instanceof Error ? err.message : String(err)}\n     \`rebase db branch prune --include-dev-diff\` clears them.`));
-	}
-}
-/**
-* The generated SQL for the project's `search` blocks, if it has any.
-*
-* @param sqlDir directory holding the generated SQL. Defaults to
-*        `.rebase/sql` under the working directory.
-*/
-function readSearchDdl(sqlDir = generatedSqlDir()) {
-	const searchFile = path.join(sqlDir, "search.sql");
-	if (!fs.existsSync(searchFile)) return "";
-	return fs.readFileSync(searchFile, "utf-8").trim();
-}
-/**
-* Bring the search column, its index and their helpers up to date.
-*
-* Runs *after* Atlas, not before: the statements are `ALTER TABLE ... ADD
-* COLUMN`, so the table has to exist. Atlas is told to ignore these objects
-* entirely (`getSearchExcludes`) — it cannot manage them, and left to itself it
-* would plan a `DROP COLUMN` for every one, since they are absent from the
-* desired state it was given.
-*
-* A no-op when no collection declared `search`. A failure is *not* swallowed:
-* silently pushing a schema whose search column never appeared is how a
-* collection ends up with search configured, no error anywhere, and no results.
-*/
-async function applySearchDdl(databaseUrl, sqlDir = generatedSqlDir()) {
-	const sql = readSearchDdl(sqlDir);
-	if (!sql) return;
-	const { Client } = await import("pg");
-	const client = new Client({ connectionString: databaseUrl });
-	await client.connect();
-	try {
-		await client.query(sql);
-	} finally {
-		await client.end();
-	}
-	out(chalk.gray("  ✓ Applied full-text search columns and indexes"));
-}
-/**
-* Glob patterns keeping Atlas away from the search objects.
-*
-* Returns an empty list — and so changes nothing — for a project with no
-* `search` block, which is every project that has not opted in.
-*/
-async function getSearchExcludes(collectionsPath) {
-	const { searchExcludePatterns } = await import("./generate-postgres-ddl-logic-BJsLaVNX.js").then((n) => n.o);
-	return searchExcludePatterns(await loadCollectionsForCli(collectionsPath));
-}
-/**
-* Every `generated column → column it reads` edge in the database.
-*
-* Read from `pg_depend` rather than by matching names in the expression text:
-* a generated column's `pg_attrdef` row carries one `deptype = 'n'` dependency
-* per column its expression references, which is the catalogue's own answer and
-* cannot be fooled by a column name that also appears inside a string literal
-* or as part of a longer identifier.
-*
-* Used by `db push` to find what has to come out of the way before Atlas runs —
-* see `generated-column-conflicts.ts` for why that is necessary at all.
-*/
-async function queryGeneratedColumnDependencies(databaseUrl) {
-	const { Client } = await import("pg");
-	const client = new Client({ connectionString: databaseUrl });
-	await client.connect();
-	try {
-		return (await client.query(`
-            SELECT n.nspname       AS "schema",
-                   c.relname       AS "table",
-                   gen.attname     AS "column",
-                   dep.attname     AS "dependsOn"
-            FROM pg_attrdef ad
-            JOIN pg_class c         ON c.oid = ad.adrelid
-            JOIN pg_namespace n     ON n.oid = c.relnamespace
-            JOIN pg_attribute gen   ON gen.attrelid = ad.adrelid AND gen.attnum = ad.adnum
-            JOIN pg_depend d        ON d.classid = 'pg_attrdef'::regclass
-                                   AND d.objid = ad.oid
-                                   AND d.refclassid = 'pg_class'::regclass
-                                   AND d.refobjid = ad.adrelid
-                                   AND d.deptype = 'n'
-            JOIN pg_attribute dep   ON dep.attrelid = ad.adrelid AND dep.attnum = d.refobjsubid
-            WHERE gen.attgenerated <> ''
-              AND NOT gen.attisdropped
-              AND NOT dep.attisdropped;
-        `)).rows;
-	} finally {
-		await client.end();
-	}
-}
-/**
-* Every column in the database with its current type, for the destructive
-* gate to tell a widening `ALTER COLUMN … TYPE` from one that loses data.
-*/
-async function queryColumnTypes(databaseUrl) {
-	const { Client } = await import("pg");
-	const client = new Client({ connectionString: databaseUrl });
-	await client.connect();
-	try {
-		return (await client.query(COLUMN_TYPES_SQL)).rows;
-	} finally {
-		await client.end();
-	}
-}
-/**
-* Drop the generated columns standing in the way of an apply.
-*
-* Their indexes and their `COMMENT ON COLUMN` stamp go with them, which is
-* exactly right: `applySearchDdl` rebuilds all three from `search.sql` and a
-* surviving stamp would make the rebuilt column look like drift.
-*/
-async function dropGeneratedColumns(databaseUrl, statements) {
-	if (statements.length === 0) return;
-	const { Client } = await import("pg");
-	const client = new Client({ connectionString: databaseUrl });
-	await client.connect();
-	try {
-		for (const statement of statements) await client.query(statement);
-	} finally {
-		await client.end();
-	}
-}
-/**
-* The generated SQL for the project's `vector` properties, if it has any.
-*
-* @param sqlDir directory holding the generated SQL. Defaults to
-*        `.rebase/sql` under the working directory.
-*/
-function readVectorDdl(sqlDir = generatedSqlDir()) {
-	const vectorFile = path.join(sqlDir, "vector.sql");
-	if (!fs.existsSync(vectorFile)) return "";
-	return fs.readFileSync(vectorFile, "utf-8").trim();
-}
-/**
-* Install pgvector and bring the vector columns and their ANN indexes up to
-* date.
-*
-* Runs *after* Atlas, like {@link applySearchDdl} and for the same reason: the
-* statements are `ALTER TABLE … ADD COLUMN`, so the table has to exist. Atlas
-* is told to ignore these objects entirely ({@link getVectorExcludes}) — it
-* cannot manage a type its dev database is structurally incapable of having,
-* and left to itself it would plan a `DROP COLUMN` for every one.
-*
-* A no-op when no collection declares a `vector` property. A failure is *not*
-* swallowed: a push that reported success while the embedding column never
-* appeared is how a project ends up with vector search configured, no error
-* anywhere, and no results.
-*/
-async function applyVectorDdl(databaseUrl, sqlDir = generatedSqlDir()) {
-	const sql = readVectorDdl(sqlDir);
-	if (!sql) return;
-	const { vectorExtensionHint } = await import("./vector-index-CMJKb3C9.js").then((n) => n.f);
-	const { Client } = await import("pg");
-	const client = new Client({ connectionString: databaseUrl });
-	await client.connect();
-	try {
-		await client.query(sql);
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		const hint = vectorExtensionHint(message);
-		if (!hint) throw err;
-		throw new Error(`${message}${hint}`, { cause: err });
-	} finally {
-		await client.end();
-	}
-	out(chalk.gray("  ✓ Applied vector columns and ANN indexes"));
-}
-/**
-* Glob patterns keeping Atlas away from the vector objects.
-*
-* Returns an empty list — and so changes nothing — for a project with no
-* `vector` property, which is every project that has not opted in.
-*/
-async function getVectorExcludes(collectionsPath) {
-	const { vectorExcludePatterns } = await import("./generate-postgres-ddl-logic-BJsLaVNX.js").then((n) => n.o);
-	return vectorExcludePatterns(await loadCollectionsForCli(collectionsPath));
-}
-/**
-* The generated SQL for the project's `autoValue: "on_update"` properties, if
-* it has any.
-*
-* @param sqlDir directory holding the generated SQL. Defaults to
-*        `.rebase/sql` under the working directory.
-*/
-function readTriggersDdl(sqlDir = generatedSqlDir()) {
-	const triggersFile = path.join(sqlDir, "triggers.sql");
-	if (!fs.existsSync(triggersFile)) return "";
-	return fs.readFileSync(triggersFile, "utf-8").trim();
-}
-/**
-* Install the `updated_at` trigger function and bind it to every column that
-* asked for one.
-*
-* Runs *after* Atlas, like {@link applySearchDdl} and {@link applyVectorDdl}:
-* a trigger needs its table and its column to exist. Atlas is told to ignore
-* the triggers ({@link getTriggerExcludes}) because it cannot manage a function
-* at all — its free tier refuses to parse a desired state containing one.
-*
-* A no-op when no property declares `autoValue: "on_update"`. A failure is
-* *not* swallowed: a push that reported success while the trigger never
-* appeared is how `updated_at` ends up silently stale for every writer that is
-* not the driver, which is the whole reason the trigger exists.
-*/
-async function applyTriggersDdl(databaseUrl, sqlDir = generatedSqlDir()) {
-	const sql = readTriggersDdl(sqlDir);
-	if (!sql) return;
-	const { Client } = await import("pg");
-	const client = new Client({ connectionString: databaseUrl });
-	await client.connect();
-	try {
-		await client.query(sql);
-	} finally {
-		await client.end();
-	}
-	out(chalk.gray("  ✓ Applied `updated_at` triggers"));
-}
-/** @see getSearchExcludes */
-async function getTriggerExcludes(collectionsPath) {
-	const { triggerExcludePatterns } = await import("./generate-postgres-ddl-logic-BJsLaVNX.js").then((n) => n.o);
-	return triggerExcludePatterns(await loadCollectionsForCli(collectionsPath));
-}
-/**
-* Query the live database for every user table/view outside the system
-* catalogs. Separated from {@link getTableExcludes} so its failure mode can
-* be handled explicitly (fail closed) and so tests can inject a stub.
-*/
-/**
-* Every index Postgres holds on a table Rebase manages, as
-* `schema.table.index`.
-*
-* Constraint-backed indexes are left out: a `PRIMARY KEY` or a `UNIQUE` is a
-* *constraint* to Atlas, diffed from the constraint declaration, and naming its
-* index in an exclude would shield the constraint itself.
-*/
-async function queryExistingIndexes(databaseUrl) {
-	const { Client } = await import("pg");
-	const client = new Client({ connectionString: databaseUrl });
-	await client.connect();
-	try {
-		return (await client.query(`
-            SELECT n.nspname || '.' || t.relname || '.' || i.relname AS full_name
-            FROM pg_index x
-            JOIN pg_class i ON i.oid = x.indexrelid
-            JOIN pg_class t ON t.oid = x.indrelid
-            JOIN pg_namespace n ON n.oid = t.relnamespace
-            WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
-              AND t.relkind IN ('r', 'p')
-              AND NOT EXISTS (
-                  SELECT 1 FROM pg_constraint c WHERE c.conindid = i.oid
-              );
-        `)).rows.map((row) => row.full_name);
-	} finally {
-		await client.end();
-	}
-}
-/**
-* Glob patterns keeping Atlas away from indexes that are not Rebase's.
-*
-* The problem this solves is live and predates the `indexes:` block. `db push`
-* is declarative, so an index on a managed table that is absent from
-* `schema.sql` is drift — and Atlas plans `DROP INDEX` for it. Verified
-* against atlas v1.2.3: create one by hand, re-run an unchanged push, and the
-* plan is a bare drop. `DROP INDEX` is not in `DESTRUCTIVE_PATTERNS`, so the
-* auto-approved apply took it without asking. Until now the only way to have
-* an index at all was to write it by hand, which made that the *only* outcome.
-*
-* Ownership rather than a prompt, because once indexes are declarable a drop
-* is usually correct: removing one from the config should remove it from the
-* database, quietly. What must never be dropped is an index Rebase never
-* created — a hand-written one, or one an introspected database arrived with.
-* {@link isRebaseIndexName} is the test, the same arrangement
-* `isGeneratedPolicyName` uses to let policy reconciliation drop only what it
-* generated.
-*
-* The named-in-the-desired-state check comes first and is what makes removal
-* work: a declared index that the author has just deleted still matches the
-* name pattern, is no longer in the plan, and so is *not* excluded — Atlas
-* drops it, as intended.
-*
-* Three-part `schema.table.index`, never two: a two-part pattern reads as a
-* *table* named `<index>` in a *schema* named `<table>`, matches nothing, and
-* reports no error — the trap already recorded for the search excludes.
-*/
-async function getForeignIndexExcludes(databaseUrl, collectionsPath, deps = {}) {
-	const queryIndexes = deps.queryExistingIndexes ?? queryExistingIndexes;
-	const managed = await (deps.getManagedIndexNames ?? managedIndexNames)(collectionsPath);
-	let existing;
-	try {
-		existing = await queryIndexes(databaseUrl);
-	} catch (err) {
-		throw new ExcludeIntrospectionError(`Failed to introspect the database for unmanaged indexes: ${err instanceof Error ? err.message : String(err)}`, err);
-	}
-	return existing.filter((full) => {
-		const indexName = full.slice(full.lastIndexOf(".") + 1);
-		if (managed.has(indexName)) return false;
-		return !isRebaseIndexName(indexName);
-	});
-}
-/**
-* The index names the current collections would create — search, vector and
-* declared alike. Anything Atlas would emit is by definition not foreign.
-*/
-async function managedIndexNames(collectionsPath) {
-	const collections = await loadCollectionsForCli(collectionsPath);
-	const { searchExcludePatterns, vectorExcludePatterns } = await import("./generate-postgres-ddl-logic-BJsLaVNX.js").then((n) => n.o);
-	const { resolveColumnName } = await import("./column-plan-helpers-1-LQD0yI.js").then((n) => n.t);
-	const { buildCollectionIndexPlan } = await import("./collection-index-DdnsxiJ_.js").then((n) => n.i);
-	const names = new Set(buildCollectionIndexPlan(collections, resolveColumnName).map((spec) => spec.indexName));
-	for (const pattern of [...searchExcludePatterns(collections), ...vectorExcludePatterns(collections)]) names.add(pattern.slice(pattern.lastIndexOf(".") + 1));
-	return names;
-}
-async function queryExistingTables(databaseUrl) {
-	const { Client } = await import("pg");
-	const client = new Client({ connectionString: databaseUrl });
-	await client.connect();
-	try {
-		return (await client.query(`
-            SELECT table_schema || '.' || table_name AS full_name
-            FROM information_schema.tables
-            WHERE table_schema NOT IN ('pg_catalog', 'information_schema')
-              AND table_type IN ('BASE TABLE', 'VIEW');
-        `)).rows.map((row) => row.full_name);
-	} finally {
-		await client.end();
-	}
-}
-/**
-* Raised when the exclude list could not be built. `db push` MUST abort on
-* this rather than continue: the exclude list is the only thing shielding
-* non-collection (user/system) tables from the auto-approved declarative
-* apply. A partial list — the old fail-open behaviour — meant a transient
-* introspection hiccup dropped every table not present in `schema.sql`.
-*/
-var ExcludeIntrospectionError = class extends Error {
-	cause;
-	constructor(message, cause) {
-		super(message);
-		this.cause = cause;
-		this.name = "ExcludeIntrospectionError";
-	}
-};
-/**
-* Build the `--exclude` list that protects tables Rebase doesn't manage from
-* the declarative apply. Anything not backing a collection (or its M2M
-* junctions) is excluded so Atlas never drops it.
-*
-* Fails **closed**: if the database can't be introspected we cannot know
-* which tables to protect, so we throw {@link ExcludeIntrospectionError}
-* instead of returning a near-empty list and letting the caller drop
-* everything.
-*
-* `deps` is injectable for tests; production uses the real pg-backed queries.
-*/
-async function getTableExcludes(databaseUrl, collectionsPath, deps = {}) {
-	const getIncludes = deps.getIncludes ?? getTableIncludes;
-	const queryTables = deps.queryExistingTables ?? queryExistingTables;
-	const includes = await getIncludes(collectionsPath);
-	const excludes = [
-		"atlas_schema_revisions.*",
-		"auth",
-		"auth.*",
-		"rebase",
-		"rebase.*"
-	];
-	let existingTables;
-	try {
-		existingTables = await queryTables(databaseUrl);
-	} catch (err) {
-		throw new ExcludeIntrospectionError(`Failed to introspect the database for unmapped tables: ${err instanceof Error ? err.message : String(err)}`, err);
-	}
-	for (const table of existingTables) if (!includes.includes(table)) excludes.push(table);
-	return excludes;
-}
-/**
-* Ask a yes/no question on an interactive terminal.
-*
-* The `isTTY` guard is the contract, not an optimisation: non-interactive
-* shells (CI, pipes, agents) can never answer, and `readline` on a
-* non-TTY stdin resolves with whatever the pipe happens to contain — or never
-* resolves at all. Returning false there is what makes an unattended
-* `db push` abort instead of auto-confirming a destructive change. Callers
-* should already have gone through {@link decidePushSafety}, which decides
-* whether interactive confirmation is even possible; this is the backstop.
-*
-* Lives here rather than in cli.ts so it is reachable from a test — cli.ts uses
-* `import.meta` and cannot be imported by the jest runner.
-*/
-async function promptConfirm(question) {
-	if (!process.stdin.isTTY) return false;
-	const rl = import___vite_browser_external.default.createInterface({
-		input: process.stdin,
-		output: process.stdout
-	});
-	try {
-		const answer = await new Promise((resolve) => rl.question(question, resolve));
-		return /^y(es)?$/i.test(answer.trim());
-	} finally {
-		rl.close();
-	}
-}
-//#endregion
 //#region src/schema/rls-bootstrap-sql.ts
 var rls_bootstrap_sql_exports = /* @__PURE__ */ __exportAll({
 	DROP_LEGACY_AUTH_SCHEMA_SQL: () => DROP_LEGACY_AUTH_SCHEMA_SQL,
@@ -7484,7 +6251,8 @@ var rls_bootstrap_sql_exports = /* @__PURE__ */ __exportAll({
 	LEGACY_RLS_FUNCTION_DEPENDENTS_SQL: () => LEGACY_RLS_FUNCTION_DEPENDENTS_SQL,
 	RLS_BOOTSTRAP_SQL: () => RLS_BOOTSTRAP_SQL,
 	RLS_BOOTSTRAP_STATEMENTS: () => RLS_BOOTSTRAP_STATEMENTS,
-	dropLegacyAuthSchema: () => dropLegacyAuthSchema
+	dropLegacyAuthSchema: () => dropLegacyAuthSchema,
+	rlsRuntimeIsCurrent: () => rlsRuntimeIsCurrent
 });
 /**
 * Canonical SQL bootstrap for the RLS helper functions.
@@ -7553,6 +6321,93 @@ $$ LANGUAGE sql STABLE`,
     SELECT COALESCE(NULLIF(current_setting('app.is_anonymous', true), ''), 'false')::boolean;
 $$ LANGUAGE sql STABLE`
 ];
+/** Everything `CREATE OR REPLACE FUNCTION` sets on a function, as one comparable string. */
+var describeFunction = (facts) => JSON.stringify([
+	facts.returns.toLowerCase(),
+	facts.language.toLowerCase(),
+	facts.volatility,
+	facts.strict,
+	facts.parallel,
+	facts.securityDefiner,
+	facts.leakproof,
+	facts.cost,
+	facts.hasConfig,
+	facts.body
+]);
+/**
+* What each `CREATE OR REPLACE FUNCTION` in {@link RLS_BOOTSTRAP_STATEMENTS}
+* would leave in the catalogue, by `schema.name`. Parsed
+* from the statements themselves, so the two cannot drift; a statement this
+* does not recognise makes {@link rlsRuntimeIsCurrent} answer "no", and the
+* bootstrap runs as it always did.
+*/
+var expectedRlsFunctions = () => {
+	const expected = /* @__PURE__ */ new Map();
+	for (const statement of RLS_BOOTSTRAP_STATEMENTS) {
+		if (/^CREATE SCHEMA IF NOT EXISTS /.test(statement)) continue;
+		const match = /^CREATE OR REPLACE FUNCTION (\w+)\.(\w+)\(\) RETURNS (\w+) AS \$\$([\s\S]*)\$\$ LANGUAGE (\w+) (IMMUTABLE|STABLE|VOLATILE)$/.exec(statement);
+		if (!match) return void 0;
+		const [, schema, name, returns, body, language, volatility] = match;
+		expected.set(`${schema}.${name}`, describeFunction({
+			returns,
+			language,
+			volatility: volatility[0].toLowerCase(),
+			strict: false,
+			parallel: "u",
+			securityDefiner: false,
+			leakproof: false,
+			cost: 100,
+			hasConfig: false,
+			body
+		}));
+	}
+	return expected;
+};
+/**
+* Whether the `rebase` schema and every RLS helper function are exactly what
+* {@link RLS_BOOTSTRAP_STATEMENTS} would make them — one catalogue read.
+*
+* The boot ran those statements unconditionally, on every boot and on every
+* source: four `CREATE OR REPLACE FUNCTION`s in a transaction under an
+* advisory lock. Replacing a function rewrites its `pg_proc` row even when
+* nothing changed, and every cached plan that inlined it — every plan of every
+* statement a policy applies to, on every connection — is invalidated by it.
+* A function that differs in anything `CREATE OR REPLACE` sets (body,
+* language, volatility, strictness, parallel safety, security, leakproofness,
+* cost, `SET` options), or is missing, answers `false`, and the statements run
+* as before.
+*/
+async function rlsRuntimeIsCurrent(run) {
+	const expected = expectedRlsFunctions();
+	if (!expected) return false;
+	const rows = await run(`SELECT n.nspname AS schema, p.proname AS name, pg_get_function_identity_arguments(p.oid) AS args,
+                format_type(p.prorettype, NULL) AS returns, l.lanname AS language,
+                p.provolatile::text AS volatility, p.proisstrict AS strict, p.proparallel::text AS parallel,
+                p.prosecdef AS security_definer, p.proleakproof AS leakproof, p.procost AS cost,
+                p.proconfig IS NOT NULL AS has_config, p.prosrc AS body
+         FROM pg_proc p
+         JOIN pg_namespace n ON p.pronamespace = n.oid
+         JOIN pg_language l ON p.prolang = l.oid
+         WHERE (n.nspname, p.proname) IN (${[...expected.keys()].map((key) => key.split(".")).map(([schema, name]) => `('${schema}', '${name}')`).join(", ")})`);
+	const live = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		if (String(row.args ?? "") !== "") continue;
+		live.set(`${row.schema}.${row.name}`, describeFunction({
+			returns: String(row.returns),
+			language: String(row.language),
+			volatility: String(row.volatility),
+			strict: row.strict === true,
+			parallel: String(row.parallel),
+			securityDefiner: row.security_definer === true,
+			leakproof: row.leakproof === true,
+			cost: Number(row.cost),
+			hasConfig: row.has_config === true,
+			body: String(row.body)
+		}));
+	}
+	for (const [key, definition] of expected) if (live.get(key) !== definition) return false;
+	return true;
+}
 /** The same statements as one script, for migration files and raw clients. */
 var RLS_BOOTSTRAP_SQL = "-- Rebase schema + RLS helper functions (required by the policies below)\n" + RLS_BOOTSTRAP_STATEMENTS.map((s) => `${s};`).join("\n\n") + "\n";
 /**
@@ -7718,6 +6573,6 @@ async function dropLegacyAuthSchema(run, report) {
 	}
 }
 //#endregion
-export { resolveLocalBin as A, forLibpq as B, loadCollectionsForCli as C, readSearchDdl as D, queryGeneratedColumnDependencies as E, decidePushSafety as F, detectDestructiveStatements as I, extractPlanStatements as L, GENERATED_SQL_DIR as M, generatedSqlDir as N, readTriggersDdl as O, prepareGeneratedSqlDir as P, fromAlterTable as R, getVectorExcludes as S, queryColumnTypes as T, getDevDatabaseUrl as _, ExcludeIntrospectionError as a, getTableExcludes as b, applyVectorDdl as c, describeReinstallCommand as d, detectProjectPackageManager as f, ensureDevDatabaseExists as g, dropGeneratedColumns as h, rls_bootstrap_sql_exports as i, DESIRED_STATE_URL as j, readVectorDdl as k, describeBuildScriptRemedy as l, dropDevDatabase as m, RLS_BOOTSTRAP_STATEMENTS as n, applySearchDdl as o, diagnoseMissingBin as p, dropLegacyAuthSchema as r, applyTriggersDdl as s, RLS_BOOTSTRAP_SQL as t, describeDevAddCommand as u, getForeignIndexExcludes as v, promptConfirm as w, getTriggerExcludes as x, getSearchExcludes as y, execa as z };
+export { rls_bootstrap_sql_exports as a, rlsRuntimeIsCurrent as i, RLS_BOOTSTRAP_STATEMENTS as n, execa as o, dropLegacyAuthSchema as r, forLibpq as s, RLS_BOOTSTRAP_SQL as t };
 
-//# sourceMappingURL=rls-bootstrap-sql-_KNnjanK.js.map
+//# sourceMappingURL=rls-bootstrap-sql-RQUljnJ1.js.map