@rebasepro/server-postgres 0.18.0 → 0.18.1

package/dist/ensure-collection-tables-DbAhrjnG.js

@@ -1,2732 +0,0 @@
-import { createRequire as __createRequire } from "module";
-import process from "process";
-const require = __createRequire(import.meta.url);
-import { i as collectionIndexStatements, n as buildCollectionIndexSpecs, r as collectionIndexStatement, t as buildCollectionIndexPlan } from "./collection-index-C7LopMyX.js";
-import { isConcurrentDdlRace, isDuplicateObjectRace, logger } from "@rebasepro/server";
-import { DEFAULT_FUZZY_THRESHOLD, DEFAULT_SEARCH_COLUMN, DEFAULT_SEARCH_LANGUAGE, DEFAULT_SEARCH_WEIGHT, REBASE_SCHEMA, declaredDatabaseExtensions, isManyToMany, isPostgresCollectionConfig } from "@rebasepro/types";
-import { findRelation, getEffectiveSecurityRules, getInjectedSecurityRules, getJunctionCollectionConfig, getJunctionSecurityRules, getTableName, policyToPostgres, relationalCollections, resolveCollectionRelations, resolveJunctionSpecs, resolveStringColumnLength, securityRuleToConditions } from "@rebasepro/common";
-import { generateForeignKeyName, getPolicyNamesForRule, legacyForeignKeyName, toPostgresIdentifier, toSnakeCase } from "@rebasepro/utils";
-import { createHash } from "node:crypto";
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
-	if (typeof require !== "undefined") return require.apply(this, arguments);
-	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
-});
-//#endregion
-//#region src/schema/search-column.ts
-/**
-* The one place a collection's `search` block becomes SQL.
-*
-* Four things describe a Postgres table in this codebase — the DDL generator,
-* the Drizzle schema generator, the runtime table builder for BaaS mode, and
-* the boot-time schema ensure — and each of them has, at some point, described
-* a column differently from the others. The `varchar(255)` note in
-* `generate-postgres-ddl-logic` is one such scar: the same property produced a
-* capped column down one path and an uncapped one down the other, and nothing
-* failed until a user hit the cap.
-*
-* So the search column is not implemented four times. It is computed once,
-* here, and every generator renders the same {@link SearchColumnSpec}. There is
-* a test asserting exactly that (`search-column-contract.test.ts`); the point of
-* this module is that the test has something to assert *about*.
-*
-* ## Why the expressions look the way they do
-*
-* A `GENERATED ALWAYS AS … STORED` expression must be strictly IMMUTABLE, and
-* Postgres is stricter here than intuition. Verified against PostgreSQL 18:
-*
-* | expression                              | immutable |
-* |-----------------------------------------|-----------|
-* | `to_tsvector('spanish', col)`           | yes       |
-* | `to_tsvector(col)` (1-arg)              | **no** — depends on `default_text_search_config` |
-* | `array_to_string(col, ' ')`             | **no**    |
-* | `col::text` on `text[]`                 | **no**    |
-* | `to_jsonb(col)`                         | **no**    |
-* | `unaccent(col)`                         | **no** — dictionary lookup is STABLE |
-* | `jsonb_to_tsvector('spanish', j, '["string"]')` | yes |
-* | `setweight(...) || setweight(...)`      | yes       |
-*
-* Three of the four things a real search column needs are therefore unavailable
-* directly, which is why {@link searchHelperFunctions} exists: each wraps a
-* stable built-in in an SQL function declared IMMUTABLE. That declaration is a
-* promise, and it is a true one for these three — array joining, JSON string
-* extraction and accent folding are all deterministic for a given input; the
-* built-ins are marked stable only because they must account for element types
-* and dictionaries in general.
-*
-* The alternative was to skip `unaccent` and text arrays entirely. That is not
-* a real option in an accented language: Postgres stems `auditoría` to
-* `auditor` and `auditoria` to `auditori` — *different lexemes* — so a query
-* typed without accents misses every row that carries them.
-*/
-/** Schema-qualified so a collection outside `public` still resolves them. */
-var HELPER_SCHEMA = "public";
-/**
-* Names of the helper functions. Frozen: they are recorded in the stored
-* generation expression of every search column ever created, so renaming one
-* orphans every table that already has a search column.
-*/
-var SEARCH_TEXT_FN = `${HELPER_SCHEMA}.rebase_search_text`;
-var SEARCH_UNACCENT_FN = `${HELPER_SCHEMA}.rebase_search_unaccent`;
-/** Raised when a `search` block names something that cannot be searched. */
-var SearchConfigError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "SearchConfigError";
-	}
-};
-/** The `search` block of a collection, or undefined when it has none. */
-var getSearchConfig = (collection) => isPostgresCollectionConfig(collection) ? collection.search : void 0;
-/**
-* Refuse a `search` block on a collection this engine does not store.
-*
-* The type only permits one on a `PostgresCollectionConfig`, so TypeScript
-* already stops the ordinary case. This catches the rest — a JS config, a cast,
-* a collection whose `engine` was changed after the block was written — because
-* the alternative is the exact failure the block exists to prevent: a developer
-* who declared what to index, saw no error, and got the substring fallback.
-*
-* Called with *every* collection, before the Postgres ones are filtered out.
-*/
-var assertSearchIsPostgresOnly = (collections) => {
-	for (const collection of collections) {
-		if (isPostgresCollectionConfig(collection)) continue;
-		if (!collection.search) continue;
-		const engine = collection.engine ?? "non-postgres";
-		throw new SearchConfigError(`${collection.slug}.search: full-text search is a Postgres feature, and this collection is served by \`${engine}\`. Remove the block — it would otherwise look configured while \`.search()\` kept using the default substring match.`);
-	}
-};
-var columnNameOf = (propName, prop) => prop && "columnName" in prop && typeof prop.columnName === "string" ? prop.columnName : toSnakeCase(propName);
-/**
-* Classify a property for search purposes.
-*
-* Deliberately narrower than `getSqlColumnType`: search only cares whether a
-* value reaches text, and the mapping from property to *physical* type is
-* asserted against `getSqlColumnType` in the contract test rather than
-* duplicated here.
-*
-* Returns null for anything that is not text-bearing, which the caller turns
-* into a boot error naming the property.
-*/
-var classify = (prop) => {
-	switch (prop.type) {
-		case "string": {
-			const sp = prop;
-			if (sp.enum) return {
-				kind: "text",
-				reason: "enum"
-			};
-			if (sp.isId === "uuid" || sp.columnType === "uuid") return {
-				kind: "text",
-				reason: "uuid"
-			};
-			return { kind: "text" };
-		}
-		case "map":
-			if (prop.columnType === "json") return {
-				kind: "jsonb",
-				reason: "json"
-			};
-			return { kind: "jsonb" };
-		case "array": {
-			const ap = prop;
-			let colType = ap.columnType;
-			if (!colType && ap.of && !Array.isArray(ap.of)) {
-				const of = ap.of;
-				if (of.type === "string") colType = "text[]";
-				else if (of.type === "number") colType = of.validation?.integer ? "integer[]" : "numeric[]";
-				else if (of.type === "boolean") colType = "boolean[]";
-			}
-			if (colType === "text[]") return { kind: "text_array" };
-			if (colType === "json") return {
-				kind: "jsonb",
-				reason: "json"
-			};
-			if (colType === "integer[]" || colType === "boolean[]" || colType === "numeric[]") return {
-				kind: "text_array",
-				reason: "non_text_array"
-			};
-			return { kind: "jsonb" };
-		}
-		default: return null;
-	}
-};
-var normalize = (inner, unaccent) => unaccent ? `${SEARCH_UNACCENT_FN}(${inner})` : inner;
-/** SQL reading one field as plain text, before normalization. */
-var rawTextSql = (field) => {
-	const col = `"${field.column}"`;
-	if (field.kind === "text") return `coalesce(${col}, '')`;
-	if (field.kind === "text_array") return `${SEARCH_TEXT_FN}(coalesce(${col}, '{}'::text[]))`;
-	return `${SEARCH_TEXT_FN}(coalesce(${field.jsonPath.length === 0 ? col : field.jsonPath.length === 1 ? `${col} -> ${quote$1(field.jsonPath[0])}` : `${col} #> ${quote$1(`{${field.jsonPath.join(",")}}`)}`}, '{}'::jsonb))`;
-};
-var quote$1 = (v) => `'${v.replace(/'/g, "''")}'`;
-/**
-* Resolve and validate one declared field path.
-*
-* A path that does not resolve throws. The whole point of an explicit block is
-* that the author knows what is indexed; a silently dropped field would make it
-* a guess again, and the failure — a search that returns nothing for content
-* that is plainly in the row — is invisible from the outside.
-*/
-var resolveField = (entry, collection, cfg) => {
-	const path = typeof entry === "string" ? entry : entry.path;
-	const weight = (typeof entry === "string" ? void 0 : entry.weight) ?? DEFAULT_SEARCH_WEIGHT;
-	const where = `${collection.slug}.search`;
-	if (!path || typeof path !== "string") throw new SearchConfigError(`${where}: every entry in \`fields\` needs a property path.`);
-	const [head, ...rest] = path.split(".");
-	const prop = collection.properties?.[head];
-	if (!prop) throw new SearchConfigError(`${where}: "${path}" starts at property "${head}", which this collection does not declare. Known properties: ${Object.keys(collection.properties ?? {}).join(", ")}.`);
-	const classified = classify(prop);
-	if (!classified) throw new SearchConfigError(`${where}: "${path}" is a \`${prop.type}\` property, which holds no text to search. Searchable kinds are \`string\`, \`string[]\` and \`map\` (or a path inside one).`);
-	if (classified.reason === "enum") throw new SearchConfigError(`${where}: "${path}" is an enum. Enums are a fixed vocabulary — filter on them with \`where\` instead, which is exact and uses an index.`);
-	if (classified.reason === "uuid") throw new SearchConfigError(`${where}: "${path}" is a UUID column. Look it up by id rather than searching it.`);
-	if (classified.reason === "json") throw new SearchConfigError(`${where}: "${path}" is a \`json\` column, and the cast from \`json\` to \`jsonb\` is not immutable, so it cannot feed a generated column. Declare the property as \`jsonb\` (the default) to search it.`);
-	if (classified.reason === "non_text_array") throw new SearchConfigError(`${where}: "${path}" is an array of numbers or booleans. Only \`string[]\` carries text to search.`);
-	if (rest.length > 0 && classified.kind !== "jsonb") throw new SearchConfigError(`${where}: "${path}" addresses a path inside "${head}", but "${head}" is a \`${prop.type}\` property, not a \`map\`. Only map properties have paths inside them.`);
-	const column = columnNameOf(head, prop);
-	const textSql = normalize(rawTextSql({
-		column,
-		jsonPath: rest,
-		kind: classified.kind
-	}), cfg.unaccent === true);
-	const language = cfg.language ?? DEFAULT_SEARCH_LANGUAGE;
-	return {
-		path,
-		column,
-		jsonPath: rest,
-		kind: classified.kind,
-		weight,
-		sql: `setweight(to_tsvector(${quote$1(language)}, ${textSql}), ${quote$1(weight)})`,
-		textSql
-	};
-};
-/**
-* Build the full spec for a collection, or undefined when it has not opted in.
-*
-* Throws {@link SearchConfigError} on a config that cannot be honoured. Callers
-* at boot surface that as a startup failure — a search block that half-works is
-* worse than one that refuses.
-*/
-var buildSearchColumnSpec = (collection) => {
-	const cfg = getSearchConfig(collection);
-	if (!cfg) return void 0;
-	if (!Array.isArray(cfg.fields) || cfg.fields.length === 0) throw new SearchConfigError(`${collection.slug}.search: \`fields\` is empty. Name the properties to index, or remove the \`search\` block to keep the default ILIKE behaviour.`);
-	const table = getTableName(collection);
-	const schema = isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public";
-	const column = cfg.column ?? DEFAULT_SEARCH_COLUMN;
-	if (collection.properties?.[column]) throw new SearchConfigError(`${collection.slug}.search: the generated column "${column}" collides with a declared property of the same name. Set \`search.column\` to something else.`);
-	const fields = cfg.fields.map((entry) => resolveField(entry, collection, cfg));
-	const seen = /* @__PURE__ */ new Set();
-	for (const f of fields) {
-		if (seen.has(f.path)) throw new SearchConfigError(`${collection.slug}.search: "${f.path}" is listed twice.`);
-		seen.add(f.path);
-	}
-	const extensions = [];
-	if (cfg.unaccent) extensions.push("unaccent");
-	if (cfg.fuzzy) extensions.push("pg_trgm");
-	const spec = {
-		schema,
-		table,
-		column,
-		language: cfg.language ?? DEFAULT_SEARCH_LANGUAGE,
-		unaccent: cfg.unaccent === true,
-		fields,
-		expression: fields.map((f) => f.sql).join(" || "),
-		indexName: toPostgresIdentifier(`${table}_${column}_gin`),
-		extensions
-	};
-	if (cfg.fuzzy) {
-		const fuzzyColumn = `${column}_text`;
-		if (collection.properties?.[fuzzyColumn]) throw new SearchConfigError(`${collection.slug}.search: \`fuzzy\` needs the column "${fuzzyColumn}", which collides with a declared property. Set \`search.column\` to something else.`);
-		spec.fuzzy = {
-			column: fuzzyColumn,
-			expression: fields.map((f) => f.textSql).join(" || ' ' || "),
-			indexName: toPostgresIdentifier(`${table}_${fuzzyColumn}_trgm`),
-			threshold: cfg.fuzzyThreshold ?? DEFAULT_FUZZY_THRESHOLD
-		};
-	}
-	return spec;
-};
-/**
-* The IMMUTABLE wrappers the generated expressions call.
-*
-* `CREATE OR REPLACE` so a boot against an existing database is a no-op rather
-* than an error, and idempotent for the same reason every other boot-time DDL
-* statement here is.
-*
-* The bodies are stable built-ins wrapped in an immutable promise — see the
-* module comment for why that promise is sound. `STRICT` matters: it makes NULL
-* in mean NULL out without executing the body, which is what the `coalesce` at
-* each call site then absorbs.
-*/
-var searchHelperFunctions = (spec) => {
-	const statements = [`CREATE OR REPLACE FUNCTION ${SEARCH_TEXT_FN}(text[]) RETURNS text\n    LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS\n    $$ SELECT array_to_string($1, ' ') $$;`, `CREATE OR REPLACE FUNCTION ${SEARCH_TEXT_FN}(jsonb) RETURNS text\n    LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS\n    $$ SELECT coalesce(string_agg(v, ' '), '')\n       FROM jsonb_array_elements_text(jsonb_path_query_array($1, 'strict $.**?(@.type() == "string")')) AS v $$;`];
-	if (spec.unaccent) statements.push(`CREATE OR REPLACE FUNCTION ${SEARCH_UNACCENT_FN}(text) RETURNS text\n    LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS\n    $$ SELECT ${HELPER_SCHEMA}.unaccent('${HELPER_SCHEMA}.unaccent'::regdictionary, $1) $$;`);
-	return statements;
-};
-/**
-* `CREATE EXTENSION` statements the spec's expressions depend on.
-*
-* `WITH SCHEMA public` is load-bearing, not tidiness. An unqualified
-* `CREATE EXTENSION` installs into the first schema on `search_path`, which
-* defaults to `"$user", public` — and the scaffold's database role is named
-* `rebase`, the same as the schema the generator creates one statement earlier.
-* So the moment that schema exists, `CREATE EXTENSION unaccent` puts the
-* dictionary in `rebase`, and every reference to `public.unaccent` below fails
-* with "text search dictionary does not exist". Observed, not theorised.
-*/
-var searchExtensionStatements = (spec) => spec.extensions.map((e) => `CREATE EXTENSION IF NOT EXISTS ${e} WITH SCHEMA ${HELPER_SCHEMA};`);
-/** The column definition as it appears inside `CREATE TABLE`. */
-var searchColumnDefinition = (spec) => `"${spec.column}" tsvector GENERATED ALWAYS AS (${spec.expression}) STORED`;
-/** The fuzzy column definition, when the spec asks for one. */
-var fuzzyColumnDefinition = (spec) => spec.fuzzy ? `"${spec.fuzzy.column}" text GENERATED ALWAYS AS (${spec.fuzzy.expression}) STORED` : void 0;
-/**
-* Index statements for the spec.
-*
-* `CONCURRENTLY` is deliberately *not* used here. This form is emitted into a
-* SQL file replayed as one unit — a migration, or `search.sql` — where a
-* concurrent build is not allowed. The boot-time ensure path runs statement by
-* statement against tables that are live and populated, and uses the
-* concurrent form instead; see `ensureSearchColumns`.
-*/
-var searchIndexStatements = (spec) => {
-	const statements = [`CREATE INDEX IF NOT EXISTS "${spec.indexName}" ON "${spec.schema}"."${spec.table}" USING GIN ("${spec.column}");`];
-	if (spec.fuzzy) statements.push(`CREATE INDEX IF NOT EXISTS "${spec.fuzzy.indexName}" ON "${spec.schema}"."${spec.table}" USING GIN ("${spec.fuzzy.column}" ${HELPER_SCHEMA}.gin_trgm_ops);`);
-	return statements;
-};
-/**
-* Marker on the comment of every generated search column this module creates.
-*
-* Versioned because the fingerprint below is only comparable against itself: a
-* future change to how it is computed has to read as "not stamped by this
-* version" rather than as drift on every existing column.
-*/
-var SEARCH_STAMP_PREFIX = "rebase:search:v1:";
-/**
-* A stable fingerprint of one generated column's expression.
-*
-* Why a stamp rather than reading the expression back: Postgres stores a
-* generated column's expression *parsed*, and hands it back deparsed — casts
-* made explicit, identifiers requoted, schema qualifications added or dropped
-* according to `search_path`. Comparing that text to the text we generated
-* would report drift on wording, and this comparison decides whether a boot
-* refuses, so a false positive is an outage. The stamp is written by the same
-* code that writes the column, so equality means what it says.
-*/
-var searchExpressionFingerprint = (expression) => `${SEARCH_STAMP_PREFIX}${createHash("sha256").update(expression).digest("hex").slice(0, 16)}`;
-/**
-* The stamps for a spec's generated columns — one per column, never shared.
-*
-* Per column on purpose: turning `fuzzy` on adds a second column and changes
-* nothing about the first, and a spec-wide fingerprint would report the
-* untouched `tsvector` column as drifted and refuse a boot over a change that
-* is purely additive.
-*/
-var searchColumnStamps = (spec) => {
-	const stamp = (column, expression) => {
-		const fingerprint = searchExpressionFingerprint(expression);
-		return {
-			column,
-			expression,
-			fingerprint,
-			sql: `COMMENT ON COLUMN "${spec.schema}"."${spec.table}"."${column}" IS ${quote$1(fingerprint)};`
-		};
-	};
-	const stamps = [stamp(spec.column, spec.expression)];
-	if (spec.fuzzy) stamps.push(stamp(spec.fuzzy.column, spec.fuzzy.expression));
-	return stamps;
-};
-/**
-* The same drift check as the boot ensure, for the SQL file.
-*
-* Needed because {@link searchColumnStamps} would otherwise *launder* drift on
-* the migration path: `ADD COLUMN IF NOT EXISTS` does nothing to a column that
-* exists, so a re-generated `search.sql` would stamp a stale column with the
-* new block's fingerprint and the next boot would find them in agreement.
-* Guarding first means the file refuses instead — `rebase db push` is attended,
-* and the operator reading the failure is the person who changed the block.
-*/
-var searchStampGuards = (spec) => searchColumnStamps(spec).map((stamp) => {
-	const relation = quote$1(`"${spec.schema}"."${spec.table}"`);
-	return `DO $rebase_search$
-DECLARE recorded text;
-BEGIN
-    SELECT col_description(a.attrelid, a.attnum) INTO recorded
-    FROM pg_attribute a
-    WHERE a.attrelid = ${relation}::regclass AND a.attname = ${quote$1(stamp.column)} AND NOT a.attisdropped;
-    IF recorded LIKE ${quote$1(`${SEARCH_STAMP_PREFIX}%`)} AND recorded <> ${quote$1(stamp.fingerprint)} THEN
-        RAISE EXCEPTION 'Rebase: the search block for ${spec.schema}.${spec.table} changed after the generated column "${stamp.column}" was built (recorded %, expected ${stamp.fingerprint}). Postgres cannot alter a generated expression in place. Drop the column and re-apply this file — it rewrites the table and rebuilds the index: ALTER TABLE ${relation.slice(1, -1)} DROP COLUMN "${stamp.column}";', recorded;
-    END IF;
-END
-$rebase_search$;`;
-});
-/**
-* The generated column names a collection's search block adds, if any.
-*
-* These are physical columns on the table, so `SELECT *` returns them. They are
-* an index in column form — a list of lexeme positions, or a concatenation of
-* every searchable field on the row — and nothing outside the query planner has
-* any use for them. Left in, every list response carries a second, larger copy
-* of the row's text.
-*/
-var searchColumnNames = (collection) => {
-	let spec;
-	try {
-		spec = buildSearchColumnSpec(collection);
-	} catch {
-		return [];
-	}
-	if (!spec) return [];
-	return spec.fuzzy ? [spec.column, spec.fuzzy.column] : [spec.column];
-};
-/**
-* True for a column whose type only ever holds a search index.
-*
-* Independent of any collection config on purpose: an introspected database
-* (BaaS mode) can carry a `tsvector` column this framework never created —
-* Pagila's `film.fulltext` is the canonical one — and it should not be returned
-* to callers either. `isDerivedIndexColumn` already keeps such a column out of
-* the *properties*; this keeps it out of the *rows*.
-*/
-var isSearchIndexColumn = (column) => {
-	const sqlType = typeof column?.getSQLType === "function" ? column.getSQLType().toLowerCase() : "";
-	return sqlType === "tsvector" || sqlType === "tsquery";
-};
-/**
-* A drizzle select projection over `table` with the search columns dropped.
-*
-* Returns undefined when nothing needs dropping, so the common case keeps using
-* a plain `select()` and this stays invisible in the generated SQL.
-*/
-var visibleColumnProjection = (tableColumns, collection) => {
-	const excluded = excludedColumnNames(tableColumns, collection);
-	if (!tableColumns || excluded.length === 0) return void 0;
-	const projection = {};
-	for (const [name, column] of Object.entries(tableColumns)) if (!excluded.includes(name)) projection[name] = column;
-	return projection;
-};
-/** The same exclusion as a drizzle `db.query` `columns` denylist. */
-var hiddenColumnsOption = (tableColumns, collection) => {
-	const excluded = excludedColumnNames(tableColumns, collection);
-	if (excluded.length === 0) return void 0;
-	return Object.fromEntries(excluded.map((name) => [name, false]));
-};
-/**
-* The columns to keep out of a response, by name.
-*
-* `tableColumns` is whatever `getTableColumns` returned, which is `undefined`
-* for anything that is not a real drizzle table — a stub in a test, a derived
-* or nested path with no table behind it. Nothing to exclude is the right
-* answer there, and it has to be an answer rather than a throw: this runs on
-* the read path of every collection, opted in or not.
-*/
-var excludedColumnNames = (tableColumns, collection) => {
-	if (!tableColumns || typeof tableColumns !== "object") return [];
-	const byName = new Set(collection ? searchColumnNames(collection) : []);
-	return Object.keys(tableColumns).filter((name) => byName.has(name) || isSearchIndexColumn(tableColumns[name]));
-};
-//#endregion
-//#region src/utils/pg-error-utils.ts
-/**
-* Shared PostgreSQL error extraction and user-friendly message formatting.
-*
-* Drizzle wraps native PG errors in a `.cause` chain. These utilities
-* unwrap that chain to get the real PostgreSQL error (identified by a
-* 5-character alphanumeric `code` such as `42P01`) and translate it into
-* a message that is safe and helpful to show to end-users.
-*/
-/**
-* Return the error when it is a deliberate 4xx, otherwise null.
-*
-* A thrown `ApiError` is a decision the server made about the request, not a
-* database failure: its message and code are already written for the client.
-*/
-function asClientFacingError(error) {
-	if (!(error instanceof Error)) return null;
-	const e = error;
-	if (typeof e.statusCode !== "number" || e.statusCode < 400 || e.statusCode >= 500) return null;
-	return e;
-}
-/**
-* Extract the underlying PostgreSQL error from a Drizzle wrapper.
-* Drizzle wraps PG errors in a `cause` property — this function
-* recursively walks the chain until it finds an object with a PG
-* error code (5-char alphanumeric, e.g. `42P01`).
-*/
-function extractPgError(error) {
-	if (!error || typeof error !== "object") return null;
-	if (!(error instanceof Error)) {
-		if ("cause" in error && error.cause && typeof error.cause === "object") return extractPgError(error.cause);
-		return null;
-	}
-	if ("code" in error && typeof error.code === "string" && /^[0-9A-Z]{5}$/.test(error.code)) return error;
-	if (error.cause && typeof error.cause === "object") return extractPgError(error.cause);
-	return null;
-}
-/**
-* Whether the failure came back from Postgres rather than from building the
-* query — which decides whether a fallback query is worth issuing.
-*
-* Reads here run inside a transaction (that is where `SET LOCAL ROLE` binds
-* RLS). Once a statement raises, that transaction is aborted, and every later
-* statement on it returns `25P02` — "current transaction is aborted, commands
-* ignored until end of transaction block". So a retry after a database error
-* cannot succeed, and it replaces a precise diagnosis ("invalid input syntax
-* for type uuid") with a generic one. Rethrow instead.
-*
-* A query the driver could not even build — a missing reciprocal relation, say
-* — never reached Postgres, leaves the transaction usable, and is exactly what
-* the fallback paths exist for.
-*/
-function reachedDatabase(error) {
-	return extractPgError(error) !== null;
-}
-/**
-* Walk the error cause chain and return the deepest meaningful message.
-*/
-function extractCauseMessage(error) {
-	if (!error || typeof error !== "object") return null;
-	if (!(error instanceof Error)) return null;
-	if (error.cause && typeof error.cause === "object") {
-		const deeper = extractCauseMessage(error.cause);
-		if (deeper) return deeper;
-		if (error.cause instanceof Error && error.cause.message) return error.cause.message;
-	}
-	return null;
-}
-/**
-* Codes that mean "this connection will never work as configured".
-*
-* A wrong password or a database that does not exist is a settled fact about
-* the connection string, not a transient fault — retrying produces the same
-* answer forever.
-*/
-var UNRECOVERABLE_CONNECT_CODES = /* @__PURE__ */ new Set([
-	"28P01",
-	"28000",
-	"3D000",
-	"42501"
-]);
-/**
-* Describe a failed connection attempt in terms a developer can act on.
-*
-* The error a caller catches is Drizzle's wrapper: its message is
-* `Failed query: SELECT 1` and its stack runs through drizzle internals, while
-* the sentence that says what is actually wrong — "password authentication
-* failed for user …", "database … does not exist" — sits in `.cause`. Logging
-* the wrapper, as the bootstrapper used to, tells a developer with a typo in
-* their `DATABASE_URL` nothing at all.
-*/
-function classifyConnectFailure(error) {
-	const pgError = extractPgError(error);
-	const reason = pgError?.message ?? extractCauseMessage(error) ?? (error instanceof Error ? error.message : String(error));
-	return {
-		fatal: Boolean(pgError?.code && UNRECOVERABLE_CONNECT_CODES.has(pgError.code)),
-		reason,
-		code: pgError?.code
-	};
-}
-/**
-* Detect whether an error is specifically a role-switching permission failure
-* (e.g. "permission denied to set role" or "must be member of role"),
-* as opposed to a table-level permission denial.
-*
-* This is used by the backend driver to auto-disable role switching when the
-* connection user lacks SET ROLE privileges, rather than surfacing a confusing
-* error to the Studio SQL Editor user.
-*/
-function isRoleSwitchingPermissionError(error) {
-	const pgError = extractPgError(error);
-	if (!pgError || pgError.code !== "42501") return false;
-	const msg = pgError.message.toLowerCase();
-	return msg.includes("set role") || msg.includes("member of role");
-}
-/**
-* Was this `42501` the *caller* being refused by a policy, rather than the
-* server lacking a privilege?
-*
-* Both arrive as `insufficient_privilege`, and they are opposite kinds of
-* problem. A row-level-security refusal is a working access-control system
-* doing its job: the caller asked for something their policies do not permit,
-* which is a 403 and nobody's bug. A missing `GRANT` is the deployment being
-* wrong — the connection role cannot touch the table at all, no policy is
-* involved, and nothing the caller changes about the request will help.
-*
-* Postgres distinguishes them in the message, so this does too:
-*
-*     new row violates row-level security policy for table "notes"  → the caller
-*     permission denied for table notes                             → the server
-*
-* Only writes reach this. A read that RLS excludes is not an error — the rows
-* are filtered and the caller gets an empty page — so the erroring case is
-* specifically an `INSERT`/`UPDATE` whose row fails a policy's `WITH CHECK`.
-*
-* Matched on the message because that is the only thing carrying the
-* distinction; the SQLSTATE is identical either way. Narrow by design: anything
-* not naming row-level security stays the server's problem, since reporting a
-* genuine privilege misconfiguration as "forbidden" would send an operator
-* hunting for a policy bug that does not exist.
-*/
-function isRowLevelSecurityDenial(error) {
-	const pgError = extractPgError(error);
-	if (!pgError || pgError.code !== "42501") return false;
-	return pgError.message.toLowerCase().includes("row-level security policy");
-}
-/**
-* Translate a raw PostgreSQL error into a user-friendly message.
-*
-* @param pgError  - The extracted PostgreSQL error (from {@link extractPgError})
-* @param context  - A human-readable context string (e.g. collection slug or path)
-* @returns An object with a `message` safe for the client and the PG `code`.
-*/
-function pgErrorToFriendlyMessage(pgError, context, options = {}) {
-	const verbose = options.verbose ?? process.env.NODE_ENV !== "production";
-	const detail = verbose ? pgError.detail : void 0;
-	const hint = verbose ? pgError.hint : void 0;
-	const constraint = pgError.constraint;
-	const column = pgError.column;
-	const table = pgError.table;
-	const dataType = verbose ? pgError.dataType : void 0;
-	const rawMessage = pgError.message || "Unknown database error";
-	const pgMessage = verbose ? rawMessage : "";
-	const code = pgError.code || "UNKNOWN";
-	const suffix = hint ? ` Hint: ${hint}` : "";
-	const tableRef = table ?? context;
-	/** `": <postgres said>"`, or nothing when the details are withheld. */
-	const said = pgMessage ? `: ${pgMessage}` : "";
-	switch (pgError.code) {
-		case "23503": return {
-			message: detail ? `Foreign key constraint violated: ${detail}${suffix}` : `Cannot complete operation: a foreign key constraint${constraint ? ` (${constraint})` : ""} was violated in "${context}".${suffix}`,
-			code
-		};
-		case "23505": return {
-			message: detail ? `Duplicate value: ${detail}${suffix}` : `Cannot complete operation: a unique constraint${constraint ? ` (${constraint})` : ""} was violated in "${context}".${suffix}`,
-			code
-		};
-		case "23502": return {
-			message: `Missing required field: "${column ?? "unknown"}" in "${tableRef}" cannot be empty.${suffix}`,
-			code
-		};
-		case "23514": return {
-			message: `Validation failed: a check constraint${constraint ? ` (${constraint})` : ""} was violated in "${context}".${suffix}`,
-			code
-		};
-		case "22P02": return {
-			message: `Invalid data format in "${context}"${said}.${suffix}`,
-			code
-		};
-		case "22001": return {
-			message: `Value too long for column "${column ?? "unknown"}" in "${tableRef}"${said}.${suffix}`,
-			code
-		};
-		case "22003": return {
-			message: `Numeric value out of range for column "${column ?? "unknown"}" in "${tableRef}"${said}.${suffix}`,
-			code
-		};
-		case "42703": return {
-			message: `Unknown column in "${tableRef}"${said}. Check if your schema is up to date (run migrations).${suffix}`,
-			code
-		};
-		case "42P01": return {
-			message: `Table not found for "${context}"${said}. Check if your schema is up to date (run migrations).${suffix}`,
-			code
-		};
-		case "42501": return rawMessage.toLowerCase().includes("row-level security policy") ? {
-			message: `Not permitted to write this row in "${tableRef}": it does not satisfy the row-level security policy.${suffix}`,
-			code
-		} : {
-			message: `Permission denied on "${tableRef}": the database role this server connects as lacks privileges on it.${suffix}`,
-			code
-		};
-		case "28000": return {
-			message: `Authorization failed for "${context}". Check your database credentials.${suffix}`,
-			code
-		};
-		default: {
-			const parts = [`Database error in "${context}" [${code}]${said}`];
-			if (detail) parts.push(`Detail: ${detail}`);
-			if (column) parts.push(`Column: ${column}`);
-			if (dataType) parts.push(`Data type: ${dataType}`);
-			if (constraint) parts.push(`Constraint: ${constraint}`);
-			if (hint) parts.push(`Hint: ${hint}`);
-			return {
-				message: parts.join(". "),
-				code
-			};
-		}
-	}
-}
-/**
-* Sanitize any error into a message safe and helpful for the client.
-*
-* A deliberate 4xx (`ApiError`) passes through untouched — the server already
-* decided what the client should read. Otherwise the PG error is extracted
-* from the Drizzle cause chain, falling back to a generic message that
-* doesn't leak SQL.
-*
-* @param error   - The raw caught error
-* @param context - A human-readable context string (e.g. collection path)
-* @returns An object with `message` (user-friendly) and optional `code`
-*          (the `ApiError` code, or the PG SQLSTATE).
-*/
-function sanitizeErrorForClient(error, context) {
-	const clientError = asClientFacingError(error);
-	if (clientError) {
-		const line = `[API ${clientError.statusCode} ${clientError.code ?? "BAD_REQUEST"}] in "${context}": ${clientError.message}`;
-		if (clientError.expected) logger.debug(line);
-		else logger.warn(`⚠️ ${line}`);
-		return {
-			message: clientError.message,
-			...clientError.code && { code: clientError.code }
-		};
-	}
-	const pgError = extractPgError(error);
-	if (pgError) {
-		logger.error(`[PG ${pgError.code}] Error in "${context}"`, {
-			code: pgError.code,
-			message: pgError.message,
-			detail: pgError.detail,
-			hint: pgError.hint,
-			column: pgError.column,
-			table: pgError.table,
-			constraint: pgError.constraint,
-			dataType: pgError.dataType
-		});
-		return pgErrorToFriendlyMessage(pgError, context);
-	}
-	logger.error(`Database error in "${context}" (no PG error extracted)`, {
-		error: error instanceof Error ? error.message : String(error),
-		stack: error instanceof Error ? error.stack : void 0,
-		cause: error instanceof Error && error.cause ? error.cause instanceof Error ? error.cause.message : String(error.cause) : void 0
-	});
-	const causeMessage = extractCauseMessage(error);
-	if (causeMessage) return { message: `Database error in "${context}": ${causeMessage}` };
-	return { message: `Could not load data for "${context}". Check server logs for details.` };
-}
-//#endregion
-//#region src/schema/auth-users-columns.ts
-/**
-* `email` is NOT NULL on purpose, and the anonymous sign-in route depends on it
-* — it synthesizes `anon_<32 hex>@anonymous.local` rather than inserting NULL.
-* The 320-char bound (RFC 5321) is a CHECK rather than a `VARCHAR(n)`, added
-* separately by `ensureAuthTablesExist` so it can be `NOT VALID` on an adopted
-* table that already holds a longer row.
-*/
-var AUTH_USERS_COLUMNS = [
-	{
-		column: "email",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		column: "display_name",
-		type: "TEXT"
-	},
-	{
-		column: "photo_url",
-		type: "TEXT"
-	},
-	{
-		column: "roles",
-		type: "TEXT[]",
-		default: "'{}'",
-		notNull: true
-	},
-	{
-		column: "password_hash",
-		type: "TEXT"
-	},
-	{
-		column: "email_verified",
-		type: "BOOLEAN",
-		default: "FALSE",
-		notNull: true
-	},
-	{
-		column: "email_verification_token",
-		type: "TEXT"
-	},
-	{
-		column: "email_verification_sent_at",
-		type: "TIMESTAMP WITH TIME ZONE"
-	},
-	{
-		column: "is_anonymous",
-		type: "BOOLEAN",
-		default: "FALSE",
-		notNull: true
-	},
-	{
-		column: "metadata",
-		type: "JSONB",
-		default: "'{}'",
-		notNull: true
-	},
-	{
-		column: "tokens_valid_after",
-		type: "TIMESTAMP WITH TIME ZONE"
-	},
-	{
-		column: "created_at",
-		type: "TIMESTAMP WITH TIME ZONE",
-		default: "NOW()",
-		notNull: true
-	},
-	{
-		column: "updated_at",
-		type: "TIMESTAMP WITH TIME ZONE",
-		default: "NOW()",
-		notNull: true
-	}
-];
-var BY_COLUMN = new Map(AUTH_USERS_COLUMNS.map((c) => [c.column, c]));
-/** Type + inline constraints, as they appear after the column name. */
-function authUsersColumnSql(spec) {
-	return [
-		spec.type,
-		spec.default !== void 0 ? `DEFAULT ${spec.default}` : "",
-		spec.notNull ? "NOT NULL" : ""
-	].filter(Boolean).join(" ");
-}
-/**
-* The auth-owned definition for a physical column name, or `undefined` when
-* auth does not own it.
-*
-* Callers pass the RESOLVED column name (after `columnName` mapping), because
-* that is the only name the three creators agree on: the scaffold's users
-* collection spells the property `displayName` and the column `display_name`.
-*/
-function authUsersColumnDefinition(column) {
-	const spec = BY_COLUMN.get(column);
-	return spec ? authUsersColumnSql(spec) : void 0;
-}
-/**
-* Whether a collection is an auth collection, i.e. whether the definitions in
-* this module apply to its table at all.
-*
-* Duplicated in shape from `@rebasepro/common`'s policy defaults on purpose:
-* that one takes a `CollectionConfig`, this one is called from DDL code paths
-* that hold looser objects, and both spellings must accept `auth: true` as well
-* as `auth: { enabled: true }`.
-*/
-function isAuthCollection(collection) {
-	const auth = collection?.auth;
-	if (auth === true) return true;
-	return typeof auth === "object" && auth !== null && auth.enabled === true;
-}
-//#endregion
-//#region src/schema/vector-index.ts
-/**
-* The widest `vector` pgvector will build an HNSW or IVFFlat index over.
-* Storage and exact search are unaffected by this limit.
-*/
-var MAX_INDEXABLE_VECTOR_DIMENSIONS = 2e3;
-/**
-* Operator class per distance. These strings are part of the database contract:
-* they appear in `CREATE INDEX`, so renaming one renames an index.
-*/
-var OPERATOR_CLASS = {
-	cosine: "vector_cosine_ops",
-	l2: "vector_l2_ops",
-	inner_product: "vector_ip_ops"
-};
-/** Short, stable tag per distance, used to name the index. */
-var DISTANCE_TAG = {
-	cosine: "cosine",
-	l2: "l2",
-	inner_product: "ip"
-};
-var VectorIndexConfigError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "VectorIndexConfigError";
-	}
-};
-var isVectorProperty = (prop) => !!prop && typeof prop === "object" && prop.type === "vector";
-var asDistances = (config, label) => {
-	const raw = config.distance ?? "cosine";
-	const list = Array.isArray(raw) ? raw : [raw];
-	if (list.length === 0) throw new VectorIndexConfigError(`${label}: \`index.distance\` is an empty array. Name at least one distance, or set \`index: false\` to create no index.`);
-	const seen = /* @__PURE__ */ new Set();
-	for (const distance of list) {
-		if (!(distance in OPERATOR_CLASS)) throw new VectorIndexConfigError(`${label}: \`index.distance\` is "${distance}", which is not a pgvector distance. Use ${Object.keys(OPERATOR_CLASS).map((d) => `"${d}"`).join(", ")}.`);
-		if (seen.has(distance)) throw new VectorIndexConfigError(`${label}: \`index.distance\` lists "${distance}" twice.`);
-		seen.add(distance);
-	}
-	return list;
-};
-var assertPositiveInteger = (value, key, label) => {
-	if (value === void 0) return;
-	if (!Number.isInteger(value) || value <= 0) throw new VectorIndexConfigError(`${label}: \`index.${key}\` is ${JSON.stringify(value)}. It must be a positive integer.`);
-};
-/**
-* Index parameters for one method. Parameters belonging to the *other* method
-* are rejected rather than ignored, because a silently dropped `lists` on an
-* HNSW index reads, from the config, exactly like a tuned index.
-*/
-var parametersFor = (method, config, label) => {
-	assertPositiveInteger(config.m, "m", label);
-	assertPositiveInteger(config.efConstruction, "efConstruction", label);
-	assertPositiveInteger(config.lists, "lists", label);
-	if (method === "hnsw") {
-		if (config.lists !== void 0) throw new VectorIndexConfigError(`${label}: \`index.lists\` only applies to \`method: "ivfflat"\`. Remove it, or switch the method.`);
-		const params = [];
-		if (config.m !== void 0) params.push(["m", config.m]);
-		if (config.efConstruction !== void 0) params.push(["ef_construction", config.efConstruction]);
-		return params;
-	}
-	for (const key of ["m", "efConstruction"]) if (config[key] !== void 0) throw new VectorIndexConfigError(`${label}: \`index.${key}\` only applies to \`method: "hnsw"\`. Remove it, or switch the method.`);
-	return config.lists !== void 0 ? [["lists", config.lists]] : [];
-};
-/**
-* Every ANN index a collection's vector properties call for.
-*
-* `resolveColumn` is passed in rather than imported so that this module stays
-* free of the DDL generator, which imports *it*. Both callers hand it the same
-* `resolveColumnName`, and a contract test asserts the names agree.
-*/
-var buildVectorIndexPlan = (collection, resolveColumn) => {
-	const specs = [];
-	const skipped = [];
-	const properties = collection.properties ?? {};
-	const table = getTableName(collection);
-	const schema = isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public";
-	for (const [propName, prop] of Object.entries(properties)) {
-		if (!isVectorProperty(prop)) continue;
-		if (prop.index === false) continue;
-		const label = `${collection.slug}.${propName}`;
-		const column = resolveColumn(propName, prop);
-		const config = prop.index ?? {};
-		const method = config.method ?? "hnsw";
-		if (method !== "hnsw" && method !== "ivfflat") throw new VectorIndexConfigError(`${label}: \`index.method\` is "${method}". Use "hnsw" or "ivfflat".`);
-		const distances = asDistances(config, label);
-		const parameters = parametersFor(method, config, label);
-		if (!Number.isInteger(prop.dimensions) || prop.dimensions <= 0) throw new VectorIndexConfigError(`${label}: \`dimensions\` is ${JSON.stringify(prop.dimensions)}. It must be a positive integer.`);
-		if (prop.dimensions > 2e3) {
-			skipped.push({
-				schema,
-				table,
-				column,
-				dimensions: prop.dimensions,
-				reason: `pgvector cannot index a vector wider than ${MAX_INDEXABLE_VECTOR_DIMENSIONS} dimensions, and ${label} declares ${prop.dimensions}. The column works and \`vectorSearch\` still answers, as an exact scan. To index it, reduce the dimensions (many embedding models support a shorter output) or set \`index: false\` to state that the scan is intended.`
-			});
-			continue;
-		}
-		for (const distance of distances) specs.push({
-			schema,
-			table,
-			column,
-			indexName: toPostgresIdentifier(`${table}_${column}_${method}_${DISTANCE_TAG[distance]}`),
-			method,
-			distance,
-			operatorClass: OPERATOR_CLASS[distance],
-			parameters
-		});
-	}
-	return {
-		specs,
-		skipped
-	};
-};
-/**
-* The `CREATE INDEX` for one spec.
-*
-* `CONCURRENTLY` is deliberately absent, for the same reason it is absent from
-* `searchIndexStatements`: this form is replayed as part of a migration, where
-* a concurrent build is not allowed. The boot-time ensure rewrites it — see
-* `ensureCollectionTables`.
-*/
-var vectorIndexStatement = (spec) => {
-	const params = spec.parameters.length ? ` WITH (${spec.parameters.map(([key, value]) => `${key} = ${value}`).join(", ")})` : "";
-	return `CREATE INDEX IF NOT EXISTS "${spec.indexName}" ON "${spec.schema}"."${spec.table}" USING ${spec.method} ("${spec.column}" ${spec.operatorClass})${params};`;
-};
-/** Every statement for a plan, in a stable order. */
-var vectorIndexStatements = (plan) => plan.specs.map(vectorIndexStatement);
-var quote = (v) => `'${v.replace(/'/g, "''")}'`;
-/**
-* The schema pgvector's types are installed into.
-*
-* `WITH SCHEMA public` for the same load-bearing reason `searchExtensionStatements`
-* gives: an unqualified `CREATE EXTENSION` lands in the first schema on
-* `search_path`, which is `"$user", public` — and the scaffold's role is named
-* `rebase`, the same as a schema the generator creates. Left to itself the
-* extension would install into `rebase`, and every unqualified `VECTOR(n)`
-* below would fail to resolve.
-*/
-var VECTOR_EXTENSION_SCHEMA = "public";
-/** The extension name a database has to name to let Rebase install pgvector. */
-var VECTOR_EXTENSION = "vector";
-/**
-* How a project says Rebase may install pgvector, quoted into the messages that
-* have to name it. Spelled once so the option and the advice cannot drift.
-*/
-var VECTOR_EXTENSION_OPT_IN = `database({ extensions: ["${VECTOR_EXTENSION}"] })`;
-/** Did the project give Rebase leave to install pgvector? */
-var vectorExtensionDeclared = (extensions) => (extensions ?? []).includes(VECTOR_EXTENSION);
-/**
-* Install pgvector — emitted only when the database asked for it.
-*
-* Opt-in because installing an extension is a decision with a deployment behind
-* it: the image has to ship the library, the role has to be allowed to install
-* it, and a managed provider has to have it on an allow-list. None of that is
-* visible from inside the connection, so Rebase does not decide it. See
-* `DatabaseOptions.extensions`.
-*
-* Withholding the statement is not withholding the *column*: the column is
-* still created, and Postgres refuses it with `type "vector" does not exist`
-* on a database where pgvector was never installed by hand. That error is the
-* one this design accepts, and `vectorExtensionHint` is what makes it name
-* {@link VECTOR_EXTENSION_OPT_IN} rather than nothing.
-*/
-var vectorExtensionStatement = () => `CREATE EXTENSION IF NOT EXISTS ${VECTOR_EXTENSION} WITH SCHEMA ${VECTOR_EXTENSION_SCHEMA};`;
-/**
-* The missing-pgvector explanation, appended to whichever error revealed it.
-*
-* Two readers, needing opposite things, which is why the branch is on the error
-* text rather than on the configuration:
-*
-*  - **`type "vector" does not exist`** — nobody opted in and the database has
-*    no pgvector. The fix is one line of config they cannot guess, so naming
-*    the option *is* the hint.
-*  - **the install itself failed** — the config is already right, and repeating
-*    the option would send them to edit a correct line. What is missing is the
-*    library on the server, or the grant.
-*
-* Lives here rather than beside either caller because both need it: the boot
-* ensure raises the first through its action applier, and `rebase db push`
-* raises it out of `applyVectorDdl`. A hint on only one path is how a bare
-* `type "vector" does not exist` reaches somebody — which is the thing this
-* exists to prevent.
-*/
-var vectorExtensionHint = (message) => {
-	if (/extension "vector" is not available/i.test(message) || /(permission denied to create extension|must be (superuser|owner).{0,40}extension)/i.test(message)) return "\n  pgvector was declared and could not be installed. It is a server extension, so it needs an image that ships the library (the scaffold's `pgvector/pgvector:pg18` does; a stock `postgres:18` does not) and a role allowed to run `CREATE EXTENSION vector;`. Managed Postgres usually allows it once the extension is on the provider's allow-list.";
-	if (!/type "(vector|halfvec|sparsevec)" does not exist/i.test(message)) return "";
-	return `
-  pgvector is not installed on this database, and Rebase installs it only where a database says it may: add \`${VECTOR_EXTENSION_OPT_IN}\` in config/resources.ts, or install it once by hand with \`CREATE EXTENSION vector;\`. Either way the server needs an image that ships the library — the scaffold's \`pgvector/pgvector:pg18\` does, a stock \`postgres:18\` does not. Rebase then creates the column and its ANN index automatically — see the \`index\` option on the property.`;
-};
-/**
-* Every vector column a collection declares.
-*
-* Wider than {@link buildVectorIndexPlan} on purpose: that one answers "what
-* gets an ANN index", and skips both a property with `index: false` and one too
-* wide to index. Either still needs its column.
-*/
-var buildVectorColumnSpecs = (collection, resolveColumn) => {
-	const table = getTableName(collection);
-	const schema = isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public";
-	const specs = [];
-	for (const [propName, prop] of Object.entries(collection.properties ?? {})) {
-		if (!isVectorProperty(prop)) continue;
-		const validation = prop.validation;
-		let modifiers = "";
-		if (validation?.unique) modifiers += " UNIQUE";
-		if (validation?.required) modifiers += " NOT NULL";
-		specs.push({
-			schema,
-			table,
-			column: resolveColumn(propName, prop),
-			dimensions: prop.dimensions,
-			modifiers
-		});
-	}
-	return specs;
-};
-/** The column type — the one place `VECTOR(n)` is spelled. */
-var vectorColumnType = (spec) => `VECTOR(${spec.dimensions})`;
-/** The column definition as it appears inside `CREATE TABLE`. */
-var vectorColumnDefinition = (spec) => `"${spec.column}" ${vectorColumnType(spec)}${spec.modifiers}`;
-/**
-* Refuse — or perform — a `dimensions` change that `ADD COLUMN IF NOT EXISTS`
-* would otherwise swallow.
-*
-* Without this the file *launders* the change: the ADD is a no-op against a
-* column that exists, so a project that went from 384 to 768 dimensions would
-* push clean, keep a 384-wide column, and fail on the next insert with a
-* message about the row rather than about the config. Atlas used to catch this
-* — it owned the column and planned the `ALTER … TYPE` — and taking the column
-* out of its sight is exactly what makes the guard necessary.
-*
-* The widening is performed when the column holds no values, because that is
-* the case Atlas handled and it is the common one: a developer changing
-* embedding models before there are any embeddings. With values present the
-* conversion is pgvector's to reject — every stored vector is the old width —
-* so this refuses first and names the statement to run afterwards.
-*
-* `atttypmod` on a `vector` column *is* the dimension count: pgvector stores it
-* directly rather than offsetting it the way `varchar` does. `-1` means the
-* column was declared as a bare `vector`, which is drift in the same sense.
-*/
-var vectorDimensionGuard = (spec) => {
-	const relation = `"${spec.schema}"."${spec.table}"`;
-	return `DO $rebase_vector$
-DECLARE actual int;
-BEGIN
-    SELECT a.atttypmod INTO actual
-    FROM pg_attribute a
-    JOIN pg_type t ON t.oid = a.atttypid
-    WHERE a.attrelid = ${quote(relation)}::regclass
-      AND a.attname = ${quote(spec.column)}
-      AND NOT a.attisdropped
-      AND t.typname = 'vector';
-    IF actual IS NOT NULL AND actual <> ${spec.dimensions} THEN
-        IF EXISTS (SELECT 1 FROM ${relation} WHERE "${spec.column}" IS NOT NULL) THEN
-            RAISE EXCEPTION 'Rebase: ${spec.schema}.${spec.table}."${spec.column}" declares ${spec.dimensions} dimensions but the column is vector(%), and it already holds values of the old width. pgvector cannot convert them. Re-embed the rows at ${spec.dimensions} dimensions (or clear the column), then re-apply: ALTER TABLE ${relation} ALTER COLUMN "${spec.column}" TYPE ${vectorColumnType(spec)};', actual;
-        END IF;
-        ALTER TABLE ${relation} ALTER COLUMN "${spec.column}" TYPE ${vectorColumnType(spec)};
-    END IF;
-END
-$rebase_vector$;`;
-};
-//#endregion
-//#region src/schema/generate-postgres-ddl-logic.ts
-var resolveColumnName = (propName, prop) => {
-	if (prop && "columnName" in prop && typeof prop.columnName === "string") return prop.columnName;
-	return toSnakeCase(propName);
-};
-var getPrimaryKeyProp = (collection) => {
-	if (collection.properties) {
-		const idPropEntry = Object.entries(collection.properties).find(([_, prop]) => "isId" in prop && Boolean(prop.isId));
-		if (idPropEntry) {
-			const prop = idPropEntry[1];
-			const isUuid = prop.type === "string" && "isId" in prop && prop.isId === "uuid";
-			return {
-				name: idPropEntry[0],
-				type: prop.type === "number" ? "number" : "string",
-				isUuid
-			};
-		}
-	}
-	const idProp = collection.properties?.["id"];
-	if (idProp?.type === "number") return {
-		name: "id",
-		type: "number",
-		isUuid: false
-	};
-	return {
-		name: "id",
-		type: "string",
-		isUuid: idProp?.type === "string" && "isId" in idProp && idProp.isId === "uuid"
-	};
-};
-var isNumericId = (collection) => {
-	return getPrimaryKeyProp(collection).type === "number";
-};
-var getPrimaryKeyName = (collection) => {
-	return getPrimaryKeyProp(collection).name;
-};
-/** The column type a junction holds for one endpoint's primary key. */
-var junctionKeyType = (collection) => isNumericId(collection) ? "INTEGER" : getPrimaryKeyProp(collection).isUuid ? "UUID" : "TEXT";
-var isIdProperty = (propName, prop, collection) => {
-	if ("isId" in prop && Boolean(prop.isId)) return true;
-	return !Object.values(collection.properties ?? {}).some((p) => "isId" in p && Boolean(p.isId)) && propName === "id";
-};
-/**
-* Render statements produced by {@link generatePolicyStatements} back into the
-* exact string the DDL/policies files have always carried: each statement on
-* its own line, terminated by a newline. Keeping the string form derived from
-* the statement array means the two can never drift — the boot-time applier and
-* the generated `policies.sql` emit the same SQL, from the same source.
-*/
-var statementsToDdl = (statements) => statements.map((s) => `${s}\n`).join("");
-/**
-* The `ON DELETE` a foreign key gets when the author did not say.
-*
-* One rule for every property that emits one — `belongsTo` relations and
-* `reference` properties alike. `reference` kept its own `CASCADE` default for
-* a release after this rule was written, which is exactly the split this
-* function exists to prevent: two spellings of the same link, two data-retention
-* behaviours, and only one of them documented.
-*
-* An optional link is `SET NULL`: the column can hold NULL, so dropping the
-* parent leaves the child row with an empty pointer, which is what "optional"
-* already means.
-*
-* A required link is **`RESTRICT`**, not `CASCADE`. `NOT NULL` says the child
-* cannot exist without a parent; it does not say deleting the parent should
-* take the child with it. That second claim is a data-retention decision, and
-* defaulting to it meant `onDelete` — a field nobody has to write — silently
-* turned every `DELETE FROM authors` into a cascade through posts, comments and
-* anything else that hung off them. `RESTRICT` fails the delete instead and
-* names the constraint, so the author chooses `cascade` on purpose or clears
-* the children first.
-*
-* Both DDL paths — the `CREATE TABLE` generator and {@link planRelationalColumns},
-* which boot-ensure compares the live database against — call this, so a
-* default that appears in one and not the other cannot make `db push` plan a
-* constraint rewrite on every run.
-*/
-var defaultBelongsToOnDelete = (required) => required ? "RESTRICT" : "SET NULL";
-var generatePolicyDdl = (collection, rule, resolveCollection) => statementsToDdl(generatePolicyStatements(collection, rule, resolveCollection));
-/**
-* The individual SQL statements a single security rule compiles to: a
-* `DROP POLICY IF EXISTS` / `CREATE POLICY` pair per operation, each a complete
-* statement (terminated by `;`, no trailing newline).
-*
-* This is the primitive the boot-time RLS applier runs one statement at a time
-* (the runtime's DB handle speaks the extended query protocol, which forbids
-* multiple commands in one execute), while `db push` writes the joined string.
-*/
-var generatePolicyStatements = (collection, rule, resolveCollection) => {
-	const tableName = getTableName(collection);
-	const ops = rule.operations && rule.operations.length > 0 ? rule.operations : [rule.operation ?? "all"];
-	const policyNames = getPolicyNamesForRule(rule, tableName);
-	return ops.flatMap((op, opIdx) => {
-		return generateSinglePolicyStatements(collection, rule, op, policyNames[opIdx], resolveCollection);
-	});
-};
-var generateSinglePolicyStatements = (collection, rule, operation, policyName, resolveCollection) => {
-	const schema = isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public";
-	const tableName = getTableName(collection);
-	const mode = (rule.mode ?? "permissive").toUpperCase();
-	const operationUpper = operation.toUpperCase();
-	const pgRoles = rule.pgRoles ? [...rule.pgRoles].sort() : ["public"];
-	const needsUsing = operation !== "insert";
-	const needsWithCheck = operation !== "select" && operation !== "delete";
-	const { usingExpr, withCheckExpr } = securityRuleToConditions(rule);
-	let usingClause = needsUsing && usingExpr ? policyToPostgres(usingExpr, collection, { resolveCollection }) : null;
-	let withCheckClause = needsWithCheck && withCheckExpr ? policyToPostgres(withCheckExpr, collection, { resolveCollection }) : null;
-	if (!usingClause && needsUsing) usingClause = "false";
-	if (!withCheckClause && needsWithCheck) withCheckClause = "false";
-	const drop = `DROP POLICY IF EXISTS "${policyName}" ON "${schema}"."${tableName}";`;
-	let create = `CREATE POLICY "${policyName}" ON "${schema}"."${tableName}" AS ${mode} FOR ${operationUpper} TO ${pgRoles.map((r) => `"${r}"`).join(", ")}`;
-	if (usingClause) create += ` USING (${usingClause})`;
-	if (withCheckClause) create += ` WITH CHECK (${withCheckClause})`;
-	create += ";";
-	return [drop, create];
-};
-/**
-* Single-quote escaping for a SQL string literal (PostgreSQL doubles the
-* quote). Enum labels come straight from user-authored collection config, so a
-* label like `it's` closes the literal early and the whole generated file stops
-* parsing at the `CREATE TYPE`. Lives here rather than next to its other caller
-* because ensure-collection-tables already imports from this module — the
-* reverse would be a cycle.
-*/
-var quoteSqlLiteral = (value) => `'${value.replace(/'/g, "''")}'`;
-var getSqlColumnType = (propName, prop, collection, collections) => {
-	switch (prop.type) {
-		case "string": {
-			const stringProp = prop;
-			if (stringProp.enum) {
-				const tableName = getTableName(collection);
-				const colName = resolveColumnName(propName, prop);
-				return `"${isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public"}"."${tableName}_${colName}"`;
-			}
-			if (stringProp.isId === "uuid" || stringProp.columnType === "uuid") return "UUID";
-			if (stringProp.columnType === "char") return `CHAR(${resolveStringColumnLength(stringProp)})`;
-			if (stringProp.columnType === "varchar") return `VARCHAR(${resolveStringColumnLength(stringProp)})`;
-			return "TEXT";
-		}
-		case "number": {
-			const numProp = prop;
-			const isId = isIdProperty(propName, prop, collection);
-			if ("isId" in numProp && numProp.isId === "increment") return "INTEGER GENERATED BY DEFAULT AS IDENTITY";
-			if (numProp.columnType) {
-				if (numProp.columnType === "double precision") return "DOUBLE PRECISION";
-				return numProp.columnType.toUpperCase();
-			}
-			return numProp.validation?.integer || isId ? "INTEGER" : "NUMERIC";
-		}
-		case "boolean": return "BOOLEAN";
-		case "date": {
-			const dateProp = prop;
-			if (dateProp.columnType === "date") return "DATE";
-			if (dateProp.columnType === "time") return "TIME";
-			return "TIMESTAMP WITH TIME ZONE";
-		}
-		case "map": return prop.columnType === "json" ? "JSON" : "JSONB";
-		case "geopoint": return "JSONB";
-		case "array": {
-			const arrayProp = prop;
-			let colType = arrayProp.columnType;
-			if (!colType && arrayProp.of && !Array.isArray(arrayProp.of)) {
-				const ofProp = arrayProp.of;
-				if (ofProp.type === "string") colType = "text[]";
-				else if (ofProp.type === "number") colType = ofProp.validation?.integer ? "integer[]" : "numeric[]";
-				else if (ofProp.type === "boolean") colType = "boolean[]";
-			}
-			if (colType === "json") return "JSON";
-			if (colType === "text[]") return "TEXT[]";
-			if (colType === "integer[]") return "INTEGER[]";
-			if (colType === "boolean[]") return "BOOLEAN[]";
-			if (colType === "numeric[]") return "NUMERIC[]";
-			return "JSONB";
-		}
-		case "vector": return `VECTOR(${prop.dimensions})`;
-		case "binary": return "BYTEA";
-		case "relation": {
-			const refProp = prop;
-			const relation = findRelation(resolveCollectionRelations(collection), refProp.relation?.relationName ?? propName);
-			if (relation?.kind !== "belongsTo") throw new Error(`Relation ${propName} does not put a column on this table (only \`belongsTo\` does)`);
-			let targetCollection;
-			try {
-				targetCollection = relation.target();
-			} catch {
-				return "TEXT";
-			}
-			const pkProp = getPrimaryKeyProp(targetCollection);
-			return pkProp.type === "number" ? "INTEGER" : pkProp.isUuid ? "UUID" : "TEXT";
-		}
-		case "reference": {
-			const refProp = prop;
-			const targetCollection = collections.find((c) => c.slug === refProp.path || getTableName(c) === refProp.path);
-			if (!targetCollection) return "TEXT";
-			const pkProp = getPrimaryKeyProp(targetCollection);
-			return pkProp.type === "number" ? "INTEGER" : pkProp.isUuid ? "UUID" : "TEXT";
-		}
-		default: throw new Error(`No Postgres column type for property '${propName}' of type '${prop.type}' in collection '${collection.slug}'. Add a case to \`getSqlColumnType\` (and to \`getDrizzleColumn\`, which must agree).`);
-	}
-};
-/**
-* Everything a `search` block needs, as a file Rebase applies itself.
-*
-* Search is the one part of the schema Atlas does not own. Two independent
-* reasons, and either alone would be enough:
-*
-* 1. Its free tier refuses to *parse* a desired-state file that so much as
-*    contains a function — "functions and procedures are available to
-*    logged-in users only". A generated `tsvector` column cannot avoid one:
-*    `unaccent` is STABLE and jsonb flattening needs a set-returning function,
-*    so both have to be wrapped in an IMMUTABLE helper to be legal in a
-*    generated column at all.
-* 2. Even with the file accepted, Atlas *wipes* the dev database it diffs
-*    against, so a helper seeded there beforehand is gone by the time the plan
-*    is analysed. There is no hook to reinstate it.
-*
-* So the column, its index and its helpers are excluded from Atlas's view
-* (`searchExcludePatterns`) and applied from here — the same arrangement the
-* RLS policies already use, and for the same underlying reason.
-*
-* Ordered as it must run: extensions, then helpers, then the column whose
-* expression calls them, then the index over that column. Every statement is
-* `IF NOT EXISTS` / `OR REPLACE`, because this is replayed on every push and
-* appended to migrations that run against databases at any stage of their
-* life. Empty when nothing opted in — the caller writes no file then.
-*
-* The dev database Atlas plans against needs none of this. `searchExcludePatterns`
-* removes the search column from the *inspected* state, so the state Atlas
-* replays there never mentions the column and never calls a helper. Seeding the
-* helpers into that database was tried and removed: measured on Atlas 1.2.3, a
-* `schema apply --dry-run` produces byte-identical output seeded or not, and
-* Atlas wipes the dev database before it plans anyway — so a seed could not have
-* helped even where the excludes are missing, which is the case that really does
-* fail with `function public.rebase_search_unaccent(text) does not exist`.
-*/
-var generatePostgresSearchDdl = (allCollections) => {
-	const collections = relationalCollections(allCollections);
-	const specs = collections.map((c) => buildSearchColumnSpec(c)).filter((s) => s !== void 0);
-	if (specs.length === 0) return "";
-	const extensions = Array.from(new Set(specs.flatMap(searchExtensionStatements)));
-	const helpers = Array.from(new Set(specs.flatMap(searchHelperFunctions)));
-	let ddl = "-- This file is auto-generated by the Rebase DDL generator. Do not edit manually.\n";
-	ddl += "--\n";
-	ddl += "-- Full-text search for the collections declaring a `search` block.\n";
-	ddl += "-- Applied by Rebase, not by Atlas — see generatePostgresSearchDdl.\n\n";
-	extensions.forEach((s) => {
-		ddl += `${s}\n`;
-	});
-	if (extensions.length > 0) ddl += "\n";
-	helpers.forEach((s) => {
-		ddl += `${s}\n\n`;
-	});
-	for (const collection of collections) {
-		const spec = buildSearchColumnSpec(collection);
-		if (!spec) continue;
-		const table = `"${isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public"}"."${getTableName(collection)}"`;
-		searchStampGuards(spec).forEach((s) => {
-			ddl += `${s}\n`;
-		});
-		ddl += `ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS ${searchColumnDefinition(spec)};\n`;
-		const fuzzyDef = fuzzyColumnDefinition(spec);
-		if (fuzzyDef) ddl += `ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS ${fuzzyDef};\n`;
-		searchColumnStamps(spec).forEach((s) => {
-			ddl += `${s.sql}\n`;
-		});
-		searchIndexStatements(spec).forEach((s) => {
-			ddl += `${s}\n`;
-		});
-		ddl += "\n";
-	}
-	return ddl;
-};
-/**
-* Everything a `{ type: "vector" }` property needs, as a file Rebase applies
-* itself.
-*
-* Vector is the second part of the schema Atlas does not own, and it is out for
-* a narrower reason than search: not that Atlas refuses to parse the file, but
-* that it cannot *execute* it. To compute a desired state Atlas materialises
-* `schema.sql` in a dev database, that database is created empty, and Atlas
-* empties it again at the start of every run — so `VECTOR(384)` resolves
-* against a database that structurally cannot have pgvector, and every push
-* dies with `type "vector" does not exist`. Seeding the extension beforehand
-* does not survive the clean (measured: present before the run, gone after),
-* putting `CREATE EXTENSION` in `schema.sql` is refused as an Atlas Pro
-* feature, and `--exclude` alone cannot help because Atlas still parses and
-* applies the whole file.
-*
-* So the column, its ANN indexes and the extension are excluded from Atlas's
-* view ({@link vectorExcludePatterns}) and applied from here — the same
-* arrangement search and the RLS policies already use.
-*
-* `CREATE EXTENSION` appears only when the project's database named `vector` in
-* its `extensions` — see `DatabaseOptions.extensions`. Everything else is
-* emitted either way: a database that already has pgvector installed by hand
-* needs no permission from anyone, and one that does not gets the column
-* refused by Postgres with a message this repo makes name the opt-in.
-*
-* Ordered as it must run: the extension, then the drift guard, then the column
-* whose type needs the extension, then the indexes over that column. Every
-* statement is `IF NOT EXISTS`, because this is replayed on every push and
-* appended to migrations that run against databases at any stage of their life.
-* Empty when no collection declares a vector — the caller writes no file then.
-*/
-var generatePostgresVectorDdl = (allCollections, options = {}) => {
-	const withVectors = relationalCollections(allCollections).filter((c) => buildVectorColumnSpecs(c, resolveColumnName).length > 0);
-	if (withVectors.length === 0) return "";
-	let ddl = "-- This file is auto-generated by the Rebase DDL generator. Do not edit manually.\n";
-	ddl += "--\n";
-	ddl += "-- Vector columns and their ANN indexes, for the collections declaring a\n";
-	ddl += "-- `vector` property. Applied by Rebase, not by Atlas — see\n";
-	ddl += "-- generatePostgresVectorDdl.\n\n";
-	ddl += vectorExtensionDeclared(options.extensions) ? `${vectorExtensionStatement()}\n\n` : `-- pgvector is not installed from here: no database declared it. To let Rebase\n-- install it, add ${VECTOR_EXTENSION_OPT_IN} in config/resources.ts.\n-- Otherwise install it once by hand; the column below needs the type either way.\n\n`;
-	for (const collection of withVectors) {
-		const table = `"${isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public"}"."${getTableName(collection)}"`;
-		for (const spec of buildVectorColumnSpecs(collection, resolveColumnName)) {
-			ddl += `${vectorDimensionGuard(spec)}\n`;
-			ddl += `ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS ${vectorColumnDefinition(spec)};\n`;
-		}
-		const plan = buildVectorIndexPlan(collection, resolveColumnName);
-		vectorIndexStatements(plan).forEach((s) => {
-			ddl += `${s}\n`;
-		});
-		for (const skip of plan.skipped) ddl += `-- No ANN index on "${skip.schema}"."${skip.table}"."${skip.column}": ${skip.reason}\n`;
-		ddl += "\n";
-	}
-	return ddl;
-};
-var generatePostgresDdl = async (allCollections, options = {
-	includePolicies: true,
-	includeSearch: true,
-	includeVector: true
-}) => {
-	const collections = relationalCollections(allCollections);
-	let ddl = "-- This file is auto-generated by the Rebase DDL generator. Do not edit manually.\n\n";
-	const uniqueSchemas = Array.from(/* @__PURE__ */ new Set([REBASE_SCHEMA, ...collections.map((c) => isPostgresCollectionConfig(c) ? c.schema : void 0).filter(Boolean)]));
-	uniqueSchemas.forEach((schema) => {
-		if (schema) ddl += `CREATE SCHEMA IF NOT EXISTS "${schema}";\n`;
-	});
-	if (uniqueSchemas.length > 0) ddl += "\n";
-	const searchSpecs = collections.map((c) => buildSearchColumnSpec(c)).filter((s) => s !== void 0);
-	if (searchSpecs.length > 0) if (options.includeSearch === false) ddl += "-- Full-text search support lives in `search.sql`, applied separately.\n\n";
-	else {
-		const extensions = Array.from(new Set(searchSpecs.flatMap(searchExtensionStatements)));
-		const helpers = Array.from(new Set(searchSpecs.flatMap(searchHelperFunctions)));
-		ddl += "-- Full-text search support (collections declaring a `search` block)\n";
-		extensions.forEach((s) => {
-			ddl += `${s}\n`;
-		});
-		if (extensions.length > 0) ddl += "\n";
-		helpers.forEach((s) => {
-			ddl += `${s}\n\n`;
-		});
-	}
-	if (options.includeVector === false && collections.some((c) => buildVectorColumnSpecs(c, resolveColumnName).length > 0)) ddl += "-- Vector columns and their ANN indexes live in `vector.sql`, applied separately.\n\n";
-	const emittedEnums = /* @__PURE__ */ new Set();
-	collections.forEach((collection) => {
-		const collectionTable = getTableName(collection);
-		const schema = isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public";
-		Object.entries(collection.properties ?? {}).forEach(([propName, prop]) => {
-			if ("enum" in prop && (prop.type === "string" || prop.type === "number") && prop.enum) {
-				const enumDbName = `${collectionTable}_${resolveColumnName(propName, prop)}`;
-				const values = Array.isArray(prop.enum) ? prop.enum.map((v) => String(typeof v === "object" && v !== null && "id" in v ? v.id : v)) : Object.keys(prop.enum);
-				if (values.length > 0 && !emittedEnums.has(`${schema}.${enumDbName}`)) {
-					emittedEnums.add(`${schema}.${enumDbName}`);
-					ddl += `CREATE TYPE "${schema}"."${enumDbName}" AS ENUM (${values.map(quoteSqlLiteral).join(", ")});\n`;
-				}
-			}
-		});
-	});
-	if (ddl.endsWith(";\n")) ddl += "\n";
-	const junctionSpecs = resolveJunctionSpecs(collections);
-	const allTablesToGenerate = /* @__PURE__ */ new Map();
-	for (const collection of collections) {
-		const tableName = getTableName(collection);
-		if (tableName) allTablesToGenerate.set(tableName, { collection });
-		const resolvedRelations = resolveCollectionRelations(collection);
-		for (const relation of Object.values(resolvedRelations)) if (isManyToMany(relation)) {
-			const junctionTableName = relation.through.table;
-			if (!allTablesToGenerate.has(junctionTableName)) allTablesToGenerate.set(junctionTableName, {
-				collection: {
-					table: junctionTableName,
-					properties: {}
-				},
-				isJunction: true,
-				relation,
-				sourceCollection: collection
-			});
-		}
-	}
-	const fkStatements = [];
-	const indexStatements = [];
-	const policyStatements = [];
-	for (const [tableName, { collection, isJunction, relation, sourceCollection }] of allTablesToGenerate.entries()) {
-		const schema = isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public";
-		const baseTableName = tableName.includes(".") ? tableName.split(".").pop() : tableName;
-		if (isJunction && relation && sourceCollection && isManyToMany(relation)) {
-			const targetCollection = relation.target();
-			const sourceTable = getTableName(sourceCollection);
-			const targetTable = getTableName(targetCollection);
-			const sourceSchema = isPostgresCollectionConfig(sourceCollection) && sourceCollection.schema ? sourceCollection.schema : "public";
-			const targetSchema = isPostgresCollectionConfig(targetCollection) && targetCollection.schema ? targetCollection.schema : "public";
-			const { sourceColumn, targetColumn } = relation.through;
-			const sourceColType = isNumericId(sourceCollection) ? "INTEGER" : getPrimaryKeyProp(sourceCollection).isUuid ? "UUID" : "TEXT";
-			const targetColType = isNumericId(targetCollection) ? "INTEGER" : getPrimaryKeyProp(targetCollection).isUuid ? "UUID" : "TEXT";
-			const sourceId = getPrimaryKeyName(sourceCollection);
-			const targetId = getPrimaryKeyName(targetCollection);
-			const onDelete = relation.onDelete ?? "CASCADE";
-			ddl += `CREATE TABLE "${schema}"."${baseTableName}" (\n`;
-			ddl += `  "${sourceColumn}" ${sourceColType} NOT NULL,\n`;
-			ddl += `  "${targetColumn}" ${targetColType} NOT NULL,\n`;
-			ddl += `  PRIMARY KEY ("${sourceColumn}", "${targetColumn}")\n`;
-			ddl += `);\n\n`;
-			fkStatements.push(`ALTER TABLE "${schema}"."${baseTableName}" ADD CONSTRAINT "${toPostgresIdentifier(`${baseTableName}_${sourceColumn}_fkey`)}" FOREIGN KEY ("${sourceColumn}") REFERENCES "${sourceSchema}"."${sourceTable}" ("${sourceId}") ON DELETE ${onDelete.toUpperCase()};`);
-			fkStatements.push(`ALTER TABLE "${schema}"."${baseTableName}" ADD CONSTRAINT "${toPostgresIdentifier(`${baseTableName}_${targetColumn}_fkey`)}" FOREIGN KEY ("${targetColumn}") REFERENCES "${targetSchema}"."${targetTable}" ("${targetId}") ON DELETE ${onDelete.toUpperCase()};`);
-			if (options.includePolicies) {
-				ddl += `ALTER TABLE "${schema}"."${baseTableName}" ENABLE ROW LEVEL SECURITY;\n`;
-				ddl += `\n`;
-				const spec = junctionSpecs.get(baseTableName);
-				if (spec) {
-					const junctionCollection = getJunctionCollectionConfig(spec);
-					const resolveCollection = (slug) => collections.find((c) => c.slug === slug || getTableName(c) === slug);
-					getJunctionSecurityRules(spec).forEach((rule) => {
-						policyStatements.push(generatePolicyDdl(junctionCollection, rule, resolveCollection));
-					});
-				}
-			}
-		} else if (!isJunction) {
-			ddl += `CREATE TABLE "${schema}"."${baseTableName}" (\n`;
-			const columns = [];
-			Object.entries(collection.properties ?? {}).forEach(([propName, prop]) => {
-				if (prop.type === "vector" && options.includeVector === false) return;
-				if (prop.type === "relation") {
-					const refProp = prop;
-					const relInfo = findRelation(resolveCollectionRelations(collection), refProp.relation?.relationName ?? propName);
-					if (relInfo?.kind !== "belongsTo") return;
-					if (collection.properties[relInfo.localKey] && propName !== relInfo.localKey) return;
-					let targetCollection;
-					try {
-						targetCollection = relInfo.target();
-					} catch {
-						return;
-					}
-					const targetTable = getTableName(targetCollection);
-					const targetSchema = isPostgresCollectionConfig(targetCollection) && targetCollection.schema ? targetCollection.schema : "public";
-					const targetId = getPrimaryKeyName(targetCollection);
-					const fkColType = getSqlColumnType(propName, prop, collection, collections);
-					const onUpdate = relInfo.onUpdate ? ` ON UPDATE ${relInfo.onUpdate.toUpperCase()}` : "";
-					const required = prop.validation?.required;
-					const onDeleteVal = relInfo.onDelete ?? defaultBelongsToOnDelete(required);
-					let colDef = `  "${relInfo.localKey}" ${fkColType}`;
-					if (required) colDef += " NOT NULL";
-					columns.push(colDef);
-					fkStatements.push(`ALTER TABLE "${schema}"."${baseTableName}" ADD CONSTRAINT "${toPostgresIdentifier(`${baseTableName}_${relInfo.localKey}_fkey`)}" FOREIGN KEY ("${relInfo.localKey}") REFERENCES "${targetSchema}"."${targetTable}" ("${targetId}") ON DELETE ${onDeleteVal.toUpperCase()}${onUpdate};`);
-				} else if (prop.type === "reference") {
-					const refProp = prop;
-					const targetCollection = collections.find((c) => c.slug === refProp.path || getTableName(c) === refProp.path);
-					const colName = resolveColumnName(propName, prop);
-					const colType = getSqlColumnType(propName, prop, collection, collections);
-					const required = prop.validation?.required;
-					if (!targetCollection) {
-						let colDef = `  "${colName}" ${colType}`;
-						if (required) colDef += " NOT NULL";
-						columns.push(colDef);
-					} else {
-						const targetTable = getTableName(targetCollection);
-						const targetSchema = isPostgresCollectionConfig(targetCollection) && targetCollection.schema ? targetCollection.schema : "public";
-						const targetId = getPrimaryKeyName(targetCollection);
-						const onDelete = defaultBelongsToOnDelete(required);
-						let colDef = `  "${colName}" ${colType}`;
-						if (required) colDef += " NOT NULL";
-						columns.push(colDef);
-						fkStatements.push(`ALTER TABLE "${schema}"."${baseTableName}" ADD CONSTRAINT "${toPostgresIdentifier(`${baseTableName}_${colName}_fkey`)}" FOREIGN KEY ("${colName}") REFERENCES "${targetSchema}"."${targetTable}" ("${targetId}") ON DELETE ${onDelete.toUpperCase()};`);
-					}
-				} else {
-					const colName = resolveColumnName(propName, prop);
-					const authDefinition = isAuthCollection(collection) ? authUsersColumnDefinition(colName) : void 0;
-					if (authDefinition && !isIdProperty(propName, prop, collection)) {
-						columns.push(`  "${colName}" ${authDefinition}`);
-						return;
-					}
-					let colDef = `  "${colName}" ${getSqlColumnType(propName, prop, collection, collections)}`;
-					if (isIdProperty(propName, prop, collection)) colDef += " PRIMARY KEY";
-					if ("isId" in prop && prop.isId !== "manual" && prop.isId !== true && prop.isId !== "increment") {
-						if (prop.isId === "uuid") colDef += " DEFAULT gen_random_uuid()";
-						else if (prop.isId === "cuid") colDef += " DEFAULT cuid()";
-						else if (typeof prop.isId === "string") colDef += ` DEFAULT ${prop.isId}`;
-					}
-					if (!isIdProperty(propName, prop, collection) && prop.validation?.unique) colDef += " UNIQUE";
-					if (prop.type === "date") {
-						const dateProp = prop;
-						if (dateProp.autoValue === "on_create" || dateProp.autoValue === "on_update") colDef += " DEFAULT now()";
-					}
-					if (prop.validation?.required && !colDef.includes("PRIMARY KEY")) colDef += " NOT NULL";
-					columns.push(colDef);
-				}
-			});
-			if (isAuthCollection(collection)) {
-				const declared = new Set(Object.entries(collection.properties ?? {}).map(([name, prop]) => resolveColumnName(name, prop)));
-				for (const spec of AUTH_USERS_COLUMNS) {
-					if (declared.has(spec.column)) continue;
-					columns.push(`  "${spec.column}" ${authUsersColumnSql(spec)}`);
-				}
-			}
-			const searchSpec = options.includeSearch === false ? void 0 : buildSearchColumnSpec(collection);
-			if (searchSpec) {
-				columns.push(`  ${searchColumnDefinition(searchSpec)}`);
-				const fuzzyDef = fuzzyColumnDefinition(searchSpec);
-				if (fuzzyDef) columns.push(`  ${fuzzyDef}`);
-				indexStatements.push(...searchIndexStatements(searchSpec));
-			}
-			if (options.includeVector !== false) {
-				const vectorPlan = buildVectorIndexPlan(collection, resolveColumnName);
-				indexStatements.push(...vectorIndexStatements(vectorPlan));
-				for (const skip of vectorPlan.skipped) indexStatements.push(`-- No ANN index on "${skip.schema}"."${skip.table}"."${skip.column}": ${skip.reason}`);
-			}
-			indexStatements.push(...collectionIndexStatements(buildCollectionIndexSpecs(collection, resolveColumnName)));
-			if (!columns.some((c) => c.includes("PRIMARY KEY"))) columns.unshift("  \"id\" TEXT PRIMARY KEY");
-			ddl += columns.join(",\n");
-			ddl += `\n);\n\n`;
-			if (options.includePolicies) {
-				ddl += `ALTER TABLE "${schema}"."${baseTableName}" ENABLE ROW LEVEL SECURITY;\n`;
-				ddl += `\n`;
-				const securityRules = getEffectiveSecurityRules(collection);
-				if (securityRules.length > 0) {
-					const resolveCollection = (slug) => collections.find((c) => c.slug === slug || getTableName(c) === slug);
-					securityRules.forEach((rule) => {
-						policyStatements.push(generatePolicyDdl(collection, rule, resolveCollection));
-					});
-				}
-			}
-		}
-	}
-	if (indexStatements.length > 0) {
-		ddl += "-- Indexes\n";
-		ddl += indexStatements.join("\n") + "\n\n";
-	}
-	if (fkStatements.length > 0) {
-		ddl += "-- Foreign Key Constraints\n";
-		ddl += fkStatements.join("\n") + "\n\n";
-	}
-	if (policyStatements.length > 0) {
-		ddl += "-- Row Level Security Policies\n";
-		ddl += policyStatements.join("");
-		ddl += "\n";
-	}
-	return ddl;
-};
-var schemaOfCollection = (collection) => isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public";
-var bareTableName = (name) => name.includes(".") ? name.split(".").pop() : name;
-/**
-* Truncate a derived identifier the way Postgres does: to 63 bytes, silently.
-*
-* This is not cosmetic, and not really a naming choice at all — it is agreeing
-* with the name the database ALREADY stored. `ADD CONSTRAINT` on a longer name
-* succeeds and records the truncated form, so the untruncated name this used to
-* derive matched nothing in the catalogue. Boot-ensure compares its planned
-* constraints against `readExistingSchema`, which reads catalogue names, so the
-* comparison could never hit: every boot re-issued `ADD CONSTRAINT` for the same
-* constraint, forever, and got "already exists" every time. Non-fatal (foreign
-* keys are the one action allowed to fail) and therefore permanent — an error in
-* the log on every restart of a project whose table and column names happened to
-* be long.
-*
-* Byte length, not string length: NAMEDATALEN is 64 bytes, and a multi-byte
-* character straddling the boundary would be cut mid-sequence by `slice(0, 63)`.
-*/
-var foreignKeyPlan = (args) => {
-	const constraintName = toPostgresIdentifier(`${args.table}_${args.column}_fkey`);
-	const onUpdate = args.onUpdate ? ` ON UPDATE ${args.onUpdate.toUpperCase()}` : "";
-	return {
-		constraintName,
-		schema: args.schema,
-		table: args.table,
-		column: args.column,
-		targetSchema: args.targetSchema,
-		targetTable: args.targetTable,
-		targetColumn: args.targetColumn,
-		sql: `ALTER TABLE "${args.schema}"."${args.table}" ADD CONSTRAINT "${constraintName}" FOREIGN KEY ("${args.column}") REFERENCES "${args.targetSchema}"."${args.targetTable}" ("${args.targetColumn}") ON DELETE ${args.onDelete.toUpperCase()}${onUpdate};`
-	};
-};
-/**
-* The FK columns the declared collections own — one entry per `relation`
-* (`belongsTo` side) or `reference` property.
-*
-* Split out of {@link generatePostgresDdl} so the boot-time schema ensure can
-* create the same columns with the same names, types and constraints. Before
-* this it skipped them outright, which was survivable only because `db push`
-* always followed; on a managed tenant nothing follows, so a table arrived
-* without the column its own collection reads and wrote 400 on every insert.
-*
-* A relation whose target is not in the bundle yields no column at all (the
-* generator returns early on an unresolvable target); a `reference` whose target
-* is unknown yields the column without a constraint. Both mirror the generator
-* exactly — a divergence here is a schema fork between boot and `db push`.
-*/
-var planRelationalColumns = (allCollections) => {
-	const collections = relationalCollections(allCollections);
-	const plans = [];
-	for (const collection of collections) {
-		const tableName = getTableName(collection);
-		if (!tableName) continue;
-		const schema = schemaOfCollection(collection);
-		const table = bareTableName(tableName);
-		for (const [propName, rawProp] of Object.entries(collection.properties ?? {})) {
-			const prop = rawProp;
-			if (prop.type === "relation") {
-				const refProp = prop;
-				const relInfo = findRelation(resolveCollectionRelations(collection), refProp.relation?.relationName ?? propName);
-				if (relInfo?.kind !== "belongsTo") continue;
-				if (collection.properties[relInfo.localKey] && propName !== relInfo.localKey) continue;
-				let targetCollection;
-				try {
-					targetCollection = relInfo.target();
-				} catch {
-					continue;
-				}
-				if (!targetCollection) continue;
-				const required = prop.validation?.required;
-				const relationName = refProp.relation?.relationName ?? propName;
-				const legacyKey = legacyForeignKeyName(relationName);
-				const derived = relInfo.localKey === generateForeignKeyName(relationName);
-				plans.push({
-					schema,
-					table,
-					column: relInfo.localKey,
-					legacyColumn: derived && legacyKey !== relInfo.localKey ? legacyKey : void 0,
-					type: getSqlColumnType(propName, prop, collection, collections),
-					foreignKey: foreignKeyPlan({
-						schema,
-						table,
-						column: relInfo.localKey,
-						targetSchema: schemaOfCollection(targetCollection),
-						targetTable: bareTableName(getTableName(targetCollection)),
-						targetColumn: getPrimaryKeyName(targetCollection),
-						onDelete: relInfo.onDelete ?? defaultBelongsToOnDelete(required),
-						onUpdate: relInfo.onUpdate
-					})
-				});
-			} else if (prop.type === "reference") {
-				const refProp = prop;
-				const targetCollection = collections.find((c) => c.slug === refProp.path || getTableName(c) === refProp.path);
-				const column = resolveColumnName(propName, prop);
-				const type = getSqlColumnType(propName, prop, collection, collections);
-				const required = prop.validation?.required;
-				plans.push({
-					schema,
-					table,
-					column,
-					type,
-					foreignKey: targetCollection ? foreignKeyPlan({
-						schema,
-						table,
-						column,
-						targetSchema: schemaOfCollection(targetCollection),
-						targetTable: bareTableName(getTableName(targetCollection)),
-						targetColumn: getPrimaryKeyName(targetCollection),
-						onDelete: defaultBelongsToOnDelete(required)
-					}) : void 0
-				});
-			}
-		}
-	}
-	return plans;
-};
-/**
-* The junction tables a bundle's many-to-many relations imply.
-*
-* Derived from {@link resolveJunctionSpecs}, the same source the junction RLS
-* comes from, so a table created here always has policies planned for it — a
-* junction with row-level security left off is readable and writable by every
-* signed-in user, which is why the two must ship together.
-*/
-var planJunctionTables = (allCollections) => {
-	const collections = relationalCollections(allCollections);
-	const plans = [];
-	for (const spec of resolveJunctionSpecs(collections).values()) {
-		const [source, target] = spec.endpoints;
-		const legacyFor = (endpoint) => {
-			const slug = toSnakeCase(endpoint.collection.slug ?? endpoint.collection.name ?? "");
-			const legacy = legacyForeignKeyName(slug);
-			return endpoint.junctionColumn === generateForeignKeyName(slug) && legacy !== endpoint.junctionColumn ? legacy : void 0;
-		};
-		const columns = [{
-			name: source.junctionColumn,
-			type: junctionKeyType(source.collection),
-			legacyName: legacyFor(source)
-		}, {
-			name: target.junctionColumn,
-			type: junctionKeyType(target.collection),
-			legacyName: legacyFor(target)
-		}];
-		const onDelete = spec.declaringSides[0]?.relation.onDelete ?? "CASCADE";
-		plans.push({
-			schema: spec.schema,
-			table: spec.table,
-			columns,
-			createTable: `CREATE TABLE IF NOT EXISTS "${spec.schema}"."${spec.table}" (` + columns.map((c) => `"${c.name}" ${c.type} NOT NULL`).join(", ") + `, PRIMARY KEY (${columns.map((c) => `"${c.name}"`).join(", ")}));`,
-			foreignKeys: [source, target].map((endpoint, i) => foreignKeyPlan({
-				schema: spec.schema,
-				table: spec.table,
-				column: columns[i].name,
-				targetSchema: schemaOfCollection(endpoint.collection),
-				targetTable: bareTableName(getTableName(endpoint.collection)),
-				targetColumn: getPrimaryKeyName(endpoint.collection),
-				onDelete
-			}))
-		});
-	}
-	return plans;
-};
-/**
-* The per-table RLS plan for the *declared* collections, as executable
-* statements — what the managed runtime applies at boot so a freshly
-* provisioned tenant database serves data instead of 401ing every read.
-*
-* Mirrors {@link generatePostgresPoliciesDdl} exactly (same
-* `generatePolicyStatements`, same enable-RLS, same effective rules, same
-* derived junction rules), so boot and `db push` produce identical policies from
-* identical collections.
-*
-* Junction tables are included, and have to be: boot creates them now
-* ({@link planJunctionTables}), and a junction with RLS left off is readable and
-* writable by every signed-in user. A junction whose table is still absent is
-* skipped by the applier, not planned away here.
-*/
-var planCollectionPolicies = (allCollections) => {
-	const collections = relationalCollections(allCollections);
-	const resolveCollection = (slug) => collections.find((c) => c.slug === slug || getTableName(c) === slug);
-	const plans = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const collection of collections) {
-		const tableName = getTableName(collection);
-		if (!tableName) continue;
-		const schema = isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public";
-		const baseTableName = tableName.includes(".") ? tableName.split(".").pop() : tableName;
-		const qualified = `${schema}.${baseTableName}`;
-		if (seen.has(qualified)) continue;
-		seen.add(qualified);
-		const policyStatements = [];
-		for (const rule of getEffectiveSecurityRules(collection)) policyStatements.push(...generatePolicyStatements(collection, rule, resolveCollection));
-		plans.push({
-			schema,
-			table: baseTableName,
-			qualified,
-			enableRls: `ALTER TABLE "${schema}"."${baseTableName}" ENABLE ROW LEVEL SECURITY;`,
-			policyStatements
-		});
-	}
-	for (const spec of resolveJunctionSpecs(collections).values()) {
-		const qualified = `${spec.schema}.${spec.table}`;
-		if (seen.has(qualified)) continue;
-		seen.add(qualified);
-		const junctionCollection = getJunctionCollectionConfig(spec);
-		const policyStatements = [];
-		for (const rule of getJunctionSecurityRules(spec)) policyStatements.push(...generatePolicyStatements(junctionCollection, rule, resolveCollection));
-		plans.push({
-			schema: spec.schema,
-			table: spec.table,
-			qualified,
-			enableRls: `ALTER TABLE "${spec.schema}"."${spec.table}" ENABLE ROW LEVEL SECURITY;`,
-			policyStatements
-		});
-	}
-	return plans;
-};
-var generatePostgresPoliciesDdl = (allCollections) => {
-	const collections = relationalCollections(allCollections);
-	let ddl = "-- This file contains RLS policies generated by Rebase. Applied separately from migrations.\n\n";
-	const allTablesToGenerate = /* @__PURE__ */ new Map();
-	for (const collection of collections) {
-		const tableName = getTableName(collection);
-		if (tableName) allTablesToGenerate.set(tableName, { collection });
-	}
-	for (const [tableName, { collection }] of allTablesToGenerate.entries()) {
-		const schema = isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public";
-		const baseTableName = tableName.includes(".") ? tableName.split(".").pop() : tableName;
-		ddl += `ALTER TABLE "${schema}"."${baseTableName}" ENABLE ROW LEVEL SECURITY;\n`;
-		ddl += `\n`;
-		const securityRules = getEffectiveSecurityRules(collection);
-		if (securityRules.length > 0) {
-			const resolveCollection = (slug) => collections.find((c) => c.slug === slug || getTableName(c) === slug);
-			const injectedNames = new Set(getInjectedSecurityRules(collection).map((rule) => rule.name));
-			securityRules.forEach((rule) => {
-				if (rule.name && injectedNames.has(rule.name)) {
-					ddl += `-- Injected by Rebase (not from this collection's securityRules).\n`;
-					ddl += `-- Set \`disableDefaultPolicies: true\` on "${collection.slug}" to drop these and own its RLS outright.\n`;
-				}
-				ddl += generatePolicyDdl(collection, rule, resolveCollection);
-			});
-			ddl += "\n";
-		}
-	}
-	const junctionSpecs = resolveJunctionSpecs(collections);
-	for (const spec of junctionSpecs.values()) {
-		ddl += `ALTER TABLE "${spec.schema}"."${spec.table}" ENABLE ROW LEVEL SECURITY;\n`;
-		ddl += `\n`;
-		const junctionRules = getJunctionSecurityRules(spec);
-		if (junctionRules.length === 0) continue;
-		const junctionCollection = getJunctionCollectionConfig(spec);
-		const resolveCollection = (slug) => collections.find((c) => c.slug === slug || getTableName(c) === slug);
-		const declaringSlugs = spec.declaringSides.map((s) => s.collection.slug).join("\", \"");
-		ddl += `-- Derived by Rebase for the junction "${spec.table}" (no collection declares it).\n`;
-		ddl += `-- Reads require both endpoint rows to be visible; writes follow the update\n`;
-		ddl += `-- rules of "${declaringSlugs}". Set \`disableDefaultPolicies: true\` on the\n`;
-		ddl += `-- declaring collection(s) to drop these and police the junction yourself.\n`;
-		junctionRules.forEach((rule) => {
-			ddl += generatePolicyDdl(junctionCollection, rule, resolveCollection);
-		});
-		ddl += "\n";
-	}
-	return ddl;
-};
-//#endregion
-//#region src/schema/column-type-drift.ts
-/**
-* Types that mean the same thing to everything above the driver.
-*
-* Keyed by every spelling either side can produce: `information_schema` reports
-* `udt_name` (`int4`, `_numeric`, `bpchar`), while the generators emit SQL
-* (`INTEGER`, `NUMERIC[]`, `CHAR(3)`). Both are normalised through here.
-*/
-var FAMILIES = {
-	int2: "number",
-	smallint: "number",
-	int4: "number",
-	int: "number",
-	integer: "number",
-	int8: "number",
-	bigint: "number",
-	numeric: "number",
-	decimal: "number",
-	float4: "number",
-	real: "number",
-	float8: "number",
-	"double precision": "number",
-	money: "number",
-	text: "text",
-	varchar: "text",
-	"character varying": "text",
-	bpchar: "text",
-	char: "text",
-	character: "text",
-	citext: "text",
-	bool: "boolean",
-	boolean: "boolean",
-	json: "json",
-	jsonb: "jsonb",
-	uuid: "uuid",
-	bytea: "bytea",
-	date: "date",
-	time: "time",
-	"time without time zone": "time",
-	timetz: "time",
-	"time with time zone": "time",
-	timestamp: "timestamp",
-	"timestamp without time zone": "timestamp",
-	timestamptz: "timestamptz",
-	"timestamp with time zone": "timestamptz",
-	interval: "interval",
-	tsvector: "tsvector",
-	vector: "vector",
-	halfvec: "halfvec",
-	sparsevec: "sparsevec"
-};
-/**
-* One SQL or `udt_name` spelling reduced to its family, or `null` when this
-* module has no opinion about it.
-*
-* `null` is not a failure. It is the answer for an enum type, a domain, a
-* PostGIS column, a quoted qualified name — everything whose identity is a
-* *name* rather than a shape, where two spellings being different says nothing
-* about whether the values are compatible.
-*/
-function typeFamily(raw) {
-	if (!raw) return null;
-	let type = raw.trim().toLowerCase();
-	if (!type) return null;
-	if (type.startsWith("\"")) return null;
-	const generated = type.indexOf(" generated ");
-	if (generated > 0) type = type.slice(0, generated).trim();
-	if (type.endsWith("[]")) {
-		const element = typeFamily(type.slice(0, -2));
-		return element && `array:${element}`;
-	}
-	if (type.startsWith("_")) {
-		const element = typeFamily(type.slice(1));
-		return element && `array:${element}`;
-	}
-	const paren = type.indexOf("(");
-	if (paren > 0) type = type.slice(0, paren).trim();
-	return FAMILIES[type] ?? null;
-}
-/**
-* Do these two spellings describe columns that hold the same kind of value?
-*
-* `true` whenever the answer is not confidently "no" — an unrecognised type on
-* either side agrees with everything, because a report needs evidence and an
-* unknown type is the absence of it.
-*/
-function typesAgree(declared, actual) {
-	const a = typeFamily(declared);
-	const b = typeFamily(actual);
-	if (a === null || b === null) return true;
-	return a === b;
-}
-/**
-* The sentence a boot log says about one drifted column.
-*
-* Written to be actionable in the place it is read, which is a runtime log with
-* no way to run a migration from it: it names both types, says which surface
-* will break first, and gives the statement that resolves it.
-*/
-function columnTypeDriftMessage(drift) {
-	const [schema, table] = drift.table.split(".");
-	return `Column "${drift.table}"."${drift.column}" is ${drift.actual} in the database, but this collection declares ${drift.declared}. Boot does not change an existing column's type, so the database keeps what it has and writes that match the declaration will be rejected by Postgres. Change it deliberately, when you can watch it:
-    ALTER TABLE "${schema}"."${table}" ALTER COLUMN "${drift.column}" TYPE ${drift.declared} USING "${drift.column}"::${drift.declared};`;
-}
-//#endregion
-//#region src/schema/ensure-collection-tables.ts
-/**
-* Bringing a database up to date with a bundle's collections, additively.
-*
-* ## Why this exists
-*
-* A managed runtime boots someone else's compiled project against a database it
-* has never seen. Auth tables are ensured at boot already, but collection tables
-* were not created by anything: the platform ran the app and every `/api/data/*`
-* request answered 500 on a missing relation. `rebase db push` cannot help — it
-* is an Atlas-driven CLI command, and the runtime image ships no CLI.
-*
-* ## Why additive-only, forever
-*
-* This runs unattended, against a database with customers' data in it, with no
-* human reading a diff. So it may only ever do things that cannot lose data:
-* create a missing table, add a missing column, create a missing enum type.
-*
-* It will **never** drop a table or a column, narrow a type, or alter a
-* constraint. A removed field leaves its column behind; a renamed field looks
-* like an addition and the old column stays. That is the correct trade for an
-* automated path — the alternative is an unattended process that can silently
-* destroy a column, which is precisely the failure `db push` was hardened
-* against. Destructive changes stay a deliberate, human-reviewed migration.
-*
-* Because of that, this is safe to run on every boot, and re-running it is a
-* no-op.
-*/
-var ensure_collection_tables_exports = /* @__PURE__ */ __exportAll({
-	describeDriverError: () => describeDriverError,
-	ensureCollectionTables: () => ensureCollectionTables,
-	planCollectionSchemaEnsure: () => planCollectionSchemaEnsure,
-	readExistingSchema: () => readExistingSchema,
-	readSchemaFactsFor: () => readSchemaFactsFor
-});
-/** Postgres identifiers this module is willing to interpolate. */
-var SAFE_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_$]*$/;
-function assertSafeIdentifier(value, what) {
-	if (!SAFE_IDENTIFIER.test(value)) throw new Error(`Refusing to build SQL with an unsafe ${what}: ${JSON.stringify(value)}`);
-	return value;
-}
-/**
-* The schema a collection lives in — validated, because it is about to be
-* interpolated into DDL.
-*
-* Validation used to run only on the names read back OUT of the catalogue,
-* which is the direction that cannot hurt anyone: those came from Postgres. The
-* names going IN — the schema and table a collection declares — were quoted and
-* concatenated on trust, and quoting is not escaping. A table named
-* `x" (id int); DROP TABLE users; --` closes the quote and the statement, and
-* the whole thing runs on the owner connection, which is the one connection in
-* the system that is exempt from every RLS policy.
-*
-* That is only a config file on a self-hosted project, where the person writing
-* it could run the SQL directly anyway. It is not only a config file where a
-* collection can be defined over the wire — the live-schema and source editors
-* both do that — and there the caller is an admin on the app, not an operator
-* of the database.
-*/
-function schemaOf(collection) {
-	return assertSafeIdentifier(isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public", "schema name");
-}
-/** A collection's table name, validated for the same reason as {@link schemaOf}. */
-function tableOf(collection) {
-	return assertSafeIdentifier(getTableName(collection), "table name");
-}
-function qualified(collection) {
-	return `${schemaOf(collection)}.${tableOf(collection)}`;
-}
-/**
-* Enum types a collection's properties require, as `schema.typename`.
-*
-* Named exactly as the DDL generator names them (`<table>_<column>`), because
-* a column added here has to reference the same type the generator would have
-* created — a second, differently-named type for the same field would be a
-* silent schema fork.
-*/
-function requiredEnums(collection) {
-	const table = tableOf(collection);
-	const schema = schemaOf(collection);
-	const out = [];
-	for (const [propName, prop] of Object.entries(collection.properties ?? {})) {
-		const p = prop;
-		if (!("enum" in p) || !p.enum) continue;
-		if (p.type !== "string" && p.type !== "number") continue;
-		const values = p.enum.map((entry) => entry && typeof entry === "object" && "id" in entry ? String(entry.id) : String(entry)).filter((v) => v.length > 0);
-		if (values.length === 0) continue;
-		out.push({
-			name: `${schema}.${table}_${resolveColumnName(propName, p)}`,
-			values
-		});
-	}
-	return out;
-}
-/**
-* Decide what to add. Pure — the caller supplies what exists and runs the result.
-*
-* Ordering matters and is deliberate: enum types before the tables and columns
-* that reference them, tables before the columns added to other tables (a new
-* table may be the target of a relation), and nothing is emitted twice.
-*/
-function planCollectionSchemaEnsure(allCollections, existing, options = {}) {
-	const constraintPolicy = options.constraints ?? "additive";
-	const withheldConstraints = [];
-	const columnTypeDrift = [];
-	assertSearchIsPostgresOnly(allCollections);
-	const collections = relationalCollections(allCollections);
-	const actions = [];
-	const plannedEnums = /* @__PURE__ */ new Set();
-	for (const collection of collections) for (const { name, values } of requiredEnums(collection)) {
-		if (existing.enums.has(name) || plannedEnums.has(name)) {
-			const current = existing.enumValues?.get(name);
-			if (!current || plannedEnums.has(name)) continue;
-			const [schema, typeName] = name.split(".");
-			for (const value of values) {
-				if (current.includes(value)) continue;
-				actions.push({
-					kind: "add-enum-value",
-					target: `${name}.${value}`,
-					sql: `ALTER TYPE "${schema}"."${typeName}" ADD VALUE IF NOT EXISTS ${quoteSqlLiteral(value)};`
-				});
-			}
-			continue;
-		}
-		plannedEnums.add(name);
-		const [schema, typeName] = name.split(".");
-		actions.push({
-			kind: "create-enum",
-			target: name,
-			sql: `CREATE TYPE "${schema}"."${typeName}" AS ENUM (${values.map(quoteSqlLiteral).join(", ")});`
-		});
-	}
-	const searchSpecs = collections.map((c) => buildSearchColumnSpec(c)).filter((spec) => spec !== void 0);
-	const plannedExtensions = /* @__PURE__ */ new Set();
-	const planExtension = (statement) => {
-		if (plannedExtensions.has(statement)) return;
-		plannedExtensions.add(statement);
-		actions.push({
-			kind: "create-extension",
-			target: statement.replace(/^CREATE EXTENSION IF NOT EXISTS |;$/g, ""),
-			sql: statement
-		});
-	};
-	for (const spec of searchSpecs) for (const statement of searchExtensionStatements(spec)) planExtension(statement);
-	if (vectorExtensionDeclared(options.databaseExtensions) && collections.some((c) => buildVectorColumnSpecs(c, resolveColumnName).length > 0)) planExtension(vectorExtensionStatement());
-	const plannedFunctions = /* @__PURE__ */ new Set();
-	for (const spec of searchSpecs) for (const statement of searchHelperFunctions(spec)) {
-		if (plannedFunctions.has(statement)) continue;
-		plannedFunctions.add(statement);
-		actions.push({
-			kind: "create-function",
-			target: statement.includes("unaccent") ? SEARCH_UNACCENT_FN : SEARCH_TEXT_FN,
-			sql: statement
-		});
-	}
-	const created = /* @__PURE__ */ new Set();
-	for (const collection of collections) {
-		const key = qualified(collection);
-		if (existing.tables.has(key) || created.has(key)) continue;
-		created.add(key);
-		const schema = schemaOf(collection);
-		const table = tableOf(collection);
-		const idEntry = Object.entries(collection.properties ?? {}).find(([n, p]) => isIdProperty(n, p, collection));
-		const idName = idEntry ? resolveColumnName(idEntry[0], idEntry[1]) : "id";
-		const idProp = idEntry?.[1];
-		const idType = idProp ? getSqlColumnType(idEntry[0], idProp, collection, collections) : "TEXT";
-		let idDef = `"${assertSafeIdentifier(idName, "column name")}" ${idType} PRIMARY KEY`;
-		if (idProp?.type === "string" && idProp.isId === "uuid") idDef += " DEFAULT gen_random_uuid()";
-		actions.push({
-			kind: "create-table",
-			target: key,
-			sql: `CREATE TABLE IF NOT EXISTS "${schema}"."${table}" (${idDef});`
-		});
-	}
-	const junctions = planJunctionTables(collections);
-	for (const junction of junctions) {
-		const key = `${junction.schema}.${junction.table}`;
-		if (existing.tables.has(key) || created.has(key)) continue;
-		created.add(key);
-		actions.push({
-			kind: "create-table",
-			target: key,
-			sql: junction.createTable
-		});
-	}
-	const legacyForeignKeys = [];
-	/**
-	* Move a relation column that is only missing because it was renamed.
-	*
-	* Returns true when it handled the column, so the caller skips the ordinary
-	* ADD. Adding here would be the wrong move and a quiet one: the data is in
-	* the old column, `ADD COLUMN` creates the new one empty beside it, every
-	* statement succeeds, and the relation reads the empty one. A rename is
-	* metadata-only in Postgres, keeps the values, and carries the column's
-	* indexes and constraints with it.
-	*
-	* Only ever reached when the new name is absent and the old name is
-	* present, so there is nothing to overwrite and nothing to choose between.
-	*/
-	const renameLegacyColumn = (key, schema, table, column, legacyName) => {
-		const present = existing.tables.get(key);
-		if (!legacyName || !present) return false;
-		if (present.has(column) || !present.has(legacyName)) return false;
-		legacyForeignKeys.push({
-			table: key,
-			expected: column,
-			legacy: legacyName
-		});
-		actions.push({
-			kind: "rename-column",
-			target: `${key}.${column}`,
-			sql: `ALTER TABLE "${schema}"."${table}" RENAME COLUMN "${legacyName}" TO "${column}";`
-		});
-		return true;
-	};
-	const addColumn = (key, schema, table, column, definition) => {
-		if (existing.tables.get(key)?.has(column)) return;
-		assertSafeIdentifier(column, "column name");
-		actions.push({
-			kind: "add-column",
-			target: `${key}.${column}`,
-			sql: `ALTER TABLE "${schema}"."${table}" ADD COLUMN IF NOT EXISTS "${column}" ${definition};`
-		});
-	};
-	for (const collection of collections) {
-		const key = qualified(collection);
-		const schema = schemaOf(collection);
-		const table = tableOf(collection);
-		const fresh = created.has(key);
-		const auth = isAuthCollection(collection);
-		for (const [propName, prop] of Object.entries(collection.properties ?? {})) {
-			const p = prop;
-			if (isIdProperty(propName, p, collection)) continue;
-			if (p.type === "reference" || p.type === "relation") continue;
-			const column = resolveColumnName(propName, p);
-			const authDefinition = auth ? authUsersColumnDefinition(column) : void 0;
-			if (authDefinition) {
-				addColumn(key, schema, table, column, authDefinition);
-				continue;
-			}
-			const declaredType = getSqlColumnType(propName, p, collection, collections);
-			let definition = declaredType;
-			if (fresh && p.validation?.unique) definition += " UNIQUE";
-			const autoValue = p.autoValue;
-			const hasDefault = p.type === "date" && (autoValue === "on_create" || autoValue === "on_update");
-			if (hasDefault) definition += " DEFAULT now()";
-			const required = p.validation?.required === true;
-			const columnKey = `${key}.${column}`;
-			const columnExists = existing.tables.get(key)?.has(column) === true;
-			const actualType = existing.columnTypes?.get(columnKey);
-			if (columnExists && actualType && !typesAgree(declaredType, actualType)) columnTypeDrift.push({
-				table: key,
-				column,
-				declared: declaredType,
-				actual: actualType
-			});
-			const tableIsEmpty = existing.populatedTables !== void 0 && existing.tables.has(key) && !existing.populatedTables.has(key);
-			const notNullIsSafe = fresh || tableIsEmpty || hasDefault;
-			if (required && !columnExists) if (notNullIsSafe) definition += " NOT NULL";
-			else withheldConstraints.push({
-				target: columnKey,
-				kind: "not-null",
-				reason: `"${column}" is required, but "${key}" already holds rows and the column has no default to backfill them with, so NOT NULL would be checked against data that does not have a value yet.`,
-				remedy: "Backfill the column, then add the constraint — or give the property a default so every existing row gets one."
-			});
-			addColumn(key, schema, table, column, definition);
-			if (columnExists && constraintPolicy === "converge") {
-				const isNotNull = existing.notNullColumns?.has(columnKey) === true;
-				if (required && !isNotNull) if (tableIsEmpty) actions.push({
-					kind: "set-not-null",
-					target: columnKey,
-					sql: `ALTER TABLE "${schema}"."${table}" ALTER COLUMN "${column}" SET NOT NULL;`
-				});
-				else withheldConstraints.push({
-					target: columnKey,
-					kind: "not-null",
-					reason: `"${column}" became required, but "${key}" holds rows and any of them with no value would make SET NOT NULL fail.`,
-					remedy: "Backfill the column first — `UPDATE … SET \"" + column + "\" = … WHERE \"" + column + "\" IS NULL` — then apply this again."
-				});
-				if (!required && isNotNull) actions.push({
-					kind: "drop-not-null",
-					target: columnKey,
-					sql: `ALTER TABLE "${schema}"."${table}" ALTER COLUMN "${column}" DROP NOT NULL;`
-				});
-			}
-		}
-		if (auth) {
-			const declared = new Set(Object.entries(collection.properties ?? {}).map(([name, prop]) => resolveColumnName(name, prop)));
-			for (const spec of AUTH_USERS_COLUMNS) {
-				if (declared.has(spec.column)) continue;
-				addColumn(key, schema, table, spec.column, authUsersColumnSql(spec));
-			}
-		}
-	}
-	const searchDrift = [];
-	const searchAdopted = [];
-	for (const spec of searchSpecs) {
-		const key = `${spec.schema}.${spec.table}`;
-		const definitions = { [spec.column]: `tsvector GENERATED ALWAYS AS (${spec.expression}) STORED` };
-		if (spec.fuzzy) definitions[spec.fuzzy.column] = `text GENERATED ALWAYS AS (${spec.fuzzy.expression}) STORED`;
-		for (const stamp of searchColumnStamps(spec)) {
-			const definition = definitions[stamp.column];
-			const exists = existing.tables.get(key)?.has(stamp.column) === true;
-			const recorded = existing.columnComments?.get(`${key}.${stamp.column}`);
-			if (exists && recorded?.startsWith("rebase:search:v1:") && recorded !== stamp.fingerprint) {
-				searchDrift.push({
-					table: key,
-					column: stamp.column,
-					found: recorded,
-					expected: stamp.fingerprint,
-					rebuild: [
-						`ALTER TABLE "${spec.schema}"."${spec.table}" DROP COLUMN "${stamp.column}";`,
-						`ALTER TABLE "${spec.schema}"."${spec.table}" ADD COLUMN "${stamp.column}" ${definition};`,
-						stamp.sql
-					]
-				});
-				continue;
-			}
-			addColumn(key, spec.schema, spec.table, stamp.column, definition);
-			if (exists && recorded === void 0) searchAdopted.push({
-				table: key,
-				column: stamp.column
-			});
-			if (recorded !== stamp.fingerprint) actions.push({
-				kind: "comment-column",
-				target: `${key}.${stamp.column}`,
-				sql: stamp.sql
-			});
-		}
-	}
-	for (const junction of junctions) {
-		const key = `${junction.schema}.${junction.table}`;
-		if (created.has(key)) continue;
-		for (const column of junction.columns) {
-			if (renameLegacyColumn(key, junction.schema, junction.table, column.name, column.legacyName)) continue;
-			addColumn(key, junction.schema, junction.table, column.name, column.type);
-		}
-	}
-	const plannedRelationColumns = /* @__PURE__ */ new Map();
-	for (const relational of planRelationalColumns(collections)) {
-		const relKey = `${relational.schema}.${relational.table}`;
-		if (!plannedRelationColumns.has(relKey)) plannedRelationColumns.set(relKey, /* @__PURE__ */ new Set());
-		plannedRelationColumns.get(relKey).add(relational.column);
-		if (relational.legacyColumn) plannedRelationColumns.get(relKey).add(relational.legacyColumn);
-		if (renameLegacyColumn(relKey, relational.schema, relational.table, relational.column, relational.legacyColumn)) continue;
-		addColumn(relKey, relational.schema, relational.table, relational.column, relational.type);
-	}
-	const knownConstraints = existing.constraints ?? /* @__PURE__ */ new Set();
-	const plannedConstraints = /* @__PURE__ */ new Set();
-	const foreignKeys = [...planRelationalColumns(collections).map((r) => r.foreignKey), ...junctions.flatMap((j) => j.foreignKeys)];
-	for (const fk of foreignKeys) {
-		if (!fk) continue;
-		const name = `${fk.schema}.${fk.table}.${fk.constraintName}`;
-		if (knownConstraints.has(name) || plannedConstraints.has(name)) continue;
-		plannedConstraints.add(name);
-		actions.push({
-			kind: "add-constraint",
-			target: `${fk.schema}.${fk.table}.${fk.constraintName}`,
-			sql: fk.sql
-		});
-	}
-	const concurrentIndexing = (schema, table) => !created.has(`${schema}.${table}`);
-	for (const spec of searchSpecs) for (const statement of searchIndexStatements(spec)) actions.push({
-		kind: "create-index",
-		target: `${spec.schema}.${spec.table}`,
-		sql: concurrentIndexing(spec.schema, spec.table) ? statement.replace("CREATE INDEX IF NOT EXISTS", "CREATE INDEX CONCURRENTLY IF NOT EXISTS") : statement
-	});
-	const vectorIndexSkipped = [];
-	for (const collection of collections) {
-		const plan = buildVectorIndexPlan(collection, resolveColumnName);
-		for (const spec of plan.specs) actions.push({
-			kind: "create-index",
-			target: `${spec.schema}.${spec.table}`,
-			sql: concurrentIndexing(spec.schema, spec.table) ? vectorIndexStatement(spec).replace("CREATE INDEX IF NOT EXISTS", "CREATE INDEX CONCURRENTLY IF NOT EXISTS") : vectorIndexStatement(spec)
-		});
-		vectorIndexSkipped.push(...plan.skipped);
-	}
-	for (const spec of buildCollectionIndexPlan(collections, resolveColumnName)) actions.push({
-		kind: "create-index",
-		target: `${spec.schema}.${spec.table}`,
-		sql: collectionIndexStatement(spec, {
-			concurrently: concurrentIndexing(spec.schema, spec.table),
-			ifNotExists: true
-		})
-	});
-	const orphanedRequiredColumns = [];
-	if (existing.notNullColumns && existing.columnDefaults) for (const collection of collections) {
-		const key = qualified(collection);
-		const live = existing.tables.get(key);
-		if (!live || created.has(key)) continue;
-		const declared = /* @__PURE__ */ new Set();
-		for (const [propName, prop] of Object.entries(collection.properties ?? {})) declared.add(resolveColumnName(propName, prop));
-		for (const column of plannedRelationColumns.get(key) ?? []) declared.add(column);
-		for (const column of live) {
-			const columnKey = `${key}.${column}`;
-			if (declared.has(column)) continue;
-			if (!existing.notNullColumns.has(columnKey)) continue;
-			if (existing.columnDefaults.has(columnKey)) continue;
-			orphanedRequiredColumns.push({
-				table: key,
-				column,
-				slug: collection.slug
-			});
-		}
-	}
-	return {
-		actions,
-		statements: actions.map((a) => a.sql),
-		legacyForeignKeys,
-		searchDrift,
-		searchAdopted,
-		vectorIndexSkipped,
-		withheldConstraints,
-		columnTypeDrift,
-		orphanedRequiredColumns
-	};
-}
-/** Read what the database has, for the schemas the collections live in. */
-async function readExistingSchema(client, schemas) {
-	const tables = /* @__PURE__ */ new Map();
-	const enums = /* @__PURE__ */ new Set();
-	if (schemas.length === 0) return {
-		tables,
-		enums
-	};
-	const inList = schemas.map((schema) => `'${assertSafeIdentifier(schema, "schema name")}'`).join(", ");
-	const notNullColumns = /* @__PURE__ */ new Set();
-	const columnTypes = /* @__PURE__ */ new Map();
-	const columnDefaults = /* @__PURE__ */ new Set();
-	const { rows: columns } = await client.query(`SELECT table_schema, table_name, column_name, is_nullable, udt_name, column_default
-         FROM information_schema.columns
-         WHERE table_schema IN (${inList})`);
-	for (const row of columns) {
-		const key = `${row.table_schema}.${row.table_name}`;
-		if (!tables.has(key)) tables.set(key, /* @__PURE__ */ new Set());
-		tables.get(key).add(row.column_name);
-		if (row.is_nullable === "NO") notNullColumns.add(`${key}.${row.column_name}`);
-		if (row.udt_name) columnTypes.set(`${key}.${row.column_name}`, row.udt_name);
-		if (row.column_default !== null) columnDefaults.add(`${key}.${row.column_name}`);
-	}
-	const populatedTables = /* @__PURE__ */ new Set();
-	const { rows: realTables } = await client.query(`SELECT n.nspname AS schema, c.relname AS name
-         FROM pg_class c
-         JOIN pg_namespace n ON c.relnamespace = n.oid
-         WHERE c.relkind IN ('r', 'p') AND n.nspname IN (${inList})`);
-	if (realTables.length > 0) {
-		const probes = realTables.map((row) => {
-			const schema = assertSafeIdentifier(row.schema, "schema name");
-			const table = assertSafeIdentifier(row.name, "table name");
-			return `SELECT ${quoteSqlLiteral(`${schema}.${table}`)} AS key, EXISTS(SELECT 1 FROM "${schema}"."${table}" LIMIT 1) AS populated`;
-		});
-		const { rows: populationRows } = await client.query(probes.join(" UNION ALL "));
-		for (const row of populationRows) if (row.populated) populatedTables.add(row.key);
-	}
-	const enumValues = /* @__PURE__ */ new Map();
-	const { rows: enumValueRows } = await client.query(`SELECT n.nspname AS schema, t.typname AS name, e.enumlabel AS value
-         FROM pg_enum e
-         JOIN pg_type t ON e.enumtypid = t.oid
-         JOIN pg_namespace n ON t.typnamespace = n.oid
-         WHERE n.nspname IN (${inList})
-         ORDER BY t.typname, e.enumsortorder`);
-	for (const row of enumValueRows) {
-		const key = `${row.schema}.${row.name}`;
-		if (!enumValues.has(key)) enumValues.set(key, []);
-		enumValues.get(key).push(row.value);
-	}
-	const { rows: enumRows } = await client.query(`SELECT n.nspname AS schema, t.typname AS name
-         FROM pg_type t
-         JOIN pg_namespace n ON t.typnamespace = n.oid
-         WHERE t.typtype = 'e' AND n.nspname IN (${inList})`);
-	for (const row of enumRows) enums.add(`${row.schema}.${row.name}`);
-	const constraints = /* @__PURE__ */ new Set();
-	const { rows: constraintRows } = await client.query(`SELECT n.nspname AS schema, c.relname AS table, con.conname AS name
-         FROM pg_constraint con
-         JOIN pg_class c ON con.conrelid = c.oid
-         JOIN pg_namespace n ON c.relnamespace = n.oid
-         WHERE n.nspname IN (${inList})`);
-	for (const row of constraintRows) constraints.add(`${row.schema}.${row.table}.${row.name}`);
-	const columnComments = /* @__PURE__ */ new Map();
-	const { rows: commentRows } = await client.query(`SELECT n.nspname AS schema, c.relname AS table, a.attname AS column, d.description AS comment
-         FROM pg_description d
-         JOIN pg_class c ON d.objoid = c.oid
-         JOIN pg_namespace n ON c.relnamespace = n.oid
-         JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum = d.objsubid
-         WHERE d.objsubid > 0 AND n.nspname IN (${inList})`);
-	for (const row of commentRows) {
-		if (row.comment == null) continue;
-		columnComments.set(`${row.schema}.${row.table}.${row.column}`, row.comment);
-	}
-	return {
-		tables,
-		enums,
-		constraints,
-		columnComments,
-		enumValues,
-		notNullColumns,
-		populatedTables,
-		columnTypes,
-		columnDefaults
-	};
-}
-/**
-* What to tell an operator whose `search` block no longer matches its column.
-*
-* Every line here is doing work: naming the collection is not enough, because
-* the symptom (a search that finds nothing) points at the data, not the schema;
-* and the remediation has to be exact, because it is a table rewrite the
-* operator is being asked to schedule rather than discover.
-*/
-function searchDriftMessage(drift) {
-	return "The `search` block changed after its generated column was created, and Postgres cannot alter a generated expression in place.\nRebase will not rebuild it for you: dropping and re-adding a STORED generated column rewrites the whole table under an ACCESS EXCLUSIVE lock and rebuilds its GIN index, which is an outage this unattended path may not schedule on your behalf.\nUntil it is rebuilt the column keeps indexing the previous fields, weights and language — searches for anything added since return nothing, which reads from outside as \"no such row\".\nRun these (or revert the block to what the column was built from), then boot again:\n" + drift.map((d) => `  "${d.table}"."${d.column}" was generated from a different \`search\` block (recorded ${d.found}, current ${d.expected}).\n` + d.rebuild.map((s) => `      ${s}`).join("\n")).join("\n") + "\n  The GIN index is dropped with the column and recreated concurrently on the next boot.";
-}
-/**
-* Read what the database looks like, for the schemas a set of collections
-* lives in.
-*
-* The same read `ensureCollectionTables` does at boot, exposed on its own for
-* the callers that want to *plan* against a real database without changing it —
-* the live schema editor, which has to tell somebody what a change would do
-* before they agree to it.
-*/
-async function readSchemaFactsFor(client, collections) {
-	const relational = relationalCollections(collections);
-	return readExistingSchema(client, Array.from(/* @__PURE__ */ new Set([...relational.map(schemaOf), ...planJunctionTables(relational).map((junction) => junction.schema)])));
-}
-/**
-* Bring the database up to date. Returns what it did.
-*
-* Each statement runs on its own rather than in one transaction: they are all
-* independently safe and idempotent, and a single failure (an enum label that
-* cannot be added, say) should not roll back the tables that were created fine.
-* The error is surfaced with the statement that caused it.
-*/
-async function ensureCollectionTables(client, collections, log, options = {}) {
-	const schemas = Array.from(/* @__PURE__ */ new Set([...collections.map(schemaOf), ...planJunctionTables(collections).map((j) => j.schema)]));
-	for (const schema of schemas) {
-		assertSafeIdentifier(schema, "schema name");
-		if (schema !== "public") await client.query(`CREATE SCHEMA IF NOT EXISTS "${schema}";`);
-	}
-	const plan = planCollectionSchemaEnsure(collections, await readExistingSchema(client, schemas), {
-		...options,
-		databaseExtensions: options.databaseExtensions ?? declaredDatabaseExtensions()
-	});
-	const failures = [];
-	for (const legacy of plan.legacyForeignKeys) {
-		const message = `Renaming "${legacy.table}"."${legacy.legacy}" to "${legacy.expected}". The old name is the one Rebase derived for this relation before it singularized properly; the column keeps its data, indexes and constraints. To keep the old name instead, set \`localKey: "${legacy.legacy}"\` on the relation and this will stop.`;
-		logger.info(`[schema] ${message}`);
-		log?.(message);
-	}
-	if (plan.searchDrift.length > 0) throw new Error(searchDriftMessage(plan.searchDrift));
-	for (const adopted of plan.searchAdopted) {
-		const message = `Adopting the existing generated column "${adopted.table}"."${adopted.column}" and recording what the current \`search\` block would generate. Any later change to that block will be detected and refused; a change made *before* this version was deployed cannot be, so if search has been missing content, rebuild the column once: ALTER TABLE "${adopted.table.split(".").join("\".\"")}" DROP COLUMN "${adopted.column}"; and boot again.`;
-		logger.info(`[schema] ${message}`);
-		log?.(message);
-	}
-	for (const skip of plan.vectorIndexSkipped) {
-		const message = `No ANN index on "${skip.table}"."${skip.column}": ${skip.reason}`;
-		logger.warn(`[schema] ${message}`);
-		log?.(message);
-	}
-	for (const withheld of plan.withheldConstraints) {
-		const message = `No NOT NULL on "${withheld.target}": ${withheld.reason} ${withheld.remedy}`;
-		logger.warn(`[schema] ${message}`);
-		log?.(message);
-	}
-	for (const drift of plan.columnTypeDrift) {
-		const message = columnTypeDriftMessage(drift);
-		logger.warn(`[schema] ${message}`);
-		log?.(message);
-	}
-	for (const orphan of plan.orphanedRequiredColumns) {
-		const [schema, table] = orphan.table.split(".");
-		const message = `"${orphan.table}"."${orphan.column}" is NOT NULL with no default, and the "${orphan.slug}" collection no longer declares it. Every insert will be rejected for a field you cannot set (PG_23502, naming "${orphan.column}"). This is what a renamed property looks like: the new column was added, and the old one cannot be dropped unattended. Fix it with ONE of:
-      ALTER TABLE "${schema}"."${table}" DROP COLUMN "${orphan.column}";               -- the rename is complete\n      ALTER TABLE "${schema}"."${table}" ALTER COLUMN "${orphan.column}" DROP NOT NULL; -- keep the data, stop requiring it\n      ...or declare the property again, if the column is still wanted.`;
-		logger.warn(`[schema] ${message}`);
-		log?.(message);
-	}
-	if (plan.actions.length === 0) {
-		log?.("Schema is up to date; nothing to create.");
-		return {
-			...plan,
-			failures
-		};
-	}
-	for (const action of plan.actions) try {
-		if (await applyAction(client, action)) log?.(`${action.kind}: ${action.target}`);
-		else log?.(`${action.kind}: ${action.target} (already created by a peer)`);
-	} catch (err) {
-		const message = describeDriverError(err);
-		if (action.kind === "add-constraint" || action.kind === "comment-column" || action.kind === "create-index" && !/CREATE\s+UNIQUE\s+INDEX/i.test(action.sql)) {
-			failures.push({
-				kind: action.kind,
-				target: action.target,
-				error: message
-			});
-			continue;
-		}
-		throw new Error(`Failed to ${action.kind} ${action.target}: ${message}${vectorExtensionHint(message)}\n  ${action.sql}`);
-	}
-	return {
-		...plan,
-		failures
-	};
-}
-/**
-* What actually went wrong, rather than what the ORM said about it.
-*
-* Drizzle wraps every driver error, and its `message` is literally
-* ``Failed query: ${sql}\nparams: ${params}`` — the statement we already know,
-* and not one word of Postgres's answer. Reporting `err.message` therefore
-* produced a failure that named the statement twice and the *reason* zero
-* times, so four unrelated boot failures — a missing extension, a wrong
-* privilege, a bad index method, a constraint the rows violate — all read
-* identically to whoever had to fix them.
-*
-* Two consequences, both observed in the field before this existed:
-*
-*  1. On a managed deployment the reason never reaches anybody. Boot dies, the
-*     pod never goes ready, and the deploy reports a readiness timeout — so the
-*     one line that says why is the one line that was thrown away here.
-*  2. {@link vectorExtensionHint} matches on the error text. Against the
-*     wrapper it matched nothing, so the hint written specifically to explain a
-*     missing pgvector never fired on the path that raises it.
-*
-* `detail` and `hint` come along because they are the fields Postgres uses to
-* say which object it meant and what to do about it — `CREATE EXTENSION` names
-* the missing library there, and a rejected constraint names the row. This
-* writes into the tenant's own boot log, about the tenant's own database.
-*/
-function describeDriverError(err) {
-	const pg = extractPgError(err);
-	if (pg) {
-		const parts = [pg.code ? `${pg.message} [${pg.code}]` : pg.message];
-		if (pg.detail) parts.push(`  detail: ${pg.detail}`);
-		if (pg.hint) parts.push(`  hint: ${pg.hint}`);
-		return parts.join("\n");
-	}
-	const cause = extractCauseMessage(err);
-	if (cause) return cause;
-	return err instanceof Error ? err.message : String(err);
-}
-/** ` CONCURRENTLY ` as it appears in a rendered `CREATE [UNIQUE] INDEX`. */
-var CONCURRENTLY_RE = /\sCONCURRENTLY\s/i;
-/**
-* `25001 active_sql_transaction` — "cannot run inside a transaction block".
-*
-* Only ever raised here by `CREATE INDEX CONCURRENTLY`, and only when the
-* connection we were handed is inside a transaction. Deliberately narrow: it
-* decides to retry a *different* statement, so it must not fire on anything it
-* has not been reasoned about.
-*/
-function isTransactionBlockRefusal(err) {
-	return extractPgError(err)?.code === "25001";
-}
-/** Attempts per action, including the first. Matches the server's bootstraps. */
-var DDL_ATTEMPTS = 4;
-/**
-* Run one planned statement, surviving a simultaneous boot.
-*
-* Every statement in a plan is written to be idempotent, and that is not the
-* same as being safe to run concurrently: `CREATE … IF NOT EXISTS` reads the
-* catalog and then writes to it as two steps, so peers starting together both
-* see "absent" and the loser gets a duplicate key on a *catalog* index. Measured
-* against Postgres 18: five instances, 8 of 10 calls lost. `CREATE TYPE` is
-* worse, because Postgres has no `IF NOT EXISTS` for it at all.
-*
-* What made that fatal here rather than merely noisy is the loop this sits in.
-* A losing statement threw, and the throw abandoned **every remaining action in
-* the plan** — so a replica that lost one race came up missing tables it never
-* attempted, and the boot log blamed the one statement that failed.
-*
-* @returns `true` if this process applied the statement, `false` if a peer had
-*   already created the object. The distinction is only for the log; both mean
-*   the object is now there.
-* @throws the original error for anything that is not a race — a syntax error, a
-*   permission failure, a unique constraint the customer's own rows violate.
-*/
-async function applyAction(client, action) {
-	let sqlText = action.sql;
-	for (let attempt = 1;; attempt++) try {
-		await client.query(sqlText);
-		return true;
-	} catch (err) {
-		if (isTransactionBlockRefusal(err) && CONCURRENTLY_RE.test(sqlText)) {
-			sqlText = sqlText.replace(CONCURRENTLY_RE, " ");
-			logger.warn(`[schema] ${action.kind} ${action.target}: this connection is inside a transaction, so the index is being built with a write lock rather than concurrently. Writes to this table block until it finishes.`);
-			continue;
-		}
-		if (isDuplicateObjectRace(err)) {
-			logger.debug(`[schema] ${action.kind} ${action.target}: already created by another instance`);
-			return false;
-		}
-		if (isConcurrentDdlRace(err) && attempt < DDL_ATTEMPTS) {
-			logger.debug(`[schema] ${action.kind} ${action.target}: lost a race with another instance (attempt ${attempt}/${DDL_ATTEMPTS}) — retrying`);
-			await new Promise((resolve) => setTimeout(resolve, 40 * attempt * (1 + Math.random())));
-			continue;
-		}
-		throw err;
-	}
-}
-//#endregion
-export { __toESM as A, SEARCH_UNACCENT_FN as C, __commonJSMin as D, visibleColumnProjection as E, __exportAll as O, sanitizeErrorForClient as S, hiddenColumnsOption as T, extractPgError as _, readSchemaFactsFor as a, pgErrorToFriendlyMessage as b, generatePostgresPoliciesDdl as c, planCollectionPolicies as d, resolveColumnName as f, extractCauseMessage as g, classifyConnectFailure as h, readExistingSchema as i, __require as k, generatePostgresSearchDdl as l, authUsersColumnSql as m, ensure_collection_tables_exports as n, defaultBelongsToOnDelete as o, AUTH_USERS_COLUMNS as p, planCollectionSchemaEnsure as r, generatePostgresDdl as s, describeDriverError as t, generatePostgresVectorDdl as u, isRoleSwitchingPermissionError as v, buildSearchColumnSpec as w, reachedDatabase as x, isRowLevelSecurityDenial as y };
-
-//# sourceMappingURL=ensure-collection-tables-DbAhrjnG.js.map