@rebasepro/server-postgres 0.25.0 → 0.25.1

package/dist/{open-rebase-BKA7Nyoe.js → open-rebase-EmqVmS14.js}

@@ -1,30 +1,29 @@
 import { createRequire as __createRequire } from "module";
 __createRequire(import.meta.url);
-import { i as createPostgresDatabaseConnection } from "./connection-C938nR3E.js";
-import { _ as visibleColumnProjection, a as buildSearchColumnSpec, l as searchColumnNames, r as SEARCH_UNACCENT_FN, s as hiddenColumnsOption } from "./search-column-BM-GV6vH.js";
-import { a as diagnoseDbError, c as isEconnrefused, n as closedDatabaseName, nt as extractCauseMessage, r as deepestErrorMessage, u as parseHostInfo } from "./cli-errors-DwQnNATs.js";
-import { a as pgErrorToFriendlyMessage, i as isRowLevelSecurityDenial, n as extractPgError, o as reachedDatabase, r as isRoleSwitchingPermissionError, s as sanitizeErrorForClient, t as classifyConnectFailure } from "./pg-error-utils-Bv5n2PLn.js";
-import { t as BranchService } from "./BranchService-iXXZeVYD.js";
-import { a as ensureAppRoleGrants, d as warnOnLegacyRlsFunctions, f as warnOnRoleSchemaCollision, i as ensureAppRole, l as validatePolicyPgRoles, n as applyAuthContext, r as detectConnectionPosture, s as revokeUserRoleSql, t as REBASE_USER_ROLE$1, u as warnOnAnonymousGrants } from "./rls-enforcement-D7P4-ZYX.js";
-import { u as resolveColumnName } from "./column-plan-helpers-D_V4oaZh.js";
-import { i as isAuthCollection, t as AUTH_USERS_COLUMNS } from "./auth-users-columns-C72EMoDJ.js";
-import { n as planSchema, o as sharedRelationName } from "./plan-schema-CXOucCw-.js";
-import { t as generateSchema } from "./generate-drizzle-schema-logic-DA3zM8zc.js";
-import { r as renderPgType } from "./render-ddl-CQNwZdse.js";
-import { u as typesAgree } from "./deferred-index-build-Cis_HoGn.js";
-import { a as isLockTimeout, c as resolveBootLockOptions, l as sleep, n as BOOT_LOCK_TIMEOUT_MS } from "./boot-ddl-s_3Hkz94.js";
-import { a as readSchemaFactsFor, r as planCollectionSchemaEnsure } from "./ensure-collection-tables-DvvImXDe.js";
-import { t as DatabasePoolManager } from "./databasePoolManager-Yqdw14wY.js";
-import { a as resolveAuthSchema, i as probeAuthSchema, r as assertAuthSchemaCompatible, t as ensureAuthTablesExist } from "./ensure-tables-Dpgwx5sy.js";
-import { _ as humanize, g as mapPgType, i as buildTablesMap, l as getIconForTable, p as singularize, r as buildEnumMap, u as identifyJoinTables } from "./introspect-db-logic-CI5CU_n0.js";
+import { i as createPostgresDatabaseConnection } from "./connection-czvI7TZL.js";
+import { _ as visibleColumnProjection, a as buildSearchColumnSpec, r as SEARCH_UNACCENT_FN, s as hiddenColumnsOption } from "./search-column-BM-GV6vH.js";
+import { a as diagnoseDbError, c as isEconnrefused, n as closedDatabaseName, nt as extractCauseMessage, r as deepestErrorMessage, u as parseHostInfo } from "./cli-errors-DiA0XFIS.js";
+import { a as pgErrorToFriendlyMessage, i as isRowLevelSecurityDenial, n as extractPgError, o as reachedDatabase, r as isRoleSwitchingPermissionError, s as sanitizeErrorForClient, t as classifyConnectFailure } from "./pg-error-utils-CFEnm2m9.js";
+import { t as BranchService } from "./BranchService-ClklxyAQ.js";
+import { a as ensureAppRoleGrants, d as warnOnLegacyRlsFunctions, f as warnOnRoleSchemaCollision, i as ensureAppRole, l as validatePolicyPgRoles, n as applyAuthContext, r as detectConnectionPosture, s as revokeUserRoleSql, t as REBASE_USER_ROLE$1, u as warnOnAnonymousGrants } from "./rls-enforcement-DDyNoOSy.js";
+import { u as resolveColumnName } from "./column-plan-helpers-IG6uFb1s.js";
+import { n as planSchema } from "./plan-schema-Czf3q4-Q.js";
+import { t as generateSchema } from "./generate-drizzle-schema-logic-CPzCRD-8.js";
+import { r as renderPgType } from "./render-ddl-4v88y-Gv.js";
+import { u as typesAgree } from "./deferred-index-build-BE0I6sYU.js";
+import { a as isLockTimeout, c as resolveBootLockOptions, l as sleep, n as BOOT_LOCK_TIMEOUT_MS } from "./boot-ddl-DYH95Qeg.js";
+import { a as readSchemaFactsFor, r as planCollectionSchemaEnsure } from "./ensure-collection-tables-Cet4650m.js";
+import { t as DatabasePoolManager } from "./databasePoolManager-3stMNFL-.js";
+import { a as resolveAuthSchema, i as probeAuthSchema, r as assertAuthSchemaCompatible, t as ensureAuthTablesExist } from "./ensure-tables-l_OgFQjN.js";
+import { a as buildBaasSchema, c as introspectSchema, i as warnOnGeneratedSchemaDrift, l as readRlsStatus, n as diffGeneratedSchemaAgainstCatalogue, o as readCatalogueSchema, s as buildCollectionsFromSchema } from "./generated-schema-diff-eZCklRZQ.js";
 import { Client, DatabaseError, Pool } from "pg";
 import { drizzle } from "drizzle-orm/node-postgres";
 import { ApiError, assertQueryFieldsReadable, createDdlBootstrapper, createEmailService, logger, rawQueryLoggingEnabled, resolveBatchRefs, rowETag, splitFieldOps } from "@rebasepro/server";
 import { and, asc, count, desc, eq, getTableColumns, getTableName, gt, ilike, inArray, is, isNotNull, isNull, isTable, lt, lte, not, notInArray, or, relations, sql } from "drizzle-orm";
-import { PgArray, PgNumeric, PgTable, PgTimestamp, PgTimestampString, PgTransaction, bigint, boolean, char, cidr, customType, date, doublePrecision, geometry, getTableConfig, index, inet, integer, interval, json, jsonb, line, macaddr, macaddr8, numeric, pgSchema, pgTable, point, primaryKey, real, smallint, text, time, timestamp, unique, uuid, varchar, vector } from "drizzle-orm/pg-core";
+import { PgArray, PgNumeric, PgTable, PgTimestamp, PgTimestampString, PgTransaction, bigint, boolean, getTableConfig, index, integer, jsonb, pgSchema, pgTable, text, timestamp, unique, uuid } from "drizzle-orm/pg-core";
 import { ALL_WHERE_FILTER_OPS, ANONYMOUS_USER_ID, DEFAULT_COMMIT_PATHS, DEFAULT_DATA_SOURCE_KEY, INCLUDE_COUNT_KEY, JUNCTION_PIVOT_KEY, ListLimitError, MAX_INCLUDE_DEPTH, Vector, encodeRelationAggregateSort, hasForeignKeyOnTarget, isChannelBusInstance, isChannelBusInstance as isChannelBusInstance$1, isManyToMany, isRelationalCollectionConfig, isSQLAdmin, parseEnvBoolean, parseRelationAggregateSort, resolveClientListLimit, resourceEnvSuffix, resourceKeyOf } from "@rebasepro/types";
