@rebasepro/server-postgres 0.17.3 → 0.18.1

package/dist/{ensure-collection-tables-DgVixhX3.js → generate-postgres-ddl-logic-CtnpIBVv.js}

@@ -1,32 +1,13 @@
 import { createRequire as __createRequire } from "module";
-import "process";
 __createRequire(import.meta.url);
-import { u as __exportAll } from "./connection-GOKU3Hu5.js";
-import { B as getPolicyNamesForRule, C as getTableName, I as generateForeignKeyName, L as legacyForeignKeyName, R as toPostgresIdentifier, T as resolveCollectionRelations, W as toSnakeCase, Z as isManyToMany, _ as securityRuleToConditions, b as findRelation, d as getJunctionCollectionConfig, f as getJunctionSecurityRules, g as policyToPostgres, h as getInjectedSecurityRules, i as collectionIndexStatements, m as getEffectiveSecurityRules, n as buildCollectionIndexSpecs, p as resolveJunctionSpecs, r as collectionIndexStatement, t as buildCollectionIndexPlan, u as relationalCollections } from "./collection-index-BRUg10H5.js";
-import { l as isPostgresCollectionConfig, r as REBASE_SCHEMA, t as declaredDatabaseExtensions } from "./src-DiB5RP2Z.js";
-import { isConcurrentDdlRace, isDuplicateObjectRace, logger } from "@rebasepro/server";
+import { r as __exportAll } from "./__vite-browser-external-BnuHet1e.js";
+import { i as isAuthCollection, n as authUsersColumnDefinition, r as authUsersColumnSql, t as AUTH_USERS_COLUMNS } from "./auth-users-columns-D2LBFrMH.js";
+import { a as vectorDimensionGuard, c as vectorExtensionStatement, d as vectorObjectNames, i as vectorColumnDefinition, n as buildVectorColumnSpecs, o as vectorExtensionDeclared, r as buildVectorIndexPlan, t as VECTOR_EXTENSION_OPT_IN, u as vectorIndexStatements } from "./vector-index-DkWxm2de.js";
+import { i as collectionIndexStatements, n as buildCollectionIndexSpecs } from "./collection-index-BHgT_TKd.js";
+import { DEFAULT_FUZZY_THRESHOLD, DEFAULT_SEARCH_COLUMN, DEFAULT_SEARCH_LANGUAGE, DEFAULT_SEARCH_WEIGHT, REBASE_SCHEMA, 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";
-/**
-* How wide a `varchar`/`char` column should be for a given property.
-*
-* One definition, three call sites, because they used to disagree. For the same
-* `columnType: "varchar"` property the DDL generator emitted `VARCHAR(255)`
-* while the Drizzle generator emitted a bare `varchar("col")` — which Postgres
-* reads as *unbounded* — so which of the two you ran decided whether the column
-* had a limit at all. Introspection then dropped the length entirely, so reading
-* an existing `character varying(500)` column back and regenerating it produced
-* a `VARCHAR(255)`: a silent narrowing of a column with data already in it.
-*
-* `validation.max` is the property's own statement about how long the value may
-* be, so it is the only sensible source for the column's width — and it keeps
-* the constraint the database enforces in step with the one the app enforces,
-* rather than inventing a second, different limit underneath it.
-*/
-function resolveStringColumnLength(prop) {
-	const max = prop.validation?.max;
-	return typeof max === "number" && Number.isInteger(max) && max > 0 ? max : 255;
-}
-//#endregion
 //#region src/schema/search-column.ts
 /**
 * The one place a collection's `search` block becomes SQL.
@@ -171,9 +152,9 @@ 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))`;
+	return `${SEARCH_TEXT_FN}(coalesce(${field.jsonPath.length === 0 ? col : field.jsonPath.length === 1 ? `${col} -> ${quote(field.jsonPath[0])}` : `${col} #> ${quote(`{${field.jsonPath.join(",")}}`)}`}, '{}'::jsonb))`;
 };
-var quote$1 = (v) => `'${v.replace(/'/g, "''")}'`;
+var quote = (v) => `'${v.replace(/'/g, "''")}'`;
 /**
 * Resolve and validate one declared field path.
 *
@@ -184,7 +165,7 @@ var quote$1 = (v) => `'${v.replace(/'/g, "''")}'`;
 */
 var resolveField = (entry, collection, cfg) => {
 	const path = typeof entry === "string" ? entry : entry.path;
-	const weight = (typeof entry === "string" ? void 0 : entry.weight) ?? "B";
+	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(".");
@@ -203,14 +184,14 @@ var resolveField = (entry, collection, cfg) => {
 		jsonPath: rest,
 		kind: classified.kind
 	}), cfg.unaccent === true);
