@vibeorm/sql 5.10.0 → 5.11.0

package/dist/index.js

@@ -3605,6 +3605,9 @@ function renderSqliteJsonEquality(params) {
   return `(SELECT CASE WHEN ${left} IS NULL THEN NULL ELSE NOT EXISTS (` + `WITH RECURSIVE ${tree} AS (` + `SELECT 1 AS ${side}, ${id}, ${parentId}, ${key}, ${type}, ${atom} FROM json_tree(CASE WHEN json_valid(${left}) THEN ${left} ELSE 'null' END) ` + `UNION ALL SELECT -1 AS ${side}, ${id}, ${parentId}, ${key}, ${type}, ${atom} FROM json_tree(${right})` + `), ${paths} (${side}, ${id}, ${path}, ${type}, ${atom}) AS (` + `SELECT ${side}, ${id}, json_array(), ${type}, ${atom} FROM ${tree} WHERE ${parentId} IS NULL ` + `UNION ALL SELECT ${child}.${side}, ${child}.${id}, json_insert(${parent}.${path}, '$[#]', ${child}.${key}), ${child}.${type}, ${child}.${atom} ` + `FROM ${tree} AS ${child} JOIN ${paths} AS ${parent} ON ${child}.${side} = ${parent}.${side} AND ${child}.${parentId} = ${parent}.${id}` + `) SELECT 1 FROM ${paths} GROUP BY ${path}, CASE WHEN ${type} IN ('integer', 'real') THEN 'number' ELSE ${type} END, ${atom} HAVING SUM(${side}) <> 0` + `) END FROM (SELECT ${params.left} AS ${q("left")}, ${params.right} AS ${q("right")}) AS ${values})`;
 }
 
+// packages/sql/src/dialects/mysql-json-keys.ts
+import { internalError as internalError2 } from "@vibeorm/schema";
+
 // packages/sql/src/json-transport.ts
 var JSON_TRANSPORT = Object.freeze({ chunkSize: 100 });
 function projectionOutputName(params) {
@@ -3612,8 +3615,176 @@ function projectionOutputName(params) {
   return column.alias ?? column.name;
 }
 
+// packages/sql/src/key-list.ts
+import { unsupportedCapability as unsupportedCapability16 } from "@vibeorm/schema";
+var SCALAR_ELEMENT_TYPES = Object.freeze({
+  String: "text",
+  Boolean: "bool",
+  Int: "int4",
+  BigInt: "int8",
+  Float: "float8",
+  Decimal: "numeric",
+  DateTime: "timestamptz",
+  Json: null,
+  Bytes: "bytea"
+});
+var NATIVE_ELEMENT_TYPES = Object.freeze({
+  text: "text",
+  varchar: "varchar",
+  charactervarying: "varchar",
+  char: "bpchar",
+  character: "bpchar",
+  bpchar: "bpchar",
+  uuid: "uuid",
+  citext: "citext",
+  xml: "xml",
+  inet: "inet",
+  money: "money",
+  bit: '"bit"',
+  varbit: "varbit",
+  bitvarying: "varbit",
+  smallint: "int2",
+  int2: "int2",
+  integer: "int4",
+  int: "int4",
+  int4: "int4",
+  bigint: "int8",
+  int8: "int8",
+  oid: "oid",
+  real: "float4",
+  float4: "float4",
+  doubleprecision: "float8",
+  double: "float8",
+  float8: "float8",
+  decimal: "numeric",
+  numeric: "numeric",
+  boolean: "bool",
+  bool: "bool",
+  timestamp: "timestamp",
+  timestampwithouttimezone: "timestamp",
+  timestamptz: "timestamptz",
+  timestampwithtimezone: "timestamptz",
+  date: "date",
+  time: "time",
+  timewithouttimezone: "time",
+  timetz: "timetz",
+  timewithtimezone: "timetz",
+  bytea: "bytea"
+});
+function postgresKeyListElementTypeOf(params) {
+  const { dialect, member } = params;
+  if (member.type === "Enum") {
+    if (member.enumType === undefined)
+      return "text";
+    const name = dialect.quoteIdent({ name: member.enumType.name });
+    return member.enumType.namespace === undefined ? name : `${dialect.quoteIdent({ name: member.enumType.namespace })}.${name}`;
+  }
+  const native = member.nativeType === undefined ? undefined : NATIVE_ELEMENT_TYPES[member.nativeType.toLowerCase().replace(/\([^)]*\)/g, "").replace(/\s+/g, "")];
+  const type = member.nativeType === undefined ? SCALAR_ELEMENT_TYPES[member.type] : native;
+  return type === null ? undefined : type;
+}
+function postgresKeyListElementType(params) {
+  const { dialect, member } = params;
+  const type = postgresKeyListElementTypeOf({ dialect, member });
+  if (type === undefined) {
+    throw unsupportedCapability16({
+      dialect: dialect.name,
+      feature: `the key-list filter (IN) on a ${member.type}${member.nativeType === undefined ? "" : ` @db.${member.nativeType}`} member`,
+      hint: "IN binds every member as a typed array; filter this field with equality inside OR instead"
+    });
+  }
+  return type;
+}
+function keyListBindsUntypedRows(params) {
+  return params.members.some((member) => member.type === "DateTime" && member.nativeType === undefined);
+}
+var MYSQL_JSON_TEXT_KEY_TYPES = new Set(["varchar", "char", "character", "text", "tinytext", "mediumtext", "longtext"]);
+var MYSQL_JSON_INTEGER_KEY_TYPES = new Set(["int", "integer", "bigint", "smallint", "tinyint", "mediumint"]);
+function mysqlJsonKeyTypeOf(params) {
+  const { member } = params;
+  const native = member.nativeType?.toLowerCase().replace(/\([^)]*\)/g, "").replace(/\s+/g, "");
+  if (member.type === "String")
+    return native === undefined || MYSQL_JSON_TEXT_KEY_TYPES.has(native) ? "text" : undefined;
+  if (member.type !== "Int" && member.type !== "BigInt")
+    return;
+  if (native === undefined)
+    return "signed";
+  const unsigned = native.startsWith("unsigned") || native.endsWith("unsigned");
+  const base = native.replace(/^unsigned|unsigned$/g, "");
+  if (!MYSQL_JSON_INTEGER_KEY_TYPES.has(base))
+    return;
+  return unsigned ? "unsigned" : "signed";
+}
+function jsonKeyTokenCast(params) {
+  const { dialect, member } = params;
+  return !(dialect.lateralJson?.keysFromJson === "jsonTable" && mysqlJsonKeyTypeOf({ member }) === "text");
+}
+function jsonKeysTyped(params) {
+  const { dialect, members } = params;
+  if (dialect.lateralJson?.keysFromJson === "jsonTable")
+    return members.every((member) => mysqlJsonKeyTypeOf({ member }) !== undefined);
+  return !keyListBindsUntypedRows({ members }) && members.every((member) => postgresKeyListElementTypeOf({ dialect, member }) !== undefined);
+}
+function postgresBulkInsertArrayCastOf(params) {
+  const { dialect, member } = params;
+  if (member.type === "Json")
+    return member.nativeType?.trim().toLowerCase() === "json" ? "text::json" : "text::jsonb";
+  return postgresKeyListElementTypeOf({ dialect, member });
+}
+function postgresBulkInsertArrayCast(params) {
+  const { dialect, member } = params;
+  const cast = postgresBulkInsertArrayCastOf({ dialect, member });
+  if (cast === undefined) {
+    throw unsupportedCapability16({
+      dialect: dialect.name,
+      feature: `a bulk insert binding a ${member.type}${member.nativeType === undefined ? "" : ` @db.${member.nativeType}`} column as a typed array`,
+      hint: "the query builder keeps VALUES for this column type"
+    });
+  }
+  return cast;
+}
+
+// packages/sql/src/dialects/mysql-json-keys.ts
+var SOURCE_ALIAS = "__vibe_s";
+var ROWS_ALIAS = "__vibe_e";
+var SET_ALIAS = "__vibe_k";
+function slotPath(params) {
+  const { slot } = params;
+  if (!Number.isSafeInteger(slot.index) || !Number.isSafeInteger(slot.width) || slot.index < 0 || slot.index >= slot.width) {
+    throw internalError2({ message: "a JSON slot must be an index inside its row" });
+  }
+  const size = JSON_TRANSPORT.chunkSize;
+  return slot.width <= size ? `[${slot.index}]` : `[${Math.floor(slot.index / size)}][${slot.index % size}]`;
+}
+function renderMysqlJsonKeys(params) {
+  const { dialect, statement, keys } = params;
+  const quote = (name) => dialect.quoteIdent({ name });
+  const source = quote(SOURCE_ALIAS);
+  const rows = quote(ROWS_ALIAS);
+  const set = quote(SET_ALIAS);
+  const rowPath = `$${keys.steps.map((step) => step.kind === "elements" ? "[*]" : slotPath({ slot: step.slot })).join("")}`;
+  const columns = keys.keys.map((key) => `${quote(key.token)} JSON PATH '$${slotPath({ slot: key.slot })}'`);
+  const typed = keys.keys.flatMap((key) => {
+    const type = mysqlJsonKeyTypeOf({ member: key.member });
+    if (type === undefined) {
+      throw internalError2({ message: "fromJsonKeys cannot type this key from its JSON text on mysql: only string and integer keys are admitted" });
+    }
+    const token = `${set}.${quote(key.token)}`;
+    const text = `CASE WHEN JSON_TYPE(${token}) = 'NULL' THEN NULL ELSE JSON_UNQUOTE(${token}) END`;
+    const value = type === "text" ? text : `CAST(${text} AS ${type === "signed" ? "SIGNED" : "UNSIGNED"})`;
+    return [`${text} AS ${quote(key.token)}`, `${value} AS ${quote(key.alias)}`];
+  });
+  const distinct = keys.keys.map((key) => `${rows}.${quote(key.token)}`);
+  const from = `${quote(keys.source.table)} AS ${source} JOIN JSON_TABLE(${source}.${quote(keys.source.name)}, '${rowPath}' COLUMNS (${columns.join(", ")})) AS ${rows}`;
+  return `(SELECT ${typed.join(", ")} FROM (SELECT DISTINCT ${distinct.join(", ")} FROM ${from}) AS ${set}) AS ${quote(statement.table.name)}`;
+}
+function mysqlPinnedCommonTableSuffix(params) {
+  const { select } = params.table;
+  return params.table.materialized !== true || select.limit !== undefined || select.offset !== undefined ? "" : " LIMIT 18446744073709551615";
+}
+
 // packages/sql/src/dialects/diagnostics.ts