-import { COMPOSITE_ID_SEPARATOR, COMPOSITE_ID_SEPARATOR as COMPOSITE_ID_SEPARATOR$1, CollectionRegistry, DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE, OrderBySpecError, REBASE_USER_ROLE, UnknownFilterOperatorError, apiHiddenFieldNames, applyDefaultValuesOnCreate, buildCompositeId, buildCompositeId as buildCompositeId$1, buildPropertyCallbacks, buildSdkData, callbackRefusal, canReadField, classifyTable, createAccessorSlugResolver, createRelationRef, createRelationRefWithData, deserializeFilter, detectJunctionTables, encodeCursor, fieldKeyForColumn, findRelation, firstSqlRow, getColumnName, getDeclaredPrimaryKeys, getJunctionCollectionConfig, getJunctionConfigForRelation, getTableName as getTableName$1, getTenantConfig, hasFieldAccessRules, includableRelationNames, isAddressableId, normalizeDriverOrderBy, normalizeEmail, normalizeInclude, normalizeToEntityRelation, parseIdValues, parseIdValues as parseIdValues$1, parseOrderBySpecStrict, queryableFieldNames, requireCallbackClient, requireCallbackCollection, resolveCollectionRelations, resolveJunctionSpecs, resolveTenantWrite, restoresSoftDeletedRow, revokeInternalTableSql, softDeleteFieldOf, sqlRows, tenantBypassRoles, toCallbackError, toFilterTuples, unknownAggregateField, unknownFilterField, unknownIncludeRelation, unknownOrderByField, unknownProjectionField, unknownRelationTargetField, unknownVectorProperty, updateDateAutoValues, updateUserAutoValues, withRelationReferencesOnly } from "@rebasepro/common";
-import { camelCase, firstFreeKey, generateForeignKeyName, isPrototypePollutingKey, legacyForeignKeyName, splitSearchTerms, toSnakeCase, toWireKey, unref } from "@rebasepro/utils";
+import { COMPOSITE_ID_SEPARATOR, COMPOSITE_ID_SEPARATOR as COMPOSITE_ID_SEPARATOR$1, CollectionRegistry, DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE, OrderBySpecError, REBASE_USER_ROLE, UnknownFilterOperatorError, apiHiddenFieldNames, applyDefaultValuesOnCreate, buildCompositeId, buildCompositeId as buildCompositeId$1, buildPropertyCallbacks, buildSdkData, callbackRefusal, canReadField, classifyTable, createAccessorSlugResolver, createRelationRef, createRelationRefWithData, deserializeFilter, detectJunctionTables, encodeCursor, fieldKeyForColumn, findRelation, firstSqlRow, getColumnName, getDeclaredPrimaryKeys, getJunctionConfigForRelation, getTableName as getTableName$1, getTenantConfig, hasFieldAccessRules, includableRelationNames, isAddressableId, normalizeDriverOrderBy, normalizeEmail, normalizeInclude, normalizeToEntityRelation, parseIdValues, parseIdValues as parseIdValues$1, parseOrderBySpecStrict, queryableFieldNames, requireCallbackClient, requireCallbackCollection, resolveCollectionRelations, resolveTenantWrite, restoresSoftDeletedRow, revokeInternalTableSql, softDeleteFieldOf, sqlRows, tenantBypassRoles, toCallbackError, toFilterTuples, unknownAggregateField, unknownFilterField, unknownIncludeRelation, unknownOrderByField, unknownProjectionField, unknownRelationTargetField, unknownVectorProperty, updateDateAutoValues, updateUserAutoValues, withRelationReferencesOnly } from "@rebasepro/common";
+import { camelCase, generateForeignKeyName, isPrototypePollutingKey, legacyForeignKeyName, splitSearchTerms, toSnakeCase, toWireKey, unref } from "@rebasepro/utils";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { WebSocket } from "ws";
 import { EventEmitter } from "events";
