@vibeorm/sql 2.2.0 → 2.3.1

package/dist/index.js

@@ -16,6 +16,130 @@ class ParamCollector {
   }
 }
 
+// packages/sql/src/dialects/module-dependency.ts
+function renderModuleDependencyQuery(params) {
+  const { dialect, operation } = params;
+  if (operation.kind === "visibility")
+    return dialect.name === "mysql" ? { text: "SHOW GRANTS FOR CURRENT_USER", values: [], returning: "none" } : undefined;
+  if (dialect.name === "sqlite" || operation.tables.length === 0)
+    return;
+  const collector = new ParamCollector(dialect);
+  const owned = operation.tables.map((table, index) => `SELECT ${collector.add(operation.namespace)}${index === 0 ? " AS namespace" : ""}, ${collector.add(table)}${index === 0 ? " AS table_name" : ""}`).join(" UNION ALL ");
+  const pg = dialect.name === "postgres";
+  const nameKey = ({ column }) => pg ? column : `CAST(IF(@@lower_case_table_names = 0, ${column}, LOWER(${column})) AS BINARY)`;
+  const isOwned = ({ namespace, table }) => `EXISTS (SELECT 1 FROM owned_tables o WHERE ${nameKey({ column: namespace })} = ${nameKey({ column: "o.namespace" })} AND ${nameKey({ column: table })} = ${nameKey({ column: "o.table_name" })})`;
+  const sourceNamespace = pg ? "sn.nspname" : "fk.CONSTRAINT_SCHEMA";
+  const sourceTable = pg ? "s.relname" : "fk.TABLE_NAME";
+  const targetNamespace = pg ? "tn.nspname" : "fk.UNIQUE_CONSTRAINT_SCHEMA";
+  const targetTable = pg ? "t.relname" : "fk.REFERENCED_TABLE_NAME";
+  const from = pg ? "pg_catalog.pg_constraint fk JOIN pg_catalog.pg_class s ON s.oid = fk.conrelid JOIN pg_catalog.pg_namespace sn ON sn.oid = s.relnamespace JOIN pg_catalog.pg_class t ON t.oid = fk.confrelid JOIN pg_catalog.pg_namespace tn ON tn.oid = t.relnamespace WHERE fk.contype = 'f'" : "information_schema.REFERENTIAL_CONSTRAINTS fk";
+  return {
+    text: `WITH owned_tables AS (${owned})
+SELECT * FROM (SELECT ${pg ? "fk.conname" : "fk.CONSTRAINT_NAME"} AS constraint_name, ${sourceNamespace} AS source_namespace, ${sourceTable} AS source_table, ${targetNamespace} AS target_namespace, ${targetTable} AS target_table, ${isOwned({ namespace: sourceNamespace, table: sourceTable })} AS source_owned, ${isOwned({ namespace: targetNamespace, table: targetTable })} AS target_owned FROM ${from}) dependencies
+WHERE source_owned OR target_owned
+ORDER BY source_namespace, source_table, constraint_name`,
+    values: collector.values,
+    returning: "none"
+  };
+}
+// packages/sql/src/dialects/migration-replay-coverage.ts
+function renderReplayCoverageGaps(params) {
+  const { dialect } = params;
+  const collector = new ParamCollector(dialect);
+  const namespace = collector.add(params.namespace);
+  if (dialect.name === "postgres")
+    return { text: `SELECT 'type' AS kind, t.typname::text AS name FROM pg_catalog.pg_type t JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace WHERE n.nspname = ${namespace} AND (t.typtype IN ('b', 'd', 'r', 'm') AND t.typelem = 0 OR t.typtype = 'c' AND EXISTS (SELECT 1 FROM pg_catalog.pg_class c WHERE c.oid = t.typrelid AND c.relkind = 'c')) AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_depend d WHERE d.classid = 'pg_type'::regclass AND d.objid = t.oid AND d.deptype = 'e')
+UNION ALL SELECT 'routine', p.proname::text FROM pg_catalog.pg_proc p JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace WHERE n.nspname = ${namespace} AND p.prokind <> 'f' AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_depend d WHERE d.classid = 'pg_proc'::regclass AND d.objid = p.oid AND d.deptype = 'e')
+UNION ALL SELECT 'relation-layout', c.relname::text FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = ${namespace} AND (c.relkind IN ('p', 'f') OR c.relispartition OR EXISTS (SELECT 1 FROM pg_catalog.pg_inherits i WHERE i.inhrelid = c.oid)) AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_depend d WHERE d.classid = 'pg_class'::regclass AND d.objid = c.oid AND d.deptype = 'e')
+UNION ALL SELECT 'rule', r.rulename::text FROM pg_catalog.pg_rewrite r JOIN pg_catalog.pg_class c ON c.oid = r.ev_class JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = ${namespace} AND r.rulename <> '_RETURN'
+UNION ALL SELECT 'namespace', n.nspname::text FROM pg_catalog.pg_namespace n WHERE n.nspname <> ${namespace} AND n.nspname <> 'information_schema' AND n.nspname NOT LIKE 'pg\\_%' ESCAPE '\\'${params.privateNamespace === undefined ? "" : ` AND n.nspname <> ${collector.add(params.privateNamespace)}`}`, values: collector.values, returning: "none" };
+  if (dialect.name === "mysql")
+    return { text: `SELECT 'procedure' AS kind, ROUTINE_NAME AS name FROM information_schema.ROUTINES WHERE ROUTINE_SCHEMA = ${namespace} AND ROUTINE_TYPE = 'PROCEDURE'
+UNION ALL SELECT 'event', EVENT_NAME FROM information_schema.EVENTS WHERE EVENT_SCHEMA = ${collector.add(params.namespace)}
+UNION ALL SELECT DISTINCT 'partition', TABLE_NAME FROM information_schema.PARTITIONS WHERE TABLE_SCHEMA = ${collector.add(params.namespace)} AND PARTITION_NAME IS NOT NULL`, values: collector.values, returning: "none" };
+  return { text: `SELECT 'table-options' AS kind, name FROM pragma_table_list WHERE schema = ${namespace} AND name NOT LIKE 'sqlite\\_%' ESCAPE '\\' AND (type = 'virtual' OR wr <> 0 OR strict <> 0)`, values: collector.values, returning: "none" };
+}
+// packages/sql/src/dialects/migration-shadow.ts
+import { unsupportedCapability } from "@vibeorm/schema";
+var SHADOW_DATABASE = Object.freeze({ schema: "_vibeorm_shadow", table: "_vibe_shadow", lock: 1447645267, timeoutSeconds: 60 });
+var SHADOW_CAPABILITIES = Object.freeze({
+  postgres: Object.freeze({ serverProvisioning: true, dedicated: true }),
+  mysql: Object.freeze({ serverProvisioning: true, dedicated: true }),
+  sqlite: Object.freeze({ serverProvisioning: false, dedicated: false })
+});
+function renderShadowOperation(params) {
+  const { dialect, operation } = params;
+  if (!SHADOW_CAPABILITIES[dialect.name].serverProvisioning)
+    throw unsupportedCapability({ dialect: dialect.name, feature: "shadowDatabaseProvisioning" });
+  const pg = dialect.name === "postgres";
+  const collector = new ParamCollector(dialect);
+  const marker = pg ? `${dialect.quoteIdent({ name: SHADOW_DATABASE.schema })}.${dialect.quoteIdent({ name: SHADOW_DATABASE.table })}` : dialect.quoteIdent({ name: SHADOW_DATABASE.table });
+  const result = (text) => [{ text, values: collector.values, returning: "none" }];
+  switch (operation.kind) {
+    case "createDatabase":
+      return result(`CREATE DATABASE ${dialect.quoteIdent({ name: operation.name })}`);
+    case "dropDatabase":
+      return result(`DROP DATABASE ${dialect.quoteIdent({ name: operation.name })}`);
+    case "identity":
+      return result(pg ? `SELECT current_database()::text AS database, (SELECT oid::text FROM pg_catalog.pg_database WHERE datname = current_database()) AS database_id, current_schema()::text AS namespace` : `SELECT DATABASE() AS \`database\`, @@lower_case_table_names AS name_folding, @@server_uuid AS server_id`);
+    case "lock":
+      return result(pg ? `SELECT pg_catalog.pg_advisory_lock(${collector.add(SHADOW_DATABASE.lock)})` : `SELECT GET_LOCK(${collector.add(`vibeorm_shadow:${operation.database}`)}, ${collector.add(SHADOW_DATABASE.timeoutSeconds)}) AS acquired`);
+    case "unlock":
+      return result(pg ? `SELECT pg_catalog.pg_advisory_unlock(${collector.add(SHADOW_DATABASE.lock)}) AS released` : `SELECT RELEASE_LOCK(${collector.add(`vibeorm_shadow:${operation.database}`)}) AS released`);
+    case "markerExists":
+      return result(pg ? `SELECT c.relname AS name FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = ${collector.add(SHADOW_DATABASE.schema)} AND c.relname = ${collector.add(SHADOW_DATABASE.table)}` : `SELECT TABLE_NAME AS name FROM information_schema.TABLES WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ${collector.add(SHADOW_DATABASE.table)}`);
+    case "markerRead":
+      return result(`SELECT payload FROM ${marker}`);
+    case "markerColumns":
+      return result(`SELECT column_name AS name, data_type AS type, is_nullable AS nullable FROM information_schema.columns AS marker_column WHERE table_schema = ${pg ? collector.add(SHADOW_DATABASE.schema) : "DATABASE()"} AND table_name = ${collector.add(SHADOW_DATABASE.table)} AND ${pg ? `EXISTS (SELECT 1 FROM pg_catalog.pg_class r JOIN pg_catalog.pg_namespace n ON n.oid = r.relnamespace WHERE n.nspname = marker_column.table_schema AND r.relname = marker_column.table_name AND r.relkind = 'r' AND r.relpersistence = 'p' AND NOT r.relrowsecurity AND NOT r.relforcerowsecurity AND NOT r.relhasrules AND NOT r.relhastriggers AND NOT r.relispartition AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_attrdef a WHERE a.adrelid = r.oid) AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_constraint c WHERE c.conrelid = r.oid AND c.contype <> 'n') AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_index i WHERE i.indrelid = r.oid) AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_inherits i WHERE i.inhrelid = r.oid OR i.inhparent = r.oid) AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_attribute a WHERE a.attrelid = r.oid AND (a.attisdropped OR a.attidentity <> '' OR a.attgenerated <> '')))` : `EXISTS (SELECT 1 FROM information_schema.TABLES t WHERE t.TABLE_SCHEMA = marker_column.table_schema AND t.TABLE_NAME = marker_column.table_name AND t.TABLE_TYPE = 'BASE TABLE' AND t.ENGINE = 'InnoDB') AND NOT EXISTS (SELECT 1 FROM information_schema.COLUMNS c WHERE c.TABLE_SCHEMA = marker_column.table_schema AND c.TABLE_NAME = marker_column.table_name AND (c.COLUMN_DEFAULT IS NOT NULL OR c.EXTRA <> '')) AND NOT EXISTS (SELECT 1 FROM information_schema.TRIGGERS t WHERE t.EVENT_OBJECT_SCHEMA = DATABASE() AND t.EVENT_OBJECT_TABLE = ${collector.add(SHADOW_DATABASE.table)}) AND NOT EXISTS (SELECT 1 FROM information_schema.TABLE_CONSTRAINTS c WHERE c.TABLE_SCHEMA = DATABASE() AND c.TABLE_NAME = ${collector.add(SHADOW_DATABASE.table)})`}
+ORDER BY ordinal_position`);
+    case "grants": {
+      if (pg)
+        throw unsupportedCapability({ dialect: dialect.name, feature: "mysqlShadowPrivileges" });
+      return result("SHOW GRANTS FOR CURRENT_USER");
+    }
+    case "markerCreate":
+      return pg ? [{ text: `CREATE SCHEMA ${dialect.quoteIdent({ name: SHADOW_DATABASE.schema })}`, values: [], returning: "none" }, { text: `CREATE TABLE ${marker} (payload text NOT NULL)`, values: [], returning: "none" }] : result(`CREATE TABLE ${marker} (payload LONGTEXT NOT NULL) ENGINE=InnoDB`);
+    case "markerWrite":
+      return result(operation.insert ? `INSERT INTO ${marker} (payload) VALUES (${collector.add(operation.value)})` : `UPDATE ${marker} SET payload = ${collector.add(operation.value)}`);
+    case "journal":
+      return result(`SELECT name, checksum, statement_index, error FROM ${dialect.quoteIdent({ name: "_vibe_migrations" })} ORDER BY name`);
+    case "inventory":
+      return result(pg ? `SELECT 'namespace' AS kind, nspname::text AS name, nspname::text AS namespace FROM pg_catalog.pg_namespace WHERE nspname NOT IN ('public', 'information_schema') AND nspname NOT LIKE 'pg\\_%' ESCAPE '\\'
+UNION ALL SELECT 'relation', c.relname::text, n.nspname::text FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname <> 'information_schema' AND n.nspname NOT LIKE 'pg\\_%' ESCAPE '\\'
+UNION ALL SELECT 'routine', p.proname::text, n.nspname::text FROM pg_catalog.pg_proc p JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace WHERE n.nspname <> 'information_schema' AND n.nspname NOT LIKE 'pg\\_%' ESCAPE '\\'
+UNION ALL SELECT 'type', t.typname::text, n.nspname::text FROM pg_catalog.pg_type t JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace WHERE n.nspname <> 'information_schema' AND n.nspname NOT LIKE 'pg\\_%' ESCAPE '\\' AND t.typrelid = 0 AND t.typelem = 0
+UNION ALL SELECT 'extension', e.extname::text, n.nspname::text FROM pg_catalog.pg_extension e JOIN pg_catalog.pg_namespace n ON n.oid = e.extnamespace WHERE e.extname <> 'plpgsql'
+UNION ALL SELECT 'marker-dependency', d.objid::text, '${SHADOW_DATABASE.schema}' FROM pg_catalog.pg_depend d JOIN pg_catalog.pg_class c ON d.classid = 'pg_class'::regclass AND d.objid = c.oid JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = '${SHADOW_DATABASE.schema}' AND d.deptype NOT IN ('i', 'a') AND d.refclassid <> 'pg_namespace'::regclass
+UNION ALL SELECT 'marker-trigger', t.tgname::text, n.nspname::text FROM pg_catalog.pg_trigger t JOIN pg_catalog.pg_class c ON c.oid = t.tgrelid JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = '${SHADOW_DATABASE.schema}'
+UNION ALL SELECT 'namespace-object', o.name::text, n.nspname::text FROM pg_catalog.pg_depend d JOIN pg_catalog.pg_namespace n ON d.refclassid = 'pg_namespace'::regclass AND d.refobjid = n.oid CROSS JOIN LATERAL pg_catalog.pg_identify_object(d.classid, d.objid, d.objsubid) o WHERE n.nspname <> 'information_schema' AND n.nspname NOT LIKE 'pg\\_%' ESCAPE '\\' AND d.classid NOT IN ('pg_class'::regclass, 'pg_proc'::regclass, 'pg_type'::regclass, 'pg_extension'::regclass)
+UNION ALL SELECT 'database-object', evtname::text, '' FROM pg_catalog.pg_event_trigger
+UNION ALL SELECT 'database-object', pubname::text, '' FROM pg_catalog.pg_publication
+UNION ALL SELECT 'database-object', subname::text, '' FROM pg_catalog.pg_subscription WHERE subdbid = (SELECT oid FROM pg_catalog.pg_database WHERE datname = current_database())
+UNION ALL SELECT 'database-object', srvname::text, '' FROM pg_catalog.pg_foreign_server
+UNION ALL SELECT 'database-object', fdwname::text, '' FROM pg_catalog.pg_foreign_data_wrapper
+UNION ALL SELECT 'database-object', c.oid::text, '' FROM pg_catalog.pg_cast c JOIN pg_catalog.pg_type s ON s.oid = c.castsource JOIN pg_catalog.pg_type t ON t.oid = c.casttarget LEFT JOIN pg_catalog.pg_proc p ON p.oid = c.castfunc WHERE s.typnamespace <> 'pg_catalog'::regnamespace OR t.typnamespace <> 'pg_catalog'::regnamespace OR p.pronamespace <> 'pg_catalog'::regnamespace` : `SELECT TABLE_TYPE AS kind, TABLE_NAME AS name, TABLE_SCHEMA AS namespace FROM information_schema.TABLES WHERE TABLE_SCHEMA = DATABASE()
+UNION ALL SELECT ROUTINE_TYPE, ROUTINE_NAME, ROUTINE_SCHEMA FROM information_schema.ROUTINES WHERE ROUTINE_SCHEMA = DATABASE()
+UNION ALL SELECT 'EVENT', EVENT_NAME, EVENT_SCHEMA FROM information_schema.EVENTS WHERE EVENT_SCHEMA = DATABASE()
+UNION ALL SELECT 'TRIGGER', TRIGGER_NAME, TRIGGER_SCHEMA FROM information_schema.TRIGGERS WHERE TRIGGER_SCHEMA = DATABASE()
+UNION ALL SELECT 'EXTERNAL FOREIGN KEY', CONCAT(TABLE_NAME, '.', CONSTRAINT_NAME), CONSTRAINT_SCHEMA FROM information_schema.REFERENTIAL_CONSTRAINTS WHERE UNIQUE_CONSTRAINT_SCHEMA = DATABASE() AND CAST(CONSTRAINT_SCHEMA AS BINARY) <> CAST(DATABASE() AS BINARY)`);
+    case "resetPostgres": {
+      if (!pg)
+        throw unsupportedCapability({ dialect: dialect.name, feature: "postgresShadowReset" });
+      return [{ text: 'DROP SCHEMA "public" CASCADE', values: [], returning: "none" }, { text: 'CREATE SCHEMA "public"', values: [], returning: "none" }];
+    }
+    case "mysqlForeignKeys": {
+      if (pg)
+        throw unsupportedCapability({ dialect: dialect.name, feature: "mysqlShadowReset" });
+      return result(`SET FOREIGN_KEY_CHECKS = ${operation.enabled ? "1" : "0"}`);
+    }
+    case "dropMysqlObject": {
+      if (pg)
+        throw unsupportedCapability({ dialect: dialect.name, feature: "mysqlShadowReset" });
+      return result(`DROP ${operation.object} ${dialect.quoteIdent({ name: operation.name })}`);
+    }
+  }
+}
 // packages/sql/src/module-journal.ts
 var MODULE_JOURNAL_COLUMN = "module_origin";
 function renderModuleJournal(params) {
@@ -525,15 +649,15 @@ var decode = Object.freeze({
   }
 });
 // packages/sql/src/exclusion.ts