-	const language = cfg.language ?? "simple";
+	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)})`,
+		sql: `setweight(to_tsvector(${quote(language)}, ${textSql}), ${quote(weight)})`,
 		textSql
 	};
 };
@@ -227,7 +208,7 @@ var buildSearchColumnSpec = (collection) => {
 	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 ?? "search_vector";
+	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();
@@ -242,7 +223,7 @@ var buildSearchColumnSpec = (collection) => {
 		schema,
 		table,
 		column,
-		language: cfg.language ?? "simple",
+		language: cfg.language ?? DEFAULT_SEARCH_LANGUAGE,
 		unaccent: cfg.unaccent === true,
 		fields,
 		expression: fields.map((f) => f.sql).join(" || "),
@@ -256,7 +237,7 @@ var buildSearchColumnSpec = (collection) => {
 			column: fuzzyColumn,
 			expression: fields.map((f) => f.textSql).join(" || ' ' || "),
 			indexName: toPostgresIdentifier(`${table}_${fuzzyColumn}_trgm`),
-			threshold: cfg.fuzzyThreshold ?? .3
+			threshold: cfg.fuzzyThreshold ?? DEFAULT_FUZZY_THRESHOLD
 		};
 	}
 	return spec;
@@ -343,7 +324,7 @@ var searchColumnStamps = (spec) => {
 			column,
 			expression,
 			fingerprint,
-			sql: `COMMENT ON COLUMN "${spec.schema}"."${spec.table}"."${column}" IS ${quote$1(fingerprint)};`
+			sql: `COMMENT ON COLUMN "${spec.schema}"."${spec.table}"."${column}" IS ${quote(fingerprint)};`
 		};
 	};
 	const stamps = [stamp(spec.column, spec.expression)];
@@ -361,20 +342,27 @@ var searchColumnStamps = (spec) => {
 * 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}"`);