@@ -8900,6 +8899,15 @@ var DEFAULT_RECONNECT_DELAY_MS = 3e3;
 /** Guards the identifier interpolated into `LISTEN`. */
 var SAFE_CHANNEL = /^[A-Za-z_][A-Za-z0-9_]*$/;
 /**
+* Why a connect failed, in one line: the message, and the SQLSTATE or socket
+* code when the message does not already carry it.
+*/
+function connectFailureReason(err) {
+	const message = err instanceof Error ? err.message : String(err);
+	const code = err instanceof Error && "code" in err && typeof err.code === "string" ? err.code : void 0;
+	return code && !message.includes(code) ? `${message} [${code}]` : message;
+}
+/**
 * A half-open connection — one whose packets stop arriving, with no FIN and no
 * RST, which is what an idle-flow timeout on a load balancer, a NAT, a dead
 * middlebox or a failed-over network looks like — fires no `error` and no
@@ -8923,6 +8931,8 @@ var PgNotifyListener = class {
 	heartbeatInFlight = false;
 	downSince;
 	lastHeartbeatAt;
+	/** Whether this outage's "could not be opened" has been said. Cleared once it listens again. */
+	outageWarned = false;
 	constructor(options) {
 		this.options = options;
 		if (!SAFE_CHANNEL.test(options.channel)) throw new Error(`Unsafe NOTIFY channel name "${options.channel}" — expected a plain SQL identifier.`);
@@ -9014,6 +9024,7 @@ var PgNotifyListener = class {
 			this.client = client;
 			pending = void 0;
 			this.downSince = void 0;
+			this.outageWarned = false;
 			this.lastHeartbeatAt = Date.now();
 			this.startHeartbeat(client);
 			logger.debug(`📡 ${logLabel} Listening on channel "${channel}".`);
@@ -9022,7 +9033,12 @@ var PgNotifyListener = class {
 				await pending.end();
 			} catch {}
 			if (first && !this.options.retryInitialConnect) throw err;
-			logger.error(`❌ ${logLabel} Failed to connect LISTEN client`, { error: err });
+			const retry = `${logLabel} LISTEN connection could not be opened (${connectFailureReason(err)}); retrying every ${Math.round((this.options.reconnectDelayMs ?? DEFAULT_RECONNECT_DELAY_MS) / 1e3)} s.`;
+			if (this.outageWarned) logger.debug(retry);
+			else {
+				this.outageWarned = true;
+				logger.warn(`⚠️ ${retry}`);
+			}
 			this.scheduleReconnect();
 			return;
 		}
@@ -18758,991 +18774,6 @@ function patchPgNumericToNumber(tables) {
 	if (patchedCount > 0) logger.debug(`[PgNumeric] ${patchedCount} numeric column(s) will be served as numbers`);
 }
 //#endregion
-//#region src/schema/introspect-runtime.ts
-/**
-* Read the RLS posture of each table in a schema.
-*
-* This is what decides whether baas mode may serve a table. A table with RLS
-* disabled has no authorization model: since every authenticated request runs
-* as `rebase_user`, and that role is granted DML on the schema, serving such a
-* table hands every row to every logged-in user.
-*/
-async function readRlsStatus(client, pgSchema) {
-	const { rows } = await client.query(`SELECT c.relname AS table,
-                c.relrowsecurity AS rls_enabled,
-                (SELECT count(*) FROM pg_policy p WHERE p.polrelid = c.oid) AS policy_count
-         FROM pg_class c
-         JOIN pg_namespace n ON n.oid = c.relnamespace
-         WHERE n.nspname = $1 AND c.relkind = 'r'`, [pgSchema]);
-	return new Map(rows.map((r) => [r.table, {
-		table: r.table,
-		rlsEnabled: r.rls_enabled === true,
-		policyCount: Number(r.policy_count ?? 0)
-	}]));
-}
-/**
-* Read tables, columns, enums, primary keys and foreign keys for a schema.
-* Mirrors the queries in introspect-db.ts.
-*/
-async function introspectSchema(client, pgSchema) {
-	const { rows: tables } = await client.query(`SELECT table_name
-         FROM information_schema.tables
-         WHERE table_schema = $1 AND table_type = 'BASE TABLE'
-           AND table_name NOT LIKE 'drizzle_%'
-           AND table_name NOT LIKE 'rebase_%'
-         ORDER BY table_name`, [pgSchema]);
-	const { rows: columns } = await client.query(`SELECT
-            c.table_name,
-            c.column_name,
-            c.data_type,
-            c.udt_name,
-            c.is_nullable,
-            c.column_default,
-            -- A stored generated column must be declared as one, or drizzle
-            -- writes DEFAULT into it on every INSERT. Postgres tolerates that
-            -- today; the generated module has always declared them properly,
-            -- and the runtime tables are built to match it.
-            c.is_generated,
-            c.generation_expression,
-            (SELECT a.atttypmod FROM pg_attribute a
-             JOIN pg_class pc ON a.attrelid = pc.oid
-             WHERE pc.relname = c.table_name
-               AND a.attname = c.column_name
-               AND pc.relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = c.table_schema)) as atttypmod
-         FROM information_schema.columns c
-         WHERE c.table_schema = $1`, [pgSchema]);
-	const { rows: enumValues } = await client.query(`SELECT t.typname AS enum_name,
-                e.enumlabel AS enum_value,
-                e.enumsortorder AS sort_order
-         FROM pg_type t
-         JOIN pg_enum e ON t.oid = e.enumtypid
-         JOIN pg_namespace n ON t.typnamespace = n.oid
-         WHERE n.nspname = $1
-         ORDER BY t.typname, e.enumsortorder`, [pgSchema]);
-	const { rows: pks } = await client.query(`SELECT t.relname as table_name, a.attname as column_name
-         FROM   pg_index i
-         JOIN   pg_attribute a ON a.attrelid = i.indrelid
-                             AND a.attnum = ANY(i.indkey)
-         JOIN   pg_class t ON t.oid = i.indrelid
-         JOIN   pg_namespace n ON n.oid = t.relnamespace
-         WHERE  i.indisprimary AND n.nspname = $1`, [pgSchema]);
-	const { rows: fks } = await client.query(`SELECT
-            tc.table_name,
-            kcu.column_name,
-            ccu.table_name AS foreign_table_name,
-            ccu.column_name AS foreign_column_name
-         FROM information_schema.table_constraints AS tc
-         JOIN information_schema.key_column_usage AS kcu
-           ON tc.constraint_name = kcu.constraint_name
-           AND tc.table_schema = kcu.table_schema
-         JOIN information_schema.constraint_column_usage AS ccu
-           ON ccu.constraint_name = tc.constraint_name
-           AND ccu.table_schema = tc.table_schema
-         WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_schema = $1`, [pgSchema]);
-	const tablesMap = buildTablesMap(tables, columns, pks, fks);
-	return {
-		tablesMap,
-		enumMap: buildEnumMap(enumValues),
-		joinTables: identifyJoinTables(tablesMap)
-	};
-}
-/** Derive the `isId` flavour for a primary-key column. */
-function idKindFor(col, propType) {
-	if (col.data_type.toLowerCase() === "uuid") return "uuid";
-	if (propType === "number") return "increment";
-	return true;
-}
-function buildProperties(meta, enumMap) {
-	const properties = {};
-	const takenKeys = /* @__PURE__ */ new Set();
-	for (const col of meta.columns) {
-		const isPk = meta.pks.includes(col.column_name);
-		if (meta.fks.some((fk) => fk.column_name === col.column_name) && !isPk) continue;
-		const enumValues = enumMap.get(col.udt_name);
-		const isEnum = col.data_type === "USER-DEFINED" && enumValues !== void 0;
-		const isVector = col.udt_name === "vector";
-		const propType = isEnum ? "string" : isVector ? "vector" : mapPgType(col.data_type);
-		const property = {
-			name: humanize(col.column_name),
-			columnName: col.column_name,
-			type: propType
-		};
-		const key = firstFreeKey([toWireKey(col.column_name), col.column_name], takenKeys);
-		takenKeys.add(key);
-		if (isPk) property.isId = idKindFor(col, propType);
-		else if (col.is_nullable === "NO" && col.column_default === null) property.validation = { required: true };
-		if (isEnum && enumValues) property.enum = enumValues.map((value) => ({
-			id: value,
-			label: humanize(value)
-		}));
-		properties[key] = property;
-	}
-	return properties;
-}
-/**
-* Owning relations, derived from this table's foreign keys — the same shape
-* `generateCollectionFile` writes into a collection file: a `relation` property
-* whose nested descriptor carries `kind`, a `target` thunk and the `localKey`.
-*
-* The shape is load-bearing, not cosmetic. `resolveCollectionRelations` reads
-* relations from `property.relation` and `resolveRelation` requires `target` to
-* be a thunk; this used to emit `target`/`cardinality`/`localKey` flat on the
-* property with the slug as a bare string, which satisfies neither. Nothing
-* threw — the resolver simply skipped every such property and reported that the
-* collection had no relations. So an introspected BaaS collection had its FK
-* columns removed from `properties` (they "surface as relations") and then no
-* resolvable relation to surface as, which is why writing the FK column
-* directly came back as `has no field 'product_id'`: `assertKnownWriteFields`
-* learns that column from the resolved relation's `localKey`.
-*
-* The thunk closes over the collections being built in this same pass rather
-* than importing a module, which is what a runtime introspection has instead of
-* generated files. It is called lazily, after the map is fully populated, so a
-* table may reference one introspected later.
-*/
-function buildRelations(meta, slugByTable, collectionBySlug) {
-	const relations = {};
-	for (const fk of meta.fks) {
-		const targetSlug = slugByTable.get(fk.foreign_table_name);
-		if (!targetSlug) continue;
-		let key = toWireKey(fk.column_name.replace(/_id$/, ""));
-		if (meta.pks.includes(fk.column_name) && key === fk.column_name) key = fk.foreign_table_name;
-		relations[key] = {
-			name: humanize(key),
-			type: "relation",
-			relation: {
-				kind: "belongsTo",
-				target: () => collectionBySlug.get(targetSlug),
-				localKey: fk.column_name
-			}
-		};
-	}
-	return relations;
-}
-/**
-* Turn an introspected schema into collections.
-*
-* Join tables are skipped: they carry no identity of their own and exist to
-* express a many-to-many edge between two other tables.
-*/
-function buildCollectionsFromSchema({ tablesMap, enumMap, joinTables }, pgSchema) {
-	const slugByTable = /* @__PURE__ */ new Map();
-	for (const tableName of tablesMap.keys()) if (!joinTables.has(tableName)) slugByTable.set(tableName, tableName);
-	const collections = [];
-	const collectionBySlug = /* @__PURE__ */ new Map();
-	for (const [tableName, meta] of tablesMap) {
-		if (joinTables.has(tableName)) continue;
-		const collectionName = humanize(tableName);
-		const collection = {
-			name: collectionName,
-			singularName: singularize(collectionName),
-			slug: tableName,
-			table: tableName,
-			schema: pgSchema,
-			icon: getIconForTable(tableName),
-			properties: {
-				...buildProperties(meta, enumMap),
-				...buildRelations(meta, slugByTable, collectionBySlug)
-			}
-		};
-		collections.push(collection);
-		collectionBySlug.set(tableName, collection);
-	}
-	return collections;
-}
-//#endregion
-//#region src/schema/dynamic-tables.ts
-/**
-* Build drizzle tables at runtime from an introspected schema.
-*
-* **Every** data source's tables are built here, from `information_schema`,
-* after boot-ensure has run — a project with declared collections included. The
-* committed `schema.generated.ts` is a build artefact for Atlas, `db push`,
-* `eject` and user code; the runtime does not read it for its tables, because a
-* file that is one commit behind the database used to change what the server
-* served (a renamed foreign-key column 500'd every request, a lost relation
-* silently emptied a list). See `catalogue-schema.ts` for the caller.
-*
-* These are handed to drizzle as its schema, which keeps the relational query
-* path (`db.query.*`) working; without them FetchService would fall back to
-* plain selects and lose relation loading.
-*
-* Two things a caller has to supply for the tables to match what the generated
-* module used to produce, both about *names*: the Drizzle object is keyed by the
-* wire name of a column and not by the column (`authorId`, not `author_id`), and
-* a relation is keyed by the collection's own relation key rather than by a
-* guess made from the foreign key. Both come from the collections — see
-* `columnKeysFromCollections` and `buildDrizzleRelationsFromCollections`.
-*/
-var columnNameAsKey = (_table, column) => column;
-/** drizzle ships no bytea builder; binary must round-trip as a Buffer. */
-var bytea = customType({ dataType: () => "bytea" });
-/**
-* A full-text search column, declared with its real SQL type.
-*
-* Not cosmetic: `isSearchIndexColumn` asks the column for its type and drops
-* every `tsvector` from the projection, so a search column that fell through to
-* `text` (the old default for an unrecognised type) would be selected, returned
-* to callers, and rendered in the admin as a wall of lexemes. drizzle ships no
-* builder for these two.
-*/
-var tsvector = customType({ dataType: () => "tsvector" });
-var tsquery = customType({ dataType: () => "tsquery" });
-/**
-* Postgres stores a column's type modifier (varchar length, vector dimensions)
-* in `atttypmod`. For length-carrying string types it is length + VARHDRSZ(4);
-* for pgvector it is the dimension count as-is. -1 means unspecified.
-*/
-function varlenLength(col) {
-	return col.atttypmod && col.atttypmod > 4 ? col.atttypmod - 4 : void 0;
-}
-/**
-* Map a Postgres type to a drizzle column builder, keyed on `udt_name` — the
-* concrete underlying type, which is exact where `data_type` reports umbrella
-* values like "ARRAY" or "USER-DEFINED".
-*
-* Unknown types fall back to `text`: the driver still reads and writes them,
-* with the value passing through as a string, which beats dropping the column.
-*/
-function scalarBuilder(udtName, name, col) {
-	switch (udtName) {
-		case "uuid": return uuid(name);
-		case "bool": return boolean(name);
-		case "int2": return smallint(name);
-		case "int4": return integer(name);
-		case "int8": return bigint(name, { mode: "number" });
-		case "float4": return real(name);
-		case "float8": return doublePrecision(name);
-		case "numeric":
-		case "money": return numeric(name);
-		case "json": return json(name);
-		case "jsonb": return jsonb(name);
-		case "date": return date(name);
-		case "time": return time(name);
-		case "timetz": return time(name, { withTimezone: true });
-		case "timestamp": return timestamp(name, { mode: "string" });
-		case "timestamptz": return timestamp(name, {
-			withTimezone: true,
-			mode: "string"
-		});
-		case "interval": return interval(name);
-		case "bytea": return bytea(name);
-		case "inet": return inet(name);
-		case "cidr": return cidr(name);
-		case "macaddr": return macaddr(name);
-		case "macaddr8": return macaddr8(name);
-		case "point": return point(name);
-		case "line": return line(name);
-		case "geometry": return geometry(name);
-		case "vector": {
-			const dimensions = col.atttypmod && col.atttypmod > 0 ? col.atttypmod : void 0;
-			return dimensions ? vector(name, { dimensions }) : text(name);
-		}
-		case "bpchar": {
-			const length = varlenLength(col);
-			return length ? char(name, { length }) : char(name);
-		}
-		case "varchar": {
-			const length = varlenLength(col);
-			return length ? varchar(name, { length }) : text(name);
-		}
-		case "tsvector": return tsvector(name);
-		case "tsquery": return tsquery(name);
-		default: return text(name);
-	}
-}
-/** See {@link FluentColumnBuilder}. */
-var fluent = (builder) => builder;
-function columnBuilderFor(col) {
-	if (col.udt_name.startsWith("_")) return fluent(scalarBuilder(col.udt_name.slice(1), col.column_name, col)).array();
-	return scalarBuilder(col.udt_name, col.column_name, col);
-}
-/**
-* Build one drizzle table per introspected table, keyed by table name.
-*
-* @param columnKey how a column is named on the wire — see {@link ColumnKeyResolver}.
-*/
-function buildDrizzleTablesFromSchema(tablesMap, pgSchemaName = "public", columnKey = columnNameAsKey) {
-	const schema = pgSchemaName === "public" ? null : pgSchema(pgSchemaName);
-	const createTable = schema ? schema.table.bind(schema) : pgTable;
-	const tables = {};
-	for (const [tableName, meta] of tablesMap) {
-		const columns = {};
-		const keyOf = /* @__PURE__ */ new Map();
-		for (const col of meta.columns) {
-			let builder = columnBuilderFor(col);
-			if (col.is_nullable === "NO") builder = fluent(builder).notNull();
-			if (meta.pks.length === 1 && meta.pks[0] === col.column_name) builder = fluent(builder).primaryKey();
-			if (col.is_generated === "ALWAYS") builder = fluent(builder).generatedAlwaysAs(sql.raw(col.generation_expression ?? ""));
-			const key = columnKey(tableName, col.column_name);
-			keyOf.set(col.column_name, key);
-			columns[key] = builder;
-		}
-		tables[tableName] = createTable(tableName, columns, meta.pks.length > 1 ? (t) => [primaryKey({ columns: meta.pks.map((pk) => t[keyOf.get(pk) ?? pk]) })] : void 0);
-	}
-	return tables;
-}
-/**
-* Build drizzle `relations()` for the foreign keys, so the relational query
-* path can actually load them.
-*
-* FetchService asks drizzle for `with: { <key>: true }`, keyed by the relation
-* property on the collection. Tables alone don't satisfy that — without these,
-* `?include=author` silently returns the raw `author_id` and no author.
-*
-* The keys here must match `buildRelations` in introspect-runtime.ts, which is
-* what names the collection's relation properties.
-*/
-function buildDrizzleRelationsFromSchema(tablesMap, tables, columnKey = columnNameAsKey) {
-	/** Owning side, per table: the `one()` relations from its foreign keys. */
-	const owning = /* @__PURE__ */ new Map();
-	/** Inverse side, per referenced table: the matching `many()` back-references. */
-	const inverse = /* @__PURE__ */ new Map();
-	for (const [tableName, meta] of tablesMap) {
-		if (!tables[tableName]) continue;
-		const columnNames = new Set(meta.columns.map((c) => columnKey(tableName, c.column_name)));
-		for (const fk of meta.fks) {
-			if (!tables[fk.foreign_table_name]) continue;
-			let key = toWireKey(fk.column_name.replace(/_id$/, ""));
-			if (meta.pks.includes(fk.column_name) && key === fk.column_name) key = fk.foreign_table_name;
-			if (columnNames.has(key)) continue;
-			const relationName = `${tableName}_${fk.column_name}`;
-			owning.set(tableName, [...owning.get(tableName) ?? [], {
-				key,
-				targetTable: fk.foreign_table_name,
-				fkColumn: columnKey(tableName, fk.column_name),
-				targetColumn: columnKey(fk.foreign_table_name, fk.foreign_column_name),
-				relationName
-			}]);
-			const backKey = tableName;
-			if (new Set((tablesMap.get(fk.foreign_table_name)?.columns ?? []).map((c) => columnKey(fk.foreign_table_name, c.column_name))).has(backKey)) continue;
-			inverse.set(fk.foreign_table_name, [...inverse.get(fk.foreign_table_name) ?? [], {
-				key: backKey,
-				sourceTable: tableName,
-				relationName
-			}]);
-		}
-	}
-	const built = {};
-	for (const tableName of tablesMap.keys()) {
-		const table = tables[tableName];
-		const ones = owning.get(tableName) ?? [];
-		const manys = inverse.get(tableName) ?? [];
-		if (!table || ones.length === 0 && manys.length === 0) continue;
-		built[`${tableName}Relations`] = relations(table, ({ one, many }) => {
-			const map = {};
-			for (const rel of ones) map[rel.key] = one(tables[rel.targetTable], {
-				fields: [getTableColumns(table)[rel.fkColumn]],
-				references: [getTableColumns(tables[rel.targetTable])[rel.targetColumn]],
-				relationName: rel.relationName
-			});
-			for (const rel of manys) {
-				if (map[rel.key]) continue;
-				map[rel.key] = many(tables[rel.sourceTable], { relationName: rel.relationName });
-			}
-			return map;
-		});
-	}
-	return built;
-}
-//#endregion
-//#region src/schema/config-relations.ts
-/**
-* Build drizzle `relations()` for declared collections, from the collections.
-*
-* The heuristic builder in `dynamic-tables.ts` names a relation after the
-* foreign-key column (`author_id` → `author`), which is the only evidence a
-* database offers and is right for BaaS mode. It is wrong for a project that
-* declares its collections: there the relation's name is whatever the author
-* called it, `include=writer` addresses that name, and a relation whose key was
-* guessed from the column simply does not answer to it — the read returns the
-* bare foreign key and no target, silently, which is how a demo lost every
-* relation in its list view while the detail view (a different code path) kept
-* working.
-*
-* So when there are collections, they are the authority for *which* relations
-* exist and what they are called; the live catalogue is the authority for the
-* columns underneath. This is the same pairing `generate-drizzle-schema-logic`
-* emits into `schema.generated.ts` — kind for kind, key for key, and paired by
-* the same {@link sharedRelationName} — only built against tables read back from
-* `information_schema` rather than against a file.
-*/
-/** A collection's table, with any schema prefix stripped — as the DDL creates it. */
-function bareTableName(name) {
-	return name.includes(".") ? name.split(".").pop() : name;
-}
-/**
-* The field key a collection's rows are addressed by, as the generated module
-* spells it: the property marked `isId`, else `id`.
-*
-* Deliberately the config's answer rather than the catalogue's primary key —
-* `references: [users.id]` in the generated file is keyed the same way, and the
-* two have to name the same Drizzle key for a relation to compile at all.
-*/
-function primaryKeyFieldKey(collection) {
-	for (const [key, prop] of Object.entries(collection.properties ?? {})) if (prop && typeof prop === "object" && "isId" in prop && Boolean(prop.isId)) return key;
-	return "id";
-}
-/**
-* The field key on the source table that a `hasOne`/`hasMany` foreign key
-* holds: its `sourceKey` when the link names one, else the primary key.
-*/
-function sourceKeyFieldKey(relation, collection) {
-	return relation.sourceKey ? fieldKeyForColumn(collection, relation.sourceKey) : primaryKeyFieldKey(collection);
-}
-/**
-* A column of a built table, by its Drizzle key or by its column name.
-*
-* The key is the answer in the ordinary case, and the name is the fallback for
-* the one place a caller holds a column and not a field: a junction table's two
-* foreign keys, which are keyed by column *unless* the project also declares a
-* collection over that table, in which case they are keyed by its property
-* names. Looking both up costs a scan of one table and removes the difference.
-*/
-function columnOf(table, key) {
-	if (!table) return void 0;
-	const direct = getTableColumns(table)[key];
-	if (direct) return direct;
-	for (const column of Object.values(getTableColumns(table))) if (column?.name === key) return column;
-}
-/**
-* Drizzle relations for every declared collection, keyed `<table>Relations`.
-*
-* @param collections every collection backed by a table in `tables`
-* @param tables      catalogue-built tables, keyed by bare table name
-*/
-function buildDrizzleRelationsFromCollections(collections, tables) {
-	const ones = /* @__PURE__ */ new Map();
-	const manys = /* @__PURE__ */ new Map();
-	/** `<relationName>::<kind>` already emitted on a table — the generator dedupes the same way. */
-	const emitted = /* @__PURE__ */ new Map();
-	const claim = (table, name, kind) => {
-		const seen = emitted.get(table) ?? /* @__PURE__ */ new Set();
-		emitted.set(table, seen);
-		const key = `${name}::${kind}`;
-		if (seen.has(key)) return false;
-		seen.add(key);
-		return true;
-	};
-	const addOne = (table, spec) => ones.set(table, [...ones.get(table) ?? [], spec]);
-	const addMany = (table, spec) => manys.set(table, [...manys.get(table) ?? [], spec]);
-	const byTable = /* @__PURE__ */ new Map();
-	for (const collection of collections) {
-		const table = bareTableName(getTableName$1(collection));
-		if (table && tables[table]) byTable.set(table, collection);
-	}
-	for (const [tableName, collection] of byTable) {
-		const table = tables[tableName];
-		for (const [relationKey, relation] of Object.entries(resolveCollectionRelations(collection))) {
-			let target;
-			try {
-				target = relation.target();
-			} catch (err) {
-				logger.debug(`[schema] Relation ${collection.slug}.${relationKey} has no resolvable target`, { error: err });
-				continue;
-			}
-			const targetTable = tables[bareTableName(getTableName$1(target))];
-			const name = sharedRelationName(relation, collection);
-			switch (relation.kind) {
-				case "belongsTo": {
-					if (!targetTable) continue;
-					if (!claim(tableName, name, relation.kind)) continue;
-					const localKey = fieldKeyForColumn(collection, relation.localKey);
-					const referenced = primaryKeyFieldKey(target);
-					const field = columnOf(table, localKey);
-					const reference = columnOf(targetTable, referenced);
-					if (!field || !reference) continue;
-					addOne(tableName, {
-						key: relationKey,
-						target: targetTable,
-						fields: [field],
-						references: [reference],
-						relationName: name
-					});
-					break;
-				}
-				case "hasOne": {
-					if (!targetTable) continue;
-					if (!claim(tableName, name, relation.kind)) continue;
-					const field = columnOf(table, sourceKeyFieldKey(relation, collection));
-					const reference = columnOf(targetTable, fieldKeyForColumn(target, relation.foreignKeyOnTarget));
-					if (!field || !reference) continue;
-					addOne(tableName, {
-						key: relationKey,
-						target: targetTable,
-						fields: [field],
-						references: [reference],
-						relationName: name
-					});
-					break;
-				}
-				case "hasMany":
-					if (!targetTable) continue;
-					if (!claim(tableName, name, relation.kind)) continue;
-					addMany(tableName, {
-						key: relationKey,
-						target: targetTable,
-						relationName: name
-					});
-					break;
-				case "manyToMany": {
-					const junctionName = bareTableName(relation.through.table);
-					const junction = tables[junctionName];
-					if (!junction) continue;
-					if (!claim(tableName, name, relation.kind)) continue;
-					addMany(tableName, {
-						key: relationKey,
-						target: junction,
-						relationName: name
-					});
-					addJunctionSides(relation, collection, target, junctionName, tables, addOne, claim);
-					break;
-				}
-				case "via": break;
-			}
-		}
-	}
-	for (const [tableName, collection] of byTable) {
-		const table = tables[tableName];
-		for (const [, relation] of Object.entries(resolveCollectionRelations(collection))) {
-			if (relation.kind !== "hasMany" && relation.kind !== "hasOne") continue;
-			let target;
-			try {
-				target = relation.target();
-			} catch {
-				continue;
-			}
-			const targetTableName = bareTableName(getTableName$1(target));
-			const targetTable = tables[targetTableName];
-			if (!targetTable) continue;
-			const name = sharedRelationName(relation, collection);
-			if (!claim(targetTableName, name, "belongsTo")) continue;
-			const fkKey = fieldKeyForColumn(target, relation.foreignKeyOnTarget);
-			const field = columnOf(targetTable, fkKey);
-			const reference = columnOf(table, sourceKeyFieldKey(relation, collection));
-			if (!field || !reference) continue;
-			addOne(targetTableName, {
-				key: `_synth_${targetTableName}_${fkKey}`,
-				target: tables[tableName],
-				fields: [field],
-				references: [reference],
-				relationName: name
-			});
-		}
-	}
-	const built = {};
-	for (const tableName of /* @__PURE__ */ new Set([...ones.keys(), ...manys.keys()])) {
-		const table = tables[tableName];
-		if (!table) continue;
-		const tableOnes = ones.get(tableName) ?? [];
-		const tableManys = manys.get(tableName) ?? [];
-		built[`${tableName}Relations`] = relations(table, ({ one, many }) => {
-			const map = {};
-			for (const spec of tableOnes) map[spec.key] = one(spec.target, {
-				fields: spec.fields,
-				references: spec.references,
-				relationName: spec.relationName
-			});
-			for (const spec of tableManys) {
-				if (map[spec.key]) continue;
-				map[spec.key] = many(spec.target, { relationName: spec.relationName });
-			}
-			return map;
-		});
-	}
-	return built;
-}
-/**
-* The junction table's own two `one()` sides.
-*
-* A many-to-many is a `many(junction)` on each endpoint, so the junction has to
-* carry the matching `one()` back to each — without them drizzle can join a
-* post to its `posts_tags` rows and no further, and the tags come back as
-* junction rows. Keyed by the junction's own columns, which is how the
-* generated file keys them too.
-*/
-function addJunctionSides(relation, sourceCollection, targetCollection, junctionName, tables, addOne, claim) {
-	const junction = tables[junctionName];
-	const sourceTable = tables[bareTableName(getTableName$1(sourceCollection))];
-	const targetTable = tables[bareTableName(getTableName$1(targetCollection))];
-	if (!junction || !sourceTable || !targetTable) return;
-	const sourceName = sharedRelationName(relation, sourceCollection);
-	const inverse = Object.values(resolveCollectionRelations(targetCollection)).find((r) => r.kind === "manyToMany" && bareTableName(r.through.table) === junctionName);
-	const targetName = inverse ? sharedRelationName(inverse, targetCollection) : `${junctionName}_${relation.through.targetColumn}`;
-	const pairs = [[
-		relation.through.sourceColumn,
-		sourceTable,
-		sourceName,
-		sourceCollection,
-		"source"
-	], [
-		relation.through.targetColumn,
-		targetTable,
-		targetName,
-		targetCollection,
-		"target"
-	]];
-	for (const [column, endpointTable, relationName, endpointCollection] of pairs) {
-		if (!claim(junctionName, relationName, "junction")) continue;
-		const field = columnOf(junction, column);
-		const reference = columnOf(endpointTable, primaryKeyFieldKey(endpointCollection));
-		if (!field || !reference) continue;
-		addOne(junctionName, {
-			key: column,
-			target: endpointTable,
-			fields: [field],
-			references: [reference],
-			relationName
-		});
-	}
-}
-//#endregion
-//#region src/schema/catalogue-schema.ts
-/** The Postgres schema a collection's table lives in. */
-function schemaOfCollection(collection, fallback) {
-	const declared = collection.schema;
-	return typeof declared === "string" && declared.length > 0 ? declared : fallback;
-}
-/**
-* How a column of each table is keyed in the Drizzle object.
-*
-* The wire name, which is the property key — `authorId`, never `author_id` —
-* because that is what every read and write path in this driver indexes tables
-* and rows by, and what the generated module has always emitted. Getting this
-* wrong does not throw: drizzle leaves an unknown key out of the statement and
-* the write reports success having stored nothing.
-*
-* Two exceptions, both columns no property declares:
-*
-*  - the generated search columns keep their raw names, because `search_vector`
-*    is how `searchColumnNames` excludes them from responses and how the
-*    condition builder finds the one to match against;
-*  - a table no collection claims (a junction) is keyed by its **key** columns'
-*    names, which is also what the generated file does for them — but a
-*    junction that declares `through.properties` keys those payload columns by
-*    their property key, for the same reason a collection does. `joinedAt` with
-*    `columnName: "joined_at"` has to be one name on both sides or a `_pivot`
-*    write is silently dropped by drizzle and the read serves a key the caller
-*    never declared.
-*/
-function columnKeysFromCollections(collections) {
-	const byTable = /* @__PURE__ */ new Map();
-	const rawColumns = /* @__PURE__ */ new Map();
-	for (const collection of collections) {
-		const table = bareTableName(getTableName$1(collection));
-		if (!table) continue;
-		byTable.set(table, collection);
-		rawColumns.set(table, new Set(searchColumnNames(collection)));
-	}
-	const junctionByTable = /* @__PURE__ */ new Map();
-	for (const spec of resolveJunctionSpecs(collections).values()) {
-		if (Object.keys(spec.properties).length === 0) continue;
-		junctionByTable.set(bareTableName(spec.table), getJunctionCollectionConfig(spec));
-	}
-	return (tableName, columnName) => {
-		const collection = byTable.get(tableName);
-		if (!collection) {
-			const junction = junctionByTable.get(tableName);
-			return junction ? fieldKeyForColumn(junction, columnName) : columnName;
-		}
-		if (rawColumns.get(tableName)?.has(columnName)) return columnName;
-		return fieldKeyForColumn(collection, columnName);
-	};
-}
-/**
-* Read the tables this data source serves out of `information_schema`.
-*
-* Restricted to the collections handed in, because the driver is given every
-* collection the project declares while each database holds only its own: an
-* unfiltered read had a second source (`database("analytics")`) reporting the
-* default's tables as its own. Junction tables come too — they back no
-* collection and a many-to-many is unreadable without them.
-*
-* Every schema the collections name is read, not just `public`. The users
-* collection lives in `rebase`, and a run restricted to `public` would leave the
-* registry with no table for it at all.
-*/
-async function readCatalogueSchema(options) {
-	const { client, collections, defaultSchema } = options;
-	/** schema → the tables wanted from it. */
-	const wanted = /* @__PURE__ */ new Map();
-	const want = (schema, table) => {
-		const set = wanted.get(schema) ?? /* @__PURE__ */ new Set();
-		wanted.set(schema, set);
-		set.add(table);
-	};
-	for (const collection of collections) {
-		const table = bareTableName(getTableName$1(collection));
-		if (table) want(schemaOfCollection(collection, defaultSchema), table);
-	}
-	for (const spec of resolveJunctionSpecs(collections).values()) want(spec.schema, bareTableName(spec.table));
-	const columnKey = columnKeysFromCollections(collections);
-	const tables = {};
-	const meta = /* @__PURE__ */ new Map();
-	const missing = [];
-	for (const [schema, names] of wanted) {
-		const live = await introspectSchema(client, schema);
-		const present = /* @__PURE__ */ new Map();
-		for (const name of names) {
-			const found = live.tablesMap.get(name);
-			if (!found) {
-				missing.push(schema === defaultSchema ? name : `${schema}.${name}`);
-				continue;
-			}
-			if (tables[name]) continue;
-			present.set(name, found);
-			meta.set(name, found);
-		}
-		Object.assign(tables, buildDrizzleTablesFromSchema(present, schema, columnKey));
-	}
-	return {
-		tables,
-		relations: buildDrizzleRelationsFromCollections(collections, tables),
-		meta,
-		missing
-	};
-}
-/**
-* The BaaS variant: no collections are declared, so every table in one schema is
-* served and both the collections and the relations are derived from the
-* foreign keys.
-*
-* Kept apart from {@link readCatalogueSchema} because the two answer different
-* questions. Here the database is the entire specification; there it supplies
-* the columns for a specification the project already wrote down.
-*/
-function buildBaasSchema(tablesMap, pgSchemaName, collections) {
-	const columnKey = columnKeysFromCollections(collections);
-	const tables = buildDrizzleTablesFromSchema(tablesMap, pgSchemaName, columnKey);
-	return {
-		tables,
-		relations: buildDrizzleRelationsFromSchema(tablesMap, tables, columnKey)
-	};
-}
-//#endregion
-//#region src/schema/generated-schema-diff.ts
-/**
-* Compare the committed `schema.generated.ts` against the live catalogue, and
-* say so — once per difference, at boot, as a warning and nothing more.
-*
-* The runtime stopped reading that file for its tables (see
-* `catalogue-schema.ts`), which removes an entire class of production failure
-* and creates a smaller one: a stale file is now *invisible*. It is still real —
-* it is what Atlas plans migrations from, what `db push` diffs, what `eject`
-* writes out and what user code imports — so a project whose file no longer
-* describes its database will hit it later, in a tool, with no clue that boot
-* already knew.
-*
-* Hence this: a guard rather than a doc. It never fails boot and never changes
-* what is served — the previous arrangement, where the file could do both,
-* is exactly what was removed.
-*
-* `generated-schema-staleness.ts` answers a narrower question (does the file
-* name every table the collections do) from the file's *source text*. This one
-* compares the loaded module against the database, column by column.
-*/
-/**
-* The families a boot warning is worth raising over.
-*
-* Deliberately coarse. `varchar(120)` and `text` are the same family because the
-* runtime treats them identically and a warning about the difference would fire
-* on every boot of a correct project — the widths still reach Postgres, which
-* enforces them. What this is looking for is the kind of drift that changes what
-* a value *is*: a number that became text, a timestamp that became a date, a
-* column that stopped existing.
-*/
-function typeFamily(sqlType) {
-	if (!sqlType) return "unknown";
-	let type = sqlType.trim().toLowerCase();
-	const isArray = type.endsWith("[]") || type.startsWith("_");
-	type = type.replace(/\[\]$/, "").replace(/^_/, "");
-	type = type.replace(/\s*\([^)]*\)\s*$/, "").trim();
-	const family = FAMILIES[type] ?? type;
-	return isArray ? `${family}[]` : family;
-}
-var FAMILIES = {
-	text: "text",
-	varchar: "text",
-	"character varying": "text",
-	bpchar: "text",
-	char: "text",
-	character: "text",
-	citext: "text",
-	name: "text",
-	int2: "integer",
-	smallint: "integer",
-	smallserial: "integer",
-	int4: "integer",
-	int: "integer",
-	integer: "integer",
-	serial: "integer",
-	int8: "bigint",
-	bigint: "bigint",
-	bigserial: "bigint",
-	float4: "float",
-	real: "float",
-	float8: "float",
-	"double precision": "float",
-	numeric: "numeric",
-	decimal: "numeric",
-	money: "numeric",
-	bool: "boolean",
-	boolean: "boolean",
-	uuid: "uuid",
-	json: "json",
-	jsonb: "jsonb",
-	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",
-	bytea: "bytea",
-	tsvector: "tsvector",
-	tsquery: "tsquery",
-	vector: "vector"
-};
-function catalogueColumns(meta) {
-	const columns = /* @__PURE__ */ new Map();
-	for (const col of meta.columns) columns.set(col.column_name, {
-		name: col.column_name,
-		family: typeFamily(col.udt_name || col.data_type),
-		notNull: col.is_nullable === "NO"
-	});
-	return columns;
-}
-/**
-* Every way the generated module and the database disagree, for the tables both
-* describe.
-*
-* One-directional in one respect only: a table the module has and the database
-* does not is reported (that is the stale-file case), while a table the database
-* has and the module does not is left alone — a database may hold anything, and
-* the collections-vs-file question is `generated-schema-staleness`'s.
-*/
-function diffGeneratedSchemaAgainstCatalogue(options) {
-	const { generated, catalogue, collections } = options;
-	if (!generated) return [];
-	const collectionByTable = /* @__PURE__ */ new Map();
-	for (const collection of collections) {
-		const table = getTableName$1(collection);
-		if (table) collectionByTable.set(bareTableName(table), collection);
-	}
-	const differences = [];
-	for (const value of Object.values(generated)) {
-		if (!isTable(value)) continue;
-		const table = getTableName(value);
-		const collection = collectionByTable.get(table);
-		const at = {
-			table,
-			collection: collection?.slug
-		};
-		const meta = catalogue.get(table);
-		if (!meta) {
-			if (collection) differences.push({
-				...at,
-				kind: "missing-table"
-			});
-			continue;
-		}
-		const live = catalogueColumns(meta);
-		const seen = /* @__PURE__ */ new Set();
-		const authOwned = isAuthCollection(collection) ? new Set(AUTH_USERS_COLUMNS.map((c) => c.column)) : void 0;
-		for (const [key, column] of Object.entries(getTableColumns(value))) {
-			const name = column.name ?? key;
-			seen.add(name);
-			const property = collection ? fieldKeyForColumn(collection, name) : key;
-			const generatedFamily = typeFamily(column.getSQLType?.());
-			const generatedNotNull = Boolean(column.notNull);
-			const found = live.get(name);
-			if (!found) {
-				differences.push({
-					...at,
-					kind: "missing-column",
-					column: name,
-					property,
-					generated: generatedFamily
-				});
-				continue;
-			}
-			if (found.family !== generatedFamily) differences.push({
-				...at,
-				kind: "type",
-				column: name,
-				property,
-				generated: generatedFamily,
-				live: found.family
-			});
-			if (found.notNull !== generatedNotNull && !authOwned?.has(name)) differences.push({
-				...at,
-				kind: "nullability",
-				column: name,
-				property,
-				generated: generatedNotNull ? "NOT NULL" : "nullable",
-				live: found.notNull ? "NOT NULL" : "nullable"
-			});
-		}
-		for (const [name, column] of live) {
-			if (seen.has(name)) continue;
-			if (authOwned?.has(name)) continue;
-			differences.push({
-				...at,
-				kind: "extra-column",
-				column: name,
-				property: collection ? fieldKeyForColumn(collection, name) : name,
-				live: column.family
-			});
-		}
-	}
-	return differences;
-}
-/** One line, in the terms the reader has: collection, property, column. */
-function describeSchemaDifference(difference) {
-	const where = difference.collection ? `${difference.collection} (table "${difference.table}")` : `table "${difference.table}"`;
-	const field = difference.column ? `${difference.property && difference.property !== difference.column ? `${difference.property} → "${difference.column}"` : `"${difference.column}"`}` : void 0;
-	switch (difference.kind) {
-		case "missing-table": return `${where} is in schema.generated.ts but not in the database`;
-		case "missing-column": return `${where}: ${field} is in schema.generated.ts but not in the database`;
-		case "extra-column": return `${where}: ${field} is in the database but not in schema.generated.ts (${difference.live})`;
-		case "type": return `${where}: ${field} is ${difference.generated} in schema.generated.ts and ${difference.live} in the database`;
-		case "nullability": return `${where}: ${field} is ${difference.generated} in schema.generated.ts and ${difference.live} in the database`;
-	}
-}
-/**
-* Report the differences, one warning each, and never throw.
-*
-* Per difference rather than one summary block on purpose: these are read out of
-* a log aggregator as often as a terminal, and a single multi-line message
-* cannot be filtered down to the one collection somebody is looking at.
-*
-* The fix it names is `rebase db push`. `rebase dev` rewrites
-* schema.generated.ts from the collections on every change, and boot applies
-* only additive changes, so what is still different at boot is the database
-* behind the file: a rename, a dropped column, a narrowed type, a NOT NULL.
-* `rebase schema generate` rewrites the file and leaves the database as it is,
-* so it is named only for collections that changed since the file was written.
-*/
-function warnOnGeneratedSchemaDrift(differences) {
-	if (differences.length === 0) return;
-	logger.warn(`📄 [schema] schema.generated.ts and the database disagree (${differences.length} difference${differences.length === 1 ? "" : "s"}). Boot applies only additive changes; these are the ones it left for you. Run \`rebase db push\` to apply them (it shows the plan and asks before anything destructive), or \`rebase db generate\` for a migration. If the collections changed since schema.generated.ts was written, run \`rebase schema generate\` first.`);
-	for (const difference of differences) logger.warn(`   • ${describeSchemaDifference(difference)}`, {
-		schemaDrift: {
-			kind: difference.kind,
-			table: difference.table,
-			collection: difference.collection,
-			column: difference.column,
-			property: difference.property,
-			generated: difference.generated,
-			live: difference.live
-		},
-		fix: "rebase db push"
-	});
-}
-//#endregion
 //#region src/PostgresBootstrapper.ts
 /**
 * PostgresBootstrapper
@@ -20164,7 +19195,7 @@ async function openPostgresDriver(pgConfig, config) {
 	const { readUrl, directUrl } = resolveSourceUrls(pgConfig, sourceKey, {});
 	let readDb;
 	if (readUrl && readUrl !== pgConfig.connectionString) try {
-		const { createReadReplicaConnection } = await import("./connection-C938nR3E.js").then((n) => n.n);
+		const { createReadReplicaConnection } = await import("./connection-czvI7TZL.js").then((n) => n.n);
 		readDb = createReadReplicaConnection(readUrl, mergedSchema).db;
 		logger.info("📖 [PostgresBootstrapper] Read replica connection established");
 	} catch (err) {
@@ -20277,7 +19308,7 @@ async function openPostgresDriver(pgConfig, config) {
 			};
 			logger.info(`📡 [CDC] Realtime source = database-level change capture (mode: ${cdcMode === "wal" ? "wal→trigger" : "trigger"}). All writes now emit realtime events regardless of origin.` + (realtimeSubscribes ? "" : " This process installs the capture but does not consume it."));
 		} catch (err) {
-			if (explicitCdc) logger.warn("⚠️ [CDC] Could not enable database-level change capture — falling back to app-level realtime.", { error: err });
+			if (explicitCdc) logger.warn("⚠️ [CDC] Could not enable database-level change capture — falling back to app-level realtime.", { detail: err instanceof Error ? err.message : String(err) });
 			else logger.info("ℹ️ [CDC] Database-level change capture unavailable (likely insufficient privileges to create triggers, or the LISTEN connection was refused) — using app-level realtime. Set REALTIME_CDC=off to silence this.", { detail: err instanceof Error ? err.message : String(err) });
 		}
 	}
@@ -20293,7 +19324,7 @@ async function openPostgresDriver(pgConfig, config) {
 	if (!cdcEnabled && directUrl && realtimeSubscribes) try {
 		await realtimeService.startListening(directUrl);
 	} catch (err) {
-		logger.warn("⚠️ Cross-instance realtime could not be started", { error: err });
+		logger.warn("⚠️ Cross-instance realtime could not be started", { detail: err instanceof Error ? err.message : String(err) });
 	}
 	else if (!cdcEnabled && !realtimeSubscribes && !realtimeOff) realtimeService.startPublishing();
 	try {
@@ -20436,7 +19467,7 @@ function createPostgresBootstrapper(pgConfig) {
 	const openIndexBuildSession = (driverResult) => async () => {
 		const db = requireProvisioningDb(driverResult);
 		const pool = "$client" in db ? db.$client : void 0;
-		const { isPgPool, poolIndexBuildSession } = await import("./deferred-index-build-Cis_HoGn.js").then((n) => n.r);
+		const { isPgPool, poolIndexBuildSession } = await import("./deferred-index-build-BE0I6sYU.js").then((n) => n.r);
 		if (isPgPool(pool)) return poolIndexBuildSession(pool)();
 		const queryable = provisioningQueryable(driverResult);
 		return {
@@ -20462,7 +19493,7 @@ function createPostgresBootstrapper(pgConfig) {
 	*/
 	const provisionRlsRuntime = async (driverResult) => {
 		const db = requireProvisioningDb(driverResult);
-		const { RLS_BOOTSTRAP_STATEMENTS, rlsRuntimeIsCurrent } = await import("./rls-bootstrap-sql-Bd-hJk08.js").then((n) => n.a);
+		const { RLS_BOOTSTRAP_STATEMENTS, rlsRuntimeIsCurrent } = await import("./db-subcommands-BPoHCxJR.js").then((n) => n.v);
 		const run = async (text) => sqlRows(await db.execute(sql.raw(text)));
 		if (await rlsRuntimeIsCurrent(run).catch(() => false)) return;
 		await db.transaction(async (tx) => {
@@ -20556,11 +19587,11 @@ function createPostgresBootstrapper(pgConfig) {
 					unavailable: historyUnavailableReason(state, { requireTransaction: false })
 				}) };
 			}