-import { assertSqlNamespace as assertSqlNamespace2, unsupportedCapability as unsupportedCapability16 } from "@vibeorm/schema";
+import { assertSqlNamespace as assertSqlNamespace2, unsupportedCapability as unsupportedCapability17 } from "@vibeorm/schema";
 var QUERIES = Object.freeze({
   postgresJsonWire: { dialect: "postgres", text: `SELECT '{"__vibeorm":1}'::jsonb AS "probe"` },
   postgresServerVersion: { dialect: "postgres", text: `SELECT pg_catalog.current_setting('server_version_num') AS "serverVersionNum"` },
@@ -3622,7 +3793,7 @@ var QUERIES = Object.freeze({
 function renderDiagnostic(params) {
   const query = QUERIES[params.query];
   if (params.dialect.name !== query.dialect) {
-    throw unsupportedCapability16({ dialect: params.dialect.name, feature: params.query, hint: `this diagnostic requires ${query.dialect}` });
+    throw unsupportedCapability17({ dialect: params.dialect.name, feature: params.query, hint: `this diagnostic requires ${query.dialect}` });
   }
   return { text: query.text, values: [], returning: "none" };
 }
@@ -3633,7 +3804,7 @@ var CAPTURE_READINESS_SQL = `SELECT pg_catalog.current_setting('server_version_n
 function renderCaptureReadiness(params) {
   const { dialect, tables } = params;
   if (dialect.name !== "postgres") {
-    throw unsupportedCapability16({ dialect: dialect.name, feature: "postgresCaptureReadiness", hint: "row capture reads RETURNING old/new, PostgreSQL 18 or newer" });
+    throw unsupportedCapability17({ dialect: dialect.name, feature: "postgresCaptureReadiness", hint: "row capture reads RETURNING old/new, PostgreSQL 18 or newer" });
   }
   const entries = tables.map((entry, index) => {
     const { name, namespace } = entry.table;
@@ -3647,7 +3818,7 @@ function renderCaptureReadiness(params) {
 }
 
 // packages/sql/src/dialects/postgres-diagnostics.ts
-import { VibeError as VibeError16, unsupportedCapability as unsupportedCapability17 } from "@vibeorm/schema";
+import { VibeError as VibeError16, unsupportedCapability as unsupportedCapability18 } from "@vibeorm/schema";
 function renderPostgresExplain(params) {
   const { dialect, query, options } = params;
   requirePostgres({ dialect, feature: "query plan inspection (EXPLAIN)" });
@@ -3682,7 +3853,7 @@ var POSTGRES_WORKLOAD_LIMITS = Object.freeze({
 });
 function requirePostgres(params) {
   if (params.dialect.name !== "postgres") {
-    throw unsupportedCapability17({
+    throw unsupportedCapability18({
       dialect: params.dialect.name,
       feature: params.feature,
       hint: "plan inspection and workload statistics are PostgreSQL-shaped; portable operation tracing works on every dialect"
@@ -3729,10 +3900,10 @@ function requireArg(params) {
 }
 
 // packages/sql/src/dialects/postgres-rls-readiness.ts
-import { unsupportedCapability as unsupportedCapability19 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability20 } from "@vibeorm/schema";
 
 // packages/sql/src/dialects/postgres-rls.ts
-import { RlsContextError, VibeError as VibeError17, assertNativeRlsAdmission, assertValidSchemaIR, unsupportedCapability as unsupportedCapability18, validateRlsContextIR } from "@vibeorm/schema";
+import { RlsContextError, VibeError as VibeError17, assertNativeRlsAdmission, assertValidSchemaIR, unsupportedCapability as unsupportedCapability19, 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" } },
@@ -3745,7 +3916,7 @@ var COLUMN_TYPES = {
 };
 function requireRls(params) {
   if (!params.dialect.capabilities.nativeRowLevelSecurity) {
-    throw unsupportedCapability18({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
+    throw unsupportedCapability19({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
   }
 }
 function identifier2(params) {
@@ -3756,7 +3927,7 @@ function identifier2(params) {
 }
 function tableRef(params) {
   if (params.schema !== undefined && params.schema !== "public" && params.schema !== "pg_temp") {
-    throw unsupportedCapability18({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: "Only public tables and temporary policy probes are supported" });
+    throw unsupportedCapability19({ 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 })}`;
 }
@@ -3797,7 +3968,7 @@ function renderRlsColumnType(params) {
     if (native !== undefined)
       return native;
   }
-  throw unsupportedCapability18({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: `Unsupported physical ownership type on field ${field.name}` });
+  throw unsupportedCapability19({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity", hint: `Unsupported physical ownership type on field ${field.name}` });
 }
 function protectedModel(params) {
   requireRls(params);
@@ -4037,7 +4208,7 @@ ORDER BY c.relname, p.polname`,
 });
 function requireRls2(params) {
   if (!params.dialect.capabilities.nativeRowLevelSecurity) {
-    throw unsupportedCapability19({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
+    throw unsupportedCapability20({ dialect: params.dialect.name, feature: "nativeRowLevelSecurity" });
   }
 }
 function renderRlsReadinessQuery(params) {
@@ -4069,7 +4240,7 @@ function renderRlsPolicyPath(params) {
 }
 
 // packages/sql/src/render.ts
-import { assertSqlNamespace as assertSqlNamespace3, internalError as internalError4, unsupportedCapability as unsupportedCapability23 } from "@vibeorm/schema";
+import { assertSqlNamespace as assertSqlNamespace3, internalError as internalError5, unsupportedCapability as unsupportedCapability23 } from "@vibeorm/schema";
 
 // packages/sql/src/like.ts
 function escapeLikePattern(params) {
@@ -4100,7 +4271,7 @@ function strictMatchCollationPrefilter(params) {
 }
 
 // packages/sql/src/locks.ts
-import { internalError as internalError2, unsupportedCapability as unsupportedCapability20 } from "@vibeorm/schema";
+import { internalError as internalError3, unsupportedCapability as unsupportedCapability21 } from "@vibeorm/schema";
 var ROW_LOCK_PROSE = Object.freeze({
   strengths: Object.freeze({
     update: "FOR UPDATE",
@@ -4120,7 +4291,7 @@ function renderRowLockClause(params) {
   if (syntax === null) {
     if (lock.strength === "update" && lock.wait === "wait")
       return null;
-    throw unsupportedCapability20({
+    throw unsupportedCapability21({
       dialect: dialect.name,
       feature: `a ${describeRowLock({ lock })} locking read`,
       hint: `${dialect.name} has no locking-read clause at all`
@@ -4128,7 +4299,7 @@ function renderRowLockClause(params) {
   }
   const strengthText = syntax.strengths[lock.strength];
   if (strengthText === undefined) {
-    throw unsupportedCapability20({
+    throw unsupportedCapability21({
       dialect: dialect.name,
       feature: `the ${describeRowLock({ lock: { ...lock, wait: "wait" } })} row-lock strength`,
       hint: `${dialect.name} can express: ${Object.keys(syntax.strengths).join(", ")}`
@@ -4136,7 +4307,7 @@ function renderRowLockClause(params) {
   }
   const waitText = syntax.wait[lock.wait];
   if (waitText === undefined) {
-    throw unsupportedCapability20({
+    throw unsupportedCapability21({
       dialect: dialect.name,
       feature: `the "${lock.wait}" lock wait policy`,
       hint: `${dialect.name} can express: ${Object.keys(syntax.wait).join(", ")}`
@@ -4144,7 +4315,7 @@ function renderRowLockClause(params) {
   }
   if (lock.of !== undefined) {
     if (lock.of.length === 0)
-      throw internalError2({ message: "a row lock's `of` list cannot be empty" });
+      throw internalError3({ message: "a row lock's `of` list cannot be empty" });
     const tables = lock.of.map((name) => dialect.quoteIdent({ name })).join(", ");
     return `${strengthText} OF ${tables}${waitText}`;
   }
@@ -4162,7 +4333,7 @@ function renderAdvisoryLock(params) {
   const { dialect, statement, collector } = params;
   const functions = dialect.advisoryLockFunctions;
   if (functions === null) {
-    throw unsupportedCapability20({
+    throw unsupportedCapability21({
       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`
@@ -4183,11 +4354,11 @@ function renderAdvisoryLocks(params) {
   const { dialect, keys, mode } = params;
   const functions = dialect.advisoryLockFunctions;
   if (functions === null)
-    throw unsupportedCapability20({ dialect: dialect.name, feature: "advisory locks" });
+    throw unsupportedCapability21({ dialect: dialect.name, feature: "advisory locks" });
   if (mode !== "exclusive" && mode !== "shared")
-    throw internalError2({ message: "advisory lock mode must be exclusive or shared" });
+    throw internalError3({ message: "advisory lock mode must be exclusive or shared" });
   if (keys.some((key) => typeof key !== "bigint" || key < ADVISORY_KEY_BOUNDS.single.min || key > ADVISORY_KEY_BOUNDS.single.max)) {
-    throw internalError2({ message: "advisory lock keys must be signed 64-bit integers" });
+    throw internalError3({ message: "advisory lock keys must be signed 64-bit integers" });
   }
   const collector = new ParamCollector(dialect);
   const binding = collector.add(JSON.stringify(keys.map((key) => key.toString())));
@@ -4204,7 +4375,7 @@ function renderAdvisoryLocks(params) {
 function assertInt32(params) {
   const { value, part } = params;
   if (!Number.isInteger(value) || value < ADVISORY_KEY_BOUNDS.pair.min || value > ADVISORY_KEY_BOUNDS.pair.max) {
-    throw internalError2({
+    throw internalError3({
       message: `advisory lock ${part} must be a 32-bit integer, got ${String(value)}`,
       meta: { part, value }
     });
@@ -4213,7 +4384,7 @@ function assertInt32(params) {
 }
 
 // packages/sql/src/date-truncation.ts
-import { DATE_TRUNCATION_UNITS, VibeError as VibeError18, internalError as internalError3, unsupportedCapability as unsupportedCapability21 } from "@vibeorm/schema";
+import { DATE_TRUNCATION_UNITS, VibeError as VibeError18, internalError as internalError4, unsupportedCapability as unsupportedCapability22 } from "@vibeorm/schema";
 var TIME_ZONE_NAME = /^[A-Za-z][A-Za-z0-9_+\-/]{0,63}$/;
 function isTimeZoneName(params) {
   return typeof params.value === "string" && TIME_ZONE_NAME.test(params.value);
@@ -4221,14 +4392,14 @@ function isTimeZoneName(params) {
 function renderDateTruncation(params) {
   const { dialect, reference, truncation } = params;
   if (!dialect.capabilities.dateTruncation) {
-    throw unsupportedCapability21({
+    throw unsupportedCapability22({
       dialect: dialect.name,
       feature: "a truncated groupBy key ({ field, truncate, timeZone })",
       hint: "only PostgreSQL and PGlite truncate a timestamp in a named time zone \u2014 group by the plain field and bucket the rows in code instead"
     });
   }
   if (!DATE_TRUNCATION_UNITS.includes(truncation.unit)) {
-    throw internalError3({ message: `unknown date truncation unit ${JSON.stringify(truncation.unit)}` });
+    throw internalError4({ message: `unknown date truncation unit ${JSON.stringify(truncation.unit)}` });
   }
   if (!isTimeZoneName({ value: truncation.timeZone })) {
     throw new VibeError18({
@@ -4245,110 +4416,8 @@ function renderDateTruncation(params) {
     case "timestamp":
       return `(date_trunc(${unit}, ${reference} AT TIME ZONE 'UTC', ${zone}) AT TIME ZONE 'UTC')`;
     default:
-      throw internalError3({ message: `unknown date truncation storage ${JSON.stringify(truncation.storage)}` });
-  }
-}
-
-// packages/sql/src/key-list.ts
-import { unsupportedCapability as unsupportedCapability22 } from "@vibeorm/schema";
-var SCALAR_ELEMENT_TYPES = Object.freeze({
-  String: "text",
-  Boolean: "bool",
-  Int: "int4",
-  BigInt: "int8",
-  Float: "float8",
-  Decimal: "numeric",
-  DateTime: "timestamptz",
-  Json: null,
-  Bytes: "bytea"
-});
-var NATIVE_ELEMENT_TYPES = Object.freeze({
-  text: "text",
-  varchar: "varchar",
-  charactervarying: "varchar",
-  char: "bpchar",
-  character: "bpchar",
-  bpchar: "bpchar",
-  uuid: "uuid",
-  citext: "citext",
-  xml: "xml",
-  inet: "inet",
-  money: "money",
-  bit: '"bit"',
-  varbit: "varbit",
-  bitvarying: "varbit",
-  smallint: "int2",
-  int2: "int2",
-  integer: "int4",
-  int: "int4",
-  int4: "int4",
-  bigint: "int8",
-  int8: "int8",
-  oid: "oid",
-  real: "float4",
-  float4: "float4",
-  doubleprecision: "float8",
-  double: "float8",
-  float8: "float8",
-  decimal: "numeric",
-  numeric: "numeric",
-  boolean: "bool",
-  bool: "bool",
-  timestamp: "timestamp",
-  timestampwithouttimezone: "timestamp",
-  timestamptz: "timestamptz",
-  timestampwithtimezone: "timestamptz",
-  date: "date",
-  time: "time",
-  timewithouttimezone: "time",
-  timetz: "timetz",
-  timewithtimezone: "timetz",
-  bytea: "bytea"
-});
-function postgresKeyListElementTypeOf(params) {
-  const { dialect, member } = params;
-  if (member.type === "Enum") {
-    if (member.enumType === undefined)
-      return "text";
-    const name = dialect.quoteIdent({ name: member.enumType.name });
-    return member.enumType.namespace === undefined ? name : `${dialect.quoteIdent({ name: member.enumType.namespace })}.${name}`;
+      throw internalError4({ message: `unknown date truncation storage ${JSON.stringify(truncation.storage)}` });
   }
-  const native = member.nativeType === undefined ? undefined : NATIVE_ELEMENT_TYPES[member.nativeType.toLowerCase().replace(/\([^)]*\)/g, "").replace(/\s+/g, "")];
-  const type = member.nativeType === undefined ? SCALAR_ELEMENT_TYPES[member.type] : native;
-  return type === null ? undefined : type;
-}
-function postgresKeyListElementType(params) {
-  const { dialect, member } = params;
-  const type = postgresKeyListElementTypeOf({ dialect, member });
-  if (type === undefined) {
-    throw unsupportedCapability22({
-      dialect: dialect.name,
-      feature: `the key-list filter (IN) on a ${member.type}${member.nativeType === undefined ? "" : ` @db.${member.nativeType}`} member`,
-      hint: "IN binds every member as a typed array; filter this field with equality inside OR instead"
-    });
-  }
-  return type;
-}
-function keyListBindsUntypedRows(params) {
-  return params.members.some((member) => member.type === "DateTime" && member.nativeType === undefined);
-}
-function postgresBulkInsertArrayCastOf(params) {
-  const { dialect, member } = params;
-  if (member.type === "Json")
-    return member.nativeType?.trim().toLowerCase() === "json" ? "text::json" : "text::jsonb";
-  return postgresKeyListElementTypeOf({ dialect, member });
-}
-function postgresBulkInsertArrayCast(params) {
-  const { dialect, member } = params;
-  const cast = postgresBulkInsertArrayCastOf({ dialect, member });
-  if (cast === undefined) {
-    throw unsupportedCapability22({
-      dialect: dialect.name,
-      feature: `a bulk insert binding a ${member.type}${member.nativeType === undefined ? "" : ` @db.${member.nativeType}`} column as a typed array`,
-      hint: "the query builder keeps VALUES for this column type"
-    });
-  }
-  return cast;
 }
 
 // packages/sql/src/render.ts
@@ -4371,7 +4440,7 @@ function renderStatement(params) {
       return renderPostgresWorkload({ dialect, ...statement });
     }
     case "select":
-      return renderSelect({ dialect, statement, collector });
+      return renderSelect({ dialect, statement, collector, outermost: true });
     case "advisoryLocks":
       return renderAdvisoryLocks({ dialect, keys: statement.keys, mode: statement.mode });
     case "advisoryLock":
@@ -4411,7 +4480,7 @@ function renderStatement(params) {
 function quoteCol(dialect, column) {
   if (column.coalesce !== undefined) {
     if (column.coalesce.length < 2 || column.coalesce.some((member) => member.coalesce !== undefined)) {
-      throw internalError4({ message: "ColRef.coalesce needs two or more plain member references" });
+      throw internalError5({ message: "ColRef.coalesce needs two or more plain member references" });
     }
     return `COALESCE(${column.coalesce.map((member) => quoteCol(dialect, member)).join(", ")})`;
   }
@@ -4425,13 +4494,13 @@ function quoteCol(dialect, column) {
     return dialect.renderEnumOrdinal({ column: ref });
   if (column.castReal === true) {
     if (dialect.name !== "sqlite") {
-      throw internalError4({ message: "ColRef.castReal is a sqlite Decimal construct" });
+      throw internalError5({ message: "ColRef.castReal is a sqlite Decimal construct" });
     }
     return `CAST(${ref} AS REAL)`;
   }
   if (column.castJsonb !== undefined) {
     if (dialect.name !== "postgres") {
-      throw internalError4({ message: "ColRef.castJsonb is a postgres json construct" });
+      throw internalError5({ message: "ColRef.castJsonb is a postgres json construct" });
     }
     return `${ref}::${column.castJsonb}`;
   }
@@ -4450,7 +4519,7 @@ function jsonCellCast(dialect, cell) {
   if (cell.storage !== "json" || dialect.jsonParamCast === "")
     return dialect.jsonParamCast;
   if (dialect.name !== "postgres") {
-    throw internalError4({ message: "JsonParamCell storage json is a postgres construct" });
+    throw internalError5({ message: "JsonParamCell storage json is a postgres construct" });
   }
   return "::text::json";
 }
@@ -4474,7 +4543,7 @@ function quoteProjection(dialect, column) {
   if (column.transform === "encodeBase64" && dialect.name === "mysql")
     return `TO_BASE64(${ref}) AS ${alias}`;
   if (dialect.name !== "postgres") {
-    throw internalError4({ message: `${column.transform} is a postgres construct` });
+    throw internalError5({ message: `${column.transform} is a postgres construct` });
   }
   if (column.transform === "encodeArrayBase64")
     return `encode(array_send(${ref}), 'base64') AS ${alias}`;
@@ -4498,7 +4567,7 @@ function renderTable(dialect, table) {
 }
 function assertCount(value, what) {
   if (!Number.isSafeInteger(value) || value < 0) {
-    throw internalError4({ message: `${what} must be a non-negative integer, got ${value}` });
+    throw internalError5({ message: `${what} must be a non-negative integer, got ${value}` });
   }
 }
 var COMPARISON_SQL2 = {
@@ -4554,14 +4623,14 @@ function renderGroupKey(params) {
   const { dialect, reference, key } = params;
   if (key.kind === "prefix") {
     if (!Number.isSafeInteger(key.length) || key.length < 1 || key.length > MAX_GROUP_KEY_PREFIX) {
-      throw internalError4({ message: `a groupBy prefix length must be an integer from 1 to ${MAX_GROUP_KEY_PREFIX}, got ${String(key.length)}` });
+      throw internalError5({ message: `a groupBy prefix length must be an integer from 1 to ${MAX_GROUP_KEY_PREFIX}, got ${String(key.length)}` });
     }
     if (dialect.name === "sqlite")
       return `substr(${reference}, 1, ${key.length})`;
     return `${dialect.name === "mysql" ? "LEFT" : "left"}(${reference}, ${key.length})`;
   }
   if (key.path.length === 0 || key.path.some((step) => typeof step !== "string" || step.length === 0 || step.includes("\x00"))) {
-    throw internalError4({ message: "a groupBy JSON path needs one or more non-empty object keys without NUL characters" });
+    throw internalError5({ message: "a groupBy JSON path needs one or more non-empty object keys without NUL characters" });
   }
   switch (dialect.jsonPathMode) {
     case "operators": {
@@ -4600,11 +4669,11 @@ function renderGroupingSets(params) {
 function groupingSetIndexes(params) {
   const { keys, grouping } = params;
   if (grouping.sets.length === 0 || keys.length === 0 || keys.length > 31) {
-    throw internalError4({ message: "grouping sets need one or more sets over 1 to 31 groupBy keys" });
+    throw internalError5({ message: "grouping sets need one or more sets over 1 to 31 groupBy keys" });
   }
   for (const set of grouping.sets) {
     if (set.some((index) => !Number.isSafeInteger(index) || index < 0 || index >= keys.length)) {
-      throw internalError4({ message: "a grouping set names a groupBy key that does not exist" });
+      throw internalError5({ message: "a grouping set names a groupBy key that does not exist" });
     }
   }
   return grouping.sets;
@@ -4650,7 +4719,7 @@ function renderExpr(params) {
     case "cmp": {
       const op = COMPARISON_SQL2[expr.op];
       if (op === undefined) {
-        throw internalError4({ message: `unknown comparison operator "${expr.op}"` });
+        throw internalError5({ message: `unknown comparison operator "${expr.op}"` });
       }
       if (isDbNowMarker(expr.value)) {
         return `${quoteCol(dialect, expr.column)} ${op} ${dialect.renderDbNow({ offsetSeconds: expr.value.offsetSeconds, collector })}`;
@@ -4661,7 +4730,7 @@ function renderExpr(params) {
     case "cmpCol": {
       const op = COMPARISON_SQL2[expr.op];
       if (op === undefined) {
-        throw internalError4({ message: `unknown comparison operator "${expr.op}"` });
+        throw internalError5({ message: `unknown comparison operator "${expr.op}"` });
       }
       return `${quoteCol(dialect, expr.left)} ${op} ${quoteCol(dialect, expr.right)}`;
     }
@@ -4685,11 +4754,11 @@ function renderExpr(params) {
     }
     case "tupleIn": {
       if (expr.columns.length === 0) {
-        throw internalError4({ message: "tupleIn needs at least one column" });
+        throw internalError5({ message: "tupleIn needs at least one column" });
       }
       for (const row of expr.rows) {
         if (row.length !== expr.columns.length) {
-          throw internalError4({
+          throw internalError5({
             message: `tupleIn row has ${row.length} values for ${expr.columns.length} columns`
           });
         }
@@ -4715,7 +4784,7 @@ function renderExpr(params) {
     case "rowCompare": {
       const op = COMPARISON_SQL2[expr.op];
       if (op === undefined || expr.columns.length === 0 || expr.values.length !== expr.columns.length) {
-        throw internalError4({ message: `rowCompare needs a range operator and one value per column (${expr.columns.length} columns, ${expr.values.length} values)` });
+        throw internalError5({ message: `rowCompare needs a range operator and one value per column (${expr.columns.length} columns, ${expr.values.length} values)` });
       }
       const columns = expr.columns.map((column) => quoteCol(dialect, column));
       const placeholders = expr.values.map((value) => collector.add(value));
@@ -4723,7 +4792,7 @@ function renderExpr(params) {
     }
     case "inSelect": {
       if (expr.columns.length === 0)
-        throw internalError4({ message: "inSelect needs at least one column" });
+        throw internalError5({ message: "inSelect needs at least one column" });
       if (dialect.name === "mysql" && (expr.select.limit !== undefined || expr.select.offset !== undefined)) {
         throw unsupportedCapability23({
           dialect: dialect.name,
@@ -4733,7 +4802,7 @@ function renderExpr(params) {
       }
       const columns = expr.columns.map((column) => quoteCol(dialect, column));
       if (expr.single === true && columns.length !== 1)
-        throw internalError4({ message: "a single-row inSelect compares exactly one column" });
+        throw internalError5({ message: "a single-row inSelect compares exactly one column" });
       const tested = columns.length === 1 ? columns[0] : `(${columns.join(", ")})`;
       const sub = renderSelect({ dialect, statement: expr.select, collector });
       return expr.single === true ? `${tested} = (${sub.text})` : `${tested} IN (${sub.text})`;
@@ -4798,7 +4867,7 @@ function renderExpr(params) {
     case "aggCmp": {
       const op = COMPARISON_SQL2[expr.op];
       if (op === undefined) {
-        throw internalError4({ message: `unknown comparison operator "${expr.op}"` });
+        throw internalError5({ message: `unknown comparison operator "${expr.op}"` });
       }
       return `${renderAggRef(dialect, expr.agg, collector)} ${op} ${collector.add(expr.value)}`;
     }
@@ -4867,13 +4936,13 @@ function renderKeyList(params) {
   const { dialect, expr, collector } = params;
   const arity = expr.columns.length;
   if (arity === 0)
-    throw internalError4({ message: "keyList needs at least one column" });
+    throw internalError5({ message: "keyList needs at least one column" });
   if (expr.members.length !== arity) {
-    throw internalError4({ message: `keyList has ${expr.members.length} members for ${arity} columns` });
+    throw internalError5({ message: `keyList has ${expr.members.length} members for ${arity} columns` });
   }
   for (const row of expr.rows) {
     if (row.length !== arity)
-      throw internalError4({ message: `keyList row has ${row.length} values for ${arity} columns` });
+      throw internalError5({ message: `keyList row has ${row.length} values for ${arity} columns` });
   }
   if (expr.rows.length === 0)
     return "1 = 0";
@@ -4905,22 +4974,22 @@ function renderKeyPage(params) {
   const { select } = page;
   const arity = page.keyColumns.length;
   if (arity === 0 || page.members.length !== arity) {
-    throw internalError4({ message: `keyPage has ${page.members.length} members for ${arity} key columns` });
+    throw internalError5({ message: `keyPage has ${page.members.length} members for ${arity} key columns` });
   }
   if (page.rows.length === 0)
-    throw internalError4({ message: "keyPage needs at least one key" });
+    throw internalError5({ message: "keyPage needs at least one key" });
   for (const row of page.rows) {
     if (row.length !== arity)
-      throw internalError4({ message: `keyPage row has ${row.length} values for ${arity} key columns` });
+      throw internalError5({ message: `keyPage row has ${row.length} values for ${arity} key columns` });
   }
   if (page.identity.length === 0)
-    throw internalError4({ message: "keyPage needs the child's identity columns" });
+    throw internalError5({ message: "keyPage needs the child's identity columns" });
   const order = select.orderBy ?? [];
   if (order.length === 0 || order.some((term) => !("column" in term))) {
-    throw internalError4({ message: "keyPage needs a non-empty order of plain column terms" });
+    throw internalError5({ message: "keyPage needs a non-empty order of plain column terms" });
   }
   if (select.table.alias !== undefined || Object.keys(select).some((member) => !KEY_PAGE_SELECT_MEMBERS.has(member))) {
-    throw internalError4({ message: "keyPage select carries a member the per-key page cannot render" });
+    throw internalError5({ message: "keyPage select carries a member the per-key page cannot render" });
   }
   if (dialect.keyPageStrategy === "window") {
     throw unsupportedCapability23({
@@ -4979,19 +5048,19 @@ function renderKeyPage(params) {
 function renderKeyRows(params) {
   const { dialect, statement, keys, collector } = params;
   if (statement.fromSelect !== undefined || statement.keyPage !== undefined || statement.fromUnion !== undefined || statement.table.alias !== undefined) {
-    throw internalError4({ message: "fromKeys uses table.name as the derived-table alias \u2014 fromSelect, keyPage, fromUnion and table.alias must be unset" });
+    throw internalError5({ message: "fromKeys uses table.name as the derived-table alias \u2014 fromSelect, keyPage, fromUnion and table.alias must be unset" });
   }
   if (statement.rowLock !== undefined)
-    throw internalError4({ message: "a locking read cannot read from key rows" });
+    throw internalError5({ message: "a locking read cannot read from key rows" });
   const arity = keys.columns.length;
   if (arity === 0 || keys.members.length !== arity) {
-    throw internalError4({ message: `fromKeys has ${keys.members.length} members for ${arity} columns` });
+    throw internalError5({ message: `fromKeys has ${keys.members.length} members for ${arity} columns` });
   }
   if (keys.rows.length === 0)
-    throw internalError4({ message: "fromKeys needs at least one key row" });
+    throw internalError5({ message: "fromKeys needs at least one key row" });
   for (const row of keys.rows) {
     if (row.length !== arity)
-      throw internalError4({ message: `fromKeys row has ${row.length} values for ${arity} columns` });
+      throw internalError5({ message: `fromKeys row has ${row.length} values for ${arity} columns` });
   }
   if (dialect.keyListStrategy !== "unnest" || keyListBindsUntypedRows({ members: keys.members })) {
     throw unsupportedCapability23({
@@ -5005,25 +5074,145 @@ function renderKeyRows(params) {
   const names = keys.columns.map((name) => dialect.quoteIdent({ name }));
   return `unnest(${arrays.join(", ")}) AS ${dialect.quoteIdent({ name: statement.table.name })} (${names.join(", ")})`;
 }
+function renderOuterRow(params) {
+  const { dialect, statement, row } = params;
+  if (!dialect.capabilities.carrierRows) {
+    throw unsupportedCapability23({
+      dialect: dialect.name,
+      feature: "carrier rows",
+      hint: "lists below a shared to-one nest on small levels and load by key otherwise on this dialect"
+    });
+  }
+  if (statement.fromSelect !== undefined || statement.keyPage !== undefined || statement.fromUnion !== undefined || statement.table.alias !== undefined || statement.table.namespace !== undefined || statement.rowLock !== undefined) {
+    throw internalError5({ message: "fromRow uses table.name as the derived-table alias \u2014 fromSelect, keyPage, fromUnion, table.alias, a namespace and a row lock must be unset" });
+  }
+  const names = row.map((entry) => entry.alias);
+  if (row.length === 0 || new Set(names).size !== names.length || row.some((entry) => entry.column.table === undefined)) {
+    throw internalError5({ message: "fromRow needs one or more table-qualified outer columns under distinct names" });
+  }
+  const cells = row.map((entry) => `${quoteCol(dialect, entry.column)} AS ${dialect.quoteIdent({ name: entry.alias })}`);
+  return `(SELECT ${cells.join(", ")}) AS ${dialect.quoteIdent({ name: statement.table.name })}`;
+}
+function refuseSharedListDictionary(params) {
+  if (params.dialect.capabilities.sharedListDictionary)
+    return;
+  throw unsupportedCapability23({
+    dialect: params.dialect.name,
+    feature: "a dictionary of shared lists",
+    hint: "lists below a to-one under a list nest on small levels and load by key otherwise on this dialect"
+  });
+}
+function renderCommonTables(params) {
+  const { dialect, tables, collector } = params;
+  refuseSharedListDictionary({ dialect });
+  const names = tables.map((table) => table.name);
+  if (tables.length === 0 || new Set(names).size !== names.length || tables.some((table) => table.select.with !== undefined)) {
+    throw internalError5({ message: "common tables need distinct names and selects without common tables of their own" });
+  }
+  const pinned = lateralJsonOf({ dialect }).pinnedCommonTable;
+  const rendered = tables.map((table) => {
+    const select = renderSelect({ dialect, statement: table.select, collector }).text;
+    if (pinned === "limit")
+      return `${dialect.quoteIdent({ name: table.name })} AS (${select}${mysqlPinnedCommonTableSuffix({ table })})`;
+    return `${dialect.quoteIdent({ name: table.name })} AS ${table.materialized === true ? "MATERIALIZED " : ""}(${select})`;
+  });
+  return `WITH ${rendered.join(", ")} `;
+}
+var JSON_KEYS_SOURCE_ALIAS = "__vibe_s";
+var JSON_KEYS_SET_ALIAS = "__vibe_k";
+function renderJsonSlot(params) {
+  const { row, slot } = params;
+  if (!Number.isSafeInteger(slot.index) || !Number.isSafeInteger(slot.width) || slot.index < 0 || slot.index >= slot.width) {
+    throw internalError5({ message: "a JSON slot must be an index inside its row" });
+  }
+  const last = params.text ? "->>" : "->";
+  const size = JSON_TRANSPORT.chunkSize;
+  if (slot.width <= size)
+    return `${row} ${last} ${slot.index}`;
+  return `${row} -> ${Math.floor(slot.index / size)} ${last} ${slot.index % size}`;
+}
+function renderJsonKeys(params) {
+  const { dialect, statement, keys } = params;
+  refuseSharedListDictionary({ dialect });
+  if (statement.fromSelect !== undefined || statement.keyPage !== undefined || statement.fromUnion !== undefined || statement.fromKeys !== undefined || statement.fromRow !== undefined || statement.table.alias !== undefined || statement.table.namespace !== undefined || statement.rowLock !== undefined) {
+    throw internalError5({ message: "fromJsonKeys uses table.name as the derived-table alias \u2014 every other FROM form, table.alias, a namespace and a row lock must be unset" });
+  }
+  const outputs = keys.keys.flatMap((key) => [key.token, key.alias]);
+  if (keys.keys.length === 0 || keys.source.table === undefined || new Set(outputs).size !== outputs.length) {
+    throw internalError5({ message: "fromJsonKeys needs a table-qualified source and one or more keys under distinct names" });
+  }
+  if (lateralJsonOf({ dialect }).keysFromJson === "jsonTable")
+    return renderMysqlJsonKeys({ dialect, statement, keys });
+  if (keyListBindsUntypedRows({ members: keys.keys.map((key) => key.member) })) {
+    throw internalError5({ message: "fromJsonKeys cannot type a DateTime key without a declared native type" });
+  }
+  const source = dialect.quoteIdent({ name: JSON_KEYS_SOURCE_ALIAS });
+  const set = dialect.quoteIdent({ name: JSON_KEYS_SET_ALIAS });
+  const column = dialect.quoteIdent({ name: "value" });
+  let value = `${source}.${dialect.quoteIdent({ name: keys.source.name })}`;
+  let from = `${dialect.quoteIdent({ name: keys.source.table })} AS ${source}`;
+  let lists = 0;
+  for (const step of keys.steps) {
+    if (step.kind === "slot") {
+      value = renderJsonSlot({ row: value, slot: step.slot, text: false });
+      continue;
+    }
+    const all = dialect.quoteIdent({ name: `__vibe_d${lists}` });
+    const element = dialect.quoteIdent({ name: `__vibe_e${lists++}` });
+    from = `json_array_elements((SELECT json_agg(${value}) FROM ${from} WHERE ${value} IS NOT NULL)) AS ${all}(${column}) ` + `CROSS JOIN LATERAL json_array_elements(${all}.${column}) AS ${element}(${column})`;
+    value = `${element}.${column}`;
+  }
+  const tokens = keys.keys.map((key) => `${renderJsonSlot({ row: value, slot: key.slot, text: true })} AS ${dialect.quoteIdent({ name: key.token })}`);
+  const typed = keys.keys.flatMap((key) => {
+    const token = `${set}.${dialect.quoteIdent({ name: key.token })}`;
+    return [token, `CAST(${token} AS ${postgresKeyListElementType({ dialect, member: key.member })}) AS ${dialect.quoteIdent({ name: key.alias })}`];
+  });
+  return `(SELECT ${typed.join(", ")} FROM (SELECT DISTINCT ${tokens.join(", ")} FROM ${from}) AS ${set}) AS ${dialect.quoteIdent({ name: statement.table.name })}`;
+}
+var TABLE_ARRAYS_ALIAS = "__vibe_a";
+function renderTableArrays(params) {
+  const { dialect, statement, rows } = params;
+  if (!dialect.capabilities.carrierRows || dialect.lateralJson?.carriedLists !== "firstRow") {
+    throw unsupportedCapability23({
+      dialect: dialect.name,
+      feature: "the rows of a common table read back through arrays (fromTableArrays)",
+      hint: "carrier rows return their lists on the row that carries, or load by key, on this dialect"
+    });
+  }
+  if (statement.fromSelect !== undefined || statement.keyPage !== undefined || statement.fromUnion !== undefined || statement.fromKeys !== undefined || statement.fromRow !== undefined || statement.fromJsonKeys !== undefined || statement.table.alias !== undefined || statement.table.namespace !== undefined || statement.rowLock !== undefined) {
+    throw internalError5({ message: "fromTableArrays uses table.name as the row alias \u2014 every other FROM form, table.alias, a namespace and a row lock must be unset" });
+  }
+  const names = rows.columns.map((entry) => entry.alias);
+  if (rows.columns.length === 0 || new Set(names).size !== names.length) {
+    throw internalError5({ message: "fromTableArrays needs one or more columns under distinct names" });
+  }
+  const quote = (name) => dialect.quoteIdent({ name });
+  const source = quote(rows.source);
+  const arrays = quote(TABLE_ARRAYS_ALIAS);
+  const order = `${source}.${quote(rows.orderBy)}`;
+  const cells = rows.columns.map((entry, index) => `array_agg(${source}.${quote(entry.name)} ORDER BY ${order}) AS ${quote(`__vibe_a${index}`)}`);
+  const read = rows.columns.map((_, index) => `${arrays}.${quote(`__vibe_a${index}`)}`);
+  return `(SELECT ${cells.join(", ")} FROM ${source}) AS ${arrays} CROSS JOIN LATERAL unnest(${read.join(", ")}) AS ${quote(statement.table.name)}(${names.map(quote).join(", ")})`;
+}
 var UNION_BRANCH_MEMBERS = new Set(["kind", "table", "columns", "where", "orderBy", "limit"]);
 function renderUnionPage(params) {
   const { dialect, statement, collector } = params;
   const branches = statement.fromUnion ?? [];
   if (branches.length < 2)
-    throw internalError4({ message: "fromUnion needs at least two branches" });
+    throw internalError5({ message: "fromUnion needs at least two branches" });
   if (statement.fromSelect !== undefined || statement.keyPage !== undefined || statement.table.alias !== undefined) {
-    throw internalError4({ message: "fromUnion uses table.name as the derived-table alias \u2014 fromSelect, keyPage and table.alias must be unset" });
+    throw internalError5({ message: "fromUnion uses table.name as the derived-table alias \u2014 fromSelect, keyPage and table.alias must be unset" });
   }
   if (statement.rowLock !== undefined)
-    throw internalError4({ message: "a locking read cannot read from a union page" });
+    throw internalError5({ message: "a locking read cannot read from a union page" });
   const outputNames = (branch) => branch.columns.map((column) => column.alias ?? column.name).join("\x00");
   const names = outputNames(branches[0]);
   return branches.map((branch, index) => {
     if (branch.columns.length === 0 || Object.keys(branch).some((member) => !UNION_BRANCH_MEMBERS.has(member))) {
-      throw internalError4({ message: "a fromUnion branch must be a plain SELECT <columns> FROM <table> [WHERE] [ORDER BY] [LIMIT]" });
+      throw internalError5({ message: "a fromUnion branch must be a plain SELECT <columns> FROM <table> [WHERE] [ORDER BY] [LIMIT]" });
     }
     if (outputNames(branch) !== names)
-      throw internalError4({ message: "fromUnion branches must project the same output names in the same order" });
+      throw internalError5({ message: "fromUnion branches must project the same output names in the same order" });
     const inner = renderSelect({ dialect, statement: branch, collector });
     return `SELECT * FROM (${inner.text}) AS ${dialect.quoteIdent({ name: `__vibe_u${index}` })}`;
   }).join(" UNION ALL ");
@@ -5031,7 +5220,7 @@ function renderUnionPage(params) {
 function jsonStringPattern(params) {
   const { expr } = params;
   if (typeof expr.value !== "string") {
-    throw internalError4({ message: `json ${expr.op} expects a string operand` });
+    throw internalError5({ message: `json ${expr.op} expects a string operand` });
   }
   if (expr.op === "string_contains")
     return containsPattern({ raw: expr.value });
@@ -5152,7 +5341,7 @@ function renderJsonFilter(params) {
         return tests.length === 0 ? guard : `(${[guard, ...tests].join(" AND ")})`;
       }
       default:
-        throw internalError4({ message: `json op "${expr.op}" leaked past supportedJsonOps on sqlite` });
+        throw internalError5({ message: `json op "${expr.op}" leaked past supportedJsonOps on sqlite` });
     }
   }
   const column = quoteCol(dialect, expr.column);
@@ -5211,7 +5400,7 @@ function renderSelectExpr(params) {
   if (expr.kind === "one")
     return "1";
   if (expr.kind === "exists")
-    throw internalError4({ message: "an exists projection renders as its whole statement" });
+    throw internalError5({ message: "an exists projection renders as its whole statement" });
   const alias = expr.alias === undefined ? "" : ` AS ${dialect.quoteIdent({ name: expr.alias })}`;
   return `COUNT(*)${alias}`;
 }
@@ -5221,16 +5410,16 @@ function renderPositionalRow(params) {
   const position = join.select.rowNumber;
   const positioned = position !== undefined && json.order === "positionSlot" && join.agg === "jsonArray" && position.partitionBy.length === 0 && position.orderBy.length > 0;
   if (join.select.columns.length === 0 || join.select.selectExpr !== undefined || (join.select.aggregates?.length ?? 0) > 0 || position !== undefined && !positioned) {
-    throw internalError4({ message: "positional lateral rows require an explicit column-only projection" });
+    throw internalError5({ message: "positional lateral rows require an explicit column-only projection" });
   }
   const projected = join.select.columns.map((column) => projectionOutputName({ column }));
   const hidden = join.hidden ?? [];
   if (hidden.some((name) => !projected.includes(name)) || hidden.length >= projected.length) {
-    throw internalError4({ message: "a hidden lateral column must be one of the projected columns, and one column must remain" });
+    throw internalError5({ message: "a hidden lateral column must be one of the projected columns, and one column must remain" });
   }
   const names = [...projected.filter((name) => !hidden.includes(name)), ...positioned ? [position.alias] : []];
   if (new Set(names).size !== names.length) {
-    throw internalError4({ message: "positional lateral projection has duplicate output names" });
+    throw internalError5({ message: "positional lateral projection has duplicate output names" });
   }
   const values = names.map((name) => `${subAlias}.${dialect.quoteIdent({ name })}`);
   const chunks = [];
@@ -5238,30 +5427,34 @@ function renderPositionalRow(params) {
     chunks.push(`${json.rowArray}(${values.slice(index, index + JSON_TRANSPORT.chunkSize).join(", ")})`);
   }
   if (chunks.length > JSON_TRANSPORT.chunkSize) {
-    throw internalError4({ message: "positional lateral projection exceeds the transport width limit" });
+    throw internalError5({ message: "positional lateral projection exceeds the transport width limit" });
   }
   return chunks.length === 1 ? chunks[0] : `${json.rowArray}(${chunks.join(", ")})`;
 }
 function lateralJsonOf(params) {
   const json = params.dialect.lateralJson;
   if (json === null)
-    throw internalError4({ message: "lateral JSON rendering on a dialect without LATERAL" });
+    throw internalError5({ message: "lateral JSON rendering on a dialect without LATERAL" });
   return json;
 }
 function renderLateralJoin(params) {
+  const { dialect, join } = params;
+  return `LEFT JOIN LATERAL (${renderLateralSubquery(params)}) AS ${dialect.quoteIdent({ name: join.alias })} ON true`;
+}
+function renderLateralSubquery(params) {
   const { dialect, join, collector } = params;
   const inner = renderSelect({ dialect, statement: join.select, collector });
   if (join.agg === "count") {
     if (join.rowFormat === "positional" || join.select.columns.length !== 0 || join.select.selectExpr?.kind !== "countAll" || join.select.selectExpr.alias !== join.columnAlias || join.select.groupBy !== undefined || join.select.having !== undefined || join.select.limit !== undefined || join.select.offset !== undefined || join.select.distinctOn !== undefined || join.select.distinct !== undefined) {
-      throw internalError4({ message: "count lateral must return one ungrouped COUNT(*) under its column alias" });
+      throw internalError5({ message: "count lateral must return one ungrouped COUNT(*) under its column alias" });
     }
-    return `LEFT JOIN LATERAL (${inner.text}) AS ${dialect.quoteIdent({ name: join.alias })} ON true`;
+    return inner.text;
   }
   if (join.agg === "aggregate") {
     if (join.rowFormat === "positional" || join.select.columns.length !== 0 || join.select.selectExpr !== undefined || (join.select.aggregates?.length ?? 0) === 0 || join.select.groupBy !== undefined || join.select.having !== undefined || join.select.groupingSets !== undefined || join.select.limit !== undefined || join.select.offset !== undefined || join.select.distinctOn !== undefined || join.select.distinct !== undefined || join.select.rowLock !== undefined) {
-      throw internalError4({ message: "aggregate lateral must return one ungrouped row of aggregates" });
+      throw internalError5({ message: "aggregate lateral must return one ungrouped row of aggregates" });
     }
-    return `LEFT JOIN LATERAL (${inner.text}) AS ${dialect.quoteIdent({ name: join.alias })} ON true`;
+    return inner.text;
   }
   const columnAlias = dialect.quoteIdent({ name: join.columnAlias });
   const subAlias = dialect.quoteIdent({ name: "__sub" });
@@ -5290,14 +5483,30 @@ function renderLateralJoin(params) {
   }
   const rowJson = join.rowFormat === "positional" ? renderPositionalRow({ dialect, join, subAlias }) : `to_json(${subAlias}.*)`;
   const projection = join.agg === "jsonArray" ? `COALESCE(${json.arrayAgg}(${rowJson}${aggOrder}), ${json.emptyArray}) AS ${columnAlias}` : `${rowJson} AS ${columnAlias}`;
-  const alias = dialect.quoteIdent({ name: join.alias });
-  return `LEFT JOIN LATERAL (SELECT ${projection} FROM (${inner.text}) AS ${subAlias}) AS ${alias} ON true`;
+  const exposed = join.expose ?? [];
+  if (exposed.length > 0) {
+    const projected = join.select.columns.map((column) => projectionOutputName({ column }));
+    if (join.agg !== "jsonObject" || exposed.some((name) => !projected.includes(name) || name === join.columnAlias) || new Set(exposed).size !== exposed.length) {
+      throw internalError5({ message: "a lateral exposes distinct projected columns of a one-row subselect, beside its JSON column" });
+    }
+  }
+  const exposure = exposed.map((name) => `, ${subAlias}.${dialect.quoteIdent({ name })}`).join("");
+  return `SELECT ${projection}${exposure} FROM (${inner.text}) AS ${subAlias}`;
+}
+function renderFirstRowList(params) {
+  const { dialect, entry, collector } = params;
+  refuseSharedListDictionary({ dialect });
+  if (entry.list.agg !== "jsonArray" || entry.list.expose !== undefined || entry.ordinal.table === undefined) {
+    throw internalError5({ message: "a first-row list is a JSON list gated by a table-qualified ordinal of the statement's row" });
+  }
+  const list = renderLateralSubquery({ dialect, join: entry.list, collector });
+  return `CASE WHEN ${quoteCol(dialect, entry.ordinal)} = 1 THEN (${list}) END AS ${dialect.quoteIdent({ name: entry.list.columnAlias })}`;
 }
 function renderCountSubquery(params) {
   const { dialect, subquery, collector } = params;
   const select = subquery.select;
   if (select.columns.length !== 0 || select.selectExpr?.kind !== "countAll" || (select.aggregates?.length ?? 0) > 0 || select.rowNumber !== undefined || select.groupBy !== undefined || select.having !== undefined || select.limit !== undefined || select.offset !== undefined || select.distinctOn !== undefined || select.distinct !== undefined || select.rowLock !== undefined || select.countSubqueries !== undefined || select.scalarSubqueries !== undefined) {
-    throw internalError4({ message: "count subquery must be one ungrouped COUNT(*)" });
+    throw internalError5({ message: "count subquery must be one ungrouped COUNT(*)" });
   }
   const inner = renderSelect({ dialect, statement: select, collector });
   return `(${inner.text}) AS ${dialect.quoteIdent({ name: subquery.alias })}`;
@@ -5362,7 +5571,7 @@ function renderCaptureReturning(params) {
   const alias = dialect.quoteIdent({ name: column.alias });
   if (column.capture === "cascade") {
     if (params.collector === undefined)
-      throw internalError4({ message: `capture cascade column "${column.alias}" rendered without a parameter collector` });
+      throw internalError5({ message: `capture cascade column "${column.alias}" rendered without a parameter collector` });
     const child = dialect.quoteIdent({ name: CAPTURE_CHILD_ALIAS });
     const match = column.cascade.on.map((pair) => `${child}.${dialect.quoteIdent({ name: pair.child })} = ${rows.old}.${dialect.quoteIdent({ name: pair.parent })}`).join(" AND ");
     return `${renderCascadeImages({ dialect, cascade: column.cascade, match, collector: params.collector })} AS ${alias}`;
@@ -5382,7 +5591,7 @@ function renderCaptureCell(params) {
   if (cell.hop === undefined)
     return textProjection({ dialect, expression: `${row}.${name}` });
   if (cell.hop.on.length === 0)
-    throw internalError4({ message: `capture hop to "${cell.hop.table.name}" needs at least one key column` });
+    throw internalError5({ message: `capture hop to "${cell.hop.table.name}" needs at least one key column` });
   const related = dialect.quoteIdent({ name: CAPTURE_HOP_ALIAS });
   const match = cell.hop.on.map((pair) => `${related}.${dialect.quoteIdent({ name: pair.target })} = ${row}.${dialect.quoteIdent({ name: pair.source })}`).join(" AND ");
   return `(SELECT ${textProjection({ dialect, expression: `${related}.${name}` })} FROM ${renderTable(dialect, cell.hop.table)} AS ${related} WHERE ${match})`;
@@ -5390,9 +5599,9 @@ function renderCaptureCell(params) {
 function renderCascadeImages(params) {
   const { dialect, cascade, match, collector } = params;
   if (cascade.cells.length === 0 || cascade.on.length === 0)
-    throw internalError4({ message: `capture cascade into "${cascade.table.name}" needs at least one cell and one key column` });
+    throw internalError5({ message: `capture cascade into "${cascade.table.name}" needs at least one cell and one key column` });
   if (!Number.isSafeInteger(cascade.limit) || cascade.limit < 1)
-    throw internalError4({ message: `capture cascade into "${cascade.table.name}" needs a positive integer limit` });
+    throw internalError5({ message: `capture cascade into "${cascade.table.name}" needs a positive integer limit` });
   const child = dialect.quoteIdent({ name: CAPTURE_CHILD_ALIAS });
   const item = dialect.quoteIdent({ name: "__vibe_i" });
   const cells = cascade.cells.map((cell) => renderCaptureCell({ dialect, row: child, cell })).join(", ");
@@ -5425,20 +5634,20 @@ function renderKeyTableJoin(params) {
     });
   }
   if (join.columns.length === 0 || join.columns.length !== join.members.length) {
-    throw internalError4({ message: `key table needs one member per column, got ${join.members.length} for ${join.columns.length}` });
+    throw internalError5({ message: `key table needs one member per column, got ${join.members.length} for ${join.columns.length}` });
   }
   if (join.rows.length === 0)
-    throw internalError4({ message: "key table needs at least one key row" });
+    throw internalError5({ message: "key table needs at least one key row" });
   for (const member of join.members) {
     if (member.kind === "decimal" && !(Number.isInteger(member.scale) && member.scale >= 0 && member.scale <= 30)) {
-      throw internalError4({ message: `key table decimal scale must be an integer 0-30, got ${String(member.scale)}` });
+      throw internalError5({ message: `key table decimal scale must be an integer 0-30, got ${String(member.scale)}` });
     }
   }
   const alias = dialect.quoteIdent({ name: join.alias });
   const memberNames = join.members.map((_, index) => dialect.quoteIdent({ name: `__vibe_k${index}` }));
   const rows = join.rows.map((row, ordinal) => {
     if (row.length !== join.members.length) {
-      throw internalError4({ message: `key table row has ${row.length} values for ${join.members.length} members` });
+      throw internalError5({ message: `key table row has ${row.length} values for ${join.members.length} members` });
     }
     const cells = row.map((value, index) => {
       const placeholder = collector.add(value);
@@ -5468,10 +5677,10 @@ function renderKeyTableJoin(params) {
 function renderLeftJoin(params) {
   const { dialect, join, collector } = params;
   if (join.on.length === 0) {
-    throw internalError4({ message: "left join needs at least one ON pair" });
+    throw internalError5({ message: "left join needs at least one ON pair" });
   }
   if (join.select.columns.length === 0 || join.select.columns.some((column) => column.alias === undefined)) {
-    throw internalError4({ message: "a left join's derived select must alias every projected column" });
+    throw internalError5({ message: "a left join's derived select must alias every projected column" });
   }
   const inner = renderSelect({ dialect, statement: join.select, collector });
   const on = join.on.map((pair) => `${quoteCol(dialect, pair.left)} = ${quoteCol(dialect, pair.right)}`).join(" AND ");
@@ -5481,19 +5690,28 @@ function renderExistsSelect(params) {
   const { dialect, statement, alias, collector } = params;
   const extra = statement.columns.length > 0 || (statement.aggregates?.length ?? 0) > 0 || statement.countSubqueries !== undefined || statement.scalarSubqueries !== undefined || statement.rowNumber !== undefined || statement.groupBy !== undefined || statement.groupingSets !== undefined || statement.having !== undefined || statement.orderBy !== undefined || statement.limit !== undefined || statement.offset !== undefined || statement.rowLock !== undefined || statement.distinct !== undefined || statement.distinctOn !== undefined || statement.lateralJoins !== undefined || statement.innerJoins !== undefined || statement.leftJoins !== undefined || statement.keyTable !== undefined;
   if (extra)
-    throw internalError4({ message: "an exists select takes only a FROM and a WHERE" });
+    throw internalError5({ message: "an exists select takes only a FROM and a WHERE" });
   const inner = renderSelect({ dialect, statement: { ...statement, selectExpr: { kind: "one" } }, collector });
   return { ...inner, text: `SELECT EXISTS (${inner.text}) AS ${dialect.quoteIdent({ name: alias })}` };
 }
 function renderSelect(params) {
   const { dialect, statement, collector } = params;
+  if (statement.with !== undefined) {
+    if (params.outermost !== true)
+      throw internalError5({ message: "common tables render on the outermost select only" });
+    const { with: tables, ...main } = statement;
+    const prefix = renderCommonTables({ dialect, tables, collector });
+    const names = new Set(tables.map((table) => table.name));
+    const rendered = renderSelect({ dialect, statement: main, collector, ...main.allColumns === true && names.has(main.table.name) ? { overCommonTable: true } : {} });
+    return { ...rendered, text: `${prefix}${rendered.text}` };
+  }
   if (statement.selectExpr?.kind === "exists")
     return renderExistsSelect({ dialect, statement, alias: statement.selectExpr.alias, collector });
   if (statement.selectExpr !== undefined && statement.columns.length > 0 && statement.selectExpr.kind !== "countAll") {
-    throw internalError4({ message: "only countAll can combine with a column list" });
+    throw internalError5({ message: "only countAll can combine with a column list" });
   }
   if (statement.selectExpr !== undefined && statement.aggregates !== undefined && statement.aggregates.length > 0) {
-    throw internalError4({ message: "selectExpr and aggregates cannot combine" });
+    throw internalError5({ message: "selectExpr and aggregates cannot combine" });
   }
   const columnList = statement.columns.map((column) => quoteProjection(dialect, column));
   if (statement.selectExpr !== undefined) {
@@ -5523,15 +5741,45 @@ function renderSelect(params) {
   if (statement.rowNumber !== undefined) {
     const rowNumber = statement.rowNumber;
     if (rowNumber.partitionBy.length === 0 && rowNumber.orderBy.length === 0) {
-      throw internalError4({ message: "rowNumber needs a partition column or an order" });
+      throw internalError5({ message: "rowNumber needs a partition column or an order" });
     }
     const partition = rowNumber.partitionBy.length === 0 ? "" : `PARTITION BY ${rowNumber.partitionBy.map((column) => quoteCol(dialect, column)).join(", ")}`;
     const order = rowNumber.orderBy.length === 0 ? "" : `${partition === "" ? "" : " "}ORDER BY ${rowNumber.orderBy.map((term) => renderOrderTerm({ dialect, term, collector })).join(", ")}`;
     columnList.push(`ROW_NUMBER() OVER (${partition}${order}) AS ${dialect.quoteIdent({ name: rowNumber.alias })}`);
   }
+  if (statement.windows !== undefined) {
+    for (const window of statement.windows) {
+      const alias = dialect.quoteIdent({ name: window.alias });
+      if (window.kind === "ordinal") {
+        const order = window.orderBy.length === 0 ? "" : `ORDER BY ${window.orderBy.map((term) => renderOrderTerm({ dialect, term, collector })).join(", ")}`;
+        columnList.push(`ROW_NUMBER() OVER (${order}) AS ${alias}`);
+        continue;
+      }
+      if (window.partitionBy.length === 0)
+        throw internalError5({ message: "a firstOrdinal window needs a partition column" });
+      columnList.push(`MIN(${quoteCol(dialect, window.ordinal)}) OVER (PARTITION BY ${window.partitionBy.map((column) => quoteCol(dialect, column)).join(", ")}) AS ${alias}`);
+    }
+  }
+  if (statement.firstRowLists !== undefined) {
+    for (const entry of statement.firstRowLists)
+      columnList.push(renderFirstRowList({ dialect, entry, collector }));
+  }
+  if (statement.allColumns === true) {
+    if (params.overCommonTable === true) {
+      if (statement.fromSelect !== undefined || statement.selectExpr !== undefined || statement.table.namespace !== undefined) {
+        throw internalError5({ message: "allColumns over a common table reads that table alone" });
+      }
+      columnList.unshift(`${dialect.quoteIdent({ name: statement.table.alias ?? statement.table.name })}.*`);
+    } else {
+      if (statement.fromSelect === undefined || statement.columns.length > 0 || statement.selectExpr !== undefined) {
+        throw internalError5({ message: "allColumns re-exposes a derived table: it needs fromSelect and no column list" });
+      }
+      columnList.unshift(`${dialect.quoteIdent({ name: statement.table.name })}.*`);
+    }
+  }
   let distinctPrefix = statement.distinct === true ? "DISTINCT " : "";
   if (statement.distinct === true && statement.distinctOn !== undefined) {
-    throw internalError4({ message: "distinct and distinctOn cannot combine" });
+    throw internalError5({ message: "distinct and distinctOn cannot combine" });
   }
   if (statement.distinctOn !== undefined && statement.distinctOn.length > 0) {
     if (!dialect.capabilities.distinctOn) {
@@ -5547,16 +5795,22 @@ function renderSelect(params) {
   let from;
   if (statement.fromKeys !== undefined) {
     from = renderKeyRows({ dialect, statement, keys: statement.fromKeys, collector });
+  } else if (statement.fromRow !== undefined) {
+    from = renderOuterRow({ dialect, statement, row: statement.fromRow });
+  } else if (statement.fromJsonKeys !== undefined) {
+    from = renderJsonKeys({ dialect, statement, keys: statement.fromJsonKeys });
+  } else if (statement.fromTableArrays !== undefined) {
+    from = renderTableArrays({ dialect, statement, rows: statement.fromTableArrays });
   } else if (statement.fromUnion !== undefined) {
     from = `(${renderUnionPage({ dialect, statement, collector })}) AS ${dialect.quoteIdent({ name: statement.table.name })}`;
   } else if (statement.keyPage !== undefined) {
     if (statement.fromSelect !== undefined || statement.table.alias !== undefined) {
-      throw internalError4({ message: "keyPage uses table.name as the derived-table alias \u2014 fromSelect and table.alias must be unset" });
+      throw internalError5({ message: "keyPage uses table.name as the derived-table alias \u2014 fromSelect and table.alias must be unset" });
     }
     from = `(${renderKeyPage({ dialect, page: statement.keyPage, collector })}) AS ${dialect.quoteIdent({ name: statement.table.name })}`;
   } else if (statement.fromSelect !== undefined) {
     if (statement.table.alias !== undefined) {
-      throw internalError4({ message: "fromSelect uses table.name as the subquery alias \u2014 table.alias must be unset" });
+      throw internalError5({ message: "fromSelect uses table.name as the subquery alias \u2014 table.alias must be unset" });
     }
     const inner = renderSelect({ dialect, statement: statement.fromSelect, collector });
     from = `(${inner.text}) AS ${dialect.quoteIdent({ name: statement.table.name })}`;
@@ -5567,7 +5821,7 @@ function renderSelect(params) {
   if (statement.innerJoins !== undefined && statement.innerJoins.length > 0) {
     for (const join of statement.innerJoins) {
       if (join.on.length === 0) {
-        throw internalError4({ message: "inner join needs at least one ON pair" });
+        throw internalError5({ message: "inner join needs at least one ON pair" });
       }
       const on = join.on.map((pair) => `${quoteCol(dialect, pair.left)} = ${quoteCol(dialect, pair.right)}`).join(" AND ");
       text += ` INNER JOIN ${renderTable(dialect, join.table)} ON ${on}`;
@@ -5578,7 +5832,7 @@ function renderSelect(params) {
   }
   if (statement.leftJoins !== undefined && statement.leftJoins.length > 0) {
     if (statement.rowLock !== undefined) {
-      throw internalError4({ message: "a locking read cannot carry a left join \u2014 postgres refuses FOR UPDATE on the nullable side of an outer join" });
+      throw internalError5({ message: "a locking read cannot carry a left join \u2014 postgres refuses FOR UPDATE on the nullable side of an outer join" });
     }
     for (const join of statement.leftJoins) {
       text += ` ${renderLeftJoin({ dialect, join, collector })}`;
@@ -5602,7 +5856,7 @@ function renderSelect(params) {
   if (statement.groupBy !== undefined && statement.groupBy.length > 0) {
     text += ` GROUP BY ${statement.groupingSets === undefined ? groupKeys.join(", ") : renderGroupingSets({ dialect, keys: groupKeys, grouping: statement.groupingSets })}`;
   } else if (statement.groupingSets !== undefined) {
-    throw internalError4({ message: "grouping sets need groupBy columns" });
+    throw internalError5({ message: "grouping sets need groupBy columns" });
   }
   if (statement.having !== undefined) {
     text += ` HAVING ${renderExpr({ dialect, expr: statement.having, collector })}`;
@@ -5635,10 +5889,10 @@ function renderSelect(params) {
   if (statement.rowLock !== undefined) {
     const target = statement.table.alias ?? statement.table.name;
     if (statement.rowLock.of !== undefined && statement.rowLock.of.some((name) => name !== target)) {
-      throw internalError4({ message: `a row lock's \`of\` list may name only the statement's own table "${target}"` });
+      throw internalError5({ message: `a row lock's \`of\` list may name only the statement's own table "${target}"` });
     }
     if (statement.rowLock.of !== undefined && (statement.fromSelect !== undefined || statement.keyPage !== undefined)) {
-      throw internalError4({ message: "a row lock's `of` list cannot name a derived table" });
+      throw internalError5({ message: "a row lock's `of` list cannot name a derived table" });
     }
     const clause = renderRowLockClause({ dialect, lock: statement.rowLock });
     if (clause !== null)
@@ -5654,7 +5908,7 @@ function unnestElement(params) {
     return null;
   if (isJsonParamCell(value)) {
     if (jsonStorage === undefined || (value.storage ?? "jsonb") !== jsonStorage) {
-      throw internalError4({ message: `unnest insert column "${column}" got a Json cell its declared type does not take` });
+      throw internalError5({ message: `unnest insert column "${column}" got a Json cell its declared type does not take` });
     }
     return value.text;
   }
@@ -5670,7 +5924,7 @@ function unnestElement(params) {
           return value;
     }
   }
-  throw internalError4({ message: `unnest insert column "${column}" got a cell that is not a plain value (DEFAULT, the database clock, a document) \u2014 such rows keep VALUES` });
+  throw internalError5({ message: `unnest insert column "${column}" got a cell that is not a plain value (DEFAULT, the database clock, a document) \u2014 such rows keep VALUES` });
 }
 function renderUnnestRows(params) {
   const { dialect, statement, members, collector } = params;
@@ -5682,12 +5936,12 @@ function renderUnnestRows(params) {
     });
   }
   if (statement.columns.length === 0)
-    throw internalError4({ message: "an unnest insert needs at least one column" });
+    throw internalError5({ message: "an unnest insert needs at least one column" });
   if (members.length !== statement.columns.length) {
-    throw internalError4({ message: `unnest insert has ${members.length} column types for ${statement.columns.length} columns` });
+    throw internalError5({ message: `unnest insert has ${members.length} column types for ${statement.columns.length} columns` });
   }
   if (statement.onConflict !== undefined && !("doNothing" in statement.onConflict)) {
-    throw internalError4({ message: "an unnest insert takes no DO UPDATE arm \u2014 upserts bind VALUES" });
+    throw internalError5({ message: "an unnest insert takes no DO UPDATE arm \u2014 upserts bind VALUES" });
   }
   const aliases = statement.columns.map((_column, index) => dialect.quoteIdent({ name: `c${index + 1}` }));
   const arrays = members.map((member, index) => {
@@ -5703,11 +5957,11 @@ function renderUnnestRows(params) {
 function renderInsert(params) {
   const { dialect, statement, collector } = params;
   if (statement.rows.length === 0) {
-    throw internalError4({ message: "insert requires at least one row" });
+    throw internalError5({ message: "insert requires at least one row" });
   }
   const defaultValues = statement.columns.length === 0 && dialect.emptyInsert.form === "defaultValues";
   if (defaultValues && statement.rows.length !== 1) {
-    throw internalError4({ message: `${dialect.name} inserts an all-default row as DEFAULT VALUES, one row per statement` });
+    throw internalError5({ message: `${dialect.name} inserts an all-default row as DEFAULT VALUES, one row per statement` });
   }
   if (defaultValues && statement.onConflict !== undefined && !(dialect.emptyInsert.form === "defaultValues" && dialect.emptyInsert.conflictClause)) {
     throw unsupportedCapability23({
@@ -5718,7 +5972,7 @@ function renderInsert(params) {
   }
   for (const row of statement.rows) {
     if (row.length !== statement.columns.length) {
-      throw internalError4({
+      throw internalError5({
         message: `insert row has ${row.length} values but ${statement.columns.length} columns`
       });
     }
@@ -5736,7 +5990,7 @@ function renderInsert(params) {
     if (!isSqlDefaultCell(value))
       return collector.add(value);
     if (!dialect.rowDefaultKeyword) {
-      throw internalError4({
+      throw internalError5({
         message: `${dialect.name} cannot render a per-row DEFAULT cell \u2014 rows must be grouped by column set`
       });
     }
@@ -5776,20 +6030,20 @@ function renderInsert(params) {
         }
         const keepName = onConflict.keepColumn ?? statement.columns[0];
         if (keepName === undefined) {
-          throw internalError4({ message: "a skip-duplicates insert of an all-default row must name its keepColumn" });
+          throw internalError5({ message: "a skip-duplicates insert of an all-default row must name its keepColumn" });
         }
         const keep = dialect.quoteIdent({ name: keepName });
         const current = `${dialect.quoteIdent({ name: statement.table.name })}.${keep}`;
         const flag = onConflict.duplicateFlag;
         if (flag !== undefined && !/^\d{1,20}$/.test(flag)) {
-          throw internalError4({ message: `duplicateFlag must be a decimal literal, got ${JSON.stringify(flag)}` });
+          throw internalError5({ message: `duplicateFlag must be a decimal literal, got ${JSON.stringify(flag)}` });
         }
         text += flag === undefined ? ` ON DUPLICATE KEY UPDATE ${keep} = ${current}` : ` ON DUPLICATE KEY UPDATE ${keep} = IF(LAST_INSERT_ID(${flag}), ${current}, ${current})`;
       }
     } else {
       const updates = Object.entries(onConflict.update);
       if (updates.length === 0) {
-        throw internalError4({ message: "upsert update must set at least one column" });
+        throw internalError5({ message: "upsert update must set at least one column" });
       }
       const selfRef = dialect.quoteIdent({ name: statement.table.name });
       if (onConflict.skipUnchanged !== undefined && !dialect.capabilities.upsertSkipUnchanged) {
@@ -5801,7 +6055,7 @@ function renderInsert(params) {
       const assignments = dialect.upsertForm !== "onConflict" && onConflict.skipUnchanged !== undefined ? renderStampFirstAssignments({ dialect, columns: onConflict.skipUnchanged, update: onConflict.update, collector, selfRef, tableName: statement.table.name }) : renderAssignments({ dialect, entries: updates, collector, selfRef, allowExcluded: true, tableName: statement.table.name });
       if (dialect.upsertForm === "onConflict") {
         if (onConflict.lastInsertIdColumn !== undefined) {
-          throw internalError4({ message: "lastInsertIdColumn is a mysql (onDuplicateKey) construct" });
+          throw internalError5({ message: "lastInsertIdColumn is a mysql (onDuplicateKey) construct" });
         }
         if (onConflict.constraint !== undefined && dialect.name !== "postgres") {
           throw unsupportedCapability23({
@@ -5811,7 +6065,7 @@ function renderInsert(params) {
           });
         }
         if (onConflict.constraint !== undefined && onConflict.conflictWhere !== undefined) {
-          throw internalError4({
+          throw internalError5({
             message: "a named-constraint conflict target already identifies the index \u2014 it cannot carry a partial predicate too"
           });
         }
@@ -5856,7 +6110,7 @@ function renderInsert(params) {
         const trick = onConflict.lastInsertIdColumn === undefined ? "" : `, ${dialect.quoteIdent({ name: onConflict.lastInsertIdColumn })} = LAST_INSERT_ID(${dialect.quoteIdent({ name: onConflict.lastInsertIdColumn })})`;
         const flagged = onConflict.duplicateFlag;
         if (flagged !== undefined && (onConflict.lastInsertIdColumn !== undefined || !/^\d{1,20}$/.test(flagged.flag))) {
-          throw internalError4({ message: "an update arm's duplicate flag must be a decimal literal, and cannot share LAST_INSERT_ID with lastInsertIdColumn" });
+          throw internalError5({ message: "an update arm's duplicate flag must be a decimal literal, and cannot share LAST_INSERT_ID with lastInsertIdColumn" });
         }
         const flag = flagged === undefined ? "" : `, ${dialect.quoteIdent({ name: flagged.column })} = IF(LAST_INSERT_ID(${flagged.flag}), ${selfRef}.${dialect.quoteIdent({ name: flagged.column })}, ${selfRef}.${dialect.quoteIdent({ name: flagged.column })})`;
         text += ` ON DUPLICATE KEY UPDATE ${assignments}${trick}${flag}`;
@@ -5870,12 +6124,12 @@ function renderUpdate(params) {
   const { dialect, statement, collector } = params;
   const assignments = Object.entries(statement.set);
   if (assignments.length === 0) {
-    throw internalError4({ message: "update must set at least one column" });
+    throw internalError5({ message: "update must set at least one column" });
   }
   const source = statement.from;
   if (source !== undefined) {
     if (statement.alias === undefined || statement.alias === source.alias)
-      throw internalError4({ message: "UPDATE \u2026 FROM needs distinct target and source aliases" });
+      throw internalError5({ message: "UPDATE \u2026 FROM needs distinct target and source aliases" });
     const target = dialect.quoteIdent({ name: statement.alias });
     const joined = dialect.quoteIdent({ name: source.alias });
     const assign = () => renderAssignments({ dialect, entries: assignments, collector, selfRef: target, source: joined, ...dialect.name === "mysql" ? { qualifyWrite: target } : {}, ...params.earlier === undefined ? {} : { steps: params.earlier } });
@@ -5915,12 +6169,12 @@ function renderAssignments(params) {
 function renderUnchangedGuard(params) {
   const { dialect, columns, update, collector, selfRef, tableName } = params;
   if (columns.length === 0)
-    throw internalError4({ message: "a skip-unchanged guard needs at least one compared column" });
+    throw internalError5({ message: "a skip-unchanged guard needs at least one compared column" });
   const left = [];
   const right = [];
   for (const entry of columns) {
     if (!Object.hasOwn(update, entry.column)) {
-      throw internalError4({ message: `the skip-unchanged column ${entry.column} has no assignment in the update arm` });
+      throw internalError5({ message: `the skip-unchanged column ${entry.column} has no assignment in the update arm` });
     }
     const assigned = update[entry.column];
     const value = renderAssignmentValue({ dialect, collector, selfRef, allowExcluded: true, tableName, name: entry.column, value: assigned });
@@ -5966,23 +6220,23 @@ function renderAssignmentValue(params) {
   const read = selfRef === undefined ? column : `${selfRef}.${column}`;
   if (isSourceColumnRef(value)) {
     if (params.source === undefined)
-      throw internalError4({ message: `an UPDATE set value reads the joined source's column ${value.column}, but the statement joins no source` });
+      throw internalError5({ message: `an UPDATE set value reads the joined source's column ${value.column}, but the statement joins no source` });
     return `${params.source}.${dialect.quoteIdent({ name: value.column })}`;
   }
   if (isStepColumnRef(value)) {
     if (params.steps === undefined || !params.steps.has(value.step)) {
-      throw internalError4({ message: `an UPDATE set value reads step "${value.step}", which is not an earlier chain step` });
+      throw internalError5({ message: `an UPDATE set value reads step "${value.step}", which is not an earlier chain step` });
     }
     return `(SELECT ${dialect.quoteIdent({ name: value.column })} FROM ${dialect.quoteIdent({ name: value.step })})`;
   }
   if (isSqlFragment(value)) {
     if (params.allowExcluded !== true || selfRef === undefined)
-      throw internalError4({ message: "SQL assignment fragments require a conflict update" });
+      throw internalError5({ message: "SQL assignment fragments require a conflict update" });
     return renderSqlFragment({ dialect, fragment: value, collector, conflict: { table: params.tableName } });
   }
   if (isExcludedRef(value)) {
     if (params.allowExcluded !== true) {
-      throw internalError4({
+      throw internalError5({
         message: `an incoming-row reference (${value.column}) is only meaningful inside an upsert's update arm`
       });
     }
@@ -5990,7 +6244,7 @@ function renderAssignmentValue(params) {
   }
   if (isSqlKeepCell(value)) {
     if (params.allowExcluded !== true || selfRef === undefined)
-      throw internalError4({ message: "a keep-column cell is only meaningful inside an upsert's update arm" });
+      throw internalError5({ message: "a keep-column cell is only meaningful inside an upsert's update arm" });
     return read;
   }
   if (isJsonPatchOperation(value)) {
@@ -6037,12 +6291,12 @@ function renderChain(params) {
     });
   }
   if (statement.steps.length === 0)
-    throw internalError4({ message: "a statement chain needs at least one step" });
+    throw internalError5({ message: "a statement chain needs at least one step" });
   const defined = new Set;
   const steps = [];
   for (const step of statement.steps) {
     if (step.name === CHAIN_ROWS_ALIAS || step.name === CHAIN_ONE_ALIAS || defined.has(step.name)) {
-      throw internalError4({ message: `chain step name "${step.name}" is reserved or repeated` });
+      throw internalError5({ message: `chain step name "${step.name}" is reserved or repeated` });
     }
     const body = renderChainStep({ dialect, statement: step.statement, collector, earlier: defined });
     steps.push(`${dialect.quoteIdent({ name: step.name })} AS (${body})`);
@@ -6055,7 +6309,7 @@ function renderChain(params) {
   }
   for (const alias of captureAliases({ captures })) {
     if (result.columns.includes(alias) || alias === result.verdict?.alias || alias === result.tally?.alias) {
-      throw internalError4({ message: `chain capture alias "${alias}" collides with a result column` });
+      throw internalError5({ message: `chain capture alias "${alias}" collides with a result column` });
     }
   }
   if (result.rowsFrom.length === 0 && result.columns.length === 0 && result.tally !== undefined && result.verdict === undefined) {
@@ -6063,11 +6317,11 @@ function renderChain(params) {
     return { text: `WITH ${steps.join(", ")} SELECT ${[tally, ...renderChainCaptures({ dialect, captures, defined, collector })].join(", ")}`, values: collector.values, returning: "none" };
   }
   if (result.rowsFrom.length === 0 || result.columns.length === 0) {
-    throw internalError4({ message: "a chain result needs at least one source step and one column" });
+    throw internalError5({ message: "a chain result needs at least one source step and one column" });
   }
   for (const name of result.rowsFrom) {
     if (!defined.has(name))
-      throw internalError4({ message: `chain result reads undefined step "${name}"` });
+      throw internalError5({ message: `chain result reads undefined step "${name}"` });
   }
   const columnList = result.columns.map((name) => dialect.quoteIdent({ name })).join(", ");
   const guarded = result.verdict !== undefined || result.tally !== undefined || result.veto !== undefined && result.veto.length > 0;
@@ -6078,7 +6332,7 @@ function renderChain(params) {
     const extra = [];
     for (const alias of [result.verdict?.alias, result.tally?.alias]) {
       if (alias !== undefined && result.columns.includes(alias)) {
-        throw internalError4({ message: `chain result alias "${alias}" collides with a result column` });
+        throw internalError5({ message: `chain result alias "${alias}" collides with a result column` });
       }
     }
     const rows = dialect.quoteIdent({ name: CHAIN_ROWS_ALIAS });
@@ -6134,7 +6388,7 @@ function renderChainCaptures(params) {
   const out = [];
   for (const entry of captures) {
     if (!defined.has(entry.step))
-      throw internalError4({ message: `chain capture reads undefined step "${entry.step}"` });
+      throw internalError5({ message: `chain capture reads undefined step "${entry.step}"` });
     const step = quote(entry.step);
     const marker = entry.inserted === undefined ? undefined : quote(entry.inserted);
     out.push(`(SELECT count(*) FROM ${step}) AS ${quote(`${entry.alias}_n`)}`);
@@ -6159,7 +6413,7 @@ function renderImageAggregates(params) {
   if (before.length === 0 && after.length === 0)
     return out;
   if (!Number.isSafeInteger(entry.limit) || entry.limit < 1)
-    throw internalError4({ message: `chain capture "${entry.alias}" needs a positive integer limit` });
+    throw internalError5({ message: `chain capture "${entry.alias}" needs a positive integer limit` });
   const limit = collector.add(entry.limit);
   const item = quote("__vibe_i");
   const image = (columns, filter) => `(SELECT array_agg(${item})::text FROM (SELECT DISTINCT ARRAY[${columns.map(quote).join(", ")}] AS ${item} FROM ${step}${filter} LIMIT ${limit}) AS ${quote("__vibe_d")})`;
@@ -6179,21 +6433,21 @@ function renderSelectCell(params) {
   if (isDbNowMarker(value))
     return dialect.renderDbNow({ offsetSeconds: value.offsetSeconds, collector });
   if (isSqlDefaultCell(value)) {
-    throw internalError4({ message: "DEFAULT is not allowed in an INSERT \u2026 SELECT list \u2014 omit the column instead" });
+    throw internalError5({ message: "DEFAULT is not allowed in an INSERT \u2026 SELECT list \u2014 omit the column instead" });
   }
   return collector.add(value);
 }
 function renderRowSource(params) {
   const { dialect, source, collector } = params;
   if (source.columns.length === 0 || source.rows.length === 0) {
-    throw internalError4({ message: "a row source needs at least one column and one row" });
+    throw internalError5({ message: "a row source needs at least one column and one row" });
   }
   const typedBy = renderTable(dialect, source.typedBy);
   const columns = source.columns.map((name) => dialect.quoteIdent({ name }));
   const rows = [`(${columns.map((column) => `(SELECT ${column} FROM ${typedBy} WHERE FALSE)`).join(", ")})`];
   for (const row of source.rows) {
     if (row.length !== source.columns.length) {
-      throw internalError4({ message: `row source row has ${row.length} values but ${source.columns.length} columns` });
+      throw internalError5({ message: `row source row has ${row.length} values but ${source.columns.length} columns` });
     }
     rows.push(`(${row.map((value) => renderSelectCell({ dialect, value, collector })).join(", ")})`);
   }
@@ -6205,12 +6459,12 @@ function renderTallyColumn(params) {
   const { dialect, result, defined, collector } = params;
   const tally = result.tally;
   if (tally === undefined)
-    throw internalError4({ message: "a chain veto needs a tally column to guard" });
+    throw internalError5({ message: "a chain veto needs a tally column to guard" });
   if (tally.steps.length === 0)
-    throw internalError4({ message: "a chain tally needs at least one step" });
+    throw internalError5({ message: "a chain tally needs at least one step" });
   const step = (name) => {
     if (!defined.has(name))
-      throw internalError4({ message: `chain tally or veto reads undefined step "${name}"` });
+      throw internalError5({ message: `chain tally or veto reads undefined step "${name}"` });
     return dialect.quoteIdent({ name });
   };
   const count = (name) => `(SELECT count(*) FROM ${step(name)})`;
@@ -6218,20 +6472,20 @@ function renderTallyColumn(params) {
   const vetoes = result.veto ?? [];
   if (vetoes.length === 0) {
     if (result.vetoGate !== undefined)
-      throw internalError4({ message: "a chain veto gate needs a veto to gate" });
+      throw internalError5({ message: "a chain veto gate needs a veto to gate" });
     return `${sum} AS ${dialect.quoteIdent({ name: tally.alias })}`;
   }
   const gate = result.vetoGate === undefined ? [] : [`WHEN NOT EXISTS (SELECT 1 FROM ${step(result.vetoGate)}) THEN ${sum}`];
   const arms = vetoes.map((veto) => {
     if (!CHAIN_VETO_TOKEN_PATTERN.test(veto.token))
-      throw internalError4({ message: `chain veto token "${veto.token}" is not a lower-case word` });
+      throw internalError5({ message: `chain veto token "${veto.token}" is not a lower-case word` });
     if (typeof veto.nonce !== "string" || veto.nonce === "")
-      throw internalError4({ message: `chain veto "${veto.token}" needs a non-empty nonce` });
+      throw internalError5({ message: `chain veto "${veto.token}" needs a non-empty nonce` });
     const minRows = veto.minRows ?? 1;
     if (!Number.isSafeInteger(minRows) || minRows < 1)
-      throw internalError4({ message: `chain veto "${veto.token}" needs a positive integer minRows` });
+      throw internalError5({ message: `chain veto "${veto.token}" needs a positive integer minRows` });
     if (veto.exactRows !== undefined && (!Number.isSafeInteger(veto.exactRows) || veto.exactRows < 0 || veto.minRows !== undefined)) {
-      throw internalError4({ message: `chain veto "${veto.token}" needs a nonnegative safe integer exactRows without minRows` });
+      throw internalError5({ message: `chain veto "${veto.token}" needs a nonnegative safe integer exactRows without minRows` });
     }
     const when = veto.exactRows !== undefined ? `WHEN ${count(veto.step)} <> ${veto.exactRows}` : minRows === 1 ? `WHEN NOT EXISTS (SELECT 1 FROM ${step(veto.step)})` : `WHEN ${count(veto.step)} < ${minRows}`;
     return `${when} THEN CAST('${CHAIN_VETO_PREFIX}${veto.token}:' || ${collector.add(veto.nonce)} || ':' || ${count(veto.step)} AS integer)`;
@@ -6241,25 +6495,25 @@ function renderTallyColumn(params) {
 function renderInsertSelect(params) {
   const { dialect, statement, collector } = params;
   if (statement.columns.length === 0)
-    throw internalError4({ message: "insert requires at least one column" });
+    throw internalError5({ message: "insert requires at least one column" });
   if (statement.cells.length !== statement.columns.length) {
-    throw internalError4({
+    throw internalError5({
       message: `insert row has ${statement.cells.length} values but ${statement.columns.length} columns`
     });
   }
   const from = statement.from ?? [];
   for (const name of from) {
     if (!params.earlier.has(name))
-      throw internalError4({ message: `INSERT \u2026 SELECT reads step "${name}" before it is defined` });
+      throw internalError5({ message: `INSERT \u2026 SELECT reads step "${name}" before it is defined` });
   }
   const source = statement.source;
   if (source !== undefined && (params.earlier.has(source.alias) || from.includes(source.alias))) {
-    throw internalError4({ message: `row source alias "${source.alias}" collides with a chain step` });
+    throw internalError5({ message: `row source alias "${source.alias}" collides with a chain step` });
   }
   const cells = statement.cells.map((value) => {
     if (isStepColumnRef(value)) {
       if (!from.includes(value.step) && value.step !== source?.alias) {
-        throw internalError4({ message: `cell reads step "${value.step}", which the INSERT \u2026 SELECT does not name in FROM` });
+        throw internalError5({ message: `cell reads step "${value.step}", which the INSERT \u2026 SELECT does not name in FROM` });
       }
       return `${dialect.quoteIdent({ name: value.step })}.${dialect.quoteIdent({ name: value.column })}`;
     }
@@ -6278,7 +6532,7 @@ function renderInsertSelect(params) {
   const conflict = statement.conflictDoNothing;
   if (conflict !== undefined) {
     if (conflict.columns.length === 0)
-      throw internalError4({ message: "an INSERT \u2026 SELECT conflict clause needs at least one column" });
+      throw internalError5({ message: "an INSERT \u2026 SELECT conflict clause needs at least one column" });
     if (dialect.doNothingForm !== "onConflictDoNothing") {
       throw unsupportedCapability23({
         dialect: dialect.name,
@@ -6538,7 +6792,7 @@ var postgresDialect = {
   keyListStrategy: "unnest",
   keysetSeekStrategy: "rowValue",
   keyPageStrategy: "lateral",
-  lateralJson: { rowArray: "json_build_array", arrayAgg: "json_agg", emptyArray: "'[]'::json", order: "inAggregate", timeOfDayAsText: false, requiresUtcDateTimeWire: false },
+  lateralJson: { rowArray: "json_build_array", arrayAgg: "json_agg", emptyArray: "'[]'::json", order: "inAggregate", timeOfDayAsText: false, requiresUtcDateTimeWire: false, keysFromJson: "elements", pinnedCommonTable: "keyword", carriedLists: "firstRow", silentSizeLimit: null },
   relationStrategyDefault: "join",
   relationFilterStrategy: "eqSelect",
   deferredJoinPage: { minSkip: 1000, requiresCoveringIndex: true },
@@ -6636,7 +6890,7 @@ var mysqlDialect = {
   keyListStrategy: "rowValue",
   keysetSeekStrategy: "or",
   keyPageStrategy: "window",
-  lateralJson: { rowArray: "JSON_ARRAY", arrayAgg: "JSON_ARRAYAGG", emptyArray: "JSON_ARRAY()", order: "positionSlot", timeOfDayAsText: true, requiresUtcDateTimeWire: true },
+  lateralJson: { rowArray: "JSON_ARRAY", arrayAgg: "JSON_ARRAYAGG", emptyArray: "JSON_ARRAY()", order: "positionSlot", timeOfDayAsText: true, requiresUtcDateTimeWire: true, keysFromJson: "jsonTable", pinnedCommonTable: "limit", carriedLists: "carrierRow", silentSizeLimit: "max_allowed_packet" },
   relationStrategyDefault: "join",
   relationFilterStrategy: "exists",
   deferredJoinPage: { minSkip: 1000, requiresCoveringIndex: false },
@@ -6903,7 +7157,7 @@ function renderGeneratedColumnClause({ dialect, generated }) {
   }
 }
 // packages/sql/src/row-rules.ts
-import { VibeError as VibeError25, internalError as internalError5, normalizeRowRules, rowRuleGateField, rowRuleIdentities, rowRuleProtectedFields, rowRuleShapeIssue, rowRuleTriggerName, unsupportedCapability as unsupportedCapability31 } from "@vibeorm/schema";
+import { VibeError as VibeError25, internalError as internalError6, normalizeRowRules, rowRuleGateField, rowRuleIdentities, rowRuleProtectedFields, rowRuleShapeIssue, rowRuleTriggerName, unsupportedCapability as unsupportedCapability31 } from "@vibeorm/schema";
 
 // packages/sql/src/dialects/postgres-row-rules.ts
 import { VibeError as VibeError22, unsupportedCapability as unsupportedCapability28 } from "@vibeorm/schema";
@@ -7073,7 +7327,7 @@ function renderRowRule({ schema, model, rule, dialect, placement }) {
       const functionIdentity = objects.find((object) => object.role === "function")?.identity;
       const triggerIdentity = objects.find((object) => object.role === "trigger")?.identity;
       if (functionIdentity?.kind !== "function" || triggerIdentity?.kind !== "trigger")
-        throw internalError5({ message: "PostgreSQL row rules own one function and one trigger", meta: { model: model.name, rule: normalized.name } });
+        throw internalError6({ message: "PostgreSQL row rules own one function and one trigger", meta: { model: model.name, rule: normalized.name } });
       const gate = rowRuleGateField({ rule: normalized });
       const gateField = gate === undefined ? undefined : model.fields.find((field) => field.name === gate);
       return renderPostgresRowRule({
@@ -7094,15 +7348,15 @@ function renderRowRule({ schema, model, rule, dialect, placement }) {
       const objects = rowRuleIdentities({ schema, model, rule: normalized, dialect: dialect.name });
       const triggers = objects.map(({ role, identity }) => {
         if (role !== "trigger" || identity.kind !== "trigger")
-          throw internalError5({ message: "Event row rules own only triggers", meta: { model: model.name, rule: normalized.name } });
+          throw internalError6({ message: "Event row rules own only triggers", meta: { model: model.name, rule: normalized.name } });
         const event = ["update", "delete"].find((event) => identity.name === rowRuleTriggerName({ rule: normalized, event }));
         if (event === undefined)
-          throw internalError5({ message: "Row-rule identity has no declared event", meta: { model: model.name, rule: normalized.name, trigger: identity.name } });
+          throw internalError6({ message: "Row-rule identity has no declared event", meta: { model: model.name, rule: normalized.name, trigger: identity.name } });
         return { event, identity: { kind: "trigger", table: identity.table, name: identity.name } };
       });
       const table = triggers[0]?.identity.table;
       if (table === undefined)
-        throw internalError5({ message: "Event row rules require at least one trigger", meta: { model: model.name, rule: normalized.name } });
+        throw internalError6({ message: "Event row rules require at least one trigger", meta: { model: model.name, rule: normalized.name } });
       const gate = rowRuleGateField({ rule: normalized });
       const gateField = gate === undefined ? undefined : model.fields.find((field) => field.name === gate);
       const context = {
@@ -7355,7 +7609,7 @@ function renderMigrationVisibility(params) {
   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${MYSQL_NO_ROW_LIMIT}`, values: collector.values, returning: "none" };
 }
 // packages/sql/src/dialects/migration-objects.ts
-import { internalError as internalError6, unsupportedCapability as unsupportedCapability38 } from "@vibeorm/schema";
+import { internalError as internalError7, unsupportedCapability as unsupportedCapability38 } from "@vibeorm/schema";
 function renderMigrationObjectQuery(params) {
   return objectQuery({ ...params, collector: new ParamCollector(params.dialect) });
 }
@@ -7607,7 +7861,7 @@ function renderMigrationObjectBatch(params) {
     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 internalError6({ message: "Batched catalog queries bind their identity in different orders", meta: { kind: identity.kind } });
+      throw internalError7({ 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);
@@ -7849,6 +8103,8 @@ export {
   isSqlQuery,
   isStepColumnRef,
   isTimeZoneName,
+  jsonKeyTokenCast,
+  jsonKeysTyped,
   jsonListParameter,
   jsonParamCell,
   jsonPatchVetoOf,
@@ -7857,6 +8113,7 @@ export {
   mapConflictColumns,
   mysqlBoundTimestampText,
   mysqlDialect,
+  mysqlJsonKeyTypeOf,
   nativeEnumArrayParameter,
   normalizeMysqlNativeType,
   normalizePostgresNativeType,
@@ -7995,4 +8252,4 @@ export {
   zonedCodec
 };
 
-//# debugId=43389FE0EFAEA89964756E2164756E21
+//# debugId=07BC696B142BA5A864756E2164756E21