-import { VibeError as VibeError5, fieldTypeIdentity as fieldTypeIdentity2, unsupportedCapability as unsupportedCapability2 } from "@vibeorm/schema";
+import { VibeError as VibeError5, fieldTypeIdentity as fieldTypeIdentity2, unsupportedCapability as unsupportedCapability3 } from "@vibeorm/schema";
 
 // packages/sql/src/predicate.ts
-import { VibeError as VibeError4, fieldTypeIdentity, isEnumType, unsupportedCapability } from "@vibeorm/schema";
+import { VibeError as VibeError4, fieldTypeIdentity, isEnumType, unsupportedCapability as unsupportedCapability2 } from "@vibeorm/schema";
 function renderPredicate(params) {
   if (params.usage === "exclusionPredicate" && !params.dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability({ dialect: params.dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability2({ dialect: params.dialect.name, feature: "exclusionConstraints" });
   if (params.usage === "indexPredicate" && !params.dialect.capabilities.partialIndexes) {
-    throw unsupportedCapability({ dialect: params.dialect.name, feature: "partialIndexes" });
+    throw unsupportedCapability2({ dialect: params.dialect.name, feature: "partialIndexes" });
   }
   const context = {
     model: params.model,
@@ -661,7 +785,7 @@ function resolveField(params) {
     });
   }
   if (context.usage === "check" && context.dialect.name === "mysql" && field.default?.kind === "autoincrement") {
-    throw unsupportedCapability({
+    throw unsupportedCapability2({
       dialect: "mysql",
       feature: `CHECK constraint referencing auto-increment column "${context.model.name}.${name}"`,
       hint: "mysql refuses this with error 3818 \u2014 enforce the rule in application code or on a non-generated column"
@@ -837,7 +961,7 @@ function invalid2(rule) {
 function compileExclusion(params) {
   const { exclusion: spec, model, dialect } = params;
   if (!dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability2({ dialect: dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability3({ dialect: dialect.name, feature: "exclusionConstraints" });
   if (!spec.name || spec.name.includes("\x00"))
     invalid2("name");
   if (!["int8range", "tsrange", "tstzrange"].includes(spec.range.type))
@@ -867,8 +991,8 @@ function compileExclusion(params) {
       if (timezone !== (spec.range.type === "tstzrange"))
         invalid2("range-timezone");
     }
-    const sql2 = dialect.quoteIdent({ name: column.dbName ?? column.name });
-    return literal === undefined ? sql2 : `COALESCE(${sql2}, ${literal})`;
+    const sql = dialect.quoteIdent({ name: column.dbName ?? column.name });
+    return literal === undefined ? sql : `COALESCE(${sql}, ${literal})`;
   };
   const keys = spec.keys.map((key) => {
     if ("expression" in key) {
@@ -890,13 +1014,13 @@ function compileExclusion(params) {
 }
 function renderExclusionSetup(params) {
   if (!params.dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability2({ dialect: params.dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability3({ dialect: params.dialect.name, feature: "exclusionConstraints" });
   return params.exclusion.requiredExtensions.map((name) => `CREATE EXTENSION IF NOT EXISTS ${params.dialect.quoteIdent({ name })};`);
 }
 function renderExclusionDdl(params) {
   const { dialect, table, exclusion, operation } = params;
   if (!dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability2({ dialect: dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability3({ dialect: dialect.name, feature: "exclusionConstraints" });
   const target = `ALTER TABLE ${dialect.quoteIdent({ name: table })}`;
   if (operation === "drop")
     return [`${target} DROP CONSTRAINT ${dialect.quoteIdent({ name: exclusion.name })};`];
@@ -905,14 +1029,14 @@ function renderExclusionDdl(params) {
 function renderExclusionCatalog(params) {
   const { dialect, probe } = params;
   if (!dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability2({ dialect: dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability3({ dialect: dialect.name, feature: "exclusionConstraints" });
   const scope = probe === undefined ? "n.nspname = 'public'" : `t.oid = ${dialect.quoteStringLiteral({ value: probe })}::regclass`;
   return `SELECT t.relname AS table_name, c.conname AS constraint_name, pg_catalog.pg_get_constraintdef(c.oid, true) AS definition, c.convalidated AS validated, i.indisvalid AS valid, i.indisready AS ready FROM pg_catalog.pg_constraint c JOIN pg_catalog.pg_class t ON t.oid = c.conrelid JOIN pg_catalog.pg_namespace n ON n.oid = t.relnamespace JOIN pg_catalog.pg_index i ON i.indexrelid = c.conindid WHERE c.contype = 'x' AND ${scope} ORDER BY t.relname, c.conname`;
 }
 function renderExclusionProbe(params) {
   const { dialect, table, probe, definition } = params;
   if (!dialect.capabilities.exclusionConstraints)
-    throw unsupportedCapability2({ dialect: dialect.name, feature: "exclusionConstraints" });
+    throw unsupportedCapability3({ dialect: dialect.name, feature: "exclusionConstraints" });
   return [`CREATE TEMP TABLE ${dialect.quoteIdent({ name: probe })} (LIKE ${dialect.quoteIdent({ name: "public" })}.${dialect.quoteIdent({ name: table })})`, `ALTER TABLE ${dialect.quoteIdent({ name: probe })} ADD CONSTRAINT ${dialect.quoteIdent({ name: `${probe}_x` })} ${definition}`];
 }
 // packages/sql/src/ast.ts
@@ -968,7 +1092,7 @@ function isExcludedRef(value) {
 }
 var ADVISORY_LOCK_RESULT_COLUMN = "acquired";
 // packages/sql/src/locks.ts
-import { internalError, unsupportedCapability as unsupportedCapability3 } from "@vibeorm/schema";
+import { internalError, unsupportedCapability as unsupportedCapability4 } from "@vibeorm/schema";
 var ROW_LOCK_PROSE = Object.freeze({
   strengths: Object.freeze({
     update: "FOR UPDATE",
@@ -988,7 +1112,7 @@ function renderRowLockClause(params) {
   if (syntax === null) {
     if (lock.strength === "update" && lock.wait === "wait")
       return null;
-    throw unsupportedCapability3({
+    throw unsupportedCapability4({
       dialect: dialect.name,
       feature: `a ${describeRowLock({ lock })} locking read`,
       hint: `${dialect.name} has no locking-read clause at all`
@@ -996,7 +1120,7 @@ function renderRowLockClause(params) {
   }
   const strengthText = syntax.strengths[lock.strength];
   if (strengthText === undefined) {
-    throw unsupportedCapability3({
+    throw unsupportedCapability4({
       dialect: dialect.name,
       feature: `the ${describeRowLock({ lock: { ...lock, wait: "wait" } })} row-lock strength`,
       hint: `${dialect.name} can express: ${Object.keys(syntax.strengths).join(", ")}`
@@ -1004,7 +1128,7 @@ function renderRowLockClause(params) {
   }
   const waitText = syntax.wait[lock.wait];
   if (waitText === undefined) {
-    throw unsupportedCapability3({
+    throw unsupportedCapability4({
       dialect: dialect.name,
       feature: `the "${lock.wait}" lock wait policy`,
       hint: `${dialect.name} can express: ${Object.keys(syntax.wait).join(", ")}`
@@ -1023,7 +1147,7 @@ function renderAdvisoryLock(params) {
   const { dialect, statement, collector } = params;
   const functions = dialect.advisoryLockFunctions;
   if (functions === null) {
-    throw unsupportedCapability3({
+    throw unsupportedCapability4({
       dialect: dialect.name,
       feature: "advisory locks",
       hint: dialect.name === "mysql" ? "mysql's GET_LOCK is SESSION-scoped \u2014 it survives a rollback, so it cannot be released with the transaction" : `${dialect.name} has no advisory-lock functions`
@@ -1064,6 +1188,19 @@ import {
   MYSQL_CAPABILITIES
 } from "@vibeorm/schema";
 
+// packages/sql/src/identifiers.ts
+import { VibeError as VibeError6 } from "@vibeorm/schema";
+function assertNoNul(params) {
+  if (params.name.includes("\x00")) {
+    throw new VibeError6({
+      code: "VIBE_VALIDATION",
+      message: "an SQL identifier cannot contain a NUL character \u2014 the server would stop reading it there and address a different object",
+      meta: { name: params.name.replaceAll("\x00", "\\0") }
+    });
+  }
+  return params.name;
+}
+
 // packages/sql/src/dialects/postgres.ts
 var postgresDialect = {
   name: "postgres",
@@ -1119,7 +1256,7 @@ var postgresDialect = {
   paramBudget: 30000,
   booleanLiteral: { true: "true", false: "false" },
   quoteIdent({ name }) {
-    return `"${name.replaceAll('"', '""')}"`;
+    return `"${assertNoNul({ name }).replaceAll('"', '""')}"`;
   },
   quoteStringLiteral({ value }) {
     return `'${value.replaceAll("'", "''")}'`;
@@ -1170,7 +1307,7 @@ var sqliteDialect = {
   paramBudget: 900,
   booleanLiteral: { true: "1", false: "0" },
   quoteIdent({ name }) {
-    return `"${name.replaceAll('"', '""')}"`;
+    return `"${assertNoNul({ name }).replaceAll('"', '""')}"`;
   },
   quoteStringLiteral({ value }) {
     return `'${value.replaceAll("'", "''")}'`;
@@ -1225,7 +1362,7 @@ var mysqlDialect = {
   paramBudget: 1e4,
   booleanLiteral: { true: "1", false: "0" },
   quoteIdent({ name }) {
-    return `\`${name.replaceAll("`", "``")}\``;
+    return `\`${assertNoNul({ name }).replaceAll("`", "``")}\``;
   },
   quoteStringLiteral({ value }) {
     return `'${value.replaceAll("\\", "\\\\").replaceAll("'", "''")}'`;
@@ -1249,7 +1386,7 @@ function getSqlDialect(params) {
   return SQL_DIALECTS[params.dialect];
 }
 // packages/sql/src/dialects/diagnostics.ts
-import { unsupportedCapability as unsupportedCapability4 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability5 } from "@vibeorm/schema";
 var QUERIES = Object.freeze({
   postgresJsonWire: { dialect: "postgres", text: `SELECT '{"__vibeorm":1}'::jsonb AS "probe"` },
   sqliteTriggers: { dialect: "sqlite", text: "SELECT name, tbl_name, sql FROM sqlite_master WHERE type = 'trigger'" }
@@ -1257,7 +1394,7 @@ var QUERIES = Object.freeze({
 function renderDiagnostic(params) {
   const query = QUERIES[params.query];
   if (params.dialect.name !== query.dialect) {
-    throw unsupportedCapability4({ dialect: params.dialect.name, feature: params.query, hint: `this diagnostic requires ${query.dialect}` });
+    throw unsupportedCapability5({ dialect: params.dialect.name, feature: params.query, hint: `this diagnostic requires ${query.dialect}` });
   }
   return { text: query.text, values: [], returning: "none" };
 }
@@ -1266,7 +1403,7 @@ function isFixedDiagnostic(params) {
 }
 
 // packages/sql/src/dialects/postgres-diagnostics.ts
-import { VibeError as VibeError6, unsupportedCapability as unsupportedCapability5 } from "@vibeorm/schema";
+import { VibeError as VibeError7, unsupportedCapability as unsupportedCapability6 } from "@vibeorm/schema";
 function renderPostgresExplain(params) {
   const { dialect, query, options } = params;
   requirePostgres({ dialect, feature: "query plan inspection (EXPLAIN)" });
@@ -1301,7 +1438,7 @@ var POSTGRES_WORKLOAD_LIMITS = Object.freeze({
 });
 function requirePostgres(params) {
   if (params.dialect.name !== "postgres") {
-    throw unsupportedCapability5({
+    throw unsupportedCapability6({
       dialect: params.dialect.name,
       feature: params.feature,
       hint: "plan inspection and workload statistics are PostgreSQL-shaped; portable operation tracing works on every dialect"
@@ -1319,7 +1456,7 @@ function renderPostgresWorkload(params) {
   if (query === "statementSnapshot") {
     const bounded = limit ?? 20;
     if (!Number.isInteger(bounded) || bounded < POSTGRES_WORKLOAD_LIMITS.minLimit || bounded > POSTGRES_WORKLOAD_LIMITS.maxLimit) {
-      throw new VibeError6({
+      throw new VibeError7({
         code: "VIBE_CONFIG",
         message: `workload snapshot limit must be an integer between ${POSTGRES_WORKLOAD_LIMITS.minLimit} and ${POSTGRES_WORKLOAD_LIMITS.maxLimit}, got ${String(limit)}`,
         meta: { limit }
@@ -1338,7 +1475,7 @@ function renderPostgresWorkload(params) {
 function requireArg(params) {
   const { value, name, query } = params;
   if (value === undefined || value.length === 0) {
-    throw new VibeError6({
+    throw new VibeError7({
       code: "VIBE_CONFIG",
       message: `the "${query}" diagnostic read requires a ${name}`,
       meta: { query, argument: name }
@@ -1348,10 +1485,10 @@ function requireArg(params) {
 }
 
 // packages/sql/src/dialects/postgres-rls-readiness.ts
-import { unsupportedCapability as unsupportedCapability7 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
 
 // packages/sql/src/dialects/postgres-rls.ts
-import { RlsContextError, VibeError as VibeError7, assertValidSchemaIR, unsupportedCapability as unsupportedCapability6, validateRlsContextIR } from "@vibeorm/schema";
+import { RlsContextError, VibeError as VibeError8, assertValidSchemaIR, unsupportedCapability as unsupportedCapability7, validateRlsContextIR } from "@vibeorm/schema";
 var NATIVE_RLS = Object.freeze({ policyName: "vibeorm_managed", tableSchema: "public", settingPrefix: "vibeorm.", parentAlias: "parent" });
 var COLUMN_TYPES = {
   String: { default: "text", native: { text: "text", varchar: "varchar", charactervarying: "varchar", uuid: "uuid" } },
@@ -1364,18 +1501,18 @@ var COLUMN_TYPES = {
 };
 function requireRls(params) {
   if (!params.dialect.capabilities.nativeRowLevelSecurity) {
-    throw unsupportedCapability6({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
+    throw unsupportedCapability7({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
   }
 }
 function identifier2(params) {
   if (typeof params.name !== "string" || params.name.length === 0 || params.name.includes("\x00") || new TextEncoder().encode(params.name).length > 63) {
-    throw new VibeError7({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS identifiers must be nonempty PostgreSQL identifiers of at most 63 bytes" });
+    throw new VibeError8({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS identifiers must be nonempty PostgreSQL identifiers of at most 63 bytes" });
   }
   return params.dialect.quoteIdent({ name: params.name });
 }
 function tableRef(params) {
   if (params.schema !== undefined && params.schema !== "public" && params.schema !== "pg_temp") {
-    throw unsupportedCapability6({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: "Only public tables and temporary policy probes are supported" });
+    throw unsupportedCapability7({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: "Only public tables and temporary policy probes are supported" });
   }
   return `${identifier2({ dialect: params.dialect, name: params.schema ?? NATIVE_RLS.tableSchema })}.${identifier2({ dialect: params.dialect, name: params.table })}`;
 }
@@ -1416,14 +1553,14 @@ function renderRlsColumnType(params) {
     if (native !== undefined)
       return native;
   }
-  throw unsupportedCapability6({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: `Unsupported physical ownership type on field ${field.name}` });
+  throw unsupportedCapability7({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: `Unsupported physical ownership type on field ${field.name}` });
 }
 function protectedModel(params) {
   requireRls(params);
   assertValidSchemaIR({ schema: params.schema });
   const model = params.schema.models.find((entry) => entry.name === params.model);
   if (model === undefined || model.rls === undefined || model.rls === "unprotected") {
-    throw new VibeError7({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS policy rendering requires a protected model", meta: { model: params.model } });
+    throw new VibeError8({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS policy rendering requires a protected model", meta: { model: params.model } });
   }
   return model;
 }
@@ -1456,7 +1593,7 @@ function predicate(params) {
     }).join(" AND ");
     return `EXISTS (SELECT 1 FROM ${tableRef({ dialect, table: parent.dbName ?? parent.name })} AS ${alias} WHERE ${join})`;
   }
-  throw new VibeError7({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS requires a protected policy rule" });
+  throw new VibeError8({ code: "VIBE_SCHEMA_INVALID", message: "Native RLS requires a protected policy rule" });
 }
 function renderRlsPolicy(params) {
   const model = protectedModel(params);
@@ -1490,7 +1627,7 @@ function renderRlsContext(params) {
 function renderRlsRole(params) {
   requireRls(params);
   if (typeof params.role !== "string" || params.role.trim().length === 0 || params.role.includes("\x00")) {
-    throw new VibeError7({ code: "VIBE_CONFIG", message: "PGlite native RLS requires a trusted nonempty runtime role name" });
+    throw new VibeError8({ code: "VIBE_CONFIG", message: "PGlite native RLS requires a trusted nonempty runtime role name" });
   }
   const collector = new ParamCollector(params.dialect);
   return query({ text: `SELECT set_config('role', ${collector.add(params.role)}, true)`, values: collector.values });
@@ -1642,7 +1779,7 @@ ORDER BY c.relname, p.polname`,
 });
 function requireRls2(params) {
   if (!params.dialect.capabilities.nativeRowLevelSecurity) {
-    throw unsupportedCapability7({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
+    throw unsupportedCapability8({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
   }
 }
 function renderRlsReadinessQuery(params) {
@@ -1674,7 +1811,7 @@ function renderRlsPolicyPath(params) {
 }
 
 // packages/sql/src/render.ts
-import { internalError as internalError2, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
+import { internalError as internalError2, unsupportedCapability as unsupportedCapability9 } from "@vibeorm/schema";
 
 // packages/sql/src/like.ts
 function escapeLikePattern(params) {
@@ -1819,7 +1956,7 @@ function renderAggRef(dialect, agg) {
 function assertScalarArrays(dialect, feature) {
   if (dialect.capabilities.scalarArrays)
     return;
-  throw unsupportedCapability8({
+  throw unsupportedCapability9({
     dialect: dialect.name,
     feature,
     hint: "only postgres has native array columns \u2014 model the list as a related table instead"
@@ -1876,8 +2013,8 @@ function renderExpr(params) {
       const columns = expr.columns.map((column) => quoteCol(dialect, column));
       if (dialect.tupleInStrategy === "rowValue") {
         const tuples = expr.rows.map((row) => `(${collector.addMany(row).join(", ")})`);
-        const base2 = `(${columns.join(", ")}) IN (${tuples.join(", ")})`;
-        return expr.negate === true ? `NOT (${base2})` : base2;
+        const base = `(${columns.join(", ")}) IN (${tuples.join(", ")})`;
+        return expr.negate === true ? `NOT (${base})` : base;
       }
       const conjunctions = expr.rows.map((row) => {
         const terms = row.map((value, index) => `${columns[index]} = ${collector.add(value)}`);
@@ -1997,7 +2134,7 @@ function jsonPathString(path) {
     } else if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(segment)) {
       out += `.${segment}`;
     } else {
-      out += `."${segment.replaceAll('"', "\\\"")}"`;
+      out += `."${segment.replaceAll("\\", "\\\\").replaceAll('"', "\\\"")}"`;
     }
   }
   return out;
@@ -2029,7 +2166,7 @@ function renderJsonLike(params) {
 function renderJsonFilter(params) {
   const { dialect, expr, collector } = params;
   if (!dialect.supportedJsonOps.includes(expr.op)) {
-    throw unsupportedCapability8({
+    throw unsupportedCapability9({
       dialect: dialect.name,
       feature: `the json filter "${expr.op}"`,
       hint: `this dialect can express: ${dialect.supportedJsonOps.join(", ")}`
@@ -2037,25 +2174,25 @@ function renderJsonFilter(params) {
   }
   const cmp = expr.negate === true ? "<>" : "=";
   if (dialect.jsonPathMode === "operators") {
-    const column2 = quoteCol(dialect, expr.column);
+    const column = quoteCol(dialect, expr.column);
     const pathParam = `${collector.add(expr.path.map(String))}::text[]`;
     switch (expr.op) {
       case "equals":
-        return `(${column2} #> ${pathParam}) ${cmp} ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
+        return `(${column} #> ${pathParam}) ${cmp} ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
       case "string_contains":
       case "string_starts_with":
       case "string_ends_with":
-        return renderJsonLike({ dialect, target: `(${column2} #>> ${pathParam})`, expr, collector });
+        return renderJsonLike({ dialect, target: `(${column} #>> ${pathParam})`, expr, collector });
       case "array_contains":
-        return `(${column2} #> ${pathParam}) @> ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
+        return `(${column} #> ${pathParam}) @> ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
       case "array_starts_with":
-        return `(${column2} #> ${pathParam}) -> 0 = ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
+        return `(${column} #> ${pathParam}) -> 0 = ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
       case "array_ends_with":
-        return `(${column2} #> ${pathParam}) -> -1 = ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
+        return `(${column} #> ${pathParam}) -> -1 = ${collector.add(JSON.stringify(expr.value))}${dialect.jsonParamCast}`;
     }
   }
   if (dialect.jsonPathMode === "sqliteExtract") {
-    const column2 = quoteCol(dialect, expr.column);
+    const column = quoteCol(dialect, expr.column);
     const typeMatches = (type, value) => {
       if (typeof value === "number")
         return `${type} IN ('integer', 'real')`;
@@ -2063,11 +2200,11 @@ function renderJsonFilter(params) {
       return `${type} = '${tag}'`;
     };
     const compareExtracted = (path, value) => {
-      const type = `json_type(${column2}, ${collector.add(path)})`;
+      const type = `json_type(${column}, ${collector.add(path)})`;
       const guard = typeMatches(type, value);
       let base = guard;
       if (value !== null) {
-        const target = `json_extract(${column2}, ${collector.add(path)})`;
+        const target = `json_extract(${column}, ${collector.add(path)})`;
         const bound = typeof value === "boolean" ? value ? 1 : 0 : value;
         const operand = typeof value === "object" ? `json(${collector.add(JSON.stringify(value))})` : collector.add(bound);
         base = `(${guard} AND ${target} = ${operand})`;
@@ -2080,7 +2217,7 @@ function renderJsonFilter(params) {
       case "string_contains":
       case "string_starts_with":
       case "string_ends_with": {
-        const target = `json_extract(${column2}, ${collector.add(jsonPathString(expr.path))})`;
+        const target = `json_extract(${column}, ${collector.add(jsonPathString(expr.path))})`;
         return renderJsonLike({ dialect, target, expr, collector });
       }
       case "array_starts_with":
@@ -2089,11 +2226,11 @@ function renderJsonFilter(params) {
         return compareExtracted(`${jsonPathString(expr.path)}${edge}`, expr.value);
       }
       case "array_contains": {
-        const guard = `json_type(${column2}, ${collector.add(jsonPathString(expr.path))}) = 'array'`;
+        const guard = `json_type(${column}, ${collector.add(jsonPathString(expr.path))}) = 'array'`;
         const elements = Array.isArray(expr.value) ? expr.value : [expr.value];
         const tests = elements.map((element) => {
           if (element === null || typeof element === "object" && element !== null) {
-            throw unsupportedCapability8({
+            throw unsupportedCapability9({
               dialect: dialect.name,
               feature: "json array_contains with object/array/null elements",
               hint: "sqlite expresses scalar-element containment only \u2014 deep structural containment needs postgres or mysql"
@@ -2102,7 +2239,7 @@ function renderJsonFilter(params) {
           const bound = typeof element === "boolean" ? element ? 1 : 0 : element;
           const path = collector.add(jsonPathString(expr.path));
           const type = `${dialect.quoteIdent({ name: "json_each" })}.${dialect.quoteIdent({ name: "type" })}`;
-          return `EXISTS (SELECT 1 FROM json_each(${column2}, ${path}) WHERE ${typeMatches(type, element)} AND ${dialect.quoteIdent({ name: "json_each" })}.${dialect.quoteIdent({ name: "value" })} = ${collector.add(bound)})`;
+          return `EXISTS (SELECT 1 FROM json_each(${column}, ${path}) WHERE ${typeMatches(type, element)} AND ${dialect.quoteIdent({ name: "json_each" })}.${dialect.quoteIdent({ name: "value" })} = ${collector.add(bound)})`;
         });
         return tests.length === 0 ? guard : `(${[guard, ...tests].join(" AND ")})`;
       }
@@ -2244,7 +2381,7 @@ function renderSelect(params) {
   let distinctPrefix = "";
   if (statement.distinctOn !== undefined && statement.distinctOn.length > 0) {
     if (!dialect.capabilities.distinctOn) {
-      throw unsupportedCapability8({
+      throw unsupportedCapability9({
         dialect: dialect.name,
         feature: "SELECT DISTINCT ON",
         hint: "postgres-only \u2014 the runtime emulates distinct client-side on this dialect"
@@ -2275,7 +2412,7 @@ function renderSelect(params) {
   }
   if (statement.lateralJoins !== undefined && statement.lateralJoins.length > 0) {
     if (!dialect.capabilities.lateralJoin) {
-      throw unsupportedCapability8({
+      throw unsupportedCapability9({
         dialect: dialect.name,
         feature: "LATERAL JOIN relation loading",
         hint: 'use the portable "query" relation strategy on this dialect'
@@ -2360,7 +2497,7 @@ function renderInsert(params) {
         let target = "";
         if (onConflict.constraint !== undefined) {
           if (dialect.name !== "postgres") {
-            throw unsupportedCapability8({
+            throw unsupportedCapability9({
               dialect: dialect.name,
               feature: "a named-constraint conflict target (ON CONFLICT ON CONSTRAINT)",
               hint: "only postgres names constraints in conflict targets \u2014 use a column-list target"
@@ -2375,7 +2512,7 @@ function renderInsert(params) {
         }
         text += ` ON CONFLICT${target} DO NOTHING`;
       } else if (onConflict.constraint !== undefined || onConflict.conflictWhere !== undefined) {
-        throw unsupportedCapability8({
+        throw unsupportedCapability9({
           dialect: dialect.name,
           feature: "a refined conflict target (constraint / partial-index predicate) on INSERT IGNORE",
           hint: "mysql skips on any duplicate key \u2014 drop the refinement or gate the call per dialect"
@@ -2393,7 +2530,7 @@ function renderInsert(params) {
           throw internalError2({ message: "lastInsertIdColumn is a mysql (onDuplicateKey) construct" });
         }
         if (onConflict.constraint !== undefined && dialect.name !== "postgres") {
-          throw unsupportedCapability8({
+          throw unsupportedCapability9({
             dialect: dialect.name,
             feature: "a named-constraint conflict target (ON CONFLICT ON CONSTRAINT)",
             hint: "sqlite conflict targets are column lists \u2014 name the indexed columns instead"
@@ -2409,14 +2546,14 @@ function renderInsert(params) {
         text += ` ON CONFLICT${target} DO UPDATE SET ${assignments}`;
       } else {
         if (onConflict.constraint !== undefined) {
-          throw unsupportedCapability8({
+          throw unsupportedCapability9({
             dialect: dialect.name,
             feature: "a named-constraint conflict target on ON DUPLICATE KEY UPDATE",
             hint: "mysql's ODKU fires on any duplicate key \u2014 no target can be named"
           });
         }
         if (onConflict.conflictWhere !== undefined) {
-          throw unsupportedCapability8({
+          throw unsupportedCapability9({
             dialect: dialect.name,
             feature: "a partial-index conflict target on ON DUPLICATE KEY UPDATE",
             hint: "mysql's ODKU fires on any duplicate key \u2014 a partial arbiter cannot be selected; gate the call per dialect"
@@ -2499,20 +2636,20 @@ function renderDelete(params) {
   return { text: text + returning.suffix, values: collector.values, returning: returning.status };
 }
 // packages/sql/src/dialects/sqlite-table-definition.ts
-import { VibeError as VibeError8 } from "@vibeorm/schema";
+import { VibeError as VibeError9 } from "@vibeorm/schema";
 function tableDefinitionParts(params) {
-  const sql2 = params.sql;
-  if (!/^\s*CREATE\s+(?:TEMP(?:ORARY)?\s+)?TABLE\b/i.test(sql2))
+  const sql = params.sql;
+  if (!/^\s*CREATE\s+(?:TEMP(?:ORARY)?\s+)?TABLE\b/i.test(sql))
     throw unavailable();
   const parts = [];
   let start = -1;
   let depth = 0;
   let quote;
-  for (let index = 0;index < sql2.length; index++) {
-    const char = sql2[index];
+  for (let index = 0;index < sql.length; index++) {
+    const char = sql[index];
     if (quote !== undefined) {
       if (char === quote) {
-        if (quote !== "]" && sql2[index + 1] === quote)
+        if (quote !== "]" && sql[index + 1] === quote)
           index++;
         else
           quote = undefined;
@@ -2527,16 +2664,16 @@ function tableDefinitionParts(params) {
       quote = "]";
       continue;
     }
-    if (char === "-" && sql2[index + 1] === "-") {
-      const end = sql2.indexOf(`
+    if (char === "-" && sql[index + 1] === "-") {
+      const end = sql.indexOf(`
 `, index + 2);
       if (end < 0)
         break;
       index = end;
       continue;
     }
-    if (char === "/" && sql2[index + 1] === "*") {
-      const end = sql2.indexOf("*/", index + 2);
+    if (char === "/" && sql[index + 1] === "*") {
+      const end = sql.indexOf("*/", index + 2);
       if (end < 0)
         break;
       index = end + 1;
@@ -2549,18 +2686,18 @@ function tableDefinitionParts(params) {
     } else if (char === ")") {
       depth--;
       if (depth === 0 && start >= 0) {
-        parts.push(sql2.slice(start, index).trim());
-        return { clauses: parts, suffix: sql2.slice(index + 1) };
+        parts.push(sql.slice(start, index).trim());
+        return { clauses: parts, suffix: sql.slice(index + 1) };
       }
     } else if (char === "," && depth === 1) {
-      parts.push(sql2.slice(start, index).trim());
+      parts.push(sql.slice(start, index).trim());
       start = index + 1;
     }
   }
   throw unavailable();
 }
 function unavailable() {
-  return new VibeError8({ code: "VIBE_MIGRATION", message: "Cannot preserve table definition", meta: { reason: "table-definition-unavailable" } });
+  return new VibeError9({ code: "VIBE_MIGRATION", message: "Cannot preserve table definition", meta: { reason: "table-definition-unavailable" } });
 }
 function sqliteColumnClauses(params) {
   const columns = [];
@@ -2575,12 +2712,58 @@ function sqliteColumnClauses(params) {
   }
   return columns;
 }
+// packages/sql/src/dialects/postgres-type-identity.ts
+import { unsupportedCapability as unsupportedCapability10 } from "@vibeorm/schema";
+var IDENTIFIER = '(?:"(?:[^"\\x00]|"")+"|[a-zA-Z_][a-zA-Z_0-9$]*)';
+var MODIFIER_VALUE = `(?:[+-]?\\d+|${IDENTIFIER}|'(?:[^'\\x00]|'')*')`;
+var TYPE_NAME = new RegExp(`^\\s*(${IDENTIFIER})(?:\\s*\\.\\s*(${IDENTIFIER}))?\\s*(\\(\\s*${MODIFIER_VALUE}(?:\\s*,\\s*${MODIFIER_VALUE})*\\s*\\))?\\s*((?:\\[\\s*\\]\\s*)*)$`);
+var MODIFIER_TOKEN = new RegExp(MODIFIER_VALUE, "g");
+function modifier(params) {
+  if (params.raw === undefined)
+    return "";
+  const tokens = params.raw.slice(1, -1).match(MODIFIER_TOKEN) ?? [];
+  return `(${tokens.map((token) => /^[+-]?\d+$/.test(token) ? BigInt(token).toString() : token.startsWith("'") || token.startsWith('"') ? token : token.toLowerCase()).join(",")})`;
+}
+function identifier3(params) {
+  return params.value.startsWith('"') ? params.value.slice(1, -1).replaceAll('""', '"') : params.value.toLowerCase();
+}
+function parsePostgresTypeName(params) {
+  const match = TYPE_NAME.exec(params.raw);
+  if (match === null)
+    return;
+  return {
+    ...match[2] === undefined ? {} : { namespace: identifier3({ value: match[1] }) },
+    name: identifier3({ value: match[2] ?? match[1] }),
+    modifier: modifier({ ...match[3] === undefined ? {} : { raw: match[3] } }),
+    array: (match[4]?.length ?? 0) > 0
+  };
+}
+function renderPostgresTypeName(params) {
+  if (params.dialect.name !== "postgres")
+    throw unsupportedCapability10({ dialect: params.dialect.name, feature: "postgresTypeIdentity" });
+  const { dialect, type } = params;
+  return `${type.namespace === undefined ? "" : `${dialect.quoteIdent({ name: type.namespace })}.`}${dialect.quoteIdent({ name: type.name })}${type.modifier}${type.array ? "[]" : ""}`;
+}
+function renderPostgresTypeIdentity(params) {
+  if (params.dialect.name !== "postgres")
+    throw unsupportedCapability10({ dialect: params.dialect.name, feature: "postgresTypeIdentity" });
+  const collector = new ParamCollector(params.dialect);
+  const { source } = params;
+  let text;
+  if ("table" in source) {
+    text = `SELECT tn.nspname::text AS "namespace", base.typname::text AS "name" FROM pg_catalog.pg_attribute a JOIN pg_catalog.pg_class c ON c.oid = a.attrelid JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace JOIN pg_catalog.pg_type t ON t.oid = a.atttypid JOIN pg_catalog.pg_type base ON base.oid = CASE WHEN t.typelem <> 0 AND t.typlen = -1 THEN t.typelem ELSE t.oid END JOIN pg_catalog.pg_namespace tn ON tn.oid = base.typnamespace WHERE n.nspname = ${collector.add(source.table.namespace)} AND c.relname = ${collector.add(source.table.name)} AND a.attname = ${collector.add(source.column)} AND a.attnum > 0 AND NOT a.attisdropped`;
+  } else {
+    const name = renderPostgresTypeName({ dialect: params.dialect, type: { ...source.type, modifier: "", array: false } });
+    text = `SELECT n.nspname::text AS "namespace", t.typname::text AS "name" FROM pg_catalog.pg_type t JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace WHERE t.oid = pg_catalog.to_regtype(${collector.add(name)})`;
+  }
+  return { text, values: collector.values, returning: "none" };
+}
 // packages/sql/src/dialects/postgres-default-identity.ts
-import { unsupportedCapability as unsupportedCapability9 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability11 } from "@vibeorm/schema";
 function renderPostgresDefaultFunctionIdentity(params) {
   const { dialect, table, column } = params;
   if (dialect.name !== "postgres")
-    throw unsupportedCapability9({ dialect: dialect.name, feature: "defaultFunctionIdentity" });
+    throw unsupportedCapability11({ dialect: dialect.name, feature: "defaultFunctionIdentity" });
   const collector = new ParamCollector(dialect);
   const namespace = collector.add(table.namespace);
   const name = collector.add(table.name);
@@ -2604,28 +2787,28 @@ WHERE n.nspname = ${namespace} AND c.relname = ${name} AND a.attname = ${field}
   };
 }
 // packages/sql/src/dialects/constraint-owned-index.ts
-import { unsupportedCapability as unsupportedCapability10 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability12 } from "@vibeorm/schema";
 function renderConstraintOwnedIndexDrop(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability10({ dialect: params.dialect.name, feature: "constraintOwnedIndexDrop" });
+    throw unsupportedCapability12({ dialect: params.dialect.name, feature: "constraintOwnedIndexDrop" });
   const quote = (name) => params.dialect.quoteIdent({ name });
   return { text: `ALTER TABLE ${quote(params.table)} DROP CONSTRAINT ${quote(params.constraint)};`, values: [], returning: "none" };
 }
 // packages/sql/src/dialects/mysql-check-probe.ts
-import { unsupportedCapability as unsupportedCapability11 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability13 } from "@vibeorm/schema";
 function renderMysqlCheckProbe(params) {
   if (params.dialect.name !== "mysql")
-    throw unsupportedCapability11({ dialect: params.dialect.name, feature: "temporaryCheckProbe" });
+    throw unsupportedCapability13({ dialect: params.dialect.name, feature: "temporaryCheckProbe" });
   const q = (name) => params.dialect.quoteIdent({ name });
   const probe = q(params.probe);
   switch (params.operation) {
     case "clone":
       if (params.table === undefined)
-        throw unsupportedCapability11({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "A source table is required" });
+        throw unsupportedCapability13({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "A source table is required" });
       return { text: `CREATE TEMPORARY TABLE ${probe} LIKE ${q(params.table.namespace)}.${q(params.table.name)}`, values: [], returning: "none" };
     case "add": {
       if (params.expression === undefined || params.definition === undefined)
-        throw unsupportedCapability11({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "An authored expression and temporary clone definition are required" });
+        throw unsupportedCapability13({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "An authored expression and temporary clone definition are required" });
       const parts = tableDefinitionParts({ sql: params.definition });
       return { text: `CREATE TEMPORARY TABLE ${probe} (
 ${[...parts.clauses, `CONSTRAINT ${probe} CHECK (${params.expression})`].join(`,
@@ -2644,8 +2827,8 @@ function renderMigrationHistoryQuery(params) {
   return { text: `SELECT ${q("name")}, ${q("checksum")}, ${q("statement_index")}, ${q("error")} FROM ${q(params.namespace)}.${q("_vibe_migrations")} ORDER BY ${q("id")}`, values: [], returning: "none" };
 }
 // packages/sql/src/dialects/sqlite-constraints.ts
-var IDENTIFIER = '(?:"(?:[^" ]| |"")+"|`(?:[^`]|``)+`|\\[[^\\]]+\\]|[A-Za-z_][A-Za-z_0-9]*)';
-function identifier3(value) {
+var IDENTIFIER2 = '(?:"(?:[^" ]| |"")+"|`(?:[^`]|``)+`|\\[[^\\]]+\\]|[A-Za-z_][A-Za-z_0-9]*)';
+function identifier4(value) {
   const text = value.trim();
   if (text.startsWith('"'))
     return text.slice(1, -1).replaceAll('""', '"');
@@ -2658,44 +2841,44 @@ function identifier3(value) {
 function sqliteTableConstraints(params) {
   const result = [];
   for (const clause of tableDefinitionParts(params).clauses) {
-    const named = new RegExp(`^CONSTRAINT\\s+(${IDENTIFIER})\\s+`, "i").exec(clause);
+    const named = new RegExp(`^CONSTRAINT\\s+(${IDENTIFIER2})\\s+`, "i").exec(clause);
     const body = named === null ? clause : clause.slice(named[0].length);
     const kind = /^(CHECK|FOREIGN\s+KEY|UNIQUE|PRIMARY\s+KEY)\s*\(/i.exec(body);
     if (kind === null)
       continue;
     const type = /^CHECK$/i.test(kind[1]) ? "check" : /^FOREIGN/i.test(kind[1]) ? "foreignKey" : /^PRIMARY/i.test(kind[1]) ? "primaryKey" : "unique";
     const parts = tableDefinitionParts({ sql: `CREATE TABLE x ${body.slice(kind[0].indexOf("("))}` });
-    const columns = type === "check" ? [] : parts.clauses.map(identifier3);
-    result.push({ name: named === null ? `@sqlite:${type}:${result.length}` : identifier3(named[1]), named: named !== null, type, sql: body, columns });
+    const columns = type === "check" ? [] : parts.clauses.map(identifier4);
+    result.push({ name: named === null ? `@sqlite:${type}:${result.length}` : identifier4(named[1]), named: named !== null, type, sql: body, columns });
   }
   return result;
 }
 // packages/sql/src/dialects/migration-visibility.ts
-import { unsupportedCapability as unsupportedCapability12 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability14 } from "@vibeorm/schema";
 function renderMigrationVisibility(params) {
   if (params.dialect.name !== "mysql")
-    throw unsupportedCapability12({ dialect: params.dialect.name, feature: "mysqlCatalogVisibility" });
+    throw unsupportedCapability14({ dialect: params.dialect.name, feature: "mysqlCatalogVisibility" });
   const collector = new ParamCollector(params.dialect);
   const grantee = "CONCAT(QUOTE(SUBSTRING_INDEX(CURRENT_USER(), '@', 1)), '@', QUOTE(SUBSTRING_INDEX(CURRENT_USER(), '@', -1)))";
   return { text: `SELECT PRIVILEGE_TYPE AS privilege FROM information_schema.USER_PRIVILEGES WHERE GRANTEE = ${grantee} UNION SELECT PRIVILEGE_TYPE AS privilege FROM information_schema.SCHEMA_PRIVILEGES WHERE GRANTEE = ${grantee} AND ${collector.add(params.namespace)} LIKE TABLE_SCHEMA`, values: collector.values, returning: "none" };
 }
 // packages/sql/src/dialects/migration-inventory.ts
-import { unsupportedCapability as unsupportedCapability13 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability15 } from "@vibeorm/schema";
 function renderSqliteColumnInventory(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability13({ dialect: params.dialect.name, feature: "sqliteColumnInventory" });
+    throw unsupportedCapability15({ dialect: params.dialect.name, feature: "sqliteColumnInventory" });
   const collector = new ParamCollector(params.dialect);
   return { text: `SELECT name, hidden, pk, dflt_value AS definition FROM pragma_table_xinfo(${collector.add(params.table)}, ${collector.add(params.namespace)}) ORDER BY cid`, values: collector.values, returning: "none" };
 }
 function renderSqliteForeignKeyInventory(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability13({ dialect: params.dialect.name, feature: "sqliteForeignKeyInventory" });
+    throw unsupportedCapability15({ dialect: params.dialect.name, feature: "sqliteForeignKeyInventory" });
   const collector = new ParamCollector(params.dialect);
   return { text: `SELECT id, seq, "from", "to", "table", on_update, on_delete, match FROM pragma_foreign_key_list(${collector.add(params.table)}, ${collector.add(params.namespace)}) ORDER BY id, seq`, values: collector.values, returning: "none" };
 }
 function renderSqliteRebuildObjects(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability13({ dialect: params.dialect.name, feature: "sqliteRebuildObjects" });
+    throw unsupportedCapability15({ dialect: params.dialect.name, feature: "sqliteRebuildObjects" });
   return { text: "SELECT name, tbl_name, type, sql FROM main.sqlite_schema WHERE type IN ('index', 'trigger') AND sql IS NOT NULL ORDER BY type, name", values: [], returning: "none" };
 }
 function renderMigrationInventory(params) {
@@ -2732,10 +2915,12 @@ ORDER BY kind, parent, name`, values: collector.values, returning: "none" };
   return { text: `SELECT type AS kind, name, tbl_name AS parent, sql AS definition FROM ${schema}.sqlite_schema WHERE name NOT LIKE 'sqlite\\_%' ESCAPE '\\' AND name <> '_vibe_migrations' ORDER BY type, tbl_name, name`, values: [], returning: "none" };
 }
 // packages/sql/src/dialects/migration-objects.ts
-import { unsupportedCapability as unsupportedCapability14 } from "@vibeorm/schema";
+import { internalError as internalError3, unsupportedCapability as unsupportedCapability16 } from "@vibeorm/schema";
 function renderMigrationObjectQuery(params) {
-  const { dialect, identity: object } = params;
-  const collector = new ParamCollector(dialect);
+  return objectQuery({ ...params, collector: new ParamCollector(params.dialect) });
+}
+function objectQuery(params) {
+  const { dialect, identity: object, collector } = params;
   const physical = "table" in object ? object.table : object.name;
   const namespace = collector.add(physical.namespace);
   const name = collector.add(physical.name);
@@ -2753,7 +2938,7 @@ function renderMigrationObjectQuery(params) {
         text = `SELECT pg_catalog.pg_get_triggerdef(t.oid, false) AS "definition", t.tgenabled::text AS "enabled", pn.nspname::text AS "functionNamespace", p.proname::text AS "functionName", pg_catalog.pg_get_function_identity_arguments(p.oid) AS "functionArguments" ${relation} JOIN pg_catalog.pg_trigger t ON t.tgrelid = c.oid JOIN pg_catalog.pg_proc p ON p.oid = t.tgfoid JOIN pg_catalog.pg_namespace pn ON pn.oid = p.pronamespace WHERE ${where} AND t.tgname = ${collector.add(object.name)} AND NOT t.tgisinternal`;
         break;
       case "function":
-        text = `SELECT pg_catalog.pg_get_functiondef(p.oid) AS "definition", p.provolatile::text AS "volatility", p.prosecdef AS "securityDefiner", p.proisstrict AS "strict", p.proconfig::text AS "config", pg_catalog.pg_get_function_result(p.oid) AS "result" FROM pg_catalog.pg_proc p JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace WHERE n.nspname = ${namespace} AND p.proname = ${name} AND p.prokind = 'f' AND ARRAY(SELECT tn.nspname || '.' || t.typname FROM unnest(p.proargtypes) WITH ORDINALITY a(oid, ord) JOIN pg_catalog.pg_type t ON t.oid = a.oid JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace ORDER BY a.ord) = ${collector.add(object.argumentTypes.map((type) => `${type.namespace}.${type.name}`))}::text[]`;
+        text = `SELECT pg_catalog.pg_get_functiondef(p.oid) AS "definition", p.provolatile::text AS "volatility", p.prosecdef AS "securityDefiner", CASE WHEN p.prosecdef THEN pg_catalog.pg_get_userbyid(p.proowner)::text ELSE NULL END AS "definerOwner", p.proisstrict AS "strict", p.proconfig::text AS "config", pg_catalog.pg_get_function_result(p.oid) AS "result" FROM pg_catalog.pg_proc p JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace WHERE n.nspname = ${namespace} AND p.proname = ${name} AND p.prokind = 'f' AND ARRAY(SELECT tn.nspname || '.' || t.typname FROM unnest(p.proargtypes) WITH ORDINALITY a(oid, ord) JOIN pg_catalog.pg_type t ON t.oid = a.oid JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace ORDER BY a.ord) = ${collector.add(object.argumentTypes.map((type) => `${type.namespace}.${type.name}`))}::text[]`;
         break;
       case "view":
         text = `SELECT pg_catalog.pg_get_viewdef(c.oid, false) AS "definition", c.relkind::text AS "type", c.reloptions::text AS "options" ${relation} WHERE ${where} AND c.relkind IN ('v', 'm')`;
@@ -2764,7 +2949,7 @@ function renderMigrationObjectQuery(params) {
       case "column":
       case "columnDefault":
       case "generatedColumn":
-        text = `SELECT pg_catalog.format_type(a.atttypid, a.atttypmod) AS "type", a.attnotnull AS "notNull", a.attgenerated::text AS "generated", a.attidentity::text AS "identity", pg_catalog.pg_get_expr(d.adbin, d.adrelid, false) AS "definition" ${relation} JOIN pg_catalog.pg_attribute a ON a.attrelid = c.oid LEFT JOIN pg_catalog.pg_attrdef d ON d.adrelid = c.oid AND d.adnum = a.attnum WHERE ${where} AND a.attname = ${collector.add(object.column)} AND a.attnum > 0 AND NOT a.attisdropped`;
+        text = `SELECT pg_catalog.format_type(a.atttypid, a.atttypmod) AS "type", a.attnotnull AS "notNull", a.attgenerated::text AS "generated", a.attidentity::text AS "identity", cn.nspname::text AS "collationNamespace", coll.collname::text AS "collationName", pg_catalog.pg_get_expr(d.adbin, d.adrelid, false) AS "definition" ${relation} JOIN pg_catalog.pg_attribute a ON a.attrelid = c.oid LEFT JOIN pg_catalog.pg_collation coll ON coll.oid = a.attcollation LEFT JOIN pg_catalog.pg_namespace cn ON cn.oid = coll.collnamespace LEFT JOIN pg_catalog.pg_attrdef d ON d.adrelid = c.oid AND d.adnum = a.attnum WHERE ${where} AND a.attname = ${collector.add(object.column)} AND a.attnum > 0 AND NOT a.attisdropped`;
         break;
       case "index":
         text = `SELECT pg_catalog.pg_get_indexdef(i.indexrelid, 0, false) AS "definition", i.indisunique AS "unique", i.indisvalid AS "valid", i.indisready AS "ready", con.conname::text AS "constraint", con.contype::text AS "constraintType" ${relation} JOIN pg_catalog.pg_index i ON i.indrelid = c.oid JOIN pg_catalog.pg_class ix ON ix.oid = i.indexrelid LEFT JOIN pg_catalog.pg_constraint con ON con.conindid = i.indexrelid AND con.contype IN ('p', 'u', 'x') WHERE ${where} AND ix.relname = ${collector.add(object.name)}`;
@@ -2793,11 +2978,11 @@ function renderMigrationObjectQuery(params) {
       case "column":
       case "columnDefault":
       case "generatedColumn":
-        text = `SELECT COLUMN_TYPE AS type, IS_NULLABLE AS nullable, COLUMN_DEFAULT AS definition, GENERATION_EXPRESSION AS generated, EXTRA AS extra, COLLATION_NAME AS collation FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = ${namespace} AND TABLE_NAME = ${name} AND COLUMN_NAME = ${collector.add(object.column)}`;
+        text = `SELECT COLUMN_TYPE AS type, IS_NULLABLE AS nullable, COLUMN_DEFAULT AS definition, GENERATION_EXPRESSION AS ${dialect.quoteIdent({ name: "generated" })}, EXTRA AS extra, COLLATION_NAME AS collation FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = ${namespace} AND TABLE_NAME = ${name} AND COLUMN_NAME = ${collector.add(object.column)}`;
         break;
       case "constraint":
         if (object.constraintType === "exclusion")
-          throw unsupportedCapability14({ dialect: "mysql", feature: "exclusionConstraints" });
+          throw unsupportedCapability16({ dialect: "mysql", feature: "exclusionConstraints" });
         text = `SELECT tc.CONSTRAINT_TYPE AS type, tc.ENFORCED AS enforced, cc.CHECK_CLAUSE AS definition, rc.UPDATE_RULE AS onUpdate, rc.DELETE_RULE AS onDelete, rc.MATCH_OPTION AS matchOption FROM information_schema.TABLE_CONSTRAINTS tc LEFT JOIN information_schema.CHECK_CONSTRAINTS cc ON cc.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA AND cc.CONSTRAINT_NAME = tc.CONSTRAINT_NAME LEFT JOIN information_schema.REFERENTIAL_CONSTRAINTS rc ON rc.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA AND rc.TABLE_NAME = tc.TABLE_NAME AND rc.CONSTRAINT_NAME = tc.CONSTRAINT_NAME WHERE tc.TABLE_SCHEMA = ${namespace} AND tc.TABLE_NAME = ${name} AND tc.CONSTRAINT_NAME = ${collector.add(object.name)}`;
         break;
       case "index":
@@ -2807,15 +2992,15 @@ function renderMigrationObjectQuery(params) {
         text = `SELECT TABLE_TYPE AS type, ENGINE AS engine, TABLE_COLLATION AS collation FROM information_schema.TABLES WHERE TABLE_SCHEMA = ${namespace} AND TABLE_NAME = ${name}`;
         break;
       default:
-        throw unsupportedCapability14({ dialect: "mysql", feature: `inspect:${object.kind}` });
+        throw unsupportedCapability16({ dialect: "mysql", feature: `inspect:${object.kind}` });
     }
   } else {
     if (physical.namespace !== "main" && physical.namespace !== "temp")
-      throw unsupportedCapability14({ dialect: "sqlite", feature: "attachedSchemaInspection" });
+      throw unsupportedCapability16({ dialect: "sqlite", feature: "attachedSchemaInspection" });
     const catalog = `${dialect.quoteIdent({ name: physical.namespace })}.sqlite_schema`;
     const kind = object.kind === "table" || object.kind === "view" ? object.kind : object.kind === "trigger" ? "trigger" : object.kind === "index" ? "index" : "table";
     if (["function", "sequence", "postgresExtension", "enum"].includes(object.kind) || object.kind === "constraint" && object.constraintType === "exclusion")
-      throw unsupportedCapability14({ dialect: "sqlite", feature: `inspect:${object.kind}` });
+      throw unsupportedCapability16({ dialect: "sqlite", feature: `inspect:${object.kind}` });
     const sqliteParams = new ParamCollector(dialect);
     if (object.kind === "column" || object.kind === "columnDefault" || object.kind === "generatedColumn") {
       text = `SELECT x.type AS type, x."notnull" AS "notNull", x.pk AS primaryKeyPosition, x.hidden AS generated, x.dflt_value AS definition, (SELECT sql FROM ${catalog} WHERE name = ${sqliteParams.add(physical.name)} AND type = 'table') AS tableDefinition FROM pragma_table_xinfo(${sqliteParams.add(physical.name)}, ${sqliteParams.add(physical.namespace)}) x WHERE x.name = ${sqliteParams.add(object.column)}`;
@@ -2841,11 +3026,14 @@ function renderMysqlObjectMembers(params) {
   return { text, values: collector.values, returning: "none" };
 }
 function renderMigrationDependencies(params) {
+  return dependencyQuery({ ...params, collector: new ParamCollector(params.dialect) });
+}
+function dependencyQuery(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability14({ dialect: params.dialect.name, feature: "catalogDependencies" });
+    throw unsupportedCapability16({ dialect: params.dialect.name, feature: "catalogDependencies" });
   const object = params.identity;
   const physical = "table" in object ? object.table : object.name;
-  const collector = new ParamCollector(params.dialect);
+  const collector = params.collector;
   const namespace = collector.add(physical.namespace);
   const name = collector.add(physical.name);
   const relation = `SELECT c.oid FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = ${namespace} AND c.relname = ${name}`;
@@ -2885,6 +3073,41 @@ function renderMigrationDependencies(params) {
   }
   return { text: `SELECT DISTINCT json_build_array(d.deptype, a.type, a.object_names, a.object_args)::text AS address FROM (${source}) s JOIN pg_catalog.pg_depend d ON d.classid = s.classid AND d.objid = s.objid AND d.objsubid = s.objsubid CROSS JOIN LATERAL pg_catalog.pg_identify_object_as_address(d.refclassid, d.refobjid, d.refobjsubid) a ORDER BY address`, values: collector.values, returning: "none" };
 }
+function inspectionReferences(params) {
+  const values = [];
+  return { values, add(value) {
+    values.push(value);
+    return `request.${params.dialect.quoteIdent({ name: `p${values.length}` })}`;
+  } };
+}
+function renderMigrationObjectBatch(params) {
+  const { dialect } = params;
+  if (dialect.name !== "postgres")
+    throw unsupportedCapability16({ dialect: dialect.name, feature: "batchedMigrationInspection" });
+  const groups = new Map;
+  for (const [position, identity] of params.identities.entries()) {
+    const kind = identity.kind === "constraint" ? `${identity.kind}:${identity.constraintType}` : identity.kind === "generatedColumn" ? "columnDefault" : identity.kind;
+    const group = groups.get(kind) ?? [];
+    group.push({ identity, position });
+    groups.set(kind, group);
+  }
+  return [...groups.values()].map((group) => {
+    const identity = group[0].identity;
+    const facts = objectQuery({ dialect, identity, collector: inspectionReferences({ dialect }) });
+    const dependencies = dependencyQuery({ dialect, identity, collector: inspectionReferences({ dialect }) });
+    if (JSON.stringify(dependencies.values) !== JSON.stringify(facts.values))
+      throw internalError3({ message: "Batched catalog queries bind their identity in different orders", meta: { kind: identity.kind } });
+    const columns = facts.values.map((value, index) => `${dialect.quoteIdent({ name: `p${index + 1}` })} ${Array.isArray(value) ? "text[]" : "text"}`);
+    const requests = group.map(({ identity, position }) => ({ position, ...Object.fromEntries(renderMigrationObjectQuery({ dialect, identity }).values.map((value, index) => [`p${index + 1}`, value])) }));
+    const collector = new ParamCollector(dialect);
+    return {
+      text: `SELECT request.position, to_jsonb(facts) AS facts, ARRAY(SELECT address FROM (${dependencies.text}) dependency ORDER BY address) AS "dependencyAddresses" FROM jsonb_to_recordset(${collector.add(JSON.stringify(requests))}::text::jsonb) AS request(position integer, ${columns.join(", ")}) CROSS JOIN LATERAL (${facts.text}) facts`,
+      values: collector.values,
+      returning: "none",
+      positions: group.map(({ position }) => position)
+    };
+  });
+}
 function renderMigrationServerVersion(params) {
   return { text: params.dialect.name === "sqlite" ? "SELECT sqlite_version() AS version" : "SELECT version() AS version", values: [], returning: "none" };
 }
@@ -2893,16 +3116,16 @@ function renderMigrationNamespace(params) {
 }
 function renderCheckProbe(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability14({ dialect: params.dialect.name, feature: "rollbackCheckProbe" });
+    throw unsupportedCapability16({ dialect: params.dialect.name, feature: "rollbackCheckProbe" });
   const q = (name) => params.dialect.quoteIdent({ name });
   return { text: `ALTER TABLE ${q(params.table.namespace)}.${q(params.table.name)} ADD CONSTRAINT ${q(params.name)} CHECK (${params.expression}) NOT VALID`, values: [], returning: "none" };
 }
 // packages/sql/src/dialects/postgres-migration.ts
-import { VibeError as VibeError9, unsupportedCapability as unsupportedCapability15 } from "@vibeorm/schema";
+import { VibeError as VibeError10, unsupportedCapability as unsupportedCapability17 } from "@vibeorm/schema";
 var SETTING_VALUE = /^[0-9]+(?:\.[0-9]+)?\s*(?:us|ms|s|min|h|d)?$/;
 function requirePostgres2(params) {
   if (params.dialect.name !== "postgres") {
-    throw unsupportedCapability15({ dialect: params.dialect.name, feature: params.feature });
+    throw unsupportedCapability17({ dialect: params.dialect.name, feature: params.feature });
   }
 }
 function renderMigrationSessionRead(params) {
@@ -2917,7 +3140,7 @@ function renderMigrationSessionSet(params) {
   requirePostgres2({ dialect: params.dialect, feature: "migrationSessionSettings" });
   const { milliseconds, setting } = params;
   if (!Number.isSafeInteger(milliseconds) || milliseconds < 0) {
-    throw new VibeError9({
+    throw new VibeError10({
       code: "VIBE_MIGRATION",
       message: `${setting} must be a non-negative integer number of milliseconds (got ${String(milliseconds)})`,
       meta: { reason: "execution-metadata-invalid", setting, value: milliseconds }
@@ -3005,113 +3228,122 @@ WHERE n.nspname = pg_catalog.current_schema() AND c.relname = ${table} AND a.att
   };
 }
 export {
-  toPgArrayLiteral,
-  strictMatchPattern,
-  startsWithPattern,
-  sqliteTableConstraints,
-  sqliteDialect,
-  sqliteColumnClauses,
-  sqlUsesIncoming,
-  sql,
-  renderStatement,
-  renderSqliteRebuildObjects,
-  renderSqliteForeignKeyInventory,
-  renderSqliteColumnInventory,
-  renderSqlFragment,
-  renderRowLockClause,
-  renderRlsRole,
-  renderRlsReadinessQuery,
-  renderRlsProbeTable,
-  renderRlsPredicate,
-  renderRlsPolicyPath,
-  renderRlsPolicy,
-  renderRlsNoForce,
-  renderRlsForce,
-  renderRlsEnable,
-  renderRlsDropPolicy,
-  renderRlsDisable,
-  renderRlsContext,
-  renderRlsColumnType,
-  renderRelationStateQuery,
-  renderPredicate,
-  renderPostgresWorkload,
-  renderPostgresExplain,
-  renderPostgresDefaultFunctionIdentity,
-  renderMysqlObjectMembers,
-  renderMysqlCheckProbe,
-  renderModuleJournal,
-  renderMigrationVisibility,
-  renderMigrationSessionSet,
-  renderMigrationSessionRestore,
-  renderMigrationSessionRead,
-  renderMigrationServerVersion,
-  renderMigrationObjectQuery,
-  renderMigrationNamespace,
-  renderMigrationInventory,
-  renderMigrationHistoryQuery,
-  renderMigrationDependencies,
-  renderIndexStateQuery,
-  renderFragment,
-  renderExpr,
-  renderExclusionSetup,
-  renderExclusionProbe,
-  renderExclusionDdl,
-  renderExclusionCatalog,
-  renderDiagnostic,
-  renderConstraintStateQuery,
-  renderConstraintOwnedIndexDrop,
-  renderColumnStateQuery,
-  renderCheckProbe,
-  renderAdvisoryLock,
-  projectionOutputName,
-  postgresDialect,
-  parsePgArrayLiteral,
-  parseDateTimeText,
-  mysqlDialect,
-  mapConflictColumns,
-  jsonParamCell,
-  isSqlFragment,
-  isSqlDefaultCell,
-  isSetOperation,
-  isListSetOperation,
-  isJsonParamCell,
-  isFixedDiagnostic,
-  isExcludedRef,
-  isDbNowMarker,
-  getSqlDialect,
-  excludedRef,
-  escapeLikePattern,
-  escapeGlobPattern,
-  enumMembershipCodec,
-  endsWithPattern,
-  describeRowLock,
-  decodeIsNoop,
-  decode,
-  dbNowMarker,
-  containsPattern,
-  compileSql,
-  compileExclusion,
-  SQL_DIALECTS,
-  SQL_DEFAULT_CELL,
-  SQLITE_SESSION_SQL,
-  SQLITE_CODECS,
-  SQLITE_CAPABILITIES,
-  RLS_READINESS_SQL,
-  ParamCollector,
-  POSTGRES_WORKLOAD_LIMITS,
-  POSTGRES_DIAGNOSTIC_SQL,
-  POSTGRES_CODECS,
-  POSTGRES_CAPABILITIES,
-  NATIVE_RLS_PROBE_POLICY,
-  NATIVE_RLS,
-  MYSQL_CODECS,
-  MYSQL_CAPABILITIES,
-  MODULE_JOURNAL_COLUMN,
-  JSON_TRANSPORT,
-  DIALECT_CODECS,
-  DIALECT_CAPABILITIES,
+  ADVISORY_KEY_BOUNDS,
   ADVISORY_LOCK_RESULT_COLUMN,
-  ADVISORY_KEY_BOUNDS
+  DIALECT_CAPABILITIES,
+  DIALECT_CODECS,
+  JSON_TRANSPORT,
+  MODULE_JOURNAL_COLUMN,
+  MYSQL_CAPABILITIES,
+  MYSQL_CODECS,
+  NATIVE_RLS,
+  NATIVE_RLS_PROBE_POLICY,
+  POSTGRES_CAPABILITIES,
+  POSTGRES_CODECS,
+  POSTGRES_DIAGNOSTIC_SQL,
+  POSTGRES_WORKLOAD_LIMITS,
+  ParamCollector,
+  RLS_READINESS_SQL,
+  SHADOW_CAPABILITIES,
+  SHADOW_DATABASE,
+  SQLITE_CAPABILITIES,
+  SQLITE_CODECS,
+  SQLITE_SESSION_SQL,
+  SQL_DEFAULT_CELL,
+  SQL_DIALECTS,
+  compileExclusion,
+  compileSql,
+  containsPattern,
+  dbNowMarker,
+  decode,
+  decodeIsNoop,
+  describeRowLock,
+  endsWithPattern,
+  enumMembershipCodec,
+  escapeGlobPattern,
+  escapeLikePattern,
+  excludedRef,
+  getSqlDialect,
+  isDbNowMarker,
+  isExcludedRef,
+  isFixedDiagnostic,
+  isJsonParamCell,
+  isListSetOperation,
+  isSetOperation,
+  isSqlDefaultCell,
+  isSqlFragment,
+  jsonParamCell,
+  mapConflictColumns,
+  mysqlDialect,
+  parseDateTimeText,
+  parsePgArrayLiteral,
+  parsePostgresTypeName,
+  postgresDialect,
+  projectionOutputName,
+  renderAdvisoryLock,
+  renderCheckProbe,
+  renderColumnStateQuery,
+  renderConstraintOwnedIndexDrop,
+  renderConstraintStateQuery,
+  renderDiagnostic,
+  renderExclusionCatalog,
+  renderExclusionDdl,
+  renderExclusionProbe,
+  renderExclusionSetup,
+  renderExpr,
+  renderFragment,
+  renderIndexStateQuery,
+  renderMigrationDependencies,
+  renderMigrationHistoryQuery,
+  renderMigrationInventory,
+  renderMigrationNamespace,
+  renderMigrationObjectBatch,
+  renderMigrationObjectQuery,
+  renderMigrationServerVersion,
+  renderMigrationSessionRead,
+  renderMigrationSessionRestore,
+  renderMigrationSessionSet,
+  renderMigrationVisibility,
+  renderModuleDependencyQuery,
+  renderModuleJournal,
+  renderMysqlCheckProbe,
+  renderMysqlObjectMembers,
+  renderPostgresDefaultFunctionIdentity,
+  renderPostgresExplain,
+  renderPostgresTypeIdentity,
+  renderPostgresTypeName,
+  renderPostgresWorkload,
+  renderPredicate,
+  renderRelationStateQuery,
+  renderReplayCoverageGaps,
+  renderRlsColumnType,
+  renderRlsContext,
+  renderRlsDisable,
+  renderRlsDropPolicy,
+  renderRlsEnable,
+  renderRlsForce,
+  renderRlsNoForce,
+  renderRlsPolicy,
+  renderRlsPolicyPath,
+  renderRlsPredicate,
+  renderRlsProbeTable,
+  renderRlsReadinessQuery,
+  renderRlsRole,
+  renderRowLockClause,
+  renderShadowOperation,
+  renderSqlFragment,
+  renderSqliteColumnInventory,
+  renderSqliteForeignKeyInventory,
+  renderSqliteRebuildObjects,
+  renderStatement,
+  sql,
+  sqlUsesIncoming,
+  sqliteColumnClauses,
+  sqliteDialect,
+  sqliteTableConstraints,
+  startsWithPattern,
+  strictMatchPattern,
+  toPgArrayLiteral
 };
 
-//# debugId=760F5D93FBC694E964756E2164756E21
+//# debugId=C1F0ADA45113049064756E2164756E21