-			const { BOOT_LOCK_TIMEOUT_MS } = await import("./boot-ddl-s_3Hkz94.js").then((n) => n.i);
+			const { BOOT_LOCK_TIMEOUT_MS } = await import("./boot-ddl-DYH95Qeg.js").then((n) => n.i);
 			const historyTable = await ensureHistoryTableExists(db, { lockTimeoutMs: BOOT_LOCK_TIMEOUT_MS });
 			const historyIndexes = await ensureHistoryIndexes(db, { lockTimeoutMs: BOOT_LOCK_TIMEOUT_MS });
 			if (historyIndexes.length > 0) {
-				const { buildDeferredIndexes, scheduleDeferredIndexBuild } = await import("./deferred-index-build-Cis_HoGn.js").then((n) => n.r);
+				const { buildDeferredIndexes, scheduleDeferredIndexBuild } = await import("./deferred-index-build-BE0I6sYU.js").then((n) => n.r);
 				const indexOptions = {
 					log: (message) => logger.info(`[history] ${message}`),
 					lockTimeoutMs: BOOT_LOCK_TIMEOUT_MS
@@ -20616,9 +19647,9 @@ function createPostgresBootstrapper(pgConfig) {
 		* proved it can bootstrap with.
 		*/
 		async ensureCollectionSchema(collections, driverResult, log) {
-			const { ensureCollectionTables } = await import("./ensure-collection-tables-DvvImXDe.js").then((n) => n.n);
+			const { ensureCollectionTables } = await import("./ensure-collection-tables-Cet4650m.js").then((n) => n.n);
 			const queryable = provisioningQueryable(driverResult);
-			const { BOOT_LOCK_TIMEOUT_MS } = await import("./boot-ddl-s_3Hkz94.js").then((n) => n.i);
+			const { BOOT_LOCK_TIMEOUT_MS } = await import("./boot-ddl-DYH95Qeg.js").then((n) => n.i);
 			const provisionOnly = ["1", "true"].includes((process.env.REBASE_PROVISION_ONLY ?? "").trim().toLowerCase());
 			const plan = await ensureCollectionTables(queryable, collections, log, {
 				lockTimeoutMs: BOOT_LOCK_TIMEOUT_MS,
@@ -20630,7 +19661,7 @@ function createPostgresBootstrapper(pgConfig) {
 			pendingIndexBuild?.cancel();
 			pendingIndexBuild = void 0;
 			if (!provisionOnly && plan.deferredIndexes.length > 0) {
-				const { scheduleDeferredIndexBuild } = await import("./deferred-index-build-Cis_HoGn.js").then((n) => n.r);
+				const { scheduleDeferredIndexBuild } = await import("./deferred-index-build-BE0I6sYU.js").then((n) => n.r);
 				logger.info(`[schema] ${plan.deferredIndexes.length} index(es) are missing, or were left INVALID, on tables that already exist. They are built in the background once the server is serving, one at a time, without blocking reads or writes.`);
 				pendingIndexBuild = scheduleDeferredIndexBuild(openIndexBuildSession(driverResult), plan.deferredIndexes, {
 					log: (message) => logger.info(`[schema] ${message}`),
@@ -20670,7 +19701,7 @@ function createPostgresBootstrapper(pgConfig) {
 			await provisionRlsRuntime(driverResult);
 		},
 		async ensureCollectionPolicies(collections, driverResult, log) {
-			const { ensureCollectionPolicies, describeRulesDropped } = await import("./ensure-collection-policies-CCqayoUz.js");
+			const { ensureCollectionPolicies, describeRulesDropped } = await import("./ensure-collection-policies-BnGOURpG.js");
 			const queryable = provisioningQueryable(driverResult);
 			const { rows } = await queryable.query("SELECT to_regprocedure('rebase.roles()') IS NOT NULL AS present");
 			if (!rows[0]?.present) await provisionRlsRuntime(driverResult);
@@ -20695,7 +19726,7 @@ function createPostgresBootstrapper(pgConfig) {
 			for (const u of outcome.unsecured.filter((u) => u.grantWithdrawn)) logger.error(`🔐 [rls] Could not enable row-level security on "${u.table}": ${u.error}. Its privileges have been revoked from ${REBASE_USER_ROLE$1}, so the table is unreachable rather than unprotected. Reads and writes to that collection will fail until RLS can be enabled.`);
 			if (unrevoked.length > 0) throw new Error("Refusing to start: row-level security could not be enabled on " + unrevoked.map((u) => `"${u.table}" (${u.error})`).join(", ") + `, and the privileges granted to ${REBASE_USER_ROLE$1} could not be revoked either. The table would be served with no row filtering. Fix the database permissions (the connection role must own these tables, or be able to ALTER them) and boot again.`);
 			try {
-				const { dropLegacyAuthSchema } = await import("./rls-bootstrap-sql-Bd-hJk08.js").then((n) => n.a);
+				const { dropLegacyAuthSchema } = await import("./db-subcommands-BPoHCxJR.js").then((n) => n.v);
 				await dropLegacyAuthSchema(async (text) => (await queryable.query(text)).rows, {
 					info: (m) => logger.info(m),
 					warn: (m) => logger.warn(m)
@@ -20786,7 +19817,7 @@ function createPostgresBootstrapper(pgConfig) {
 			return driverResult.internals.driver.admin;
 		},
 		async initializeWebsockets(server, realtimeService, driver, config, adapter, limits) {
-			const { createPostgresWebSocket, isSocketRealtimeService, socketRealtimeMissing } = await import("./websocket-MC0zTBar.js").then((n) => n.c);
+			const { createPostgresWebSocket, isSocketRealtimeService, socketRealtimeMissing } = await import("./websocket-BKZwsjmf.js").then((n) => n.c);
 			if (!isSocketRealtimeService(realtimeService)) throw new Error(`The realtime service handed to the Postgres socket cannot serve it — it has no ${socketRealtimeMissing(realtimeService).join(", ")}. Every socket would fail on its first frame.`);
 			const realtimeConfig = effectiveConfig().realtime;
 			const maxSocketsPerUser = realtimeConfig?.maxSocketsPerUser !== void 0 ? parseMaxSocketsPerUser(realtimeConfig.maxSocketsPerUser, "realtime.maxSocketsPerUser") : void 0;
@@ -20925,4 +19956,4 @@ async function openRebase(options) {
 //#endregion
 export { AuthenticatedPostgresBackendDriver as $, budgetSendBuffers as A, mfaFactors as B, PG_NOTIFY_MAX_PAYLOAD_BYTES as C, MemoryChannelBus as D, parseChannelBusPayload as E, createAuthSchema as F, recoveryCodesRelations as G, passwordResetTokens as H, magicLinkTokens as I, userIdentities as J, refreshTokens as K, magicLinkTokensRelations as L, terminateIfBacklogged as M, assertReadRequestReadable as N, frameByteLength as O, appConfig as P, usersSchema as Q, mfaChallenges as R, DEFAULT_BATCH_WINDOW_MS as S, parseChannelBusFrame as T, passwordResetTokensRelations as U, mfaFactorsRelations as V, recoveryCodes as W, users as X, userIdentitiesRelations as Y, usersRelations as Z, parseRealtimeTuning as _, listedColumnKeys as _t, openPostgresDriver as a, isRoleSwitchingOptedOut as at, resolveChannelBusSetting as b, resolveSourceUrls as c, SqlResultTooLargeError as ct, DEFAULT_RECOUNT_MIN_ROWS as d, DrizzleConditionBuilder as dt, CONNECTION_OWNER as et, PostgresRealtimeProvider as f, PostgresConditionBuilder as ft, parseMaxSubscriptionsPerSocket as g, joinColumn as gt, parseMaxSocketsPerUser as h, getUnknownFilterFieldsMode as ht, isScaffoldedLocalDatabase as i, effectiveSqlRole as it, reapSilentSockets as j, isChannelBusInstance$1 as k, PostgresCollectionRegistry as l, isNestedPath as lt, packEntityChanges as m, escapeLikePattern as mt, createPostgresBootstrapper as n, RoleSwitchUnavailableError as nt, postgresDriverConfigFromEnv as o, sqlRoleRanAs as ot, RealtimeService as p, configureUnknownFilterFields as pt, refreshTokensRelations as q, describeSchemaDriftCause as r, branchParentDatabase as rt, resolveDriftCheckName as s, SQL_RESULT_BYTE_BUDGET as st, openRebase as t, PostgresBackendDriver as tt, DEFAULT_MAX_SUBSCRIPTIONS_PER_SOCKET as u, resolveNestedPath as ut, refetchConcurrencyFor as v, PostgresChannelBus as w, CHANNEL_BUS_NOTIFY_CHANNEL as x, createChannelBus as y, mfaChallengesRelations as z };
 
-//# sourceMappingURL=open-rebase-BKA7Nyoe.js.map
+//# sourceMappingURL=open-rebase-EmqVmS14.js.map