effect-qb 0.15.0 → 0.17.0

package/dist/mysql.js

@@ -24,6 +24,7 @@ __export(exports_column, {
   json: () => json,
   int: () => int,
   generated: () => generated2,
+  driverValueMapping: () => driverValueMapping2,
   default: () => default_2,
   datetime: () => datetime,
   date: () => date,
@@ -76,6 +77,7 @@ var makeColumnDefinition = (schema, metadata) => {
     runtime: undefined,
     dbType: metadata.dbType,
     runtimeSchema: schema,
+    driverValueMapping: metadata.driverValueMapping,
     nullability: metadata.nullable ? "maybe" : "never",
     dialect: metadata.dbType.dialect,
     kind: "scalar",
@@ -95,6 +97,7 @@ var makeColumnDefinition = (schema, metadata) => {
     defaultValue: metadata.defaultValue,
     generatedValue: metadata.generatedValue,
     ddlType: metadata.ddlType,
+    driverValueMapping: metadata.driverValueMapping,
     identity: metadata.identity,
     enum: metadata.enum
   };
@@ -111,6 +114,7 @@ var remapColumnDefinition = (column, options = {}) => {
     runtime: undefined,
     dbType: metadata.dbType,
     runtimeSchema: schema,
+    driverValueMapping: metadata.driverValueMapping,
     nullability: metadata.nullable ? "maybe" : "never",
     dialect: metadata.dbType.dialect
   };
@@ -129,6 +133,7 @@ var remapColumnDefinition = (column, options = {}) => {
     defaultValue: metadata.defaultValue,
     generatedValue: metadata.generatedValue,
     ddlType: metadata.ddlType,
+    driverValueMapping: metadata.driverValueMapping,
     identity: metadata.identity,
     enum: metadata.enum
   };
@@ -150,6 +155,7 @@ var bindColumn = (tableName, columnName, column, baseTableName, schemaName) => {
     runtime: undefined,
     dbType: column.metadata.dbType,
     runtimeSchema: schema,
+    driverValueMapping: column.metadata.driverValueMapping,
     nullability: column.metadata.nullable ? "maybe" : "never",
     dialect: column.metadata.dbType.dialect,
     kind: "scalar",
@@ -238,6 +244,10 @@ var ddlType = (sqlType) => (column) => mapColumn(column, {
   ...column.metadata,
   ddlType: sqlType
 });
+var driverValueMapping = (mapping) => (column) => mapColumn(column, {
+  ...column.metadata,
+  driverValueMapping: mapping
+});
 var array = (options) => (column) => remapColumnDefinition(column, {
   schema: Schema2.Array(options?.nullableElements ? Schema2.NullOr(column.schema) : column.schema),
   metadata: {
@@ -302,19 +312,109 @@ var references = (target) => foreignKey(target);
 // src/internal/runtime/value.ts
 import * as Schema3 from "effect/Schema";
 var brandString = (pattern2, brand5) => Schema3.String.pipe(Schema3.pattern(pattern2), Schema3.brand(brand5));
-var LocalDateStringSchema = brandString(/^\d{4}-\d{2}-\d{2}$/, "LocalDateString");
-var LocalTimeStringSchema = brandString(/^\d{2}:\d{2}:\d{2}(?:\.\d+)?$/, "LocalTimeString");
-var OffsetTimeStringSchema = brandString(/^\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/, "OffsetTimeString");
-var LocalDateTimeStringSchema = brandString(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?$/, "LocalDateTimeString");
-var InstantStringSchema = brandString(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/, "InstantString");
+var localDatePattern = /^(\d{4})-(\d{2})-(\d{2})$/;
+var isValidLocalDateString = (value) => {
+  const match = localDatePattern.exec(value);
+  if (match === null) {
+    return false;
+  }
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const parsed = new Date(Date.UTC(year, month - 1, day));
+  parsed.setUTCFullYear(year);
+  return parsed.getUTCFullYear() === year && parsed.getUTCMonth() === month - 1 && parsed.getUTCDate() === day;
+};
+var localTimePattern = /^(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?$/;
+var isValidLocalTimeString = (value) => {
+  const match = localTimePattern.exec(value);
+  if (match === null) {
+    return false;
+  }
+  const hour = Number(match[1]);
+  const minute = Number(match[2]);
+  const second = Number(match[3]);
+  return hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59 && second >= 0 && second <= 59;
+};
+var offsetPattern = /^(?:Z|[+-](\d{2}):(\d{2}))$/;
+var isValidOffset = (value) => {
+  const match = offsetPattern.exec(value);
+  if (match === null) {
+    return false;
+  }
+  if (value === "Z") {
+    return true;
+  }
+  const hour = Number(match[1]);
+  const minute = Number(match[2]);
+  return hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59;
+};
+var offsetTimePattern = /^(\d{2}:\d{2}:\d{2}(?:\.\d+)?)(Z|[+-]\d{2}:\d{2})$/;
+var isValidOffsetTimeString = (value) => {
+  const match = offsetTimePattern.exec(value);
+  return match !== null && isValidLocalTimeString(match[1]) && isValidOffset(match[2]);
+};
+var localDateTimePattern = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}(?:\.\d+)?)$/;
+var isValidLocalDateTimeString = (value) => {
+  const match = localDateTimePattern.exec(value);
+  return match !== null && isValidLocalDateString(match[1]) && isValidLocalTimeString(match[2]);
+};
+var instantPattern = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}(?:\.\d+)?)(Z|[+-]\d{2}:\d{2})$/;
+var isValidInstantString = (value) => {
+  const match = instantPattern.exec(value);
+  return match !== null && isValidLocalDateString(match[1]) && isValidLocalTimeString(match[2]) && isValidOffset(match[3]);
+};
+var LocalDateStringSchema = Schema3.String.pipe(Schema3.pattern(localDatePattern), Schema3.filter(isValidLocalDateString), Schema3.brand("LocalDateString"));
+var LocalTimeStringSchema = Schema3.String.pipe(Schema3.pattern(localTimePattern), Schema3.filter(isValidLocalTimeString), Schema3.brand("LocalTimeString"));
+var OffsetTimeStringSchema = Schema3.String.pipe(Schema3.pattern(offsetTimePattern), Schema3.filter(isValidOffsetTimeString), Schema3.brand("OffsetTimeString"));
+var LocalDateTimeStringSchema = Schema3.String.pipe(Schema3.pattern(localDateTimePattern), Schema3.filter(isValidLocalDateTimeString), Schema3.brand("LocalDateTimeString"));
+var InstantStringSchema = Schema3.String.pipe(Schema3.pattern(instantPattern), Schema3.filter(isValidInstantString), Schema3.brand("InstantString"));
 var YearStringSchema = brandString(/^\d{4}$/, "YearString");
-var BigIntStringSchema = brandString(/^-?\d+$/, "BigIntString");
-var DecimalStringSchema = brandString(/^-?(?:0|[1-9]\d*)(?:\.\d+)?$/, "DecimalString");
-var JsonValueSchema = Schema3.suspend(() => Schema3.Union(Schema3.String, Schema3.Number, Schema3.Boolean, Schema3.Null, Schema3.Array(JsonValueSchema), Schema3.Record({
+var canonicalizeBigIntString = (input) => {
+  const trimmed = input.trim();
+  if (!/^-?\d+$/.test(trimmed)) {
+    throw new Error("Expected an integer-like bigint value");
+  }
+  return BigInt(trimmed).toString();
+};
+var isCanonicalBigIntString = (value) => {
+  try {
+    return canonicalizeBigIntString(value) === value;
+  } catch {
+    return false;
+  }
+};
+var canonicalizeDecimalString = (input) => {
+  const trimmed = input.trim();
+  const match = /^([+-]?)(\d+)(?:\.(\d+))?$/.exec(trimmed);
+  if (match === null) {
+    throw new Error("Expected a decimal string");
+  }
+  const sign = match[1] === "-" ? "-" : "";
+  const integer = match[2].replace(/^0+(?=\d)/, "") || "0";
+  const fraction = (match[3] ?? "").replace(/0+$/, "");
+  if (fraction.length === 0) {
+    if (integer === "0") {
+      return "0";
+    }
+    return `${sign}${integer}`;
+  }
+  return `${sign}${integer}.${fraction}`;
+};
+var isCanonicalDecimalString = (value) => {
+  try {
+    return canonicalizeDecimalString(value) === value;
+  } catch {
+    return false;
+  }
+};
+var BigIntStringSchema = Schema3.String.pipe(Schema3.filter(isCanonicalBigIntString), Schema3.brand("BigIntString"));
+var DecimalStringSchema = Schema3.String.pipe(Schema3.filter(isCanonicalDecimalString), Schema3.brand("DecimalString"));
+var JsonValueSchema = Schema3.suspend(() => Schema3.Union(Schema3.String, Schema3.Number.pipe(Schema3.finite()), Schema3.Boolean, Schema3.Null, Schema3.Array(JsonValueSchema), Schema3.Record({
   key: Schema3.String,
   value: JsonValueSchema
 })));
-var JsonPrimitiveSchema = Schema3.Union(Schema3.String, Schema3.Number, Schema3.Boolean, Schema3.Null);
+var JsonPrimitiveSchema = Schema3.Union(Schema3.String, Schema3.Number.pipe(Schema3.finite()), Schema3.Boolean, Schema3.Null);
 
 // src/mysql/datatypes/index.ts
 var exports_datatypes = {};
@@ -532,6 +632,12 @@ var mysqlDatatypeModule = {
 for (const kind of Object.keys(mysqlDatatypeKinds)) {
   mysqlDatatypeModule[kind] = () => withMetadata(kind);
 }
+mysqlDatatypeModule.json = () => ({
+  ...withMetadata("json"),
+  driverValueMapping: {
+    toDriver: (value) => value !== null && typeof value === "object" ? JSON.stringify(value) : value
+  }
+});
 var mysqlDatatypes = mysqlDatatypeModule;
 
 // src/mysql/column.ts
@@ -600,6 +706,7 @@ var primaryKey2 = primaryKey;
 var unique2 = unique;
 var default_2 = default_;
 var generated2 = generated;
+var driverValueMapping2 = driverValueMapping;
 var references2 = references;
 var schema2 = schema;
 // src/mysql/errors/index.ts
@@ -52227,10 +52334,8 @@ var mysqlErrorCatalogByNumber = {
   "MY-015152": [mysqlErrorCatalogBySymbol["ER_AUDIT_LOG_JSON_INVALID_FILTER_CANNOT_BE_USED"]],
   "MY-015153": [mysqlErrorCatalogBySymbol["ER_WARN_AUDIT_LOG_FILTER_RECOVERY_LOGGING_DISABLED_LOG"]]
 };
-var mysqlSymbolPattern = /^(?:[A-Z][A-Z0-9_]*|MY-\d+)$/;
-var mysqlNumberPattern = /^(?:\d+|MY-\d+)$/;
-var isMysqlErrorSymbol = (value) => mysqlSymbolPattern.test(value);
-var isMysqlErrorNumber = (value) => mysqlNumberPattern.test(value);
+var isMysqlErrorSymbol = (value) => (value in mysqlErrorCatalogBySymbol);
+var isMysqlErrorNumber = (value) => (value in mysqlErrorCatalogByNumber);
 var getMysqlErrorDescriptor = (symbol) => mysqlErrorCatalogBySymbol[symbol];
 var findMysqlErrorDescriptorsByNumber = (value) => mysqlErrorCatalogByNumber[value];
 var findMysqlErrorDescriptorsByNumberLoose = (value) => mysqlErrorCatalogByNumber[String(value)];
@@ -109602,8 +109707,8 @@ var asNumber = (value) => {
   if (typeof value === "number" && Number.isFinite(value)) {
     return value;
   }
-  if (typeof value === "string" && value.trim() !== "") {
-    const parsed = Number(value);
+  if (typeof value === "string" && /^[+-]?\d+$/.test(value.trim())) {
+    const parsed = Number(value.trim());
     return Number.isFinite(parsed) ? parsed : undefined;
   }
   return;
@@ -109786,6 +109891,27 @@ var TypeId3 = Symbol.for("effect-qb/Plan");
 import { pipeArguments as pipeArguments2 } from "effect/Pipeable";
 
 // src/internal/table-options.ts
+var referentialActionError = "Foreign key action must be noAction, restrict, cascade, setNull, or setDefault";
+var renderReferentialAction = (action) => {
+  switch (action) {
+    case "noAction":
+      return "no action";
+    case "restrict":
+      return "restrict";
+    case "cascade":
+      return "cascade";
+    case "setNull":
+      return "set null";
+    case "setDefault":
+      return "set default";
+  }
+  throw new Error(referentialActionError);
+};
+var validateReferentialAction = (action) => {
+  if (action !== undefined) {
+    renderReferentialAction(action);
+  }
+};
 var normalizeColumnList = (columns) => {
   const normalized = Array.isArray(columns) ? [...columns] : [columns];
   if (normalized.length === 0) {
@@ -109813,6 +109939,8 @@ var collectInlineOptions = (fields2) => {
       });
     }
     if (column.metadata.references) {
+      validateReferentialAction(column.metadata.references.onUpdate);
+      validateReferentialAction(column.metadata.references.onDelete);
       const local = [columnName];
       options.push({
         kind: "foreignKey",
@@ -109889,6 +110017,8 @@ var validateOptions = (tableName, fields2, options) => {
           }
         }
         if (option.kind === "foreignKey") {
+          validateReferentialAction(option.onUpdate);
+          validateReferentialAction(option.onDelete);
           const reference = option.references();
           if (reference.columns.length !== columns.length) {
             throw new Error(`Foreign key on table '${tableName}' must reference the same number of columns`);
@@ -109913,7 +110043,7 @@ var validateOptions = (tableName, fields2, options) => {
               throw new Error(`Unknown index key column '${key.column}' on table '${tableName}'`);
             }
           }
-          if (option.columns === undefined && (option.keys === undefined || option.keys.length === 0)) {
+          if (columns.length === 0 && (option.keys === undefined || option.keys.length === 0)) {
             throw new Error(`Index on table '${tableName}' requires at least one column or key`);
           }
         }
@@ -110127,10 +110257,13 @@ function make2(name, fields2, schemaName) {
   const resolvedSchemaName = arguments.length >= 3 ? schemaName : "public";
   return makeTable(name, fields2, [], name, "schema", resolvedSchemaName, arguments.length >= 3 ? "explicit" : "default");
 }
-var schema3 = (schemaName) => ({
-  schemaName,
-  table: (name, fields2, ...options2) => applyDeclaredOptions(makeTable(name, fields2, [], name, "schema", schemaName, "explicit"), options2)
-});
+var schema3 = (schemaName) => {
+  const table = (name, fields2, ...options2) => applyDeclaredOptions(makeTable(name, fields2, [], name, "schema", schemaName, "explicit"), options2);
+  return {
+    schemaName,
+    table
+  };
+};
 var alias = (table, aliasName) => {
   const state = table[TypeId4];
   const columns = Object.fromEntries(Object.entries(state.fields).map(([key, column]) => [key, bindColumn(aliasName, key, column, state.baseName, state.schemaName)]));
@@ -110254,6 +110387,309 @@ var check = (name, predicate) => makeOption({
   predicate
 });
 
+// src/internal/runtime/normalize.ts
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isPlainRecord = (value) => {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};
+var pad = (value, width = 2) => value.toString().padStart(width, "0");
+var formatLocalDate = (value) => `${pad(value.getUTCFullYear(), 4)}-${pad(value.getUTCMonth() + 1)}-${pad(value.getUTCDate())}`;
+var formatLocalTime = (value) => {
+  const milliseconds = value.getUTCMilliseconds();
+  const base = `${pad(value.getUTCHours())}:${pad(value.getUTCMinutes())}:${pad(value.getUTCSeconds())}`;
+  return milliseconds === 0 ? base : `${base}.${pad(milliseconds, 3)}`;
+};
+var formatLocalDateTime = (value) => {
+  const milliseconds = value.getUTCMilliseconds();
+  const base = `${formatLocalDate(value)}T${pad(value.getUTCHours())}:${pad(value.getUTCMinutes())}:${pad(value.getUTCSeconds())}`;
+  return milliseconds === 0 ? base : `${base}.${pad(milliseconds, 3)}`;
+};
+var runtimeTagOfBaseDbType = (dbType) => {
+  return dbType.runtime;
+};
+var expectString = (value, label) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  throw new Error(`Expected ${label} as string`);
+};
+var finiteNumberStringPattern = /^[+-]?(?:(?:\d+\.?\d*)|(?:\.\d+))(?:[eE][+-]?\d+)?$/;
+var normalizeNumber = (value) => {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    const parsed = finiteNumberStringPattern.test(trimmed) ? Number(trimmed) : Number.NaN;
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  if (typeof value === "bigint" && Number.isSafeInteger(Number(value))) {
+    return Number(value);
+  }
+  throw new Error("Expected a finite numeric value");
+};
+var normalizeBoolean = (value) => {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (value === 1) {
+      return true;
+    }
+    if (value === 0) {
+      return false;
+    }
+  }
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true" || normalized === "t" || normalized === "1") {
+      return true;
+    }
+    if (normalized === "false" || normalized === "f" || normalized === "0") {
+      return false;
+    }
+  }
+  throw new Error("Expected a boolean-like value");
+};
+var normalizeBigIntString = (value) => {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "number" && Number.isSafeInteger(value)) {
+    return BigInt(value).toString();
+  }
+  if (typeof value === "string") {
+    return canonicalizeBigIntString(value);
+  }
+  throw new Error("Expected an integer-like bigint value");
+};
+var normalizeDecimalString = (value) => {
+  if (typeof value === "string") {
+    return canonicalizeDecimalString(value);
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const rendered = String(value);
+    if (/[eE]/.test(rendered)) {
+      throw new Error("Scientific notation is not a supported decimal runtime");
+    }
+    return canonicalizeDecimalString(rendered);
+  }
+  throw new Error("Expected a decimal-like value");
+};
+var normalizeLocalDate = (value) => {
+  if (value instanceof Date) {
+    return formatLocalDate(value);
+  }
+  const raw = expectString(value, "local date").trim();
+  if (isValidLocalDateString(raw)) {
+    return raw;
+  }
+  const canonicalInstant = raw.replace(" ", "T").replace(/z$/, "Z");
+  if (isValidInstantString(canonicalInstant)) {
+    const parsed = new Date(canonicalInstant);
+    if (!Number.isNaN(parsed.getTime())) {
+      return formatLocalDate(parsed);
+    }
+  }
+  throw new Error("Expected a local-date value");
+};
+var normalizeLocalTime = (value) => {
+  if (value instanceof Date) {
+    return formatLocalTime(value);
+  }
+  const raw = expectString(value, "local time").trim();
+  if (isValidLocalTimeString(raw)) {
+    return raw;
+  }
+  throw new Error("Expected a local-time value");
+};
+var normalizeOffsetTime = (value) => {
+  if (value instanceof Date) {
+    return `${formatLocalTime(value)}Z`;
+  }
+  const raw = expectString(value, "offset time").trim();
+  if (isValidOffsetTimeString(raw)) {
+    return raw;
+  }
+  throw new Error("Expected an offset-time value");
+};
+var normalizeLocalDateTime = (value) => {
+  if (value instanceof Date) {
+    return formatLocalDateTime(value);
+  }
+  const raw = expectString(value, "local datetime").trim();
+  const canonicalLocalDateTime = raw.replace(" ", "T");
+  if (isValidLocalDateTimeString(canonicalLocalDateTime)) {
+    return canonicalLocalDateTime;
+  }
+  const canonicalInstant = raw.replace(" ", "T").replace(/z$/, "Z");
+  if (isValidInstantString(canonicalInstant)) {
+    const parsed = new Date(canonicalInstant);
+    if (!Number.isNaN(parsed.getTime())) {
+      return formatLocalDateTime(parsed);
+    }
+  }
+  throw new Error("Expected a local-datetime value");
+};
+var normalizeInstant = (value) => {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  const raw = expectString(value, "instant").trim();
+  if (!/[zZ]|[+-]\d{2}:\d{2}$/.test(raw)) {
+    throw new Error("Instant values require a timezone offset");
+  }
+  const canonicalInstant = raw.replace(" ", "T").replace(/z$/, "Z");
+  if (!isValidInstantString(canonicalInstant)) {
+    throw new Error("Expected an ISO instant value");
+  }
+  const parsed = new Date(canonicalInstant);
+  if (Number.isNaN(parsed.getTime())) {
+    throw new Error("Expected an ISO instant value");
+  }
+  return parsed.toISOString();
+};
+var normalizeYear = (value) => {
+  if (typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 9999) {
+    return pad(value, 4);
+  }
+  const raw = expectString(value, "year").trim();
+  if (/^\d{4}$/.test(raw)) {
+    return raw;
+  }
+  throw new Error("Expected a four-digit year");
+};
+var normalizeBytes = (value) => {
+  if (value instanceof Uint8Array) {
+    return new Uint8Array(value);
+  }
+  const BufferConstructor = globalThis.Buffer;
+  if (BufferConstructor !== undefined && value instanceof BufferConstructor) {
+    return new Uint8Array(value);
+  }
+  throw new Error("Expected a byte array value");
+};
+var isJsonValue = (value) => {
+  if (value === null) {
+    return true;
+  }
+  switch (typeof value) {
+    case "string":
+    case "boolean":
+      return true;
+    case "number":
+      return Number.isFinite(value);
+    case "object":
+      if (Array.isArray(value)) {
+        return value.every(isJsonValue);
+      }
+      return isPlainRecord(value) && Object.values(value).every(isJsonValue);
+    default:
+      return false;
+  }
+};
+var normalizeJson = (value) => {
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      if (isJsonValue(parsed)) {
+        return parsed;
+      }
+      throw new Error("Parsed JSON value is not a valid JSON runtime");
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        return value;
+      }
+      throw error;
+    }
+  }
+  if (isJsonValue(value)) {
+    return value;
+  }
+  throw new Error("Expected a JSON value");
+};
+var normalizeDbValue = (dbType, value) => {
+  if (value === null) {
+    return null;
+  }
+  if ("base" in dbType) {
+    return normalizeDbValue(dbType.base, value);
+  }
+  if ("element" in dbType) {
+    if (!Array.isArray(value)) {
+      throw new Error("Expected an array value");
+    }
+    return value.map((entry) => normalizeDbValue(dbType.element, entry));
+  }
+  if ("fields" in dbType) {
+    if (!isRecord2(value)) {
+      throw new Error("Expected a record value");
+    }
+    const normalized = {};
+    for (const [key, fieldDbType] of Object.entries(dbType.fields)) {
+      if (key in value) {
+        normalized[key] = normalizeDbValue(fieldDbType, value[key]);
+      }
+    }
+    return normalized;
+  }
+  if ("variant" in dbType && dbType.variant === "json") {
+    return normalizeJson(value);
+  }
+  if ("variant" in dbType && (dbType.variant === "enum" || dbType.variant === "set")) {
+    return expectString(value, "text");
+  }
+  switch (runtimeTagOfBaseDbType(dbType)) {
+    case "string":
+      return expectString(value, "text");
+    case "number":
+      return normalizeNumber(value);
+    case "bigintString":
+      return normalizeBigIntString(value);
+    case "boolean":
+      return normalizeBoolean(value);
+    case "json":
+      return normalizeJson(value);
+    case "localDate":
+      return normalizeLocalDate(value);
+    case "localTime":
+      return normalizeLocalTime(value);
+    case "offsetTime":
+      return normalizeOffsetTime(value);
+    case "localDateTime":
+      return normalizeLocalDateTime(value);
+    case "instant":
+      return normalizeInstant(value);
+    case "year":
+      return normalizeYear(value);
+    case "decimalString":
+      return normalizeDecimalString(value);
+    case "bytes":
+      return normalizeBytes(value);
+    case "array":
+      if (!Array.isArray(value)) {
+        throw new Error("Expected an array value");
+      }
+      return value;
+    case "record":
+      if (!isRecord2(value)) {
+        throw new Error("Expected a record value");
+      }
+      return value;
+    case "null":
+      return null;
+    case "unknown":
+    case undefined:
+      return value;
+  }
+};
+
 // src/internal/query.ts
 import { pipeArguments as pipeArguments3 } from "effect/Pipeable";
 
@@ -110274,6 +110710,7 @@ var emptyContext = () => ({
   nullKeys: new Set,
   eqLiterals: new Map,
   neqLiterals: new Map,
+  literalSets: new Map,
   sourceNames: new Set,
   contradiction: false,
   unknown: false
@@ -110283,12 +110720,24 @@ var cloneContext = (context) => ({
   nullKeys: new Set(context.nullKeys),
   eqLiterals: new Map(context.eqLiterals),
   neqLiterals: new Map(Array.from(context.neqLiterals.entries(), ([key, values]) => [key, new Set(values)])),
+  literalSets: new Map(Array.from(context.literalSets.entries(), ([key, values]) => [key, new Set(values)])),
   sourceNames: new Set(context.sourceNames),
   contradiction: context.contradiction,
   unknown: context.unknown
 });
 var freezeContext = (context) => context;
-var sourceNameOfKey = (key) => key.split(".", 1)[0] ?? key;
+var columnPredicateKey = (tableName, columnName) => JSON.stringify([tableName, columnName]);
+var columnPredicateKeyParts = (key) => {
+  const jsonSeparator = key.indexOf("#json:");
+  const columnKey = jsonSeparator === -1 ? key : key.slice(0, jsonSeparator);
+  try {
+    const parsed = JSON.parse(columnKey);
+    return Array.isArray(parsed) && parsed.length === 2 && typeof parsed[0] === "string" && typeof parsed[1] === "string" ? [parsed[0], parsed[1]] : undefined;
+  } catch {
+    return;
+  }
+};
+var sourceNameOfKey = (key) => columnPredicateKeyParts(key)?.[0] ?? key.split(".", 1)[0] ?? key;
 var addSourceName = (context, key) => {
   context.sourceNames.add(sourceNameOfKey(key));
 };
@@ -110316,7 +110765,12 @@ var addEqLiteral = (context, key, value) => {
   if (neqValues?.has(value)) {
     context.contradiction = true;
   }
+  const existingSet = context.literalSets.get(key);
+  if (existingSet !== undefined && !existingSet.has(value)) {
+    context.contradiction = true;
+  }
   context.eqLiterals.set(key, value);
+  context.literalSets.set(key, new Set([value]));
 };
 var addNeqLiteral = (context, key, value) => {
   addNonNull(context, key);
@@ -110327,6 +110781,18 @@ var addNeqLiteral = (context, key, value) => {
   values.add(value);
   context.neqLiterals.set(key, values);
 };
+var addLiteralSet = (context, key, values) => {
+  addNonNull(context, key);
+  const existingEq = context.eqLiterals.get(key);
+  if (existingEq !== undefined && !values.has(existingEq)) {
+    context.contradiction = true;
+  }
+  const existing = context.literalSets.get(key);
+  context.literalSets.set(key, existing === undefined ? new Set(values) : new Set(Array.from(existing).filter((value) => values.has(value))));
+  if (context.literalSets.get(key)?.size === 0) {
+    context.contradiction = true;
+  }
+};
 var applyEqColumn = (context, left, right) => {
   const leftValue = context.eqLiterals.get(left);
   const rightValue = context.eqLiterals.get(right);
@@ -110366,6 +110832,9 @@ var applyAtom = (context, atom) => {
     case "neq-literal":
       addNeqLiteral(context, atom.key, atom.value);
       return;
+    case "literal-set":
+      addLiteralSet(context, atom.key, new Set(atom.values));
+      return;
     case "eq-column":
       applyEqColumn(context, atom.left, atom.right);
       return;
@@ -110388,6 +110857,9 @@ var applyNegativeAtom = (context, atom) => {
     case "neq-literal":
       addEqLiteral(context, atom.key, atom.value);
       return;
+    case "literal-set":
+      addNonNull(context, atom.key);
+      return;
     case "eq-column":
       addNonNull(context, atom.left);
       addNonNull(context, atom.right);
@@ -110420,6 +110892,17 @@ var intersectNeqLiterals = (left, right) => {
   }
   return result;
 };
+var unionLiteralSets = (left, right) => {
+  const result = new Map;
+  for (const [key, leftValues] of left) {
+    const rightValues = right.get(key);
+    if (rightValues === undefined) {
+      continue;
+    }
+    result.set(key, new Set([...leftValues, ...rightValues]));
+  }
+  return result;
+};
 var intersectContexts = (left, right) => {
   if (left.contradiction) {
     return cloneContext(right);
@@ -110432,6 +110915,7 @@ var intersectContexts = (left, right) => {
     nullKeys: new Set(Array.from(left.nullKeys).filter((key) => right.nullKeys.has(key))),
     eqLiterals: intersectEqLiterals(left.eqLiterals, right.eqLiterals),
     neqLiterals: intersectNeqLiterals(left.neqLiterals, right.neqLiterals),
+    literalSets: unionLiteralSets(left.literalSets, right.literalSets),
     sourceNames: new Set(Array.from(left.sourceNames).filter((name) => right.sourceNames.has(name))),
     contradiction: false,
     unknown: left.unknown || right.unknown
@@ -110503,7 +110987,47 @@ var analyzeFormula = (formula) => freezeContext(analyzeStack(emptyContext(), [{
 var astOf = (value) => value[TypeId2];
 var columnKeyOfExpression = (value) => {
   const ast = astOf(value);
-  return ast.kind === "column" ? `${ast.tableName}.${ast.columnName}` : undefined;
+  return ast.kind === "column" ? columnPredicateKey(ast.tableName, ast.columnName) : undefined;
+};
+var sameDbType = (left, right) => left.dialect === right.dialect && left.kind === right.kind;
+var escapeJsonPathPredicateKeySegment = (value) => value.replaceAll("\\", "\\\\").replaceAll(".", "\\.");
+var jsonPathPredicateKeyOfExpression = (value) => {
+  const ast = astOf(value);
+  switch (ast.kind) {
+    case "jsonGetText":
+    case "jsonPathText":
+    case "jsonAccessText":
+    case "jsonTraverseText": {
+      const jsonAst = ast;
+      const segments = jsonAst.segments;
+      if (segments.length === 0 || segments.length > 8) {
+        return;
+      }
+      const path = [];
+      for (const segment of segments) {
+        if (typeof segment !== "object" || segment === null || segment.kind !== "key") {
+          return;
+        }
+        path.push(segment.key);
+      }
+      if (path.length === 0) {
+        return;
+      }
+      const baseKey = columnKeyOfExpression(jsonAst.base);
+      return baseKey === undefined ? undefined : `${baseKey}#json:${path.map(escapeJsonPathPredicateKeySegment).join(".")}`;
+    }
+    default:
+      return;
+  }
+};
+var predicateKeyOfExpression = (value) => columnKeyOfExpression(value) ?? castPredicateKeyOfExpression(value) ?? jsonPathPredicateKeyOfExpression(value);
+var castPredicateKeyOfExpression = (value) => {
+  const ast = astOf(value);
+  if (ast.kind !== "cast") {
+    return;
+  }
+  const source = ast.value;
+  return sameDbType(source[TypeId].dbType, ast.target) ? predicateKeyOfExpression(source) : undefined;
 };
 var valueKeyOfLiteral = (value) => {
   if (typeof value === "string") {
@@ -110524,7 +111048,7 @@ var valueKeyOfLiteral = (value) => {
   return "unknown";
 };
 var nonNullFactsOfExpression = (value) => {
-  const key = columnKeyOfExpression(value);
+  const key = predicateKeyOfExpression(value);
   return key === undefined ? undefined : atomFormula({ kind: "is-not-null", key });
 };
 var combineFacts = (left, right) => {
@@ -110537,8 +111061,8 @@ var combineFacts = (left, right) => {
   return andFormula(left, right);
 };
 var formulaOfEq = (left, right) => {
-  const leftKey = columnKeyOfExpression(left);
-  const rightKey = columnKeyOfExpression(right);
+  const leftKey = predicateKeyOfExpression(left);
+  const rightKey = predicateKeyOfExpression(right);
   const leftAst = astOf(left);
   const rightAst = astOf(right);
   const leftLiteral = leftAst.kind === "literal" ? leftAst.value : undefined;
@@ -110585,8 +111109,8 @@ var formulaOfEq = (left, right) => {
   });
 };
 var formulaOfNeq = (left, right) => {
-  const leftKey = columnKeyOfExpression(left);
-  const rightKey = columnKeyOfExpression(right);
+  const leftKey = predicateKeyOfExpression(left);
+  const rightKey = predicateKeyOfExpression(right);
   const leftAst = astOf(left);
   const rightAst = astOf(right);
   const leftLiteral = leftAst.kind === "literal" ? leftAst.value : undefined;
@@ -110629,8 +111153,8 @@ var formulaOfNeq = (left, right) => {
   return combineFacts(nonNullFactsOfExpression(left), nonNullFactsOfExpression(right));
 };
 var formulaOfIsNotDistinctFrom = (left, right) => {
-  const leftKey = columnKeyOfExpression(left);
-  const rightKey = columnKeyOfExpression(right);
+  const leftKey = predicateKeyOfExpression(left);
+  const rightKey = predicateKeyOfExpression(right);
   const leftAst = astOf(left);
   const rightAst = astOf(right);
   const leftLiteral = leftAst.kind === "literal" ? leftAst.value : undefined;
@@ -110736,11 +111260,11 @@ var formulaOfExpression = (value) => {
       }
       return unknownTag("literal:non-boolean");
     case "isNull": {
-      const key = columnKeyOfExpression(ast.value);
+      const key = predicateKeyOfExpression(ast.value);
       return key === undefined ? unknownTag("isNull:unsupported") : atomFormula({ kind: "is-null", key });
     }
     case "isNotNull": {
-      const key = columnKeyOfExpression(ast.value);
+      const key = predicateKeyOfExpression(ast.value);
       return key === undefined ? unknownTag("isNotNull:unsupported") : atomFormula({ kind: "is-not-null", key });
     }
     case "not":
@@ -110759,7 +111283,15 @@ var formulaOfExpression = (value) => {
       return anyFormula(ast.values.map((value2) => formulaOfExpression(value2)));
     case "in": {
       const [left, ...rest] = ast.values;
-      return left === undefined ? falseFormula() : anyFormula(rest.map((value2) => formulaOfEq(left, value2)));
+      if (left === undefined) {
+        return falseFormula();
+      }
+      const key = predicateKeyOfExpression(left);
+      const literalValues = rest.map((entry) => {
+        const entryAst = astOf(entry);
+        return entryAst.kind === "literal" && entryAst.value !== null ? valueKeyOfLiteral(entryAst.value) : undefined;
+      });
+      return key !== undefined && literalValues.every((entry) => entry !== undefined) ? atomFormula({ kind: "literal-set", key, values: literalValues }) : anyFormula(rest.map((value2) => formulaOfEq(left, value2)));
     }
     case "notIn": {
       const [left, ...rest] = ast.values;
@@ -110823,6 +111355,7 @@ var makeExpression = (state, ast) => {
     runtime: state.runtime,
     dbType: state.dbType,
     runtimeSchema: state.runtimeSchema,
+    driverValueMapping: state.driverValueMapping,
     nullability: state.nullability,
     dialect: state.dialect,
     kind: state.kind ?? "scalar",
@@ -110831,7 +111364,7 @@ var makeExpression = (state, ast) => {
   expression[TypeId2] = ast;
   return expression;
 };
-var makePlan = (state, ast, _assumptions, _capabilities, _statement, _target, _insertState) => {
+var makePlan = (state, ast, _assumptions, _capabilities, _statement, _target, _insertState, _facts) => {
   const plan = Object.create(PlanProto);
   Object.defineProperty(plan, "pipe", {
     configurable: true,
@@ -110847,6 +111380,7 @@ var makePlan = (state, ast, _assumptions, _capabilities, _statement, _target, _i
     availableNames: undefined,
     grouped: undefined,
     assumptions: _assumptions ?? trueFormula(),
+    facts: _facts ?? undefined,
     capabilities: undefined,
     statement: _statement ?? "select",
     target: _target ?? undefined,
@@ -110896,7 +111430,7 @@ var collectPresenceWitnesses = (selection, output) => {
     const expression = selection;
     const ast = expression[TypeId2];
     if (ast.kind === "column" && expression[TypeId].nullability === "never") {
-      output.add(`${ast.tableName}.${ast.columnName}`);
+      output.add(columnPredicateKey(ast.tableName, ast.columnName));
     }
     return;
   }
@@ -111045,6 +111579,20 @@ var path = (...segments) => ({
 });
 
 // src/internal/grouping-key.ts
+var subqueryPlanIds = new WeakMap;
+var nextSubqueryPlanId = 0;
+var subqueryPlanGroupingKey = (plan) => {
+  if (plan === null || typeof plan !== "object") {
+    return "unknown";
+  }
+  const existing = subqueryPlanIds.get(plan);
+  if (existing !== undefined) {
+    return existing;
+  }
+  const next = `${nextSubqueryPlanId++}`;
+  subqueryPlanIds.set(plan, next);
+  return next;
+};
 var literalGroupingKey = (value) => {
   if (value instanceof Date) {
     return `date:${value.toISOString()}`;
@@ -111063,15 +111611,62 @@ var literalGroupingKey = (value) => {
       return `literal:${JSON.stringify(value)}`;
   }
 };
+var isExpression = (value) => value !== null && typeof value === "object" && (TypeId in value);
+var expressionGroupingKey = (value) => isExpression(value) ? groupingKeyOfExpression(value) : "missing";
+var escapeGroupingText = (value) => value.replace(/\\/g, "\\\\").replace(/,/g, "\\,").replace(/\|/g, "\\|").replace(/=/g, "\\=").replace(/>/g, "\\>");
+var jsonSegmentGroupingKey = (segment) => {
+  if (segment !== null && typeof segment === "object" && "kind" in segment) {
+    switch (segment.kind) {
+      case "key":
+        return `key:${escapeGroupingText(segment.key)}`;
+      case "index":
+        return `index:${segment.index}`;
+      case "wildcard":
+        return "wildcard";
+      case "slice": {
+        const slice2 = segment;
+        return `slice:${slice2.start ?? ""}:${slice2.end ?? ""}`;
+      }
+      case "descend":
+        return "descend";
+    }
+  }
+  if (typeof segment === "string") {
+    return `key:${escapeGroupingText(segment)}`;
+  }
+  if (typeof segment === "number") {
+    return `index:${segment}`;
+  }
+  return "unknown";
+};
+var jsonPathGroupingKey = (segments) => (segments ?? []).map(jsonSegmentGroupingKey).join(",");
+var isJsonPath = (value) => value !== null && typeof value === "object" && (TypeId6 in value);
+var jsonOpaquePathGroupingKey = (value) => {
+  if (isJsonPath(value)) {
+    return `jsonpath:${jsonPathGroupingKey(value.segments)}`;
+  }
+  if (typeof value === "string") {
+    return `jsonpath:${escapeGroupingText(value)}`;
+  }
+  if (isExpression(value)) {
+    return `jsonpath:${groupingKeyOfExpression(value)}`;
+  }
+  return "jsonpath:unknown";
+};
+var jsonEntryGroupingKey = (entry) => `${escapeGroupingText(entry.key)}=>${groupingKeyOfExpression(entry.value)}`;
 var groupingKeyOfExpression = (expression) => {
   const ast = expression[TypeId2];
   switch (ast.kind) {
     case "column":
-      return `column:${ast.tableName}.${ast.columnName}`;
+      return `column:${columnPredicateKey(ast.tableName, ast.columnName)}`;
     case "literal":
       return `literal:${literalGroupingKey(ast.value)}`;
     case "cast":
       return `cast(${groupingKeyOfExpression(ast.value)} as ${ast.target.dialect}:${ast.target.kind})`;
+    case "collate":
+      return `collate(${groupingKeyOfExpression(ast.value)},${ast.collation.map(escapeGroupingText).join(",")})`;
+    case "function":
+      return `function(${escapeGroupingText(ast.name)},${ast.args.map(groupingKeyOfExpression).join(",")})`;
     case "isNull":
     case "isNotNull":
     case "not":
@@ -111089,8 +111684,15 @@ var groupingKeyOfExpression = (expression) => {
     case "gte":
     case "like":
     case "ilike":
+    case "regexMatch":
+    case "regexIMatch":
+    case "regexNotMatch":
+    case "regexNotIMatch":
     case "isDistinctFrom":
     case "isNotDistinctFrom":
+    case "contains":
+    case "containedBy":
+    case "overlaps":
       return `${ast.kind}(${groupingKeyOfExpression(ast.left)},${groupingKeyOfExpression(ast.right)})`;
     case "and":
     case "or":
@@ -111102,6 +111704,54 @@ var groupingKeyOfExpression = (expression) => {
       return `${ast.kind}(${ast.values.map(groupingKeyOfExpression).join(",")})`;
     case "case":
       return `case(${ast.branches.map((branch) => `when:${groupingKeyOfExpression(branch.when)}=>${groupingKeyOfExpression(branch.then)}`).join("|")};else:${groupingKeyOfExpression(ast.else)})`;
+    case "exists":
+      return `exists(${subqueryPlanGroupingKey(ast.plan)})`;
+    case "scalarSubquery":
+      return `scalarSubquery(${subqueryPlanGroupingKey(ast.plan)})`;
+    case "inSubquery":
+      return `inSubquery(${groupingKeyOfExpression(ast.left)},${subqueryPlanGroupingKey(ast.plan)})`;
+    case "comparisonAny":
+    case "comparisonAll":
+      return `${ast.kind}(${ast.operator},${groupingKeyOfExpression(ast.left)},${subqueryPlanGroupingKey(ast.plan)})`;
+    case "jsonGet":
+    case "jsonPath":
+    case "jsonAccess":
+    case "jsonTraverse":
+    case "jsonGetText":
+    case "jsonPathText":
+    case "jsonAccessText":
+    case "jsonTraverseText":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${jsonPathGroupingKey(ast.segments)})`;
+    case "jsonHasKey":
+    case "jsonKeyExists":
+    case "jsonHasAnyKeys":
+    case "jsonHasAllKeys":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${(ast.keys ?? []).map(escapeGroupingText).join(",")})`;
+    case "jsonConcat":
+    case "jsonMerge":
+      return `json(${ast.kind},${expressionGroupingKey(ast.left)},${expressionGroupingKey(ast.right)},)`;
+    case "jsonDelete":
+    case "jsonDeletePath":
+    case "jsonRemove":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${expressionGroupingKey(undefined)},${jsonPathGroupingKey(ast.segments)})`;
+    case "jsonSet":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${expressionGroupingKey(ast.newValue)},${jsonPathGroupingKey(ast.segments)})`;
+    case "jsonInsert":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${expressionGroupingKey(ast.insert)},${jsonPathGroupingKey(ast.segments)})`;
+    case "jsonPathExists":
+    case "jsonPathMatch":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${jsonOpaquePathGroupingKey(ast.query)})`;
+    case "jsonBuildObject":
+      return `json(${ast.kind},${(ast.entries ?? []).map(jsonEntryGroupingKey).join("|")})`;
+    case "jsonBuildArray":
+      return `json(${ast.kind},${(ast.values ?? []).map(groupingKeyOfExpression).join(",")})`;
+    case "jsonToJson":
+    case "jsonToJsonb":
+    case "jsonTypeOf":
+    case "jsonLength":
+    case "jsonKeys":
+    case "jsonStripNulls":
+      return `json(${ast.kind},${expressionGroupingKey(ast.value)})`;
     default:
       throw new Error("Unsupported expression for grouping key generation");
   }
@@ -111119,8 +111769,112 @@ var dedupeGroupedExpressions = (values) => {
 };
 
 // src/internal/dsl-mutation-runtime.ts
+var expectInsertSourceKind = (source) => {
+  if (source !== undefined && source.kind !== "values" && source.kind !== "query" && source.kind !== "unnest") {
+    throw new Error("Unsupported insert source kind");
+  }
+  return source;
+};
+var expectConflictClause = (conflict) => {
+  if (conflict === undefined) {
+    return conflict;
+  }
+  if (conflict.kind !== "conflict") {
+    throw new Error("Unsupported conflict clause kind");
+  }
+  if (conflict.action !== "doNothing" && conflict.action !== "doUpdate") {
+    throw new Error("Unsupported conflict action");
+  }
+  if (conflict.target !== undefined && conflict.target.kind !== "columns" && conflict.target.kind !== "constraint") {
+    throw new Error("Unsupported conflict target kind");
+  }
+  return conflict;
+};
 var makeDslMutationRuntime = (ctx) => {
+  const aliasedSourceKinds = new Set(["derived", "cte", "lateral", "values", "unnest", "tableFunction"]);
+  const isRecord3 = (value) => typeof value === "object" && value !== null;
+  const isTableTarget = (target) => typeof target === "object" && target !== null && (TypeId4 in target) && (TypeId3 in target);
+  const hasColumnRecord = (value) => isRecord3(value.columns);
+  const isAliasedSource = (source) => {
+    if (!isRecord3(source)) {
+      return false;
+    }
+    if (isTableTarget(source)) {
+      return true;
+    }
+    if (!("kind" in source) || !("name" in source) || !("baseName" in source)) {
+      return false;
+    }
+    if (typeof source.kind !== "string" || !aliasedSourceKinds.has(source.kind)) {
+      return false;
+    }
+    if (typeof source.name !== "string" || typeof source.baseName !== "string") {
+      return false;
+    }
+    switch (source.kind) {
+      case "derived":
+      case "cte":
+      case "lateral":
+        return isRecord3(source.plan) && TypeId3 in source.plan && hasColumnRecord(source);
+      case "values":
+        return Array.isArray(source.rows) && hasColumnRecord(source);
+      case "unnest":
+        return isRecord3(source.arrays) && hasColumnRecord(source);
+      case "tableFunction":
+        return typeof source.functionName === "string" && Array.isArray(source.args) && hasColumnRecord(source);
+    }
+    return false;
+  };
+  const assertMutationTarget = (target, apiName) => {
+    if (!isTableTarget(target)) {
+      throw new Error(`${apiName}(...) requires table targets`);
+    }
+  };
+  const assertAliasedSource = (source, apiName) => {
+    if (!isAliasedSource(source)) {
+      throw new Error(`${apiName}(...) requires an aliased source`);
+    }
+  };
+  const assertMutationTargets = (target, apiName, options2 = {}) => {
+    const targets = Array.isArray(target) ? target : [target];
+    if (targets.length === 0) {
+      throw new Error(`${apiName}(...) requires at least one table target`);
+    }
+    if (Array.isArray(target) && targets.length === 1) {
+      throw new Error(`${apiName}(...) requires a table target, not a single-element target tuple`);
+    }
+    for (const entry of targets) {
+      assertMutationTarget(entry, apiName);
+    }
+    if (targets.length > 1 && options2.allowMultiple !== true) {
+      throw new Error(`${apiName}(...) requires a single table target`);
+    }
+    if (targets.length > 1 && ctx.profile.dialect !== "mysql" && ctx.profile.dialect !== "sqlite") {
+      throw new Error(`${apiName}(...) only supports multiple mutation targets for mysql`);
+    }
+  };
+  const assertUniqueTargetNames = (targets) => {
+    const seen = new Set;
+    for (const target of targets) {
+      if (seen.has(target.tableName)) {
+        throw new Error(`mutation target source names must be unique: ${target.tableName}`);
+      }
+      seen.add(target.tableName);
+    }
+  };
+  const assertInsertSelectSource = (sourcePlan, selection) => {
+    const statement = ctx.getQueryState(sourcePlan).statement;
+    if (statement !== "select" && statement !== "set") {
+      throw new Error("insert sources only accept select-like query plans");
+    }
+    for (const value of Object.values(selection)) {
+      if (value === null || typeof value !== "object" || !(TypeId in value)) {
+        throw new Error("insert sources require a flat selection object");
+      }
+    }
+  };
   const insert = (target, values) => {
+    assertMutationTargets(target, "insert");
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
     const assignments = values === undefined ? [] : ctx.buildMutationAssignments(target, values);
     const required = assignments.flatMap((entry) => Object.keys(entry.value[TypeId].dependencies));
@@ -111196,10 +111950,11 @@ var makeDslMutationRuntime = (ctx) => {
     }
     const sourcePlan = source;
     const selection = sourcePlan[TypeId3].selection;
+    assertInsertSelectSource(sourcePlan, selection);
     const columns = ctx.normalizeInsertSelectColumns(selection);
     return ctx.makePlan({
       selection: current.selection,
-      required: ctx.currentRequiredList(sourcePlan[TypeId3].required).filter((name) => name !== sourceName),
+      required: ctx.currentRequiredList(sourcePlan[TypeId3].required),
       available: current.available,
       dialect: current.dialect
     }, {
@@ -111216,14 +111971,22 @@ var makeDslMutationRuntime = (ctx) => {
     const current = plan[TypeId3];
     const currentAst = ctx.getAst(plan);
     const currentQuery = ctx.getQueryState(plan);
+    if (currentQuery.statement !== "insert") {
+      throw new Error(`onConflict(...) is not supported for ${currentQuery.statement} statements`);
+    }
     const insertTarget = currentAst.into.source;
     const conflictTarget = ctx.buildConflictTarget(insertTarget, target);
     const updateAssignments = options2.update ? ctx.buildMutationAssignments(insertTarget, options2.update) : [];
+    if (options2.update !== undefined && updateAssignments.length === 0) {
+      throw new Error("conflict update assignments require at least one assignment");
+    }
     const updateWhere = options2.where === undefined ? undefined : ctx.toDialectExpression(options2.where);
+    const targetWhere = conflictTarget.kind === "columns" ? conflictTarget.where : undefined;
     const required = [
       ...ctx.currentRequiredList(current.required),
       ...updateAssignments.flatMap((entry) => Object.keys(entry.value[TypeId].dependencies)),
-      ...updateWhere ? Object.keys(updateWhere[TypeId].dependencies) : []
+      ...updateWhere ? Object.keys(updateWhere[TypeId].dependencies) : [],
+      ...targetWhere ? Object.keys(targetWhere[TypeId].dependencies) : []
     ].filter((name, index4, list) => !(name in current.available) && list.indexOf(name) === index4);
     return ctx.makePlan({
       selection: current.selection,
@@ -111242,7 +112005,9 @@ var makeDslMutationRuntime = (ctx) => {
     }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement, currentQuery.target, currentQuery.insertSource);
   };
   const update = (target, values) => {
+    assertMutationTargets(target, "update", { allowMultiple: true });
     const targets = ctx.mutationTargetClauses(target);
+    assertUniqueTargetNames(targets);
     const primaryTarget = targets[0];
     const assignments = ctx.buildMutationAssignments(target, values);
     const targetNames = new Set(targets.map((entry) => entry.tableName));
@@ -111266,9 +112031,13 @@ var makeDslMutationRuntime = (ctx) => {
     }, undefined, "write", "update");
   };
   const upsert = (target, values, conflictColumns, updateValues) => {
+    assertMutationTargets(target, "upsert");
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
     const assignments = ctx.buildMutationAssignments(target, values);
     const updateAssignments = updateValues ? ctx.buildMutationAssignments(target, updateValues) : [];
+    if (updateValues !== undefined && updateAssignments.length === 0) {
+      throw new Error("upsert update assignments require at least one assignment");
+    }
     const required = [
       ...assignments.flatMap((entry) => Object.keys(entry.value[TypeId].dependencies)),
       ...updateAssignments.flatMap((entry) => Object.keys(entry.value[TypeId].dependencies))
@@ -111298,7 +112067,7 @@ var makeDslMutationRuntime = (ctx) => {
         kind: "conflict",
         target: {
           kind: "columns",
-          columns: ctx.normalizeColumnList(conflictColumns)
+          columns: ctx.normalizeConflictColumns(target, conflictColumns)
         },
         action: updateAssignments.length > 0 ? "doUpdate" : "doNothing",
         values: updateAssignments.length > 0 ? updateAssignments : undefined
@@ -111311,7 +112080,9 @@ var makeDslMutationRuntime = (ctx) => {
     }, undefined, "write", "insert", target, "ready");
   };
   const delete_ = (target) => {
+    assertMutationTargets(target, "delete", { allowMultiple: true });
     const targets = ctx.mutationTargetClauses(target);
+    assertUniqueTargetNames(targets);
     const primaryTarget = targets[0];
     return ctx.makePlan({
       selection: {},
@@ -111331,6 +112102,7 @@ var makeDslMutationRuntime = (ctx) => {
     }, undefined, "write", "delete");
   };
   const truncate = (target, options2 = {}) => {
+    assertMutationTargets(target, "truncate");
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
     return ctx.makePlan({
       selection: {},
@@ -111359,8 +112131,13 @@ var makeDslMutationRuntime = (ctx) => {
     }, undefined, "write", "truncate");
   };
   const merge = (target, source, on, options2 = {}) => {
+    assertMutationTargets(target, "merge");
+    assertAliasedSource(source, "merge");
     const { sourceName: targetName, sourceBaseName: targetBaseName } = ctx.targetSourceDetails(target);
     const { sourceName: usingName, sourceBaseName: usingBaseName } = ctx.sourceDetails(source);
+    if (targetName === usingName) {
+      throw new Error(`merge(...) source name must differ from target source name: ${targetName}`);
+    }
     const onExpression = ctx.toDialectExpression(on);
     const matched = options2.whenMatched;
     const notMatched = options2.whenNotMatched;
@@ -111446,8 +112223,98 @@ var makeDslMutationRuntime = (ctx) => {
 };
 
 // src/internal/dsl-plan-runtime.ts
+var renderSelectLockMode = (mode) => {
+  switch (mode) {
+    case "update":
+      return "for update";
+    case "share":
+      return "for share";
+  }
+  throw new Error("lock(...) mode must be update or share for select statements");
+};
+var renderMysqlMutationLockMode = (mode, statement) => {
+  switch (mode) {
+    case "lowPriority":
+      return " low_priority";
+    case "ignore":
+      return " ignore";
+    case "quick":
+      if (statement === "delete") {
+        return " quick";
+      }
+      break;
+  }
+  throw new Error(statement === "update" ? "lock(...) mode must be lowPriority or ignore for update statements" : "lock(...) mode must be lowPriority, quick, or ignore for delete statements");
+};
 var makeDslPlanRuntime = (ctx) => {
+  const aliasedSourceKinds = new Set(["derived", "cte", "lateral", "values", "unnest", "tableFunction"]);
+  const isRecord3 = (value) => typeof value === "object" && value !== null;
+  const isPlan = (value) => isRecord3(value) && (TypeId3 in value);
+  const hasColumnRecord = (value) => isRecord3(value.columns);
+  const sourceRequiredList = (source) => typeof source === "object" && source !== null && ("required" in source) ? ctx.currentRequiredList(source.required) : [];
+  const isAliasedSource = (source) => {
+    if (!isRecord3(source)) {
+      return false;
+    }
+    if (TypeId4 in source) {
+      return true;
+    }
+    if (!("kind" in source) || !("name" in source) || !("baseName" in source)) {
+      return false;
+    }
+    if (typeof source.kind !== "string" || !aliasedSourceKinds.has(source.kind)) {
+      return false;
+    }
+    if (typeof source.name !== "string" || typeof source.baseName !== "string") {
+      return false;
+    }
+    switch (source.kind) {
+      case "derived":
+      case "cte":
+      case "lateral":
+        return isPlan(source.plan) && hasColumnRecord(source);
+      case "values":
+        return Array.isArray(source.rows) && hasColumnRecord(source);
+      case "unnest":
+        return isRecord3(source.arrays) && hasColumnRecord(source);
+      case "tableFunction":
+        return typeof source.functionName === "string" && Array.isArray(source.args) && hasColumnRecord(source);
+    }
+    return false;
+  };
+  const assertAliasedSource = (source, message) => {
+    if (!isAliasedSource(source)) {
+      throw new Error(message);
+    }
+  };
+  const assertPlanComplete = (plan) => {
+    const required = ctx.currentRequiredList(plan[TypeId3].required);
+    if (required.length > 0) {
+      throw new Error(`query references sources that are not yet in scope: ${required.join(", ")}`);
+    }
+  };
+  const assertSourceNameAvailable = (available, sourceName) => {
+    if (sourceName in available) {
+      throw new Error(`query source name is already in scope: ${sourceName}`);
+    }
+  };
+  const assertSelectHasBaseSourceForJoin = (statement, available) => {
+    if (statement === "select" && Object.keys(available).length === 0) {
+      throw new Error("select joins require a from(...) source before joining");
+    }
+  };
+  const supportsJoinSources = (statement) => statement === "select" || statement === "update" || statement === "delete";
+  const assertSetOperandStatement = (plan) => {
+    const statement = ctx.getQueryState(plan).statement;
+    if (statement !== "select" && statement !== "set") {
+      throw new Error("set operator operands only accept select-like query plans");
+    }
+  };
   const buildSetOperation = (kind, all, left, right) => {
+    assertSetOperandStatement(left);
+    assertSetOperandStatement(right);
+    assertPlanComplete(left);
+    assertPlanComplete(right);
     const leftState = left[TypeId3];
     const leftAst = ctx.getAst(left);
     const basePlan = leftAst.kind === "set" ? leftAst.setBase ?? left : left;
@@ -111502,25 +112369,29 @@ var makeDslPlanRuntime = (ctx) => {
     if (currentQuery.statement === "insert") {
       return ctx.attachInsertSource(plan, source);
     }
-    if (typeof source !== "object" || source === null || "kind" in source && source.kind === "values" && !("name" in source) || !(TypeId4 in source) && !(("name" in source) && ("baseName" in source))) {
-      throw new Error("from(...) requires an aliased source in select/update statements");
+    assertAliasedSource(source, "from(...) requires an aliased source in select/update statements");
+    if (currentQuery.statement === "select" && currentAst.from !== undefined) {
+      throw new Error("select statements accept only one from(...) source; use joins for additional sources");
     }
     const sourceLike = source;
     const { sourceName, sourceBaseName } = ctx.sourceDetails(sourceLike);
     const presenceWitnesses = ctx.presenceWitnessesOfSourceLike(sourceLike);
+    const sourceRequired = sourceRequiredList(sourceLike);
+    assertSourceNameAvailable(current.available, sourceName);
     if (currentQuery.statement === "select") {
+      const nextAvailable = {
+        [sourceName]: {
+          name: sourceName,
+          mode: "required",
+          baseName: sourceBaseName,
+          _presentFormula: ctx.trueFormula(),
+          _presenceWitnesses: presenceWitnesses
+        }
+      };
       return ctx.makePlan({
         selection: current.selection,
-        required: ctx.currentRequiredList(current.required).filter((name) => name !== sourceName),
-        available: {
-          [sourceName]: {
-            name: sourceName,
-            mode: "required",
-            baseName: sourceBaseName,
-            _presentFormula: ctx.trueFormula(),
-            _presenceWitnesses: presenceWitnesses
-          }
-        },
+        required: [...ctx.currentRequiredList(current.required), ...sourceRequired].filter((name, index4, values) => !(name in nextAvailable) && values.indexOf(name) === index4),
+        available: nextAvailable,
         dialect: current.dialect
       }, {
         ...currentAst,
@@ -111545,7 +112416,7 @@ var makeDslPlanRuntime = (ctx) => {
       };
       return ctx.makePlan({
         selection: current.selection,
-        required: ctx.currentRequiredList(current.required).filter((name) => !(name in nextAvailable)),
+        required: [...ctx.currentRequiredList(current.required), ...sourceRequired].filter((name, index4, values) => !(name in nextAvailable) && values.indexOf(name) === index4),
         available: nextAvailable,
         dialect: current.dialect
       }, {
@@ -111586,8 +112457,16 @@ var makeDslPlanRuntime = (ctx) => {
     const current = plan[TypeId3];
     const currentAst = ctx.getAst(plan);
     const currentQuery = ctx.getQueryState(plan);
+    if (supportsJoinSources(currentQuery.statement)) {
+      assertAliasedSource(table, "join(...) requires an aliased source in select/update/delete statements");
+      assertSelectHasBaseSourceForJoin(currentQuery.statement, current.available);
+    }
     const { sourceName, sourceBaseName } = ctx.sourceDetails(table);
     const presenceWitnesses = ctx.presenceWitnessesOfSourceLike(table);
+    const sourceRequired = sourceRequiredList(table);
+    if (supportsJoinSources(currentQuery.statement)) {
+      assertSourceNameAvailable(current.available, sourceName);
+    }
     const nextAvailable = {
       ...current.available,
       [sourceName]: {
@@ -111600,7 +112479,7 @@ var makeDslPlanRuntime = (ctx) => {
     };
     return ctx.makePlan({
       selection: current.selection,
-      required: ctx.currentRequiredList(current.required).filter((name) => !(name in nextAvailable)),
+      required: [...ctx.currentRequiredList(current.required), ...sourceRequired].filter((name, index4, values) => !(name in nextAvailable) && values.indexOf(name) === index4),
       available: nextAvailable,
       dialect: current.dialect ?? table[TypeId3]?.dialect ?? table.dialect
     }, {
@@ -111619,8 +112498,16 @@ var makeDslPlanRuntime = (ctx) => {
     const currentQuery = ctx.getQueryState(plan);
     const onExpression = ctx.toDialectExpression(on);
     const onFormula = ctx.formulaOfExpressionRuntime(onExpression);
+    if (supportsJoinSources(currentQuery.statement)) {
+      assertAliasedSource(table, "join(...) requires an aliased source in select/update/delete statements");
+      assertSelectHasBaseSourceForJoin(currentQuery.statement, current.available);
+    }
     const { sourceName, sourceBaseName } = ctx.sourceDetails(table);
     const presenceWitnesses = ctx.presenceWitnessesOfSourceLike(table);
+    const sourceRequired = sourceRequiredList(table);
+    if (supportsJoinSources(currentQuery.statement)) {
+      assertSourceNameAvailable(current.available, sourceName);
+    }
     const baseAvailable = kind === "right" || kind === "full" ? Object.fromEntries(Object.entries(current.available).map(([name, source]) => [name, {
       name: source.name,
       mode: "optional",
@@ -111640,7 +112527,7 @@ var makeDslPlanRuntime = (ctx) => {
     };
     return ctx.makePlan({
       selection: current.selection,
-      required: [...ctx.currentRequiredList(current.required), ...ctx.extractRequiredFromDialectInputRuntime(on)].filter((name, index4, values) => !(name in nextAvailable) && values.indexOf(name) === index4),
+      required: [...ctx.currentRequiredList(current.required), ...sourceRequired, ...ctx.extractRequiredFromDialectInputRuntime(on)].filter((name, index4, values) => !(name in nextAvailable) && values.indexOf(name) === index4),
       available: nextAvailable,
       dialect: current.dialect ?? table.dialect ?? onExpression[TypeId].dialect
     }, {
@@ -111655,6 +112542,9 @@ var makeDslPlanRuntime = (ctx) => {
     }, kind === "inner" ? ctx.assumeFormulaTrue(currentQuery.assumptions, onFormula) : currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
   };
   const orderBy = (value, direction = "asc") => (plan) => {
+    if (direction !== "asc" && direction !== "desc") {
+      throw new Error("orderBy(...) direction must be asc or desc");
+    }
     const current = plan[TypeId3];
     const currentAst = ctx.getAst(plan);
     const currentQuery = ctx.getQueryState(plan);
@@ -111678,6 +112568,15 @@ var makeDslPlanRuntime = (ctx) => {
     const current = plan[TypeId3];
     const currentAst = ctx.getAst(plan);
     const currentQuery = ctx.getQueryState(plan);
+    if (currentQuery.statement === "select") {
+      renderSelectLockMode(mode);
+    }
+    if (ctx.profile.dialect === "mysql" && currentQuery.statement === "update") {
+      renderMysqlMutationLockMode(mode, "update");
+    }
+    if (ctx.profile.dialect === "mysql" && currentQuery.statement === "delete") {
+      renderMysqlMutationLockMode(mode, "delete");
+    }
     return ctx.makePlan({
       selection: current.selection,
       required: current.required,
@@ -111754,18 +112653,96 @@ var makeDslPlanRuntime = (ctx) => {
   };
 };
 
+// src/internal/projection-alias.ts
+var TypeId7 = Symbol.for("effect-qb/ProjectionAlias");
+
+// src/internal/projections.ts
+var aliasFromPath = (path2) => path2.join("__");
+var isExpression2 = (value) => typeof value === "object" && value !== null && (TypeId in value);
+var projectionAliasOf = (expression) => (TypeId7 in expression) ? expression[TypeId7].alias : undefined;
+var pathKeyOf = (path2) => JSON.stringify(path2);
+var formatProjectionPath = (path2) => path2.join(".");
+var isPrefixPath = (left, right) => left.length < right.length && left.every((segment, index4) => segment === right[index4]);
+var flattenSelection = (selection, path2 = []) => {
+  const fields2 = [];
+  for (const [key2, value] of Object.entries(selection)) {
+    const nextPath = [...path2, key2];
+    if (isExpression2(value)) {
+      fields2.push({
+        path: nextPath,
+        expression: value,
+        alias: projectionAliasOf(value) ?? aliasFromPath(nextPath)
+      });
+      continue;
+    }
+    fields2.push(...flattenSelection(value, nextPath));
+  }
+  return fields2;
+};
+var validateProjections = (projections) => {
+  const seen = new Set;
+  const pathKeys = new Set;
+  for (const projection of projections) {
+    if (seen.has(projection.alias)) {
+      throw new Error(`Duplicate projection alias: ${projection.alias}`);
+    }
+    seen.add(projection.alias);
+    const pathKey = pathKeyOf(projection.path);
+    if (pathKeys.has(pathKey)) {
+      throw new Error(`Duplicate projection path: ${formatProjectionPath(projection.path)}`);
+    }
+    pathKeys.add(pathKey);
+  }
+  for (let index4 = 0;index4 < projections.length; index4++) {
+    const current = projections[index4];
+    for (let compareIndex = index4 + 1;compareIndex < projections.length; compareIndex++) {
+      const other = projections[compareIndex];
+      if (isPrefixPath(current.path, other.path) || isPrefixPath(other.path, current.path)) {
+        throw new Error(`Conflicting projection paths: ${formatProjectionPath(current.path)} conflicts with ${formatProjectionPath(other.path)}`);
+      }
+    }
+  }
+};
+
 // src/internal/dsl-query-runtime.ts
 var makeDslQueryRuntime = (ctx) => {
+  const assertSelectionObject = (apiName, selection) => {
+    if (selection === null || typeof selection !== "object" || Array.isArray(selection) || TypeId in selection) {
+      throw new Error(`${apiName}(...) expects a projection object`);
+    }
+  };
+  const assertSelectionTree = (apiName, selection) => {
+    const visit = (value, isRoot) => {
+      if (value !== null && typeof value === "object" && TypeId in value) {
+        return;
+      }
+      if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${apiName}(...) selection leaves must be expressions`);
+      }
+      const nested = Object.values(value);
+      if (!isRoot && nested.length === 0) {
+        throw new Error(`${apiName}(...) projection objects cannot contain empty nested selections`);
+      }
+      for (const item of nested) {
+        visit(item, false);
+      }
+    };
+    visit(selection, true);
+  };
   const values = (rows) => {
     if (rows.length === 0) {
       throw new Error("values(...) requires at least one row");
     }
     const normalizedRows = rows.map((row) => ctx.normalizeValuesRow(row));
     const columnNames = Object.keys(normalizedRows[0]);
+    if (columnNames.length === 0) {
+      throw new Error("values(...) rows must specify at least one column");
+    }
+    const columnNameSet = new Set(columnNames);
     for (const row of normalizedRows) {
       const rowKeys = Object.keys(row);
-      if (rowKeys.length !== columnNames.length || !rowKeys.every((key2, index4) => key2 === columnNames[index4])) {
-        throw new Error("values(...) rows must project the same columns in the same order");
+      if (rowKeys.length !== columnNames.length || !rowKeys.every((key2) => columnNameSet.has(key2))) {
+        throw new Error("values(...) rows must project the same columns");
       }
     }
     return Object.assign(Object.create(ctx.ValuesInputProto), {
@@ -111824,21 +112801,28 @@ var makeDslQueryRuntime = (ctx) => {
     };
     return Object.assign(source, columns);
   };
-  const select = (selection) => ctx.makePlan({
-    selection,
-    required: ctx.extractRequiredRuntime(selection),
-    available: {},
-    dialect: ctx.profile.dialect
-  }, {
-    kind: "select",
-    select: selection,
-    where: [],
-    having: [],
-    joins: [],
-    groupBy: [],
-    orderBy: []
-  }, undefined, "read", "select");
+  const select = (selection = {}) => {
+    assertSelectionObject("select", selection);
+    assertSelectionTree("select", selection);
+    return ctx.makePlan({
+      selection,
+      required: ctx.extractRequiredRuntime(selection),
+      available: {},
+      dialect: ctx.profile.dialect
+    }, {
+      kind: "select",
+      select: selection,
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "read", "select");
+  };
   const groupBy = (...values2) => (plan) => {
+    if (values2.length === 0) {
+      throw new Error("groupBy(...) requires at least one expression");
+    }
     const current = plan[TypeId3];
     const currentAst = ctx.getAst(plan);
     const currentQuery = ctx.getQueryState(plan);
@@ -111853,19 +112837,29 @@ var makeDslQueryRuntime = (ctx) => {
       groupBy: ctx.dedupeGroupedExpressions([...currentAst.groupBy, ...values2])
     }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
   };
-  const returning = (selection) => (plan) => {
-    const current = plan[TypeId3];
-    const currentAst = ctx.getAst(plan);
-    const currentQuery = ctx.getQueryState(plan);
-    return ctx.makePlan({
-      selection,
-      required: [...ctx.currentRequiredList(current.required), ...ctx.extractRequiredRuntime(selection)].filter((name, index4, list) => !(name in current.available) && list.indexOf(name) === index4),
-      available: current.available,
-      dialect: current.dialect
-    }, {
-      ...currentAst,
-      select: selection
-    }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement, currentQuery.target, currentQuery.insertSource);
+  const returning = (selection) => {
+    assertSelectionObject("returning", selection);
+    assertSelectionTree("returning", selection);
+    if (flattenSelection(selection).length === 0) {
+      throw new Error("returning(...) requires at least one selected expression");
+    }
+    return (plan) => {
+      const current = plan[TypeId3];
+      const currentAst = ctx.getAst(plan);
+      const currentQuery = ctx.getQueryState(plan);
+      if (currentQuery.statement !== "insert" && currentQuery.statement !== "update" && currentQuery.statement !== "delete") {
+        throw new Error(`returning(...) is not supported for ${currentQuery.statement} statements`);
+      }
+      return ctx.makePlan({
+        selection,
+        required: [...ctx.currentRequiredList(current.required), ...ctx.extractRequiredRuntime(selection)].filter((name, index4, list) => !(name in current.available) && list.indexOf(name) === index4),
+        available: current.available,
+        dialect: current.dialect
+      }, {
+        ...currentAst,
+        select: selection
+      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement, currentQuery.target, currentQuery.insertSource);
+    };
   };
   return {
     values,
@@ -111878,26 +112872,71 @@ var makeDslQueryRuntime = (ctx) => {
 };
 
 // src/internal/dsl-transaction-ddl-runtime.ts
+var allowedIsolationLevels = new Set(["read committed", "repeatable read", "serializable"]);
+var renderTransactionIsolationLevel = (isolationLevel) => {
+  if (isolationLevel === undefined) {
+    return "";
+  }
+  if (typeof isolationLevel !== "string" || !allowedIsolationLevels.has(isolationLevel)) {
+    throw new Error("Unsupported transaction isolation level");
+  }
+  return `isolation level ${isolationLevel}`;
+};
+var expectDdlClauseKind = (ddl, kind) => {
+  if (ddl === undefined || ddl.kind !== kind) {
+    throw new Error("Unsupported DDL statement kind");
+  }
+  return ddl;
+};
+var expectTruncateClause = (truncate) => {
+  if (truncate === undefined || truncate.kind !== "truncate") {
+    throw new Error("Unsupported truncate statement kind");
+  }
+  return truncate;
+};
+var validateIsolationLevel = (isolationLevel) => {
+  renderTransactionIsolationLevel(isolationLevel);
+};
 var makeDslTransactionDdlRuntime = (ctx) => {
-  const transaction = (options2 = {}) => ctx.makePlan({
-    selection: {},
-    required: [],
-    available: {},
-    dialect: ctx.profile.dialect
-  }, {
-    kind: "transaction",
-    select: {},
-    transaction: {
+  const isRecord3 = (value) => typeof value === "object" && value !== null;
+  const assertTableTarget = (target, apiName) => {
+    if (!isRecord3(target) || !(TypeId4 in target) || !(TypeId3 in target)) {
+      throw new Error(`${apiName}(...) requires a table target`);
+    }
+  };
+  const validateIndexColumns = (target, columns) => {
+    const fields2 = target[TypeId4]?.fields;
+    if (fields2 === undefined) {
+      return;
+    }
+    for (const columnName of columns) {
+      if (!(columnName in fields2)) {
+        throw new Error(`effect-qb: unknown index column '${columnName}'`);
+      }
+    }
+  };
+  const transaction = (options2 = {}) => {
+    validateIsolationLevel(options2.isolationLevel);
+    return ctx.makePlan({
+      selection: {},
+      required: [],
+      available: {},
+      dialect: ctx.profile.dialect
+    }, {
       kind: "transaction",
-      isolationLevel: options2.isolationLevel,
-      readOnly: options2.readOnly
-    },
-    where: [],
-    having: [],
-    joins: [],
-    groupBy: [],
-    orderBy: []
-  }, undefined, "transaction", "transaction");
+      select: {},
+      transaction: {
+        kind: "transaction",
+        isolationLevel: options2.isolationLevel,
+        readOnly: options2.readOnly
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "transaction", "transaction");
+  };
   const commit = () => ctx.makePlan({
     selection: {},
     required: [],
@@ -111987,6 +113026,7 @@ var makeDslTransactionDdlRuntime = (ctx) => {
     orderBy: []
   }, undefined, "transaction", "releaseSavepoint");
   const createTable = (target, options2 = {}) => {
+    assertTableTarget(target, "createTable");
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
     return ctx.makePlan({
       selection: {},
@@ -112014,6 +113054,7 @@ var makeDslTransactionDdlRuntime = (ctx) => {
     }, undefined, "ddl", "createTable");
   };
   const dropTable = (target, options2 = {}) => {
+    assertTableTarget(target, "dropTable");
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
     return ctx.makePlan({
       selection: {},
@@ -112041,7 +113082,9 @@ var makeDslTransactionDdlRuntime = (ctx) => {
     }, undefined, "ddl", "dropTable");
   };
   const createIndex = (target, columns, options2 = {}) => {
+    assertTableTarget(target, "createIndex");
     const normalizedColumns = ctx.normalizeColumnList(columns);
+    validateIndexColumns(target, normalizedColumns);
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
     return ctx.makePlan({
       selection: {},
@@ -112072,7 +113115,9 @@ var makeDslTransactionDdlRuntime = (ctx) => {
     }, undefined, "ddl", "createIndex");
   };
   const dropIndex = (target, columns, options2 = {}) => {
+    assertTableTarget(target, "dropIndex");
     const normalizedColumns = ctx.normalizeColumnList(columns);
+    validateIndexColumns(target, normalizedColumns);
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
     return ctx.makePlan({
       selection: {},
@@ -112116,59 +113161,6 @@ var makeDslTransactionDdlRuntime = (ctx) => {
 
 // src/internal/derived-table.ts
 import { pipeArguments as pipeArguments4 } from "effect/Pipeable";
-
-// src/internal/projection-alias.ts
-var TypeId7 = Symbol.for("effect-qb/ProjectionAlias");
-
-// src/internal/projections.ts
-var aliasFromPath = (path2) => path2.join("__");
-var isExpression = (value) => typeof value === "object" && value !== null && (TypeId in value);
-var projectionAliasOf = (expression) => (TypeId7 in expression) ? expression[TypeId7].alias : undefined;
-var pathKeyOf = (path2) => JSON.stringify(path2);
-var formatProjectionPath = (path2) => path2.join(".");
-var isPrefixPath = (left, right) => left.length < right.length && left.every((segment, index4) => segment === right[index4]);
-var flattenSelection = (selection, path2 = []) => {
-  const fields2 = [];
-  for (const [key2, value] of Object.entries(selection)) {
-    const nextPath = [...path2, key2];
-    if (isExpression(value)) {
-      fields2.push({
-        path: nextPath,
-        expression: value,
-        alias: projectionAliasOf(value) ?? aliasFromPath(nextPath)
-      });
-      continue;
-    }
-    fields2.push(...flattenSelection(value, nextPath));
-  }
-  return fields2;
-};
-var validateProjections = (projections) => {
-  const seen = new Set;
-  const pathKeys = new Set;
-  for (const projection of projections) {
-    if (seen.has(projection.alias)) {
-      throw new Error(`Duplicate projection alias: ${projection.alias}`);
-    }
-    seen.add(projection.alias);
-    const pathKey = pathKeyOf(projection.path);
-    if (pathKeys.has(pathKey)) {
-      throw new Error(`Duplicate projection path: ${formatProjectionPath(projection.path)}`);
-    }
-    pathKeys.add(pathKey);
-  }
-  for (let index4 = 0;index4 < projections.length; index4++) {
-    const current = projections[index4];
-    for (let compareIndex = index4 + 1;compareIndex < projections.length; compareIndex++) {
-      const other = projections[compareIndex];
-      if (isPrefixPath(current.path, other.path) || isPrefixPath(other.path, current.path)) {
-        throw new Error(`Conflicting projection paths: ${formatProjectionPath(current.path)} conflicts with ${formatProjectionPath(other.path)}`);
-      }
-    }
-  }
-};
-
-// src/internal/derived-table.ts
 var DerivedProto = {
   pipe() {
     return pipeArguments4(this, arguments);
@@ -112200,10 +113192,24 @@ var setPath = (target, path2, value) => {
   current[path2[path2.length - 1]] = value;
 };
 var pathAlias = (path2) => path2.join("__");
+var assertSourceComplete = (plan) => {
+  const required = currentRequiredList(plan[TypeId3].required);
+  if (required.length > 0) {
+    throw new Error(`query references sources that are not yet in scope: ${required.join(", ")}`);
+  }
+};
+var assertInlineSourceStatement = (plan) => {
+  const statement = getQueryState(plan).statement;
+  if (statement !== "select" && statement !== "set") {
+    throw new Error("inline derived sources only accept select-like query plans");
+  }
+};
 var reboundedColumns = (plan, alias2) => {
   const ast = getAst(plan);
   const selection = {};
-  for (const projection of flattenSelection(ast.select)) {
+  const projections = flattenSelection(ast.select);
+  validateProjections(projections);
+  for (const projection of projections) {
     const expectedAlias = pathAlias(projection.path);
     if (projection.alias !== expectedAlias) {
       throw new Error(`Derived subqueries currently require path-based output aliases; expected '${expectedAlias}' for path '${projection.path.join(".")}'`);
@@ -112228,6 +113234,8 @@ var reboundedColumns = (plan, alias2) => {
   return selection;
 };
 var makeDerivedSource = (plan, alias2) => {
+  assertInlineSourceStatement(plan);
+  assertSourceComplete(plan);
   const columns = reboundedColumns(plan, alias2);
   const derived = attachPipe3(Object.create(DerivedProto));
   Object.assign(derived, columns);
@@ -112241,6 +113249,7 @@ var makeDerivedSource = (plan, alias2) => {
   return derived;
 };
 var makeCteSource = (plan, alias2, recursive = false) => {
+  assertSourceComplete(plan);
   const columns = reboundedColumns(plan, alias2);
   const cte = attachPipe3(Object.create(DerivedProto));
   Object.assign(cte, columns);
@@ -112255,6 +113264,7 @@ var makeCteSource = (plan, alias2, recursive = false) => {
   return cte;
 };
 var makeLateralSource = (plan, alias2) => {
+  assertInlineSourceStatement(plan);
   const columns = reboundedColumns(plan, alias2);
   const lateral = attachPipe3(Object.create(DerivedProto));
   Object.assign(lateral, columns);
@@ -112263,7 +113273,7 @@ var makeLateralSource = (plan, alias2) => {
   lateral.baseName = alias2;
   lateral.dialect = plan[TypeId3].dialect;
   lateral.plan = plan;
-  lateral.required = undefined;
+  lateral.required = currentRequiredList(plan[TypeId3].required);
   lateral.columns = columns;
   return lateral;
 };
@@ -112326,6 +113336,34 @@ var toDialectExpression = (value) => {
   }
   return literal(value);
 };
+var retargetLiteralExpression = (value, target) => {
+  const ast = value[TypeId2];
+  if (ast.kind !== "literal") {
+    return value;
+  }
+  const targetState = target[TypeId];
+  return makeExpression({
+    runtime: value[TypeId].runtime,
+    dbType: targetState.dbType,
+    runtimeSchema: targetState.runtimeSchema,
+    driverValueMapping: targetState.driverValueMapping,
+    nullability: value[TypeId].nullability,
+    dialect: targetState.dialect,
+    kind: "scalar",
+    dependencies: {}
+  }, ast);
+};
+var alignBinaryPredicateExpressions = (left, right) => {
+  const leftAst = left[TypeId2];
+  const rightAst = right[TypeId2];
+  if (leftAst.kind === "literal" && rightAst.kind !== "literal") {
+    return [retargetLiteralExpression(left, right), right];
+  }
+  if (rightAst.kind === "literal" && leftAst.kind !== "literal") {
+    return [left, retargetLiteralExpression(right, left)];
+  }
+  return [left, right];
+};
 var toDialectStringExpression = (value) => typeof value === "string" ? literal(value) : value;
 var toDialectNumericExpression = (value) => typeof value === "number" ? literal(value) : value;
 var flattenVariadicBooleanExpressions = (kind, values) => {
@@ -112379,10 +113417,16 @@ var extractRequiredFromDialectInputRuntime = (value) => {
 };
 var normalizeWindowSpec = (spec) => {
   const partitionBy = [...spec?.partitionBy ?? []];
-  const orderBy = (spec?.orderBy ?? []).map((term) => ({
-    value: term.value,
-    direction: term.direction ?? "asc"
-  }));
+  const orderBy = (spec?.orderBy ?? []).map((term) => {
+    const direction = term.direction ?? "asc";
+    if (direction !== "asc" && direction !== "desc") {
+      throw new Error("window order direction must be asc or desc");
+    }
+    return {
+      value: term.value,
+      direction
+    };
+  });
   return {
     partitionBy,
     orderBy
@@ -112394,8 +113438,7 @@ var extractRequiredFromDialectNumericInputRuntime = (value) => {
   return Object.keys(expression[TypeId].dependencies);
 };
 var buildBinaryPredicate = (left, right, kind, nullability = "maybe") => {
-  const leftExpression = toDialectExpression(left);
-  const rightExpression = toDialectExpression(right);
+  const [leftExpression, rightExpression] = alignBinaryPredicateExpressions(toDialectExpression(left), toDialectExpression(right));
   return makeExpression({
     runtime: true,
     dbType: profile.boolDb,
@@ -112411,16 +113454,18 @@ var buildBinaryPredicate = (left, right, kind, nullability = "maybe") => {
 };
 var buildVariadicPredicate = (values, kind) => {
   const expressions = values.map((value) => toDialectExpression(value));
+  const [head, ...tail] = expressions;
+  const alignedExpressions = head !== undefined && (kind === "in" || kind === "notIn" || kind === "between") ? [head, ...tail.map((value) => retargetLiteralExpression(value, head))] : expressions;
   return makeExpression({
     runtime: true,
     dbType: profile.boolDb,
     nullability: "maybe",
-    dialect: expressions.find((value) => value[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile.dialect,
+    dialect: alignedExpressions.find((value) => value[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile.dialect,
     kind: "scalar",
-    dependencies: mergeManyDependencies(expressions)
+    dependencies: mergeManyDependencies(alignedExpressions)
   }, {
     kind,
-    values: expressions
+    values: alignedExpressions
   });
 };
 var eq = (...args) => {
@@ -112541,6 +113586,7 @@ var cast = (value, target) => {
     runtime: undefined,
     dbType: target,
     runtimeSchema: undefined,
+    driverValueMapping: target.driverValueMapping,
     nullability: expression[TypeId].nullability,
     dialect: expression[TypeId].dialect,
     kind: expression[TypeId].kind,
@@ -112590,6 +113636,10 @@ var custom2 = (kind) => ({
   dialect: profile.dialect,
   kind
 });
+var driverValueMapping3 = (dbType, mapping) => ({
+  ...dbType,
+  driverValueMapping: mapping
+});
 var type = {
   ...profile.type,
   array: array2,
@@ -112599,7 +113649,8 @@ var type = {
   domain,
   enum: enum_,
   set,
-  custom: custom2
+  custom: custom2,
+  driverValueMapping: driverValueMapping3
 };
 var makeJsonDb = (kind) => ({
   dialect: profile.dialect,
@@ -113112,6 +114163,8 @@ var scalar = (plan) => {
   return makeExpression({
     runtime: undefined,
     dbType: expression[TypeId].dbType,
+    runtimeSchema: expression[TypeId].runtimeSchema,
+    driverValueMapping: expression[TypeId].driverValueMapping,
     nullability: "maybe",
     dialect: profile.dialect,
     kind: "scalar",
@@ -113340,6 +114393,7 @@ var excluded = (value) => {
     runtime: undefined,
     dbType: value[TypeId].dbType,
     runtimeSchema: value[TypeId].runtimeSchema,
+    driverValueMapping: value[TypeId].driverValueMapping,
     nullability: value[TypeId].nullability,
     dialect: profile.dialect,
     kind: "scalar",
@@ -113350,19 +114404,52 @@ var excluded = (value) => {
   });
 };
 var toMutationValueExpression = (value, column2) => {
+  const columnState = column2[TypeId];
+  const normalizeMutationValue = (candidate) => {
+    if (candidate === null && columnState.nullability !== "never") {
+      return null;
+    }
+    const runtimeSchemaAccepts = columnState.runtimeSchema !== undefined && Schema6.is(columnState.runtimeSchema)(candidate);
+    if (runtimeSchemaAccepts) {
+      return candidate;
+    }
+    const normalized = normalizeDbValue(columnState.dbType, candidate);
+    return columnState.runtimeSchema === undefined ? normalized : Schema6.decodeUnknownSync(columnState.runtimeSchema)(normalized);
+  };
   if (value !== null && typeof value === "object" && TypeId in value) {
-    return value;
+    const expression = value;
+    const ast = expression[TypeId2];
+    if (ast.kind === "literal") {
+      const normalizedValue2 = normalizeMutationValue(ast.value);
+      return makeExpression({
+        runtime: normalizedValue2,
+        dbType: columnState.dbType,
+        runtimeSchema: columnState.runtimeSchema,
+        driverValueMapping: columnState.driverValueMapping,
+        nullability: normalizedValue2 === null ? "always" : "never",
+        dialect: columnState.dialect,
+        kind: "scalar",
+        dependencies: {}
+      }, {
+        kind: "literal",
+        value: normalizedValue2
+      });
+    }
+    return retargetLiteralExpression(value, column2);
   }
+  const normalizedValue = normalizeMutationValue(value);
   return makeExpression({
-    runtime: value,
-    dbType: column2[TypeId].dbType,
-    nullability: value === null ? "always" : "never",
-    dialect: column2[TypeId].dialect,
+    runtime: normalizedValue,
+    dbType: columnState.dbType,
+    runtimeSchema: columnState.runtimeSchema,
+    driverValueMapping: columnState.driverValueMapping,
+    nullability: normalizedValue === null ? "always" : "never",
+    dialect: columnState.dialect,
     kind: "scalar",
     dependencies: {}
   }, {
     kind: "literal",
-    value
+    value: normalizedValue
   });
 };
 var renderQuantifiedComparisonAst = (left, plan, operator, quantifier) => ({
@@ -113397,6 +114484,7 @@ var makeColumnReferenceSelection = (alias2, selection) => {
       runtime: undefined,
       dbType: state.dbType,
       runtimeSchema: state.runtimeSchema,
+      driverValueMapping: state.driverValueMapping,
       nullability: state.nullability,
       dialect: state.dialect,
       kind: "scalar",
@@ -113424,7 +114512,12 @@ var makeAliasedValuesSource = (rows, selection, alias2) => {
   return Object.assign(source, columns);
 };
 var normalizeValuesRow = (row) => Object.fromEntries(Object.entries(row).map(([key2, value]) => [key2, toDialectExpression(value)]));
-var normalizeUnnestColumns = (columns) => Object.fromEntries(Object.entries(columns).map(([key2, values]) => [key2, values.map((value) => toDialectExpression(value))]));
+var normalizeUnnestColumns = (columns) => Object.fromEntries(Object.entries(columns).map(([key2, values]) => {
+  if (!Array.isArray(values)) {
+    throw new Error("unnest(...) expects every value to be an array");
+  }
+  return [key2, values.map((value) => toDialectExpression(value))];
+}));
 var normalizeMutationTargets = (target) => Array.isArray(target) ? target : [target];
 var mutationTargetClauses = (target) => normalizeMutationTargets(target).map((table) => {
   const { sourceName, sourceBaseName } = targetSourceDetails(table);
@@ -113446,13 +114539,20 @@ var mutationAvailableSources = (target, mode = "required") => Object.fromEntries
     }
   ];
 }));
+var getMutationColumn = (columns, columnName) => {
+  const column2 = columns[columnName];
+  if (column2 === undefined || column2 === null || typeof column2 !== "object" || !(TypeId in column2)) {
+    throw new Error("effect-qb: unknown mutation column");
+  }
+  return column2;
+};
 var buildMutationAssignments = (target, values) => {
   const targets = normalizeMutationTargets(target);
   if (targets.length === 1 && !Array.isArray(target)) {
     const columns = target;
     return Object.entries(values).map(([columnName, value]) => ({
       columnName,
-      value: toMutationValueExpression(value, columns[columnName])
+      value: toMutationValueExpression(value, getMutationColumn(columns, columnName))
     }));
   }
   const valueMap = values;
@@ -113463,7 +114563,7 @@ var buildMutationAssignments = (target, values) => {
     return Object.entries(scopedValues).map(([columnName, value]) => ({
       tableName: targetName,
       columnName,
-      value: toMutationValueExpression(value, columns[columnName])
+      value: toMutationValueExpression(value, getMutationColumn(columns, columnName))
     }));
   });
 };
@@ -113526,25 +114626,22 @@ var normalizeInsertUnnestValues = (target, values) => {
     values: normalized
   };
 };
+var normalizeConflictColumns = (target, columnsInput) => {
+  const columns = normalizeColumnList(columnsInput);
+  const knownColumns = new Set(Object.keys(target[TypeId4].fields));
+  if (columns.some((columnName) => !knownColumns.has(columnName))) {
+    throw new Error("effect-qb: unknown conflict target column");
+  }
+  return columns;
+};
 var buildConflictTarget = (target, input) => {
-  if (Array.isArray(input)) {
+  if (typeof input === "string" || Array.isArray(input)) {
     return {
       kind: "columns",
-      columns: normalizeColumnList(input)
+      columns: normalizeConflictColumns(target, input)
     };
   }
-  if (!Array.isArray(input) && "constraint" in input) {
-    return {
-      kind: "constraint",
-      name: input.constraint
-    };
-  }
-  const columnTarget = input;
-  return {
-    kind: "columns",
-    columns: normalizeColumnList(columnTarget.columns),
-    where: columnTarget.where === undefined ? undefined : toDialectExpression(columnTarget.where)
-  };
+  throw new Error("Unsupported mysql conflict target");
 };
 var defaultIndexName = (tableName, columns, unique4) => `${tableName}_${columns.join("_")}_${unique4 ? "uniq" : "idx"}`;
 function as(valueOrAlias, alias2) {
@@ -113657,6 +114754,7 @@ var distinctOn = {
   __effect_qb_hint__: "Use postgres.Query.distinctOn(...) or regular distinct()/grouping logic"
 };
 var mutationRuntime = makeDslMutationRuntime({
+  profile,
   makePlan,
   getAst,
   getQueryState,
@@ -113669,7 +114767,7 @@ var mutationRuntime = makeDslMutationRuntime({
   buildConflictTarget,
   mutationTargetClauses,
   mutationAvailableSources,
-  normalizeColumnList,
+  normalizeConflictColumns,
   targetSourceDetails,
   sourceDetails
 });
@@ -113680,7 +114778,7 @@ var update = (target, values2) => mutationRuntime.update(target, values2);
 var upsert = (target, values2, conflictColumns, updateValues) => mutationRuntime.upsert(target, values2, conflictColumns, updateValues);
 var delete_ = (target) => mutationRuntime.delete_(target);
 var truncate = (target, options2 = {}) => mutationRuntime.truncate(target, options2);
-var merge = (target, source, on, options2 = {}) => mutationRuntime.merge(target, source, on, options2);
+var merge = (target, source, on, options2) => mutationRuntime.merge(target, source, on, options2);
 var {
   transaction,
   commit,
@@ -113785,315 +114883,195 @@ import * as Stream2 from "effect/Stream";
 import * as Chunk from "effect/Chunk";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
-import * as Schema8 from "effect/Schema";
+import * as Schema9 from "effect/Schema";
 import * as SqlClient from "@effect/sql/SqlClient";
 import * as Stream from "effect/Stream";
 
-// src/internal/runtime/normalize.ts
-var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var pad = (value, width = 2) => value.toString().padStart(width, "0");
-var formatLocalDate = (value) => `${value.getUTCFullYear()}-${pad(value.getUTCMonth() + 1)}-${pad(value.getUTCDate())}`;
-var formatLocalTime = (value) => {
-  const milliseconds = value.getUTCMilliseconds();
-  const base = `${pad(value.getUTCHours())}:${pad(value.getUTCMinutes())}:${pad(value.getUTCSeconds())}`;
-  return milliseconds === 0 ? base : `${base}.${pad(milliseconds, 3)}`;
-};
-var formatLocalDateTime = (value) => {
-  const milliseconds = value.getUTCMilliseconds();
-  const base = `${formatLocalDate(value)}T${pad(value.getUTCHours())}:${pad(value.getUTCMinutes())}:${pad(value.getUTCSeconds())}`;
-  return milliseconds === 0 ? base : `${base}.${pad(milliseconds, 3)}`;
-};
-var runtimeTagOfBaseDbType = (dbType) => {
-  return dbType.runtime;
-};
-var expectString = (value, label) => {
-  if (typeof value === "string") {
-    return value;
-  }
-  throw new Error(`Expected ${label} as string`);
-};
-var normalizeNumber = (value) => {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value;
+// src/internal/runtime/driver-value-mapping.ts
+import * as Schema7 from "effect/Schema";
+var runtimeTagOfDbType = (dbType) => {
+  if (dbType === undefined) {
+    return;
   }
-  if (typeof value === "string" && value.trim() !== "") {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) {
-      return parsed;
-    }
+  if ("base" in dbType) {
+    return runtimeTagOfDbType(dbType.base);
   }
-  if (typeof value === "bigint" && Number.isSafeInteger(Number(value))) {
-    return Number(value);
+  if ("element" in dbType) {
+    return "array";
   }
-  throw new Error("Expected a finite numeric value");
-};
-var normalizeBoolean = (value) => {
-  if (typeof value === "boolean") {
-    return value;
+  if ("fields" in dbType) {
+    return "record";
   }
-  if (typeof value === "number") {
-    if (value === 1) {
-      return true;
-    }
-    if (value === 0) {
-      return false;
-    }
+  if ("variant" in dbType && dbType.variant === "json") {
+    return "json";
   }
-  if (typeof value === "string") {
-    const normalized = value.trim().toLowerCase();
-    if (normalized === "true" || normalized === "t" || normalized === "1") {
-      return true;
-    }
-    if (normalized === "false" || normalized === "f" || normalized === "0") {
-      return false;
-    }
+  if ("variant" in dbType && (dbType.variant === "enum" || dbType.variant === "set")) {
+    return "string";
   }
-  throw new Error("Expected a boolean-like value");
+  return dbType.runtime;
 };
-var normalizeBigIntString = (value) => {
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
-  if (typeof value === "number" && Number.isSafeInteger(value)) {
-    return BigInt(value).toString();
+var familyOfDbType = (dbType) => {
+  if (dbType === undefined) {
+    return;
   }
-  if (typeof value === "string" && /^-?\d+$/.test(value.trim())) {
-    return BigInt(value.trim()).toString();
+  if ("base" in dbType) {
+    return familyOfDbType(dbType.base);
   }
-  throw new Error("Expected an integer-like bigint value");
+  return dbType.family;
 };
-var canonicalizeDecimalString = (input) => {
-  const trimmed = input.trim();
-  const match2 = /^([+-]?)(\d+)(?:\.(\d+))?$/.exec(trimmed);
-  if (match2 === null) {
-    throw new Error("Expected a decimal string");
-  }
-  const sign = match2[1] === "-" ? "-" : "";
-  const integer = match2[2].replace(/^0+(?=\d)/, "") || "0";
-  const fraction = (match2[3] ?? "").replace(/0+$/, "");
-  if (fraction.length === 0) {
-    return `${sign}${integer}`;
-  }
-  return `${sign}${integer}.${fraction}`;
+var mappingCandidates = (context) => {
+  const dbType = context.dbType;
+  const runtimeTag = runtimeTagOfDbType(dbType);
+  const family = familyOfDbType(dbType);
+  return [
+    context.driverValueMapping,
+    dbType?.driverValueMapping,
+    dbType === undefined ? undefined : context.valueMappings?.[dbType.kind],
+    family === undefined ? undefined : context.valueMappings?.[family],
+    runtimeTag === undefined ? undefined : context.valueMappings?.[runtimeTag]
+  ];
 };
-var normalizeDecimalString = (value) => {
-  if (typeof value === "string") {
-    return canonicalizeDecimalString(value);
-  }
-  if (typeof value === "number" && Number.isFinite(value)) {
-    const rendered = String(value);
-    if (/[eE]/.test(rendered)) {
-      throw new Error("Scientific notation is not a supported decimal runtime");
+var findMapping = (context, key2) => {
+  for (const candidate of mappingCandidates(context)) {
+    const value = candidate?.[key2];
+    if (value !== undefined) {
+      return value;
     }
-    return canonicalizeDecimalString(rendered);
   }
-  throw new Error("Expected a decimal-like value");
+  return;
 };
-var normalizeLocalDate = (value) => {
-  if (value instanceof Date) {
-    return formatLocalDate(value);
+var isJsonDbType = (dbType) => {
+  if (dbType === undefined) {
+    return false;
   }
-  const raw = expectString(value, "local date").trim();
-  if (/^\d{4}-\d{2}-\d{2}$/.test(raw)) {
-    return raw;
-  }
-  const parsed = new Date(raw);
-  if (!Number.isNaN(parsed.getTime())) {
-    return formatLocalDate(parsed);
-  }
-  throw new Error("Expected a local-date value");
-};
-var normalizeLocalTime = (value) => {
-  if (value instanceof Date) {
-    return formatLocalTime(value);
+  if ("base" in dbType) {
+    return isJsonDbType(dbType.base);
   }
-  const raw = expectString(value, "local time").trim();
-  if (/^\d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(raw)) {
-    return raw;
+  if (!("variant" in dbType)) {
+    return false;
   }
-  throw new Error("Expected a local-time value");
+  const variant = dbType.variant;
+  return variant === "json" || variant === "jsonb";
 };
-var normalizeOffsetTime = (value) => {
-  if (value instanceof Date) {
-    return `${formatLocalTime(value)}Z`;
+var schemaAccepts = (schema4, value) => schema4 !== undefined && Schema7.is(schema4)(value);
+var encodeWithSchema = (schema4, value) => {
+  if (schema4 === undefined) {
+    return { value, encoded: false };
   }
-  const raw = expectString(value, "offset time").trim();
-  if (/^\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(raw)) {
-    return raw;
+  if (!Schema7.is(schema4)(value)) {
+    return { value, encoded: false };
   }
-  throw new Error("Expected an offset-time value");
+  return {
+    value: Schema7.encodeUnknownSync(schema4)(value),
+    encoded: true
+  };
 };
-var normalizeLocalDateTime = (value) => {
-  if (value instanceof Date) {
-    return formatLocalDateTime(value);
-  }
-  const raw = expectString(value, "local datetime").trim();
-  if (/^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(raw)) {
-    return raw.replace(" ", "T");
+var normalizeJsonDriverString = (value, context) => {
+  if (!isJsonDbType(context.dbType) || context.runtimeSchema === undefined) {
+    return;
   }
-  if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(raw)) {
-    const parsed = new Date(raw);
-    if (!Number.isNaN(parsed.getTime())) {
-      return formatLocalDateTime(parsed);
+  try {
+    const parsed = JSON.parse(value);
+    if (value.trimStart().startsWith('"') && schemaAccepts(context.runtimeSchema, parsed)) {
+      return parsed;
+    }
+    if (schemaAccepts(context.runtimeSchema, value) && !schemaAccepts(context.runtimeSchema, parsed)) {
+      return value;
+    }
+  } catch (error) {
+    if (error instanceof SyntaxError && schemaAccepts(context.runtimeSchema, value)) {
+      return value;
+    }
+    if (!(error instanceof SyntaxError)) {
+      throw error;
     }
   }
-  throw new Error("Expected a local-datetime value");
-};
-var normalizeInstant = (value) => {
-  if (value instanceof Date) {
-    return value.toISOString();
-  }
-  const raw = expectString(value, "instant").trim();
-  if (!/[zZ]|[+-]\d{2}:\d{2}$/.test(raw)) {
-    throw new Error("Instant values require a timezone offset");
-  }
-  const parsed = new Date(raw);
-  if (Number.isNaN(parsed.getTime())) {
-    throw new Error("Expected an ISO instant value");
-  }
-  return parsed.toISOString();
-};
-var normalizeYear = (value) => {
-  if (typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 9999) {
-    return pad(value, 4);
-  }
-  const raw = expectString(value, "year").trim();
-  if (/^\d{4}$/.test(raw)) {
-    return raw;
-  }
-  throw new Error("Expected a four-digit year");
-};
-var normalizeBytes = (value) => {
-  if (value instanceof Uint8Array) {
-    return new Uint8Array(value);
-  }
-  const BufferConstructor = globalThis.Buffer;
-  if (BufferConstructor !== undefined && value instanceof BufferConstructor) {
-    return new Uint8Array(value);
-  }
-  throw new Error("Expected a byte array value");
+  return;
 };
-var isJsonValue = (value) => {
+var toDriverValue = (value, context) => {
   if (value === null) {
-    return true;
+    return null;
   }
-  switch (typeof value) {
-    case "string":
-    case "number":
-    case "boolean":
-      return true;
-    case "object":
-      if (Array.isArray(value)) {
-        return value.every(isJsonValue);
-      }
-      return isRecord2(value) && Object.values(value).every(isJsonValue);
-    default:
-      return false;
+  if (value instanceof Date && Number.isNaN(value.getTime())) {
+    throw new Error("Expected a valid Date value");
   }
-};
-var normalizeJson = (value) => {
-  if (typeof value === "string") {
-    const parsed = JSON.parse(value);
-    if (isJsonValue(parsed)) {
-      return parsed;
-    }
-    throw new Error("Parsed JSON value is not a valid JSON runtime");
+  const dbType = context.dbType;
+  const encoded = encodeWithSchema(context.runtimeSchema, value);
+  let current = encoded.value;
+  const custom3 = findMapping(context, "toDriver");
+  if (custom3 !== undefined && dbType !== undefined) {
+    return custom3(current, dbType);
   }
-  if (isJsonValue(value)) {
-    return value;
+  if (encoded.encoded && typeof current === "string" && isJsonDbType(dbType)) {
+    return current;
   }
-  throw new Error("Expected a JSON value");
+  return dbType === undefined || !encoded.encoded ? current : normalizeDbValue(dbType, current);
 };
-var normalizeDbValue = (dbType, value) => {
+var fromDriverValue = (value, context) => {
   if (value === null) {
     return null;
   }
-  if ("base" in dbType) {
-    return normalizeDbValue(dbType.base, value);
-  }
-  if ("element" in dbType) {
-    if (!Array.isArray(value)) {
-      throw new Error("Expected an array value");
-    }
-    return value.map((entry) => normalizeDbValue(dbType.element, entry));
+  const dbType = context.dbType;
+  const custom3 = findMapping(context, "fromDriver");
+  if (custom3 !== undefined && dbType !== undefined) {
+    return custom3(value, dbType);
   }
-  if ("fields" in dbType) {
-    if (!isRecord2(value)) {
-      throw new Error("Expected a record value");
-    }
-    const normalized = {};
-    for (const [key2, fieldDbType] of Object.entries(dbType.fields)) {
-      if (key2 in value) {
-        normalized[key2] = normalizeDbValue(fieldDbType, value[key2]);
-      }
+  if (typeof value === "string") {
+    const normalizedJsonString = normalizeJsonDriverString(value, context);
+    if (normalizedJsonString !== undefined) {
+      return normalizedJsonString;
     }
-    return normalized;
-  }
-  if ("variant" in dbType && dbType.variant === "json") {
-    return normalizeJson(value);
-  }
-  if ("variant" in dbType && (dbType.variant === "enum" || dbType.variant === "set")) {
-    return expectString(value, "text");
   }
-  switch (runtimeTagOfBaseDbType(dbType)) {
-    case "string":
-      return expectString(value, "text");
-    case "number":
-      return normalizeNumber(value);
+  return dbType === undefined ? value : normalizeDbValue(dbType, value);
+};
+var textCast = (sql) => `(${sql})::text`;
+var postgresJsonSql = (sql, dbType) => {
+  const runtimeTag = runtimeTagOfDbType(dbType);
+  switch (runtimeTag) {
     case "bigintString":
-      return normalizeBigIntString(value);
-    case "boolean":
-      return normalizeBoolean(value);
-    case "json":
-      return normalizeJson(value);
+    case "decimalString":
     case "localDate":
-      return normalizeLocalDate(value);
     case "localTime":
-      return normalizeLocalTime(value);
     case "offsetTime":
-      return normalizeOffsetTime(value);
     case "localDateTime":
-      return normalizeLocalDateTime(value);
     case "instant":
-      return normalizeInstant(value);
     case "year":
-      return normalizeYear(value);
-    case "decimalString":
-      return normalizeDecimalString(value);
+      return textCast(sql);
     case "bytes":
-      return normalizeBytes(value);
-    case "array":
-      if (!Array.isArray(value)) {
-        throw new Error("Expected an array value");
-      }
-      return value;
-    case "record":
-      if (!isRecord2(value)) {
-        throw new Error("Expected a record value");
-      }
-      return value;
-    case "null":
-      return null;
-    case "unknown":
-    case undefined:
-      return value;
+      return `encode(${sql}, 'base64')`;
+    default:
+      return sql;
+  }
+};
+var renderSelectSql = (sql, context) => {
+  const dbType = context.dbType;
+  const custom3 = findMapping(context, "selectSql");
+  return custom3 !== undefined && dbType !== undefined ? custom3(sql, dbType) : sql;
+};
+var renderJsonSelectSql = (sql, context) => {
+  const dbType = context.dbType;
+  const custom3 = findMapping(context, "jsonSelectSql");
+  if (custom3 !== undefined && dbType !== undefined) {
+    return custom3(sql, dbType);
   }
+  return context.dialect === "postgres" && dbType !== undefined ? postgresJsonSql(sql, dbType) : sql;
 };
 
 // src/internal/runtime/schema.ts
-import * as Schema7 from "effect/Schema";
+import * as Schema8 from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
 var schemaCache = new WeakMap;
+var FiniteNumberSchema = Schema8.Number.pipe(Schema8.finite());
 var runtimeSchemaForTag = (tag) => {
   switch (tag) {
     case "string":
-      return Schema7.String;
+      return Schema8.String;
     case "number":
-      return Schema7.Number;
+      return FiniteNumberSchema;
     case "bigintString":
       return BigIntStringSchema;
     case "boolean":
-      return Schema7.Boolean;
+      return Schema8.Boolean;
     case "json":
       return JsonValueSchema;
     case "localDate":
@@ -114111,16 +115089,16 @@ var runtimeSchemaForTag = (tag) => {
     case "decimalString":
       return DecimalStringSchema;
     case "bytes":
-      return Schema7.Uint8ArrayFromSelf;
+      return Schema8.Uint8ArrayFromSelf;
     case "array":
-      return Schema7.Array(Schema7.Unknown);
+      return Schema8.Array(Schema8.Unknown);
     case "record":
-      return Schema7.Record({
-        key: Schema7.String,
-        value: Schema7.Unknown
+      return Schema8.Record({
+        key: Schema8.String,
+        value: Schema8.Unknown
       });
     case "null":
-      return Schema7.Null;
+      return Schema8.Null;
     case "unknown":
       return;
   }
@@ -114133,22 +115111,22 @@ var runtimeSchemaForDbType = (dbType) => {
     return runtimeSchemaForDbType(dbType.base);
   }
   if ("element" in dbType) {
-    return Schema7.Array(runtimeSchemaForDbType(dbType.element) ?? Schema7.Unknown);
+    return Schema8.Array(runtimeSchemaForDbType(dbType.element) ?? Schema8.Unknown);
   }
   if ("fields" in dbType) {
-    const fields2 = Object.fromEntries(Object.entries(dbType.fields).map(([key2, field]) => [key2, runtimeSchemaForDbType(field) ?? Schema7.Unknown]));
-    return Schema7.Struct(fields2);
+    const fields2 = Object.fromEntries(Object.entries(dbType.fields).map(([key2, field]) => [key2, runtimeSchemaForDbType(field) ?? Schema8.Unknown]));
+    return Schema8.Struct(fields2);
   }
   if ("variant" in dbType && dbType.variant === "json") {
     return JsonValueSchema;
   }
   if ("variant" in dbType && (dbType.variant === "enum" || dbType.variant === "set")) {
-    return Schema7.String;
+    return Schema8.String;
   }
   const runtimeTag = runtimeTagOfBaseDbType2(dbType);
   return runtimeTag === undefined ? undefined : runtimeSchemaForTag(runtimeTag);
 };
-var makeSchemaFromAst = (ast) => Schema7.make(ast);
+var makeSchemaFromAst = (ast) => Schema8.make(ast);
 var unionAst = (asts) => {
   if (asts.length === 0) {
     return;
@@ -114246,7 +115224,7 @@ var unionSchemas = (schemas) => {
   if (resolved.length === 1) {
     return resolved[0];
   }
-  return Schema7.Union(...resolved);
+  return Schema8.Union(...resolved);
 };
 var firstSelectedExpression = (plan) => {
   const selection = getAst(plan).select;
@@ -114281,9 +115259,9 @@ var jsonCompatibleSchema = (schema4) => {
 };
 var buildStructSchema = (entries, context) => {
   const fields2 = Object.fromEntries(entries.map((entry) => [entry.key, expressionRuntimeSchema(entry.value, context) ?? JsonValueSchema]));
-  return Schema7.Struct(fields2);
+  return Schema8.Struct(fields2);
 };
-var buildTupleSchema = (values2, context) => Schema7.Tuple(...values2.map((value) => expressionRuntimeSchema(value, context) ?? JsonValueSchema));
+var buildTupleSchema = (values2, context) => Schema8.Tuple(...values2.map((value) => expressionRuntimeSchema(value, context) ?? JsonValueSchema));
 var deriveCaseSchema = (ast, context) => {
   if (context === undefined) {
     return unionSchemas([
@@ -114323,10 +115301,10 @@ var deriveRuntimeSchema = (expression, context) => {
       return state.runtimeSchema;
     case "literal":
       if (ast.value === null) {
-        return Schema7.Null;
+        return Schema8.Null;
       }
       if (typeof ast.value === "string" || typeof ast.value === "number" || typeof ast.value === "boolean") {
-        return Schema7.Literal(ast.value);
+        return Schema8.Literal(ast.value);
       }
       return runtimeSchemaForDbType(state.dbType);
     case "cast":
@@ -114362,7 +115340,7 @@ var deriveRuntimeSchema = (expression, context) => {
     case "jsonHasAllKeys":
     case "jsonPathExists":
     case "jsonPathMatch":
-      return Schema7.Boolean;
+      return Schema8.Boolean;
     case "upper":
     case "lower":
     case "concat":
@@ -114371,10 +115349,10 @@ var deriveRuntimeSchema = (expression, context) => {
     case "jsonAccessText":
     case "jsonTraverseText":
     case "jsonTypeOf":
-      return Schema7.String;
+      return Schema8.String;
     case "count":
     case "jsonLength":
-      return Schema7.Number;
+      return FiniteNumberSchema;
     case "max":
     case "min":
       return expressionRuntimeSchema(ast.value, context);
@@ -114387,7 +115365,7 @@ var deriveRuntimeSchema = (expression, context) => {
       return selection === undefined ? undefined : expressionRuntimeSchema(selection, context);
     }
     case "window":
-      return ast.function === "over" && ast.value !== undefined ? expressionRuntimeSchema(ast.value, context) : Schema7.Number;
+      return ast.function === "over" && ast.value !== undefined ? expressionRuntimeSchema(ast.value, context) : FiniteNumberSchema;
     case "jsonGet":
     case "jsonPath":
     case "jsonAccess":
@@ -114419,7 +115397,7 @@ var deriveRuntimeSchema = (expression, context) => {
     case "jsonToJsonb":
       return jsonCompatibleSchema(expressionRuntimeSchema(ast.value, context));
     case "jsonKeys":
-      return Schema7.Array(Schema7.String);
+      return Schema8.Array(Schema8.String);
   }
 };
 var expressionRuntimeSchema = (expression, context) => {
@@ -114509,7 +115487,7 @@ var effectiveRuntimeNullability = (expression, scope) => {
     return "always";
   }
   if (ast.kind === "column") {
-    const key2 = `${ast.tableName}.${ast.columnName}`;
+    const key2 = columnPredicateKey(ast.tableName, ast.columnName);
     if (scope.absentSourceNames.has(ast.tableName) || scope.nullKeys.has(key2)) {
       return "always";
     }
@@ -114522,18 +115500,35 @@ var effectiveRuntimeNullability = (expression, scope) => {
   }
   return hasOptionalSourceDependency(expression, scope) ? "maybe" : nullability;
 };
-var decodeProjectionValue = (rendered, projection, expression, raw, scope, driverMode) => {
+var dbTypeAllowsTopLevelJsonNull = (dbType) => {
+  if ("base" in dbType) {
+    return dbTypeAllowsTopLevelJsonNull(dbType.base);
+  }
+  return "variant" in dbType && dbType.variant === "json" || dbType.runtime === "json";
+};
+var schemaAcceptsNull = (schema4) => schema4 !== undefined && Schema9.is(schema4)(null);
+var decodeProjectionValue = (rendered, projection, expression, raw, scope, driverMode, valueMappings) => {
   let normalized = raw;
   if (driverMode === "raw") {
     try {
-      normalized = normalizeDbValue(expression[TypeId].dbType, raw);
+      normalized = fromDriverValue(raw, {
+        dialect: rendered.dialect,
+        dbType: expression[TypeId].dbType,
+        runtimeSchema: expression[TypeId].runtimeSchema,
+        driverValueMapping: expression[TypeId].driverValueMapping,
+        valueMappings
+      });
     } catch (cause) {
       throw makeRowDecodeError(rendered, projection, expression, raw, "normalize", cause);
     }
   }
   const nullability = effectiveRuntimeNullability(expression, scope);
+  const schema4 = expressionRuntimeSchema(expression, { assumptions: scope.assumptions });
   if (normalized === null) {
     if (nullability === "never") {
+      if (dbTypeAllowsTopLevelJsonNull(expression[TypeId].dbType) && schemaAcceptsNull(schema4)) {
+        return null;
+      }
       throw makeRowDecodeError(rendered, projection, expression, raw, "schema", new Error("Received null for a non-null projection"), normalized);
     }
     return null;
@@ -114541,35 +115536,38 @@ var decodeProjectionValue = (rendered, projection, expression, raw, scope, drive
   if (nullability === "always") {
     throw makeRowDecodeError(rendered, projection, expression, raw, "schema", new Error("Received non-null for an always-null projection"), normalized);
   }
-  const schema4 = expressionRuntimeSchema(expression, { assumptions: scope.assumptions });
+  if (dbTypeAllowsTopLevelJsonNull(expression[TypeId].dbType) && !isJsonValue(normalized)) {
+    throw makeRowDecodeError(rendered, projection, expression, raw, "schema", new Error("Expected a JSON value"), normalized);
+  }
   if (schema4 === undefined) {
     return normalized;
   }
-  if (Schema8.is(schema4)(normalized)) {
+  if (Schema9.is(schema4)(normalized)) {
     return normalized;
   }
   try {
-    return Schema8.decodeUnknownSync(schema4)(normalized);
+    return Schema9.decodeUnknownSync(schema4)(normalized);
   } catch (cause) {
     throw makeRowDecodeError(rendered, projection, expression, raw, "schema", cause, normalized);
   }
 };
 var makeRowDecoder = (rendered, plan, options2 = {}) => {
   const projections = flattenSelection(getAst(plan).select);
-  const byAlias = new Map(projections.map((projection) => [projection.alias, projection.expression]));
+  const byPath = new Map(projections.map((projection) => [JSON.stringify(projection.path), projection.expression]));
   const driverMode = options2.driverMode ?? "raw";
+  const valueMappings = options2.valueMappings ?? rendered.valueMappings;
   const scope = resolveImplicationScope(plan[TypeId3].available, getQueryState(plan).assumptions);
   return (row) => {
     const decoded = {};
     for (const projection of rendered.projections) {
-      if (!(projection.alias in row)) {
-        continue;
-      }
-      const expression = byAlias.get(projection.alias);
+      const expression = byPath.get(JSON.stringify(projection.path));
       if (expression === undefined) {
-        continue;
+        throw new Error(`Rendered projection path '${projection.path.join(".")}' does not exist in the query selection`);
       }
-      setPath2(decoded, projection.path, decodeProjectionValue(rendered, projection, expression, row[projection.alias], scope, driverMode));
+      if (!(projection.alias in row)) {
+        throw makeRowDecodeError(rendered, projection, expression, undefined, "schema", new Error(`Missing required projection alias '${projection.alias}'`));
+      }
+      setPath2(decoded, projection.path, decodeProjectionValue(rendered, projection, expression, row[projection.alias], scope, driverMode, valueMappings));
     }
     return decoded;
   };
@@ -114614,6 +115612,23 @@ var withSavepoint = (effect) => Effect.flatMap(SqlClient.SqlClient, (sql) => sql
 
 // src/internal/renderer.ts
 var TypeId8 = Symbol.for("effect-qb/Renderer");
+var projectionPathKey = (path2) => JSON.stringify(path2);
+var formatProjectionPath2 = (path2) => path2.join(".");
+var validateProjectionPathsMatchSelection = (plan, projections) => {
+  const expected = flattenSelection(getAst(plan).select);
+  const expectedPaths = new Set(expected.map((projection) => projectionPathKey(projection.path)));
+  const actualPaths = new Set(projections.map((projection) => projectionPathKey(projection.path)));
+  for (const projection of projections) {
+    if (!expectedPaths.has(projectionPathKey(projection.path))) {
+      throw new Error(`Projection path ${formatProjectionPath2(projection.path)} does not exist in the query selection`);
+    }
+  }
+  for (const projection of expected) {
+    if (!actualPaths.has(projectionPathKey(projection.path))) {
+      throw new Error(`Projection path ${formatProjectionPath2(projection.path)} is missing from rendered projections`);
+    }
+  }
+};
 function make5(dialect, render) {
   if (typeof render !== "function") {
     throw new Error(`Renderer.make requires an explicit render implementation for dialect: ${dialect}`);
@@ -114621,13 +115636,23 @@ function make5(dialect, render) {
   return {
     dialect,
     render(plan) {
+      const required = currentRequiredList(plan[TypeId3].required);
+      if (required.length > 0) {
+        throw new Error(`query references sources that are not yet in scope: ${required.join(", ")}`);
+      }
+      const planDialect = plan[TypeId3].dialect;
+      if (planDialect !== dialect) {
+        throw new Error("effect-qb: plan dialect is not compatible with the target renderer or executor");
+      }
       const rendered = render(plan);
       const projections = rendered.projections ?? [];
       validateProjections(projections);
+      validateProjectionPathsMatchSelection(plan, projections);
       return {
         sql: rendered.sql,
         params: rendered.params ?? [],
         projections,
+        valueMappings: rendered.valueMappings,
         dialect,
         [TypeId8]: {
           row: undefined,
@@ -114640,14 +115665,19 @@ function make5(dialect, render) {
 
 // src/mysql/internal/dialect.ts
 var quoteIdentifier = (value) => `\`${value.replaceAll("`", "``")}\``;
-var renderLiteral = (value, state) => {
-  if (value === null) {
+var renderLiteral = (value, state, context = {}) => {
+  const driverValue = toDriverValue(value, {
+    dialect: "mysql",
+    valueMappings: state.valueMappings,
+    ...context
+  });
+  if (driverValue === null) {
     return "null";
   }
-  if (typeof value === "boolean") {
-    return value ? "true" : "false";
+  if (typeof driverValue === "boolean") {
+    return driverValue ? "true" : "false";
   }
-  state.params.push(value);
+  state.params.push(driverValue);
   return "?";
 };
 var mysqlDialect = {
@@ -114663,16 +115693,19 @@ var mysqlDialect = {
   }
 };
 
+// src/mysql/internal/sql-expression-renderer.ts
+import * as Schema10 from "effect/Schema";
+
 // src/internal/aggregation-validation.ts
-var isExpression2 = (value) => typeof value === "object" && value !== null && (TypeId in value);
+var isExpression3 = (value) => typeof value === "object" && value !== null && (TypeId in value);
 var selectionHasAggregate = (selection) => {
-  if (isExpression2(selection)) {
+  if (isExpression3(selection)) {
     return selection[TypeId].kind === "aggregate";
   }
   return Object.values(selection).some((value) => selectionHasAggregate(value));
 };
 var isGroupedSelectionValid = (selection, groupedExpressions) => {
-  if (isExpression2(selection)) {
+  if (isExpression3(selection)) {
     const aggregation = selection[TypeId].kind;
     if (aggregation === "aggregate") {
       return true;
@@ -114777,7 +115810,46 @@ var renderCastType = (dialect, dbType) => {
       return dbType.kind;
   }
 };
-var renderDdlExpression = (expression, state, dialect) => isSchemaExpression(expression) ? render(expression) : renderExpression(expression, state, dialect);
+var renderMysqlDdlString = (value) => `'${value.replaceAll("'", "''")}'`;
+var renderMysqlDdlBytes = (value) => `x'${Array.from(value, (byte) => byte.toString(16).padStart(2, "0")).join("")}'`;
+var renderMysqlDdlLiteral = (value, state, context = {}) => {
+  const driverValue = toDriverValue(value, {
+    dialect: "mysql",
+    valueMappings: state.valueMappings,
+    ...context
+  });
+  if (driverValue === null) {
+    return "null";
+  }
+  switch (typeof driverValue) {
+    case "boolean":
+      return driverValue ? "true" : "false";
+    case "number":
+      if (!Number.isFinite(driverValue)) {
+        throw new Error("Expected a finite numeric value");
+      }
+      return String(driverValue);
+    case "bigint":
+      return driverValue.toString();
+    case "string":
+      return renderMysqlDdlString(driverValue);
+    case "object":
+      if (driverValue instanceof Uint8Array) {
+        return renderMysqlDdlBytes(driverValue);
+      }
+      break;
+  }
+  throw new Error("Unsupported mysql DDL literal value");
+};
+var renderDdlExpression = (expression, state, dialect) => {
+  if (isSchemaExpression(expression)) {
+    return render(expression);
+  }
+  return renderExpression(expression, state, {
+    ...dialect,
+    renderLiteral: renderMysqlDdlLiteral
+  });
+};
 var renderMysqlMutationLimit = (expression, state, dialect) => {
   const ast = expression[TypeId2];
   if (ast.kind === "literal" && typeof ast.value === "number" && Number.isInteger(ast.value) && ast.value >= 0) {
@@ -114812,30 +115884,52 @@ var renderCreateTableSql = (targetSource, state, dialect, ifNotExists) => {
         definitions.push(`${option2.name ? `constraint ${dialect.quoteIdentifier(option2.name)} ` : ""}primary key (${option2.columns.map((column2) => dialect.quoteIdentifier(column2)).join(", ")})${option2.deferrable ? ` deferrable${option2.initiallyDeferred ? " initially deferred" : ""}` : ""}`);
         break;
       case "unique":
+        if (option2.nullsNotDistinct || option2.deferrable || option2.initiallyDeferred) {
+          throw new Error("Unsupported mysql unique constraint options");
+        }
         definitions.push(`${option2.name ? `constraint ${dialect.quoteIdentifier(option2.name)} ` : ""}unique${option2.nullsNotDistinct ? " nulls not distinct" : ""} (${option2.columns.map((column2) => dialect.quoteIdentifier(column2)).join(", ")})${option2.deferrable ? ` deferrable${option2.initiallyDeferred ? " initially deferred" : ""}` : ""}`);
         break;
       case "foreignKey": {
         const reference = option2.references();
-        definitions.push(`${option2.name ? `constraint ${dialect.quoteIdentifier(option2.name)} ` : ""}foreign key (${option2.columns.map((column2) => dialect.quoteIdentifier(column2)).join(", ")}) references ${dialect.renderTableReference(reference.tableName, reference.tableName, reference.schemaName)} (${reference.columns.map((column2) => dialect.quoteIdentifier(column2)).join(", ")})${option2.onDelete ? ` on delete ${option2.onDelete.replace(/[A-Z]/g, (value) => ` ${value.toLowerCase()}`).trim()}` : ""}${option2.onUpdate ? ` on update ${option2.onUpdate.replace(/[A-Z]/g, (value) => ` ${value.toLowerCase()}`).trim()}` : ""}${option2.deferrable ? ` deferrable${option2.initiallyDeferred ? " initially deferred" : ""}` : ""}`);
+        definitions.push(`${option2.name ? `constraint ${dialect.quoteIdentifier(option2.name)} ` : ""}foreign key (${option2.columns.map((column2) => dialect.quoteIdentifier(column2)).join(", ")}) references ${dialect.renderTableReference(reference.tableName, reference.tableName, reference.schemaName)} (${reference.columns.map((column2) => dialect.quoteIdentifier(column2)).join(", ")})${option2.onDelete !== undefined ? ` on delete ${renderReferentialAction(option2.onDelete)}` : ""}${option2.onUpdate !== undefined ? ` on update ${renderReferentialAction(option2.onUpdate)}` : ""}${option2.deferrable ? ` deferrable${option2.initiallyDeferred ? " initially deferred" : ""}` : ""}`);
         break;
       }
       case "check":
-        definitions.push(`constraint ${dialect.quoteIdentifier(option2.name)} check (${renderDdlExpression(option2.predicate, state, dialect)})${option2.noInherit ? " no inherit" : ""}`);
+        definitions.push(`constraint ${dialect.quoteIdentifier(option2.name)} check (${renderDdlExpression(option2.predicate, { ...state, rowLocalColumns: true }, dialect)})${option2.noInherit ? " no inherit" : ""}`);
         break;
       case "index":
         break;
+      default:
+        throw new Error("Unsupported table option kind");
     }
   }
   return `create table${ifNotExists ? " if not exists" : ""} ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} (${definitions.join(", ")})`;
 };
 var renderCreateIndexSql = (targetSource, ddl, state, dialect) => {
+  if (ddl.ifNotExists) {
+    throw new Error("Unsupported mysql create index options");
+  }
   const maybeIfNotExists = dialect.name === "postgres" && ddl.ifNotExists ? " if not exists" : "";
   return `create${ddl.unique ? " unique" : ""} index${maybeIfNotExists} ${dialect.quoteIdentifier(ddl.name)} on ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} (${ddl.columns.map((column2) => dialect.quoteIdentifier(column2)).join(", ")})`;
 };
-var renderDropIndexSql = (targetSource, ddl, state, dialect) => dialect.name === "postgres" ? `drop index${ddl.ifExists ? " if exists" : ""} ${dialect.quoteIdentifier(ddl.name)}` : `drop index ${dialect.quoteIdentifier(ddl.name)} on ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)}`;
-var isExpression3 = (value) => value !== null && typeof value === "object" && (TypeId in value);
-var isJsonDbType = (dbType) => dbType.kind === "jsonb" || dbType.kind === "json" || ("variant" in dbType) && dbType.variant === "json";
-var isJsonExpression = (value) => isExpression3(value) && isJsonDbType(value[TypeId].dbType);
+var renderDropIndexSql = (targetSource, ddl, state, dialect) => {
+  if (ddl.ifExists) {
+    throw new Error("Unsupported mysql drop index options");
+  }
+  return dialect.name === "postgres" ? `drop index${ddl.ifExists ? " if exists" : ""} ${dialect.quoteIdentifier(ddl.name)}` : `drop index ${dialect.quoteIdentifier(ddl.name)} on ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)}`;
+};
+var isExpression4 = (value) => value !== null && typeof value === "object" && (TypeId in value);
+var isJsonDbType2 = (dbType) => {
+  if (dbType.kind === "jsonb" || dbType.kind === "json") {
+    return true;
+  }
+  if (!("variant" in dbType)) {
+    return false;
+  }
+  const variant = dbType.variant;
+  return variant === "json" || variant === "jsonb";
+};
+var isJsonExpression = (value) => isExpression4(value) && isJsonDbType2(value[TypeId].dbType);
 var unsupportedJsonFeature = (dialect, feature) => {
   const error = new Error(`Unsupported JSON feature for ${dialect.name}: ${feature}`);
   Object.assign(error, {
@@ -114878,15 +115972,16 @@ var extractJsonPathSegments = (node) => {
 };
 var extractJsonValue = (node) => node.newValue ?? node.insert ?? node.right;
 var renderJsonPathSegment = (segment) => {
+  const renderKey = (value) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(value) ? `.${value}` : `.${JSON.stringify(value)}`;
   if (typeof segment === "string") {
-    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(segment) ? `.${segment}` : `."${segment.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+    return renderKey(segment);
   }
   if (typeof segment === "number") {
     return `[${segment}]`;
   }
   switch (segment.kind) {
     case "key":
-      return /^[A-Za-z_][A-Za-z0-9_]*$/.test(segment.key) ? `.${segment.key}` : `."${segment.key.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+      return renderKey(segment.key);
     case "index":
       return `[${segment.index}]`;
     case "wildcard":
@@ -114899,14 +115994,45 @@ var renderJsonPathSegment = (segment) => {
       throw new Error("Unsupported JSON path segment");
   }
 };
-var renderJsonPathStringLiteral = (segments) => {
+var renderMySqlJsonIndex = (index4) => index4 >= 0 ? String(index4) : index4 === -1 ? "last" : `last-${Math.abs(index4) - 1}`;
+var renderMySqlJsonPathSegment = (segment) => {
+  if (typeof segment === "number") {
+    return `[${renderMySqlJsonIndex(segment)}]`;
+  }
+  if (typeof segment === "object" && segment !== null && segment.kind === "index") {
+    return `[${renderMySqlJsonIndex(segment.index)}]`;
+  }
+  if (typeof segment === "object" && segment !== null && segment.kind === "slice") {
+    return `[${renderMySqlJsonIndex(segment.start ?? 0)} to ${segment.end === undefined ? "last" : renderMySqlJsonIndex(segment.end)}]`;
+  }
+  if (typeof segment === "object" && segment !== null && segment.kind === "descend") {
+    return "**";
+  }
+  return renderJsonPathSegment(segment);
+};
+var renderJsonPathStringLiteral = (segments, renderSegment = renderJsonPathSegment) => {
   let path2 = "$";
   for (const segment of segments) {
-    path2 += renderJsonPathSegment(segment);
+    path2 += renderSegment(segment);
   }
   return path2;
 };
-var renderMySqlJsonPath = (segments, state, dialect) => dialect.renderLiteral(renderJsonPathStringLiteral(segments), state);
+var renderMySqlJsonPath = (segments, state, dialect) => dialect.renderLiteral(renderJsonPathStringLiteral(segments, renderMySqlJsonPathSegment), state);
+var isJsonArrayIndexSegment = (segment) => typeof segment === "number" || typeof segment === "object" && segment !== null && segment.kind === "index";
+var renderMySqlJsonInsertPath = (segments, insertAfter, state, dialect) => {
+  if (!insertAfter || segments.length === 0) {
+    return renderMySqlJsonPath(segments, state, dialect);
+  }
+  const last = segments[segments.length - 1];
+  const nextSegments = segments.slice(0, -1);
+  if (typeof last === "number") {
+    return renderMySqlJsonPath([...nextSegments, last + 1], state, dialect);
+  }
+  if (typeof last === "object" && last !== null && last.kind === "index") {
+    return renderMySqlJsonPath([...nextSegments, { ...last, index: last.index + 1 }], state, dialect);
+  }
+  return renderMySqlJsonPath(segments, state, dialect);
+};
 var renderPostgresJsonPathArray = (segments, state, dialect) => `array[${segments.map((segment) => {
   if (typeof segment === "string") {
     return dialect.renderLiteral(segment, state);
@@ -114935,21 +116061,61 @@ var renderPostgresJsonAccessStep = (segment, textMode, state, dialect) => {
   }
 };
 var renderPostgresJsonValue = (value, state, dialect) => {
-  if (!isExpression3(value)) {
+  if (!isExpression4(value)) {
     throw new Error("Expected a JSON expression");
   }
   const rendered = renderExpression(value, state, dialect);
   return value[TypeId].dbType.kind === "jsonb" ? rendered : `cast(${rendered} as jsonb)`;
 };
+var expressionDriverContext = (expression, state, dialect) => ({
+  dialect: dialect.name,
+  valueMappings: state.valueMappings,
+  dbType: expression[TypeId].dbType,
+  runtimeSchema: expression[TypeId].runtimeSchema,
+  driverValueMapping: expression[TypeId].driverValueMapping
+});
+var renderMySqlStructuredJsonLiteral = (expression, state) => {
+  const ast = expression[TypeId2];
+  if (ast.kind !== "literal" || ast.value === null || typeof ast.value !== "object") {
+    return;
+  }
+  state.params.push(JSON.stringify(ast.value));
+  return "cast(? as json)";
+};
+var renderJsonInputExpression = (expression, state, dialect) => {
+  if (dialect.name === "mysql") {
+    const jsonLiteral = renderMySqlStructuredJsonLiteral(expression, state);
+    if (jsonLiteral !== undefined) {
+      return jsonLiteral;
+    }
+  }
+  return renderJsonSelectSql(renderExpression(expression, state, dialect), expressionDriverContext(expression, state, dialect));
+};
+var encodeArrayValues = (values2, column2, state, dialect) => values2.map((value) => {
+  if (value === null && column2.metadata.nullable) {
+    return null;
+  }
+  const runtimeSchemaAccepts = column2.schema !== undefined && Schema10.is(column2.schema)(value);
+  const normalizedValue = runtimeSchemaAccepts ? value : normalizeDbValue(column2.metadata.dbType, value);
+  const encodedValue = column2.schema === undefined || runtimeSchemaAccepts ? normalizedValue : Schema10.decodeUnknownSync(column2.schema)(normalizedValue);
+  return toDriverValue(encodedValue, {
+    dialect: dialect.name,
+    valueMappings: state.valueMappings,
+    dbType: column2.metadata.dbType,
+    runtimeSchema: column2.schema,
+    driverValueMapping: column2.metadata.driverValueMapping
+  });
+});
 var renderPostgresJsonKind = (value) => value[TypeId].dbType.kind === "jsonb" ? "jsonb" : "json";
 var renderJsonOpaquePath = (value, state, dialect) => {
   if (isJsonPathValue2(value)) {
-    return dialect.renderLiteral(renderJsonPathStringLiteral(value.segments), state);
+    const renderSegment = dialect.name === "mysql" ? renderMySqlJsonPathSegment : renderJsonPathSegment;
+    return dialect.renderLiteral(renderJsonPathStringLiteral(value.segments, renderSegment), state);
   }
   if (typeof value === "string") {
     return dialect.renderLiteral(value, state);
   }
-  if (isExpression3(value)) {
+  if (isExpression4(value)) {
     return renderExpression(value, state, dialect);
   }
   throw new Error("Unsupported SQL/JSON path input");
@@ -114967,7 +116133,7 @@ var renderFunctionCall = (name, args, state, dialect) => {
     if (source === undefined) {
       throw new Error("Unsupported SQL extract expression");
     }
-    const fieldRuntime = isExpression3(field) && field[TypeId].dbType.kind === "text" && typeof field[TypeId].runtime === "string" ? field[TypeId].runtime : undefined;
+    const fieldRuntime = isExpression4(field) && field[TypeId].dbType.kind === "text" && typeof field[TypeId].runtime === "string" ? field[TypeId].runtime : undefined;
     const renderedField = fieldRuntime ?? renderExpression(field, state, dialect);
     return `extract(${renderedField} from ${renderExpression(source, state, dialect)})`;
   }
@@ -115005,7 +116171,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     case "jsonPathText":
     case "jsonAccessText":
     case "jsonTraverseText": {
-      if (!isExpression3(base) || segments.length === 0) {
+      if (!isExpression4(base) || segments.length === 0) {
         return;
       }
       const baseSql = renderExpression(base, state, dialect);
@@ -115028,7 +116194,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     case "jsonKeyExists":
     case "jsonHasAnyKeys":
     case "jsonHasAllKeys": {
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       const baseSql = dialect.name === "postgres" ? renderPostgresJsonValue(base, state, dialect) : renderExpression(base, state, dialect);
@@ -115047,21 +116213,22 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       if (dialect.name === "mysql") {
         const mode = kind === "jsonHasAllKeys" ? "all" : "one";
+        const modeSql = dialect.renderLiteral(mode, state);
         const paths = keys.map((segment) => renderMySqlJsonPath([segment], state, dialect)).join(", ");
-        return `json_contains_path(${baseSql}, ${dialect.renderLiteral(mode, state)}, ${paths})`;
+        return `json_contains_path(${baseSql}, ${modeSql}, ${paths})`;
       }
       return;
     }
     case "jsonConcat":
     case "jsonMerge": {
-      if (!isExpression3(ast.left) || !isExpression3(ast.right)) {
+      if (!isExpression4(ast.left) || !isExpression4(ast.right)) {
         return;
       }
       if (dialect.name === "postgres") {
         return `(${renderPostgresJsonValue(ast.left, state, dialect)} || ${renderPostgresJsonValue(ast.right, state, dialect)})`;
       }
       if (dialect.name === "mysql") {
-        return `json_merge_preserve(${renderExpression(ast.left, state, dialect)}, ${renderExpression(ast.right, state, dialect)})`;
+        return `json_merge_preserve(${renderJsonInputExpression(ast.left, state, dialect)}, ${renderJsonInputExpression(ast.right, state, dialect)})`;
       }
       return;
     }
@@ -115069,7 +116236,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       const entries = Array.isArray(ast.entries) ? ast.entries : [];
       const renderedEntries = entries.flatMap((entry) => [
         dialect.renderLiteral(entry.key, state),
-        renderExpression(entry.value, state, dialect)
+        renderJsonInputExpression(entry.value, state, dialect)
       ]);
       if (dialect.name === "postgres") {
         return `${postgresExpressionKind === "jsonb" ? "jsonb" : "json"}_build_object(${renderedEntries.join(", ")})`;
@@ -115081,7 +116248,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     }
     case "jsonBuildArray": {
       const values2 = Array.isArray(ast.values) ? ast.values : [];
-      const renderedValues = values2.map((value) => renderExpression(value, state, dialect)).join(", ");
+      const renderedValues = values2.map((value) => renderJsonInputExpression(value, state, dialect)).join(", ");
       if (dialect.name === "postgres") {
         return `${postgresExpressionKind === "jsonb" ? "jsonb" : "json"}_build_array(${renderedValues})`;
       }
@@ -115091,29 +116258,29 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       return;
     }
     case "jsonToJson":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
-        return `to_json(${renderExpression(base, state, dialect)})`;
+        return `to_json(${renderJsonInputExpression(base, state, dialect)})`;
       }
       if (dialect.name === "mysql") {
-        return `cast(${renderExpression(base, state, dialect)} as json)`;
+        return renderMySqlStructuredJsonLiteral(base, state) ?? `cast(${renderExpression(base, state, dialect)} as json)`;
       }
       return;
     case "jsonToJsonb":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
-        return `to_jsonb(${renderExpression(base, state, dialect)})`;
+        return `to_jsonb(${renderJsonInputExpression(base, state, dialect)})`;
       }
       if (dialect.name === "mysql") {
-        return `cast(${renderExpression(base, state, dialect)} as json)`;
+        return renderMySqlStructuredJsonLiteral(base, state) ?? `cast(${renderExpression(base, state, dialect)} as json)`;
       }
       return;
     case "jsonTypeOf":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -115125,7 +116292,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonLength":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -115140,7 +116307,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonKeys":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -115154,7 +116321,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonStripNulls":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -115165,7 +116332,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     case "jsonDelete":
     case "jsonDeletePath":
     case "jsonRemove": {
-      if (!isExpression3(base) || segments.length === 0) {
+      if (!isExpression4(base) || segments.length === 0) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -115177,17 +116344,17 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
         return `(${baseSql} #- ${renderPostgresJsonPathArray(segments, state, dialect)})`;
       }
       if (dialect.name === "mysql") {
-        return `json_remove(${renderExpression(base, state, dialect)}, ${segments.map((segment) => renderMySqlJsonPath([segment], state, dialect)).join(", ")})`;
+        return `json_remove(${renderExpression(base, state, dialect)}, ${renderMySqlJsonPath(segments, state, dialect)})`;
       }
       return;
     }
     case "jsonSet":
     case "jsonInsert": {
-      if (!isExpression3(base) || segments.length === 0) {
+      if (!isExpression4(base) || segments.length === 0) {
         return;
       }
       const nextValue = extractJsonValue(ast);
-      if (!isExpression3(nextValue)) {
+      if (!isExpression4(nextValue)) {
         return;
       }
       const createMissing = ast.createMissing === true;
@@ -115198,13 +116365,21 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
         return `${functionName}(${renderPostgresJsonValue(base, state, dialect)}, ${renderPostgresJsonPathArray(segments, state, dialect)}, ${renderPostgresJsonValue(nextValue, state, dialect)}${extra})`;
       }
       if (dialect.name === "mysql") {
-        const functionName = kind === "jsonInsert" ? "json_insert" : "json_set";
-        return `${functionName}(${renderExpression(base, state, dialect)}, ${renderMySqlJsonPath(segments, state, dialect)}, ${renderExpression(nextValue, state, dialect)})`;
+        const renderedBase = renderExpression(base, state, dialect);
+        if (kind === "jsonInsert" && isJsonArrayIndexSegment(segments[segments.length - 1])) {
+          const renderedPath2 = renderMySqlJsonInsertPath(segments, insertAfter, state, dialect);
+          const renderedValue2 = renderJsonInputExpression(nextValue, state, dialect);
+          return `json_array_insert(${renderedBase}, ${renderedPath2}, ${renderedValue2})`;
+        }
+        const functionName = kind === "jsonInsert" ? "json_insert" : createMissing ? "json_set" : "json_replace";
+        const renderedPath = renderMySqlJsonPath(segments, state, dialect);
+        const renderedValue = renderJsonInputExpression(nextValue, state, dialect);
+        return `${functionName}(${renderedBase}, ${renderedPath}, ${renderedValue})`;
       }
       return;
     }
     case "jsonPathExists": {
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       const path2 = ast.path ?? ast.query ?? ast.right;
@@ -115220,7 +116395,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       return;
     }
     case "jsonPathMatch": {
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       const path2 = ast.path ?? ast.query ?? ast.right;
@@ -115251,23 +116426,15 @@ var renderMysqlMutationLock = (lock2, statement) => {
   if (!lock2) {
     return "";
   }
-  switch (lock2.mode) {
-    case "lowPriority":
-      return " low_priority";
-    case "ignore":
-      return " ignore";
-    case "quick":
-      return statement === "delete" ? " quick" : "";
-    default:
-      return "";
-  }
+  return renderMysqlMutationLockMode(lock2.mode, statement);
 };
 var renderTransactionClause = (clause, dialect) => {
   switch (clause.kind) {
     case "transaction": {
       const modes = [];
-      if (clause.isolationLevel) {
-        modes.push(`isolation level ${clause.isolationLevel}`);
+      const isolationLevel = renderTransactionIsolationLevel(clause.isolationLevel);
+      if (isolationLevel) {
+        modes.push(isolationLevel);
       }
       if (clause.readOnly === true) {
         modes.push("read only");
@@ -115285,21 +116452,101 @@ var renderTransactionClause = (clause, dialect) => {
     case "releaseSavepoint":
       return `release savepoint ${dialect.quoteIdentifier(clause.name)}`;
   }
-  return "";
+  throw new Error("Unsupported transaction statement kind");
 };
 var renderSelectionList = (selection, state, dialect, validateAggregation) => {
   if (validateAggregation) {
     validateAggregationSelection(selection, []);
   }
   const flattened = flattenSelection(selection);
+  if (dialect.name === "mysql" && flattened.length === 0) {
+    throw new Error("mysql select statements require at least one selected expression");
+  }
   const projections = selectionProjections(selection);
-  const sql = flattened.map(({ expression, alias: alias2 }) => `${renderExpression(expression, state, dialect)} as ${dialect.quoteIdentifier(alias2)}`).join(", ");
+  const sql = flattened.map(({ expression, alias: alias2 }) => `${renderSelectSql(renderExpression(expression, state, dialect), expressionDriverContext(expression, state, dialect))} as ${dialect.quoteIdentifier(alias2)}`).join(", ");
   return {
     sql,
     projections
   };
 };
-var renderQueryAst = (ast, state, dialect) => {
+var nestedRenderState = (state) => ({
+  params: state.params,
+  valueMappings: state.valueMappings,
+  ctes: [],
+  cteNames: new Set(state.cteNames),
+  cteSources: new Map(state.cteSources)
+});
+var assertMatchingSetProjections = (left, right) => {
+  const leftKeys = left.map((projection) => JSON.stringify(projection.path));
+  const rightKeys = right.map((projection) => JSON.stringify(projection.path));
+  if (leftKeys.length !== rightKeys.length || leftKeys.some((key2, index4) => key2 !== rightKeys[index4])) {
+    throw new Error("set operator operands must have matching result rows");
+  }
+};
+var assertNoGroupedMutationClauses = (ast, statement) => {
+  if (ast.groupBy.length > 0) {
+    throw new Error(`groupBy(...) is not supported for ${statement} statements`);
+  }
+  if (ast.having.length > 0) {
+    throw new Error(`having(...) is not supported for ${statement} statements`);
+  }
+};
+var assertNoInsertQueryClauses = (ast) => {
+  if (ast.where.length > 0) {
+    throw new Error("where(...) is not supported for insert statements");
+  }
+  if (ast.joins.length > 0) {
+    throw new Error("join(...) is not supported for insert statements");
+  }
+  if (ast.orderBy.length > 0) {
+    throw new Error("orderBy(...) is not supported for insert statements");
+  }
+  if (ast.limit) {
+    throw new Error("limit(...) is not supported for insert statements");
+  }
+  if (ast.offset) {
+    throw new Error("offset(...) is not supported for insert statements");
+  }
+  if (ast.lock) {
+    throw new Error("lock(...) is not supported for insert statements");
+  }
+};
+var assertNoStatementQueryClauses = (ast, statement, options2 = {}) => {
+  if (ast.distinct) {
+    throw new Error(`distinct(...) is not supported for ${statement} statements`);
+  }
+  if (ast.where.length > 0) {
+    throw new Error(`where(...) is not supported for ${statement} statements`);
+  }
+  if ((ast.fromSources?.length ?? 0) > 0 || ast.from) {
+    throw new Error(`from(...) is not supported for ${statement} statements`);
+  }
+  if (ast.joins.length > 0) {
+    throw new Error(`join(...) is not supported for ${statement} statements`);
+  }
+  if (ast.groupBy.length > 0) {
+    throw new Error(`groupBy(...) is not supported for ${statement} statements`);
+  }
+  if (ast.having.length > 0) {
+    throw new Error(`having(...) is not supported for ${statement} statements`);
+  }
+  if (ast.orderBy.length > 0) {
+    throw new Error(`orderBy(...) is not supported for ${statement} statements`);
+  }
+  if (ast.limit) {
+    throw new Error(`limit(...) is not supported for ${statement} statements`);
+  }
+  if (ast.offset) {
+    throw new Error(`offset(...) is not supported for ${statement} statements`);
+  }
+  if (ast.lock) {
+    throw new Error(`lock(...) is not supported for ${statement} statements`);
+  }
+  if (options2.allowSelection !== true && Object.keys(ast.select).length > 0) {
+    throw new Error(`returning(...) is not supported for ${statement} statements`);
+  }
+};
+var renderQueryAst = (ast, state, dialect, options2 = {}) => {
   let sql = "";
   let projections = [];
   switch (ast.kind) {
@@ -115307,13 +116554,17 @@ var renderQueryAst = (ast, state, dialect) => {
       validateAggregationSelection(ast.select, ast.groupBy);
       const rendered = renderSelectionList(ast.select, state, dialect, false);
       projections = rendered.projections;
+      const selectList = rendered.sql.length > 0 ? ` ${rendered.sql}` : "";
       const clauses = [
-        ast.distinctOn && ast.distinctOn.length > 0 ? `select distinct on (${ast.distinctOn.map((value) => renderExpression(value, state, dialect)).join(", ")}) ${rendered.sql}` : `select${ast.distinct ? " distinct" : ""} ${rendered.sql}`
+        ast.distinctOn && ast.distinctOn.length > 0 ? `select distinct on (${ast.distinctOn.map((value) => renderExpression(value, state, dialect)).join(", ")})${selectList}` : `select${ast.distinct ? " distinct" : ""}${selectList}`
       ];
       if (ast.from) {
         clauses.push(`from ${renderSourceReference(ast.from.source, ast.from.tableName, ast.from.baseTableName, state, dialect)}`);
       }
       for (const join2 of ast.joins) {
+        if (dialect.name === "mysql" && join2.kind === "full") {
+          throw new Error("Unsupported mysql full join");
+        }
         const source = renderSourceReference(join2.source, join2.tableName, join2.baseTableName, state, dialect);
         clauses.push(join2.kind === "cross" ? `cross join ${source}` : `${join2.kind} join ${source} on ${renderExpression(join2.on, state, dialect)}`);
       }
@@ -115336,19 +116587,25 @@ var renderQueryAst = (ast, state, dialect) => {
         clauses.push(`offset ${renderExpression(ast.offset, state, dialect)}`);
       }
       if (ast.lock) {
-        clauses.push(`${ast.lock.mode === "update" ? "for update" : "for share"}${ast.lock.nowait ? " nowait" : ""}${ast.lock.skipLocked ? " skip locked" : ""}`);
+        if (ast.lock.nowait && ast.lock.skipLocked) {
+          throw new Error("lock(...) cannot specify both nowait and skipLocked");
+        }
+        clauses.push(`${renderSelectLockMode(ast.lock.mode)}${ast.lock.nowait ? " nowait" : ""}${ast.lock.skipLocked ? " skip locked" : ""}`);
       }
       sql = clauses.join(" ");
       break;
     }
     case "set": {
       const setAst = ast;
+      assertNoStatementQueryClauses(setAst, "set", { allowSelection: true });
       const base = renderQueryAst(getAst(setAst.setBase), state, dialect);
       projections = selectionProjections(setAst.select);
+      assertMatchingSetProjections(projections, base.projections);
       sql = [
         `(${base.sql})`,
         ...(setAst.setOperations ?? []).map((entry) => {
           const rendered = renderQueryAst(getAst(entry.query), state, dialect);
+          assertMatchingSetProjections(projections, rendered.projections);
           return `${entry.kind}${entry.all ? " all" : ""} (${rendered.sql})`;
         })
       ].join(" ");
@@ -115356,28 +116613,40 @@ var renderQueryAst = (ast, state, dialect) => {
     }
     case "insert": {
       const insertAst = ast;
+      if (insertAst.distinct) {
+        throw new Error("distinct(...) is not supported for insert statements");
+      }
+      assertNoGroupedMutationClauses(insertAst, "insert");
+      assertNoInsertQueryClauses(insertAst);
       const targetSource = insertAst.into;
       const target = renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect);
+      const insertSource = expectInsertSourceKind(insertAst.insertSource);
+      const conflict = expectConflictClause(insertAst.conflict);
       sql = `insert into ${target}`;
-      if (insertAst.insertSource?.kind === "values") {
-        const columns = insertAst.insertSource.columns.map((column2) => dialect.quoteIdentifier(column2)).join(", ");
-        const rows = insertAst.insertSource.rows.map((row) => `(${row.values.map((entry) => renderExpression(entry.value, state, dialect)).join(", ")})`).join(", ");
+      if (insertSource?.kind === "values") {
+        const columns = insertSource.columns.map((column2) => dialect.quoteIdentifier(column2)).join(", ");
+        const rows = insertSource.rows.map((row) => `(${row.values.map((entry) => renderExpression(entry.value, state, dialect)).join(", ")})`).join(", ");
         sql += ` (${columns}) values ${rows}`;
-      } else if (insertAst.insertSource?.kind === "query") {
-        const columns = insertAst.insertSource.columns.map((column2) => dialect.quoteIdentifier(column2)).join(", ");
-        const renderedQuery = renderQueryAst(getAst(insertAst.insertSource.query), state, dialect);
+      } else if (insertSource?.kind === "query") {
+        const columns = insertSource.columns.map((column2) => dialect.quoteIdentifier(column2)).join(", ");
+        const renderedQuery = renderQueryAst(getAst(insertSource.query), state, dialect);
         sql += ` (${columns}) ${renderedQuery.sql}`;
-      } else if (insertAst.insertSource?.kind === "unnest") {
-        const unnestSource = insertAst.insertSource;
-        const columns = unnestSource.columns.map((column2) => dialect.quoteIdentifier(column2)).join(", ");
+      } else if (insertSource?.kind === "unnest") {
+        const columns = insertSource.columns.map((column2) => dialect.quoteIdentifier(column2)).join(", ");
         if (dialect.name === "postgres") {
           const table = targetSource.source;
           const fields2 = table[TypeId4].fields;
-          const rendered = unnestSource.values.map((entry) => `cast(${dialect.renderLiteral(entry.values, state)} as ${renderCastType(dialect, fields2[entry.columnName].metadata.dbType)}[])`).join(", ");
+          const rendered = insertSource.values.map((entry) => `cast(${dialect.renderLiteral(encodeArrayValues(entry.values, fields2[entry.columnName], state, dialect), state)} as ${renderCastType(dialect, fields2[entry.columnName].metadata.dbType)}[])`).join(", ");
           sql += ` (${columns}) select * from unnest(${rendered})`;
         } else {
-          const rowCount = unnestSource.values[0]?.values.length ?? 0;
-          const rows = Array.from({ length: rowCount }, (_, index4) => `(${unnestSource.values.map((entry) => dialect.renderLiteral(entry.values[index4], state)).join(", ")})`).join(", ");
+          const table = targetSource.source;
+          const fields2 = table[TypeId4].fields;
+          const encodedValues = insertSource.values.map((entry) => ({
+            columnName: entry.columnName,
+            values: encodeArrayValues(entry.values, fields2[entry.columnName], state, dialect)
+          }));
+          const rowCount = encodedValues[0]?.values.length ?? 0;
+          const rows = Array.from({ length: rowCount }, (_, index4) => `(${encodedValues.map((entry) => dialect.renderLiteral(entry.values[index4], state)).join(", ")})`).join(", ");
           sql += ` (${columns}) values ${rows}`;
         }
       } else {
@@ -115386,22 +116655,29 @@ var renderQueryAst = (ast, state, dialect) => {
         if ((insertAst.values ?? []).length > 0) {
           sql += ` (${columns}) values (${values2})`;
         } else {
-          sql += " default values";
+          sql += " () values ()";
         }
       }
-      if (insertAst.conflict) {
-        const updateValues = (insertAst.conflict.values ?? []).map((entry) => `${dialect.quoteIdentifier(entry.columnName)} = ${renderExpression(entry.value, state, dialect)}`).join(", ");
+      if (conflict) {
+        if (conflict.where) {
+          throw new Error("Unsupported mysql conflict action predicates");
+        }
+        const updateValues = (conflict.values ?? []).map((entry) => `${dialect.quoteIdentifier(entry.columnName)} = ${renderExpression(entry.value, state, dialect)}`).join(", ");
         if (dialect.name === "postgres") {
-          const targetSql = insertAst.conflict.target?.kind === "constraint" ? ` on conflict on constraint ${dialect.quoteIdentifier(insertAst.conflict.target.name)}` : insertAst.conflict.target?.kind === "columns" ? ` on conflict (${insertAst.conflict.target.columns.map((column2) => dialect.quoteIdentifier(column2)).join(", ")})${insertAst.conflict.target.where ? ` where ${renderExpression(insertAst.conflict.target.where, state, dialect)}` : ""}` : " on conflict";
+          const targetSql = conflict.target?.kind === "constraint" ? ` on conflict on constraint ${dialect.quoteIdentifier(conflict.target.name)}` : conflict.target?.kind === "columns" ? ` on conflict (${conflict.target.columns.map((column2) => dialect.quoteIdentifier(column2)).join(", ")})${conflict.target.where ? ` where ${renderExpression(conflict.target.where, state, dialect)}` : ""}` : " on conflict";
           sql += targetSql;
-          sql += insertAst.conflict.action === "doNothing" ? " do nothing" : ` do update set ${updateValues}${insertAst.conflict.where ? ` where ${renderExpression(insertAst.conflict.where, state, dialect)}` : ""}`;
-        } else if (insertAst.conflict.action === "doNothing") {
+          sql += conflict.action === "doNothing" ? " do nothing" : ` do update set ${updateValues}${conflict.where ? ` where ${renderExpression(conflict.where, state, dialect)}` : ""}`;
+        } else if (conflict.action === "doNothing") {
           sql = sql.replace(/^insert/, "insert ignore");
         } else {
           sql += ` on duplicate key update ${updateValues}`;
         }
       }
-      const returning2 = renderSelectionList(insertAst.select, state, dialect, false);
+      const hasReturning = Object.keys(insertAst.select).length > 0;
+      const returning2 = hasReturning ? renderSelectionList(insertAst.select, state, dialect, false) : { sql: "", projections: [] };
+      if (dialect.name === "mysql" && returning2.sql.length > 0) {
+        throw new Error("Unsupported mysql returning");
+      }
       projections = returning2.projections;
       if (returning2.sql.length > 0) {
         sql += ` returning ${returning2.sql}`;
@@ -115410,15 +116686,27 @@ var renderQueryAst = (ast, state, dialect) => {
     }
     case "update": {
       const updateAst = ast;
+      if (updateAst.distinct) {
+        throw new Error("distinct(...) is not supported for update statements");
+      }
+      assertNoGroupedMutationClauses(updateAst, "update");
+      if (updateAst.offset) {
+        throw new Error("offset(...) is not supported for update statements");
+      }
       const targetSource = updateAst.target;
       const target = renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect);
       const targets = updateAst.targets ?? [targetSource];
       const fromSources = updateAst.fromSources ?? [];
+      if ((updateAst.set ?? []).length === 0) {
+        throw new Error("update statements require at least one assignment");
+      }
       const assignments = updateAst.set.map((entry) => renderMutationAssignment(entry, state, dialect)).join(", ");
       if (dialect.name === "mysql") {
         const modifiers = renderMysqlMutationLock(updateAst.lock, "update");
         const extraSources = renderFromSources(fromSources, state, dialect);
-        const joinSources = updateAst.joins.map((join2) => join2.kind === "cross" ? `cross join ${renderSourceReference(join2.source, join2.tableName, join2.baseTableName, state, dialect)}` : `${join2.kind} join ${renderSourceReference(join2.source, join2.tableName, join2.baseTableName, state, dialect)} on ${renderExpression(join2.on, state, dialect)}`).join(" ");
+        const joinSources = updateAst.joins.map((join2) => join2.kind === "full" ? (() => {
+          throw new Error("Unsupported mysql full join");
+        })() : join2.kind === "cross" ? `cross join ${renderSourceReference(join2.source, join2.tableName, join2.baseTableName, state, dialect)}` : `${join2.kind} join ${renderSourceReference(join2.source, join2.tableName, join2.baseTableName, state, dialect)} on ${renderExpression(join2.on, state, dialect)}`).join(" ");
         const targetList = [
           ...targets.map((entry) => renderSourceReference(entry.source, entry.tableName, entry.baseTableName, state, dialect)),
           ...extraSources.length > 0 ? [extraSources] : []
@@ -115447,7 +116735,11 @@ var renderQueryAst = (ast, state, dialect) => {
       if (dialect.name === "mysql" && updateAst.limit) {
         sql += ` limit ${renderMysqlMutationLimit(updateAst.limit, state, dialect)}`;
       }
-      const returning2 = renderSelectionList(updateAst.select, state, dialect, false);
+      const hasReturning = Object.keys(updateAst.select).length > 0;
+      const returning2 = hasReturning ? renderSelectionList(updateAst.select, state, dialect, false) : { sql: "", projections: [] };
+      if (dialect.name === "mysql" && returning2.sql.length > 0) {
+        throw new Error("Unsupported mysql returning");
+      }
       projections = returning2.projections;
       if (returning2.sql.length > 0) {
         sql += ` returning ${returning2.sql}`;
@@ -115456,6 +116748,13 @@ var renderQueryAst = (ast, state, dialect) => {
     }
     case "delete": {
       const deleteAst = ast;
+      if (deleteAst.distinct) {
+        throw new Error("distinct(...) is not supported for delete statements");
+      }
+      assertNoGroupedMutationClauses(deleteAst, "delete");
+      if (deleteAst.offset) {
+        throw new Error("offset(...) is not supported for delete statements");
+      }
       const targetSource = deleteAst.target;
       const target = renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect);
       const targets = deleteAst.targets ?? [targetSource];
@@ -115464,7 +116763,9 @@ var renderQueryAst = (ast, state, dialect) => {
         const hasJoinedSources = deleteAst.joins.length > 0 || targets.length > 1;
         const targetList = renderDeleteTargets(targets, dialect);
         const fromSources = targets.map((entry) => renderSourceReference(entry.source, entry.tableName, entry.baseTableName, state, dialect)).join(", ");
-        const joinSources = deleteAst.joins.map((join2) => join2.kind === "cross" ? `cross join ${renderSourceReference(join2.source, join2.tableName, join2.baseTableName, state, dialect)}` : `${join2.kind} join ${renderSourceReference(join2.source, join2.tableName, join2.baseTableName, state, dialect)} on ${renderExpression(join2.on, state, dialect)}`).join(" ");
+        const joinSources = deleteAst.joins.map((join2) => join2.kind === "full" ? (() => {
+          throw new Error("Unsupported mysql full join");
+        })() : join2.kind === "cross" ? `cross join ${renderSourceReference(join2.source, join2.tableName, join2.baseTableName, state, dialect)}` : `${join2.kind} join ${renderSourceReference(join2.source, join2.tableName, join2.baseTableName, state, dialect)} on ${renderExpression(join2.on, state, dialect)}`).join(" ");
         sql = hasJoinedSources ? `delete${modifiers} ${targetList} from ${fromSources}${joinSources.length > 0 ? ` ${joinSources}` : ""}` : `delete${modifiers} from ${fromSources}`;
       } else {
         sql = `delete from ${target}`;
@@ -115485,7 +116786,11 @@ var renderQueryAst = (ast, state, dialect) => {
       if (dialect.name === "mysql" && deleteAst.limit) {
         sql += ` limit ${renderMysqlMutationLimit(deleteAst.limit, state, dialect)}`;
       }
-      const returning2 = renderSelectionList(deleteAst.select, state, dialect, false);
+      const hasReturning = Object.keys(deleteAst.select).length > 0;
+      const returning2 = hasReturning ? renderSelectionList(deleteAst.select, state, dialect, false) : { sql: "", projections: [] };
+      if (dialect.name === "mysql" && returning2.sql.length > 0) {
+        throw new Error("Unsupported mysql returning");
+      }
       projections = returning2.projections;
       if (returning2.sql.length > 0) {
         sql += ` returning ${returning2.sql}`;
@@ -115494,12 +116799,17 @@ var renderQueryAst = (ast, state, dialect) => {
     }
     case "truncate": {
       const truncateAst = ast;
+      assertNoStatementQueryClauses(truncateAst, "truncate");
+      const truncate2 = expectTruncateClause(truncateAst.truncate);
       const targetSource = truncateAst.target;
+      if (dialect.name === "mysql" && (truncate2.restartIdentity || truncate2.cascade)) {
+        throw new Error("Unsupported mysql truncate options");
+      }
       sql = `truncate table ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)}`;
-      if (truncateAst.truncate?.restartIdentity) {
+      if (truncate2.restartIdentity) {
         sql += " restart identity";
       }
-      if (truncateAst.truncate?.cascade) {
+      if (truncate2.cascade) {
         sql += " cascade";
       }
       break;
@@ -115512,6 +116822,9 @@ var renderQueryAst = (ast, state, dialect) => {
       const targetSource = mergeAst.target;
       const usingSource = mergeAst.using;
       const merge2 = mergeAst.merge;
+      if (Object.keys(mergeAst.select).length > 0) {
+        throw new Error("returning(...) is not supported for merge statements");
+      }
       sql = `merge into ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} using ${renderSourceReference(usingSource.source, usingSource.tableName, usingSource.baseTableName, state, dialect)} on ${renderExpression(merge2.on, state, dialect)}`;
       if (merge2.whenMatched) {
         sql += " when matched";
@@ -115539,32 +116852,40 @@ var renderQueryAst = (ast, state, dialect) => {
     case "savepoint":
     case "rollbackTo":
     case "releaseSavepoint": {
+      assertNoStatementQueryClauses(ast, ast.kind);
       sql = renderTransactionClause(ast.transaction, dialect);
       break;
     }
     case "createTable": {
       const createTableAst = ast;
-      sql = renderCreateTableSql(createTableAst.target, state, dialect, createTableAst.ddl?.kind === "createTable" && createTableAst.ddl.ifNotExists);
+      assertNoStatementQueryClauses(createTableAst, "createTable");
+      const ddl = expectDdlClauseKind(createTableAst.ddl, "createTable");
+      sql = renderCreateTableSql(createTableAst.target, state, dialect, ddl.ifNotExists);
       break;
     }
     case "dropTable": {
       const dropTableAst = ast;
-      const ifExists = dropTableAst.ddl?.kind === "dropTable" && dropTableAst.ddl.ifExists;
-      sql = `drop table${ifExists ? " if exists" : ""} ${renderSourceReference(dropTableAst.target.source, dropTableAst.target.tableName, dropTableAst.target.baseTableName, state, dialect)}`;
+      assertNoStatementQueryClauses(dropTableAst, "dropTable");
+      const ddl = expectDdlClauseKind(dropTableAst.ddl, "dropTable");
+      sql = `drop table${ddl.ifExists ? " if exists" : ""} ${renderSourceReference(dropTableAst.target.source, dropTableAst.target.tableName, dropTableAst.target.baseTableName, state, dialect)}`;
       break;
     }
     case "createIndex": {
       const createIndexAst = ast;
-      sql = renderCreateIndexSql(createIndexAst.target, createIndexAst.ddl, state, dialect);
+      assertNoStatementQueryClauses(createIndexAst, "createIndex");
+      sql = renderCreateIndexSql(createIndexAst.target, expectDdlClauseKind(createIndexAst.ddl, "createIndex"), state, dialect);
       break;
     }
     case "dropIndex": {
       const dropIndexAst = ast;
-      sql = renderDropIndexSql(dropIndexAst.target, dropIndexAst.ddl, state, dialect);
+      assertNoStatementQueryClauses(dropIndexAst, "dropIndex");
+      sql = renderDropIndexSql(dropIndexAst.target, expectDdlClauseKind(dropIndexAst.ddl, "dropIndex"), state, dialect);
       break;
     }
+    default:
+      throw new Error("Unsupported query statement kind");
   }
-  if (state.ctes.length === 0) {
+  if (state.ctes.length === 0 || options2.emitCtes === false) {
     return {
       sql,
       projections
@@ -115587,9 +116908,22 @@ var renderSourceReference = (source, tableName, baseTableName, state, dialect) =
   };
   if (typeof source === "object" && source !== null && "kind" in source && source.kind === "cte") {
     const cte = source;
+    const registeredCteSource = state.cteSources.get(cte.name);
+    if (registeredCteSource !== undefined && registeredCteSource !== cte.plan) {
+      throw new Error(`common table expression name is already registered with a different plan: ${cte.name}`);
+    }
     if (!state.cteNames.has(cte.name)) {
       state.cteNames.add(cte.name);
-      const rendered = renderQueryAst(getAst(cte.plan), state, dialect);
+      state.cteSources.set(cte.name, cte.plan);
+      const statement = getQueryState(cte.plan).statement;
+      if (statement !== "select" && statement !== "set") {
+        const cteAst = getAst(cte.plan);
+        if (Object.keys(cteAst.select ?? {}).length > 0) {
+          throw new Error("Unsupported mysql returning");
+        }
+        throw new Error("Unsupported mysql data-modifying cte");
+      }
+      const rendered = renderQueryAst(getAst(cte.plan), state, dialect, { emitCtes: false });
       state.ctes.push({
         name: cte.name,
         sql: rendered.sql,
@@ -115601,11 +116935,11 @@ var renderSourceReference = (source, tableName, baseTableName, state, dialect) =
   if (typeof source === "object" && source !== null && "kind" in source && source.kind === "derived") {
     const derived = source;
     if (!state.cteNames.has(derived.name)) {}
-    return `(${renderQueryAst(getAst(derived.plan), state, dialect).sql}) as ${dialect.quoteIdentifier(derived.name)}`;
+    return `(${renderQueryAst(getAst(derived.plan), nestedRenderState(state), dialect).sql}) as ${dialect.quoteIdentifier(derived.name)}`;
   }
   if (typeof source === "object" && source !== null && "kind" in source && source.kind === "lateral") {
     const lateral2 = source;
-    return `lateral (${renderQueryAst(getAst(lateral2.plan), state, dialect).sql}) as ${dialect.quoteIdentifier(lateral2.name)}`;
+    return `lateral (${renderQueryAst(getAst(lateral2.plan), nestedRenderState(state), dialect).sql}) as ${dialect.quoteIdentifier(lateral2.name)}`;
   }
   if (typeof source === "object" && source !== null && source.kind === "values") {
     const values2 = source;
@@ -115626,6 +116960,13 @@ var renderSourceReference = (source, tableName, baseTableName, state, dialect) =
   const schemaName = typeof source === "object" && source !== null && TypeId4 in source ? source[TypeId4].schemaName : undefined;
   return dialect.renderTableReference(tableName, baseTableName, schemaName);
 };
+var renderSubqueryExpressionPlan = (plan, state, dialect) => {
+  const statement = getQueryState(plan).statement;
+  if (statement !== "select" && statement !== "set") {
+    throw new Error("subquery expressions only accept select-like query plans");
+  }
+  return renderQueryAst(getAst(plan), state, dialect).sql;
+};
 var renderExpression = (expression, state, dialect) => {
   const rawAst = expression[TypeId2];
   const jsonSql = renderJsonExpression(expression, rawAst, state, dialect);
@@ -115636,9 +116977,12 @@ var renderExpression = (expression, state, dialect) => {
   const renderComparisonOperator = (operator) => operator === "eq" ? "=" : operator === "neq" ? "<>" : operator === "lt" ? "<" : operator === "lte" ? "<=" : operator === "gt" ? ">" : ">=";
   switch (ast.kind) {
     case "column":
-      return ast.tableName.length === 0 ? dialect.quoteIdentifier(ast.columnName) : `${dialect.quoteIdentifier(ast.tableName)}.${dialect.quoteIdentifier(ast.columnName)}`;
+      return state.rowLocalColumns || ast.tableName.length === 0 ? dialect.quoteIdentifier(ast.columnName) : `${dialect.quoteIdentifier(ast.tableName)}.${dialect.quoteIdentifier(ast.columnName)}`;
     case "literal":
-      return dialect.renderLiteral(ast.value, state);
+      if (typeof ast.value === "number" && !Number.isFinite(ast.value)) {
+        throw new Error("Expected a finite numeric value");
+      }
+      return dialect.renderLiteral(ast.value, state, expression[TypeId]);
     case "excluded":
       return dialect.name === "mysql" ? `values(${dialect.quoteIdentifier(ast.columnName)})` : `excluded.${dialect.quoteIdentifier(ast.columnName)}`;
     case "cast":
@@ -115680,7 +117024,7 @@ var renderExpression = (expression, state, dialect) => {
         return `(${left} @> ${right})`;
       }
       if (dialect.name === "mysql" && isJsonExpression(ast.left) && isJsonExpression(ast.right)) {
-        return `json_contains(${renderExpression(ast.left, state, dialect)}, ${renderExpression(ast.right, state, dialect)})`;
+        return `json_contains(${renderJsonInputExpression(ast.left, state, dialect)}, ${renderJsonInputExpression(ast.right, state, dialect)})`;
       }
       throw new Error("Unsupported container operator for SQL rendering");
     case "containedBy":
@@ -115690,7 +117034,7 @@ var renderExpression = (expression, state, dialect) => {
         return `(${left} <@ ${right})`;
       }
       if (dialect.name === "mysql" && isJsonExpression(ast.left) && isJsonExpression(ast.right)) {
-        return `json_contains(${renderExpression(ast.right, state, dialect)}, ${renderExpression(ast.left, state, dialect)})`;
+        return `json_contains(${renderJsonInputExpression(ast.right, state, dialect)}, ${renderJsonInputExpression(ast.left, state, dialect)})`;
       }
       throw new Error("Unsupported container operator for SQL rendering");
     case "overlaps":
@@ -115700,7 +117044,7 @@ var renderExpression = (expression, state, dialect) => {
         return `(${left} && ${right})`;
       }
       if (dialect.name === "mysql" && isJsonExpression(ast.left) && isJsonExpression(ast.right)) {
-        return `json_overlaps(${renderExpression(ast.left, state, dialect)}, ${renderExpression(ast.right, state, dialect)})`;
+        return `json_overlaps(${renderJsonInputExpression(ast.left, state, dialect)}, ${renderJsonInputExpression(ast.right, state, dialect)})`;
       }
       throw new Error("Unsupported container operator for SQL rendering");
     case "isNull":
@@ -115720,14 +117064,26 @@ var renderExpression = (expression, state, dialect) => {
     case "min":
       return `min(${renderExpression(ast.value, state, dialect)})`;
     case "and":
+      if (ast.values.length === 0) {
+        throw new Error("and(...) requires at least one predicate");
+      }
       return `(${ast.values.map((value) => renderExpression(value, state, dialect)).join(" and ")})`;
     case "or":
+      if (ast.values.length === 0) {
+        throw new Error("or(...) requires at least one predicate");
+      }
       return `(${ast.values.map((value) => renderExpression(value, state, dialect)).join(" or ")})`;
     case "coalesce":
       return `coalesce(${ast.values.map((value) => renderExpression(value, state, dialect)).join(", ")})`;
     case "in":
+      if (ast.values.length < 2) {
+        throw new Error("in(...) requires at least one candidate value");
+      }
       return `(${renderExpression(ast.values[0], state, dialect)} in (${ast.values.slice(1).map((value) => renderExpression(value, state, dialect)).join(", ")}))`;
     case "notIn":
+      if (ast.values.length < 2) {
+        throw new Error("notIn(...) requires at least one candidate value");
+      }
       return `(${renderExpression(ast.values[0], state, dialect)} not in (${ast.values.slice(1).map((value) => renderExpression(value, state, dialect)).join(", ")}))`;
     case "between":
       return `(${renderExpression(ast.values[0], state, dialect)} between ${renderExpression(ast.values[1], state, dialect)} and ${renderExpression(ast.values[2], state, dialect)})`;
@@ -115736,15 +117092,15 @@ var renderExpression = (expression, state, dialect) => {
     case "case":
       return `case ${ast.branches.map((branch) => `when ${renderExpression(branch.when, state, dialect)} then ${renderExpression(branch.then, state, dialect)}`).join(" ")} else ${renderExpression(ast.else, state, dialect)} end`;
     case "exists":
-      return `exists (${renderQueryAst(getAst(ast.plan), state, dialect).sql})`;
+      return `exists (${renderSubqueryExpressionPlan(ast.plan, state, dialect)})`;
     case "scalarSubquery":
-      return `(${renderQueryAst(getAst(ast.plan), state, dialect).sql})`;
+      return `(${renderSubqueryExpressionPlan(ast.plan, state, dialect)})`;
     case "inSubquery":
-      return `(${renderExpression(ast.left, state, dialect)} in (${renderQueryAst(getAst(ast.plan), state, dialect).sql}))`;
+      return `(${renderExpression(ast.left, state, dialect)} in (${renderSubqueryExpressionPlan(ast.plan, state, dialect)}))`;
     case "comparisonAny":
-      return `(${renderExpression(ast.left, state, dialect)} ${renderComparisonOperator(ast.operator)} any (${renderQueryAst(getAst(ast.plan), state, dialect).sql}))`;
+      return `(${renderExpression(ast.left, state, dialect)} ${renderComparisonOperator(ast.operator)} any (${renderSubqueryExpressionPlan(ast.plan, state, dialect)}))`;
     case "comparisonAll":
-      return `(${renderExpression(ast.left, state, dialect)} ${renderComparisonOperator(ast.operator)} all (${renderQueryAst(getAst(ast.plan), state, dialect).sql}))`;
+      return `(${renderExpression(ast.left, state, dialect)} ${renderComparisonOperator(ast.operator)} all (${renderSubqueryExpressionPlan(ast.plan, state, dialect)}))`;
     case "window": {
       if (!Array.isArray(ast.partitionBy) || !Array.isArray(ast.orderBy) || typeof ast.function !== "string") {
         break;
@@ -115774,17 +117130,20 @@ var renderExpression = (expression, state, dialect) => {
 };
 
 // src/mysql/internal/renderer.ts
-var renderMysqlPlan = (plan) => {
+var renderMysqlPlan = (plan, options2 = {}) => {
   const state = {
     params: [],
+    valueMappings: options2.valueMappings,
     ctes: [],
-    cteNames: new Set
+    cteNames: new Set,
+    cteSources: new Map
   };
   const rendered = renderQueryAst(getAst(plan), state, mysqlDialect);
   return {
     sql: rendered.sql,
     params: state.params,
-    projections: rendered.projections
+    projections: rendered.projections,
+    valueMappings: state.valueMappings
   };
 };
 
@@ -115794,12 +117153,12 @@ var withSavepoint2 = withSavepoint;
 function driver2(executeOrHandlers) {
   return driver("mysql", executeOrHandlers);
 }
-var fromDriver = (renderer, sqlDriver, driverMode = "raw") => ({
+var fromDriver = (renderer, sqlDriver, driverMode = "raw", valueMappings) => ({
   dialect: "mysql",
   execute(plan) {
     const rendered = renderer.render(plan);
     return Effect2.mapError(Effect2.flatMap(sqlDriver.execute(rendered), (rows) => Effect2.try({
-      try: () => decodeRows(rendered, plan, rows, { driverMode }),
+      try: () => decodeRows(rendered, plan, rows, { driverMode, valueMappings }),
       catch: (error) => error
     })), (error) => {
       if (typeof error === "object" && error !== null && "_tag" in error && error._tag === "RowDecodeError") {
@@ -115812,7 +117171,7 @@ var fromDriver = (renderer, sqlDriver, driverMode = "raw") => ({
   stream(plan) {
     const rendered = renderer.render(plan);
     return Stream2.mapError(Stream2.mapChunksEffect(sqlDriver.stream(rendered), (rows) => Effect2.try({
-      try: () => decodeChunk(rendered, plan, rows, { driverMode }),
+      try: () => decodeChunk(rendered, plan, rows, { driverMode, valueMappings }),
       catch: (error) => error
     })), (error) => {
       if (typeof error === "object" && error !== null && "_tag" in error && error._tag === "RowDecodeError") {
@@ -115829,9 +117188,9 @@ var sqlClientDriver = () => driver2({
 });
 function make6(options2 = {}) {
   if (options2.driver) {
-    return fromDriver(options2.renderer ?? make5("mysql", renderMysqlPlan), options2.driver, options2.driverMode);
+    return fromDriver(options2.renderer ?? make5("mysql", (plan) => renderMysqlPlan(plan, { valueMappings: options2.valueMappings })), options2.driver, options2.driverMode, options2.valueMappings);
   }
-  return fromDriver(options2.renderer ?? make5("mysql", renderMysqlPlan), sqlClientDriver(), options2.driverMode);
+  return fromDriver(options2.renderer ?? make5("mysql", (plan) => renderMysqlPlan(plan, { valueMappings: options2.valueMappings })), sqlClientDriver(), options2.driverMode, options2.valueMappings);
 }
 var custom3 = (execute) => make4("mysql", execute);
 // src/mysql/query.ts
@@ -115946,10 +117305,13 @@ var TypeId10 = TypeId4;
 var OptionsSymbol2 = OptionsSymbol;
 var options2 = options;
 var make7 = (name, fields2, schemaName = undefined) => make2(name, fields2, schemaName);
-var schema4 = (schemaName) => ({
-  schemaName,
-  table: (name, fields2, ...declaredOptions) => schema3(schemaName).table(name, fields2, ...declaredOptions)
-});
+var schema4 = (schemaName) => {
+  const table = (name, fields2, ...declaredOptions) => schema3(schemaName).table(name, fields2, ...declaredOptions);
+  return {
+    schemaName,
+    table
+  };
+};
 var alias2 = (table, aliasName) => alias(table, aliasName);
 var Class2 = (name, schemaName = undefined) => {
   const base = Class(name, schemaName);
@@ -115967,7 +117329,7 @@ __export(exports_renderer2, {
   make: () => make8,
   TypeId: () => TypeId8
 });
-var make8 = () => make5("mysql", renderMysqlPlan);
+var make8 = (options3 = {}) => make5("mysql", (plan) => renderMysqlPlan(plan, options3));
 var mysql = make8();
 export {
   exports_table2 as Table,