+	const relation = quote(`"${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
+    WHERE a.attrelid = ${relation}::regclass AND a.attname = ${quote(stamp.column)} AND NOT a.attisdropped;
+    IF recorded LIKE ${quote(`${SEARCH_STAMP_PREFIX}%`)} AND recorded <> ${quote(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 index names the spec creates.
+*
+* Needed by name, not just by statement, so Atlas can be told to exclude them
+* from its diff — see `searchExcludePatterns`.
+*/
+var searchIndexNames = (spec) => spec.fuzzy ? [spec.indexName, spec.fuzzy.indexName] : [spec.indexName];
+/**
 * 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
@@ -440,381 +428,27 @@ var excludedColumnNames = (tableColumns, collection) => {
 	return Object.keys(tableColumns).filter((name) => byName.has(name) || isSearchIndexColumn(tableColumns[name]));
 };
 //#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 generate_postgres_ddl_logic_exports = /* @__PURE__ */ __exportAll({
+	defaultBelongsToOnDelete: () => defaultBelongsToOnDelete,
+	generatePolicyStatements: () => generatePolicyStatements,
+	generatePostgresDdl: () => generatePostgresDdl,
+	generatePostgresPoliciesDdl: () => generatePostgresPoliciesDdl,
+	generatePostgresSearchDdl: () => generatePostgresSearchDdl,
+	generatePostgresVectorDdl: () => generatePostgresVectorDdl,
+	getPrimaryKeyName: () => getPrimaryKeyName,
+	getPrimaryKeyProp: () => getPrimaryKeyProp,
+	getSqlColumnType: () => getSqlColumnType,
+	isIdProperty: () => isIdProperty,
+	isNumericId: () => isNumericId,
+	planCollectionPolicies: () => planCollectionPolicies,
+	planJunctionTables: () => planJunctionTables,
+	planRelationalColumns: () => planRelationalColumns,
+	quoteSqlLiteral: () => quoteSqlLiteral,
+	resolveColumnName: () => resolveColumnName,
+	searchExcludePatterns: () => searchExcludePatterns,
+	vectorExcludePatterns: () => vectorExcludePatterns
+});
 var resolveColumnName = (propName, prop) => {
 	if (prop && "columnName" in prop && typeof prop.columnName === "string") return prop.columnName;
 	return toSnakeCase(propName);
@@ -864,6 +498,34 @@ var isIdProperty = (propName, prop, collection) => {
 * 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
@@ -1058,6 +720,31 @@ var generatePostgresSearchDdl = (allCollections) => {
 	return ddl;
 };
 /**
+* Glob patterns telling Atlas to leave the search column and its index alone.
+*
+* Without these, a desired state that omits search reads to Atlas as an
+* instruction to drop the column — taking the index and the whole search
+* feature with it on the next push.
+*
+* Fully qualified, `schema.table.object`, matching the include list. The
+* two-part form is what Atlas wants when the connection URL scopes it to one
+* schema and is *silently ignored* otherwise: it reads `posts.search_vector`
+* as a table named `search_vector` in a schema named `posts`, matches nothing,
+* and reports no error for the pattern that never fired.
+*/
+var searchExcludePatterns = (allCollections) => {
+	const patterns = [];
+	for (const collection of relationalCollections(allCollections)) {
+		const spec = buildSearchColumnSpec(collection);
+		if (!spec) continue;
+		const schema = isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public";
+		const table = getTableName(collection);
+		for (const name of searchColumnNames(collection)) patterns.push(`${schema}.${table}.${name}`);
+		for (const index of searchIndexNames(spec)) patterns.push(`${schema}.${table}.${index}`);
+	}
+	return patterns;
+};
+/**
 * Everything a `{ type: "vector" }` property needs, as a file Rebase applies
 * itself.
 *
@@ -1113,6 +800,27 @@ var generatePostgresVectorDdl = (allCollections, options = {}) => {
 	}
 	return ddl;
 };
+/**
+* Glob patterns telling Atlas to leave the vector column and its ANN indexes
+* alone.
+*
+* Without these, a desired state that omits the column reads to Atlas as an
+* instruction to drop it, taking the embeddings and the indexes with it on the
+* next push.
+*
+* Fully qualified, `schema.table.object`, for the reason spelled out on
+* {@link searchExcludePatterns}: the two-part form matches nothing and reports
+* no error, which turns a protection into a `DROP COLUMN`.
+*/
+var vectorExcludePatterns = (allCollections) => {
+	const patterns = [];
+	for (const collection of relationalCollections(allCollections)) {
+		const schema = isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public";
+		const table = getTableName(collection);
+		for (const name of vectorObjectNames(collection, resolveColumnName)) patterns.push(`${schema}.${table}.${name}`);
+	}
+	return patterns;
+};
 var generatePostgresDdl = async (allCollections, options = {
 	includePolicies: true,
 	includeSearch: true,
@@ -1234,7 +942,7 @@ var generatePostgresDdl = async (allCollections, options = {
 					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 ?? (required ? "CASCADE" : "SET NULL");
+					const onDeleteVal = relInfo.onDelete ?? defaultBelongsToOnDelete(required);
 					let colDef = `  "${relInfo.localKey}" ${fkColType}`;
 					if (required) colDef += " NOT NULL";
 					columns.push(colDef);
@@ -1253,7 +961,7 @@ var generatePostgresDdl = async (allCollections, options = {
 						const targetTable = getTableName(targetCollection);
 						const targetSchema = isPostgresCollectionConfig(targetCollection) && targetCollection.schema ? targetCollection.schema : "public";
 						const targetId = getPrimaryKeyName(targetCollection);
-						const onDelete = required ? "CASCADE" : "SET NULL";
+						const onDelete = defaultBelongsToOnDelete(required);
 						let colDef = `  "${colName}" ${colType}`;
 						if (required) colDef += " NOT NULL";
 						columns.push(colDef);
@@ -1420,7 +1128,7 @@ var planRelationalColumns = (allCollections) => {
 						targetSchema: schemaOfCollection(targetCollection),
 						targetTable: bareTableName(getTableName(targetCollection)),
 						targetColumn: getPrimaryKeyName(targetCollection),
-						onDelete: relInfo.onDelete ?? (required ? "CASCADE" : "SET NULL"),
+						onDelete: relInfo.onDelete ?? defaultBelongsToOnDelete(required),
 						onUpdate: relInfo.onUpdate
 					})
 				});
@@ -1442,7 +1150,7 @@ var planRelationalColumns = (allCollections) => {
 						targetSchema: schemaOfCollection(targetCollection),
 						targetTable: bareTableName(getTableName(targetCollection)),
 						targetColumn: getPrimaryKeyName(targetCollection),
-						onDelete: required ? "CASCADE" : "SET NULL"
+						onDelete: defaultBelongsToOnDelete(required)
 					}) : void 0
 				});
 			}
@@ -1599,572 +1307,6 @@ var generatePostgresPoliciesDdl = (allCollections) => {
 	return ddl;
 };
 //#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({
-	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;
-}
-function schemaOf(collection) {
-	return isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public";
-}
-function qualified(collection) {
-	return `${schemaOf(collection)}.${getTableName(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 = getTableName(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 = [];
-	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 = getTableName(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];
-		let idDef = `"${idName}" ${idProp ? getSqlColumnType(idEntry[0], idProp, collection, collections) : "TEXT"} 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;
-		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 = getTableName(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;
-			}
-			let definition = getSqlColumnType(propName, p, collection, collections);
-			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 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);
-		}
-	}
-	for (const relational of planRelationalColumns(collections)) {
-		const relKey = `${relational.schema}.${relational.table}`;
-		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
-		});
-	}
-	for (const spec of searchSpecs) for (const statement of searchIndexStatements(spec)) actions.push({
-		kind: "create-index",
-		target: `${spec.schema}.${spec.table}`,
-		sql: statement.replace("CREATE INDEX IF NOT EXISTS", "CREATE INDEX CONCURRENTLY IF NOT EXISTS")
-	});
-	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: vectorIndexStatement(spec).replace("CREATE INDEX IF NOT EXISTS", "CREATE INDEX CONCURRENTLY IF NOT EXISTS")
-		});
-		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: true,
-			ifNotExists: true
-		})
-	});
-	return {
-		actions,
-		statements: actions.map((a) => a.sql),
-		legacyForeignKeys,
-		searchDrift,
-		searchAdopted,
-		vectorIndexSkipped,
-		withheldConstraints
-	};
-}
-/** 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 { rows: columns } = await client.query(`SELECT table_schema, table_name, column_name, is_nullable
-         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}`);
-	}
-	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
-	};
-}
-/**
-* 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);
-	}
-	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 = err instanceof Error ? err.message : String(err);
-		if (action.kind === "add-constraint" || action.kind === "comment-column") {
-			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
-	};
-}
-/** 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) {
-	for (let attempt = 1;; attempt++) try {
-		await client.query(action.sql);
-		return true;
-	} catch (err) {
-		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 { resolveStringColumnLength as _, generatePostgresDdl as a, generatePostgresVectorDdl as c, AUTH_USERS_COLUMNS as d, authUsersColumnSql as f, visibleColumnProjection as g, hiddenColumnsOption as h, readSchemaFactsFor as i, planCollectionPolicies as l, buildSearchColumnSpec as m, planCollectionSchemaEnsure as n, generatePostgresPoliciesDdl as o, SEARCH_UNACCENT_FN as p, readExistingSchema as r, generatePostgresSearchDdl as s, ensure_collection_tables_exports as t, resolveColumnName as u };
+export { searchIndexStatements as C, searchHelperFunctions as S, assertSearchIsPostgresOnly as _, generatePostgresVectorDdl as a, searchColumnStamps as b, isIdProperty as c, planRelationalColumns as d, quoteSqlLiteral as f, SEARCH_UNACCENT_FN as g, SEARCH_TEXT_FN as h, generatePostgresSearchDdl as i, planCollectionPolicies as l, SEARCH_STAMP_PREFIX as m, generatePostgresDdl as n, generate_postgres_ddl_logic_exports as o, resolveColumnName as p, generatePostgresPoliciesDdl as r, getSqlColumnType as s, defaultBelongsToOnDelete as t, planJunctionTables as u, buildSearchColumnSpec as v, visibleColumnProjection as w, searchExtensionStatements as x, hiddenColumnsOption as y };
 
-//# sourceMappingURL=ensure-collection-tables-DgVixhX3.js.map
+//# sourceMappingURL=generate-postgres-ddl-logic-CtnpIBVv.js.map