effect-qb 0.16.0 → 4.0.0-beta.66

package/dist/mysql.js

@@ -311,20 +311,119 @@ 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 brandString = (pattern, brand5) => Schema3.String.pipe(Schema3.check(Schema3.isPattern(pattern)), Schema3.brand(brand5));
+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.check(Schema3.isPattern(localDatePattern)), Schema3.check(Schema3.makeFilter((value) => isValidLocalDateString(value))), Schema3.brand("LocalDateString"));
+var LocalTimeStringSchema = Schema3.String.pipe(Schema3.check(Schema3.isPattern(localTimePattern)), Schema3.check(Schema3.makeFilter((value) => isValidLocalTimeString(value))), Schema3.brand("LocalTimeString"));
+var OffsetTimeStringSchema = Schema3.String.pipe(Schema3.check(Schema3.isPattern(offsetTimePattern)), Schema3.check(Schema3.makeFilter((value) => isValidOffsetTimeString(value))), Schema3.brand("OffsetTimeString"));
+var LocalDateTimeStringSchema = Schema3.String.pipe(Schema3.check(Schema3.isPattern(localDateTimePattern)), Schema3.check(Schema3.makeFilter((value) => isValidLocalDateTimeString(value))), Schema3.brand("LocalDateTimeString"));
+var InstantStringSchema = Schema3.String.pipe(Schema3.check(Schema3.isPattern(instantPattern)), Schema3.check(Schema3.makeFilter((value) => isValidInstantString(value))), 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({
-  key: Schema3.String,
-  value: JsonValueSchema
-})));
-var JsonPrimitiveSchema = Schema3.Union(Schema3.String, Schema3.Number, Schema3.Boolean, Schema3.Null);
+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.check(Schema3.makeFilter((value) => isCanonicalBigIntString(value))), Schema3.brand("BigIntString"));
+var DecimalStringSchema = Schema3.String.pipe(Schema3.check(Schema3.makeFilter((value) => isCanonicalDecimalString(value))), Schema3.brand("DecimalString"));
+var JsonValueSchema = Schema3.suspend(() => Schema3.Union([
+  Schema3.String,
+  Schema3.Number.check(Schema3.isFinite()),
+  Schema3.Boolean,
+  Schema3.Null,
+  Schema3.Array(JsonValueSchema),
+  Schema3.Record(Schema3.String, JsonValueSchema)
+]));
+var JsonPrimitiveSchema = Schema3.Union([
+  Schema3.String,
+  Schema3.Number.check(Schema3.isFinite()),
+  Schema3.Boolean,
+  Schema3.Null
+]);
 
 // src/mysql/datatypes/index.ts
 var exports_datatypes = {};
@@ -542,6 +641,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
@@ -575,7 +680,7 @@ var custom = (schema2, dbType) => makeColumnDefinition(schema2, {
   ddlType: undefined,
   identity: undefined
 });
-var uuid = () => primitive(Schema4.UUID, mysqlDatatypes.uuid());
+var uuid = () => primitive(Schema4.String.check(Schema4.isUUID()), mysqlDatatypes.uuid());
 var text = () => primitive(Schema4.String, mysqlDatatypes.text());
 var int = () => primitive(Schema4.Int, mysqlDatatypes.int());
 var number = (options) => makeColumnDefinition(DecimalStringSchema, {
@@ -52238,10 +52343,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)];
@@ -109613,8 +109716,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;
@@ -109797,6 +109900,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) {
@@ -109824,6 +109948,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",
@@ -109900,6 +110026,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`);
@@ -109924,7 +110052,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`);
           }
         }
@@ -109943,12 +110071,7 @@ var validateOptions = (tableName, fields2, options) => {
 };
 
 // src/internal/schema-derivation.ts
-import * as VariantSchema from "@effect/experimental/VariantSchema";
 import * as Schema5 from "effect/Schema";
-var TableSchema = VariantSchema.make({
-  variants: ["select", "insert", "update"],
-  defaultVariant: "select"
-});
 var maybeBrandSchema = (column, tableName, columnName) => column.metadata.brand === true ? Schema5.brand(`${tableName}.${columnName}`)(column.schema) : column.schema;
 var selectSchema = (column, tableName, columnName) => column.metadata.nullable ? Schema5.NullOr(maybeBrandSchema(column, tableName, columnName)) : maybeBrandSchema(column, tableName, columnName);
 var insertSchema = (column, tableName, columnName) => {
@@ -109965,42 +110088,37 @@ var updateSchema = (column, tableName, columnName, isPrimaryKey) => {
   const base = column.metadata.nullable ? Schema5.NullOr(maybeBrandSchema(column, tableName, columnName)) : maybeBrandSchema(column, tableName, columnName);
   return Schema5.optional(base);
 };
-var deriveSchemas = (tableName, fields2, primaryKeyColumns) => {
+var fieldSchemaForVariant = (variant, column, tableName, columnName, primaryKeySet) => {
+  switch (variant) {
+    case "select":
+      return selectSchema(column, tableName, columnName);
+    case "insert":
+      return insertSchema(column, tableName, columnName);
+    case "update":
+      return updateSchema(column, tableName, columnName, primaryKeySet.has(columnName));
+  }
+};
+var deriveSchema = (variant, tableName, fields2, primaryKeyColumns) => {
   const primaryKeySet = new Set(primaryKeyColumns);
-  const variants = {};
+  const structFields = {};
   for (const [key, column] of Object.entries(fields2)) {
-    const config = {
-      select: selectSchema(column, tableName, key),
-      insert: undefined,
-      update: undefined
-    };
-    const insert = insertSchema(column, tableName, key);
-    const update = updateSchema(column, tableName, key, primaryKeySet.has(key));
-    if (insert !== undefined) {
-      config.insert = insert;
-    } else {
-      delete config.insert;
+    const schema3 = fieldSchemaForVariant(variant, column, tableName, key, primaryKeySet);
+    if (schema3 !== undefined) {
+      structFields[key] = schema3;
     }
-    if (update !== undefined) {
-      config.update = update;
-    } else {
-      delete config.update;
-    }
-    variants[key] = TableSchema.Field(config);
   }
-  const struct = TableSchema.Struct(variants);
-  return {
-    select: TableSchema.extract(struct, "select"),
-    insert: TableSchema.extract(struct, "insert"),
-    update: TableSchema.extract(struct, "update")
-  };
+  return Schema5.Struct(structFields);
 };
+var deriveSelectSchema = (tableName, fields2, primaryKeyColumns) => deriveSchema("select", tableName, fields2, primaryKeyColumns);
+var deriveInsertSchema = (tableName, fields2, primaryKeyColumns) => deriveSchema("insert", tableName, fields2, primaryKeyColumns);
+var deriveUpdateSchema = (tableName, fields2, primaryKeyColumns) => deriveSchema("update", tableName, fields2, primaryKeyColumns);
 
 // src/internal/table.ts
 var TypeId4 = Symbol.for("effect-qb/Table");
 var OptionsSymbol = Symbol.for("effect-qb/Table/normalizedOptions");
 var options = Symbol.for("effect-qb/Table/declaredOptions");
 var CacheSymbol = Symbol.for("effect-qb/Table/cache");
+var SchemaCacheSymbol = Symbol.for("effect-qb/Table/schemaCache");
 var DeclaredOptionsSymbol = Symbol.for("effect-qb/Table/factoryDeclaredOptions");
 var TableProto = {
   pipe() {
@@ -110023,14 +110141,86 @@ var buildArtifacts = (name, fields2, declaredOptions, schemaName) => {
   validateOptions(name, fields2, declaredOptions);
   const primaryKey3 = resolvePrimaryKeyColumns(fields2, declaredOptions);
   const columns = Object.fromEntries(Object.entries(fields2).map(([key, column]) => [key, bindColumn(name, key, column, name, schemaName)]));
-  const schemas = deriveSchemas(name, fields2, primaryKey3);
   return {
     columns,
-    schemas,
     normalizedOptions,
     primaryKey: primaryKey3
   };
 };
+var getSchemaCache = (table) => {
+  const target = table;
+  if (target[SchemaCacheSymbol] !== undefined) {
+    return target[SchemaCacheSymbol];
+  }
+  const cache = {};
+  Object.defineProperty(table, SchemaCacheSymbol, {
+    configurable: true,
+    value: cache
+  });
+  return cache;
+};
+var deriveTableSchema = (table, variant) => {
+  const state = table[TypeId4];
+  switch (variant) {
+    case "select":
+      return deriveSelectSchema(state.name, state.fields, state.primaryKey);
+    case "insert":
+      return deriveInsertSchema(state.name, state.fields, state.primaryKey);
+    case "update":
+      return deriveUpdateSchema(state.name, state.fields, state.primaryKey);
+  }
+};
+var schemaFor = (table, variant) => {
+  const cache = getSchemaCache(table);
+  const cached = cache[variant];
+  if (cached !== undefined) {
+    return cached;
+  }
+  const schema3 = deriveTableSchema(table, variant);
+  cache[variant] = schema3;
+  return schema3;
+};
+function selectSchema2(table) {
+  return schemaFor(table, "select");
+}
+function insertSchema2(table) {
+  return schemaFor(table, "insert");
+}
+function updateSchema2(table) {
+  return schemaFor(table, "update");
+}
+var schemasFor = (table) => {
+  const cache = getSchemaCache(table);
+  if (cache.schemas !== undefined) {
+    return cache.schemas;
+  }
+  const schemas = {};
+  Object.defineProperties(schemas, {
+    select: {
+      enumerable: true,
+      get: () => selectSchema2(table)
+    },
+    insert: {
+      enumerable: true,
+      get: () => insertSchema2(table)
+    },
+    update: {
+      enumerable: true,
+      get: () => updateSchema2(table)
+    }
+  });
+  cache.schemas = schemas;
+  return schemas;
+};
+var defineSchemasGetter = (table) => {
+  Object.defineProperty(table, "schemas", {
+    configurable: true,
+    enumerable: true,
+    get() {
+      return schemasFor(table);
+    }
+  });
+};
 var makeTable = (name, fields2, declaredOptions, baseName = name, kind = "schema", schemaName, schemaMode = "default") => {
   const resolvedSchemaName = schemaMode === "explicit" ? schemaName : "public";
   const artifacts = buildArtifacts(name, fields2, declaredOptions, resolvedSchemaName);
@@ -110038,7 +110228,7 @@ var makeTable = (name, fields2, declaredOptions, baseName = name, kind = "schema
   const table = attachPipe2(Object.create(TableProto));
   table.name = name;
   table.columns = artifacts.columns;
-  table.schemas = artifacts.schemas;
+  defineSchemasGetter(table);
   table[TypeId4] = {
     name,
     baseName,
@@ -110111,7 +110301,6 @@ var ensureClassArtifacts = (self) => {
   const table = applyDeclaredOptions(makeTable(state.name, state.fields, [], state.name, "schema", state.schemaName, state.schemaName === undefined || state.schemaName === "public" ? "default" : "explicit"), classOptions);
   const artifacts = {
     columns: table.columns,
-    schemas: table.schemas,
     normalizedOptions: table[OptionsSymbol],
     primaryKey: table[TypeId4].primaryKey
   };
@@ -110134,21 +110323,24 @@ var makeOption = (option) => {
   return builder;
 };
 var option = (spec) => makeOption(spec);
-function make2(name, fields2, schemaName) {
+function make(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)]));
   const aliased = attachPipe2(Object.create(TableProto));
   aliased.name = aliasName;
   aliased.columns = columns;
-  aliased.schemas = deriveSchemas(aliasName, state.fields, state.primaryKey);
+  defineSchemasGetter(aliased);
   aliased[TypeId4] = {
     name: aliasName,
     baseName: state.baseName,
@@ -110189,7 +110381,7 @@ function Class(name, schemaName) {
         return ensureClassArtifacts(this).columns;
       }
       static get schemas() {
-        return ensureClassArtifacts(this).schemas;
+        return schemasFor(this);
       }
       static get [TypeId4]() {
         const declaredOptions = extractDeclaredOptions(this[options]);
@@ -110259,12 +110451,315 @@ var foreignKey2 = (columns, target, referencedColumns) => makeOption({
     knownColumns: Object.keys(target()[TypeId4].fields)
   })
 });
-var check = (name, predicate) => makeOption({
+var check2 = (name, predicate) => makeOption({
   kind: "check",
   name,
   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";
 
@@ -110301,7 +110796,18 @@ var cloneContext = (context) => ({
   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));
 };
@@ -110551,9 +111057,10 @@ 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) {
@@ -110577,7 +111084,7 @@ var jsonPathPredicateKeyOfExpression = (value) => {
         return;
       }
       const baseKey = columnKeyOfExpression(jsonAst.base);
-      return baseKey === undefined ? undefined : `${baseKey}#json:${path.join(".")}`;
+      return baseKey === undefined ? undefined : `${baseKey}#json:${path.map(escapeJsonPathPredicateKeySegment).join(".")}`;
     }
     default:
       return;
@@ -110993,7 +111500,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;
   }
@@ -111142,6 +111649,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()}`;
@@ -111160,15 +111681,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":
@@ -111186,8 +111754,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":
@@ -111199,6 +111774,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");
   }
@@ -111216,8 +111839,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));
@@ -111293,10 +112020,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
     }, {
@@ -111313,14 +112041,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,
@@ -111339,7 +112075,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));
@@ -111363,9 +112101,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))
@@ -111395,7 +112137,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
@@ -111408,7 +112150,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: {},
@@ -111428,6 +112172,7 @@ var makeDslMutationRuntime = (ctx) => {
     }, undefined, "write", "delete");
   };
   const truncate = (target, options2 = {}) => {
+    assertMutationTargets(target, "truncate");
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
     return ctx.makePlan({
       selection: {},
@@ -111456,8 +112201,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;
@@ -111543,8 +112293,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;
@@ -111599,25 +112439,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,
@@ -111642,7 +112486,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
       }, {
@@ -111683,8 +112527,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]: {
@@ -111697,7 +112549,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
     }, {
@@ -111716,8 +112568,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",
@@ -111737,7 +112597,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
     }, {
@@ -111752,6 +112612,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);
@@ -111775,6 +112638,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,
@@ -111851,18 +112723,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), {
@@ -111921,21 +112871,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);
@@ -111950,19 +112907,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,
@@ -111975,26 +112942,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: [],
@@ -112084,6 +113096,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: {},
@@ -112111,6 +113124,7 @@ var makeDslTransactionDdlRuntime = (ctx) => {
     }, undefined, "ddl", "createTable");
   };
   const dropTable = (target, options2 = {}) => {
+    assertTableTarget(target, "dropTable");
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
     return ctx.makePlan({
       selection: {},
@@ -112138,7 +113152,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: {},
@@ -112169,7 +113185,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: {},
@@ -112213,59 +113231,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);
@@ -112297,10 +113262,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(".")}'`);
@@ -112325,6 +113304,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);
@@ -112338,6 +113319,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);
@@ -112352,6 +113334,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);
@@ -112360,7 +113343,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;
 };
@@ -112504,10 +113487,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
@@ -113485,21 +114474,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) {
+    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,
-    runtimeSchema: column2[TypeId].runtimeSchema,
-    driverValueMapping: column2[TypeId].driverValueMapping,
-    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) => ({
@@ -113562,7 +114582,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);
@@ -113584,13 +114609,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;
@@ -113601,7 +114633,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))
     }));
   });
 };
@@ -113664,25 +114696,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)
-    };
-  }
-  if (!Array.isArray(input) && "constraint" in input) {
-    return {
-      kind: "constraint",
-      name: input.constraint
+      columns: normalizeConflictColumns(target, input)
     };
   }
-  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) {
@@ -113795,6 +114824,7 @@ var distinctOn = {
   __effect_qb_hint__: "Use postgres.Query.distinctOn(...) or regular distinct()/grouping logic"
 };
 var mutationRuntime = makeDslMutationRuntime({
+  profile,
   makePlan,
   getAst,
   getQueryState,
@@ -113807,7 +114837,7 @@ var mutationRuntime = makeDslMutationRuntime({
   buildConflictTarget,
   mutationTargetClauses,
   mutationAvailableSources,
-  normalizeColumnList,
+  normalizeConflictColumns,
   targetSourceDetails,
   sourceDetails
 });
@@ -113818,7 +114848,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,
@@ -113911,317 +114941,25 @@ var exports_executor = {};
 __export(exports_executor, {
   withTransaction: () => withTransaction2,
   withSavepoint: () => withSavepoint2,
-  make: () => make6,
+  make: () => make5,
   driver: () => driver2,
   custom: () => custom3
 });
 import * as Effect2 from "effect/Effect";
-import * as SqlClient3 from "@effect/sql/SqlClient";
+import * as SqlClient3 from "effect/unstable/sql/SqlClient";
 import * as Stream2 from "effect/Stream";
 
 // src/internal/executor.ts
 import * as Chunk from "effect/Chunk";
 import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
 import * as Option from "effect/Option";
 import * as Schema9 from "effect/Schema";
-import * as SqlClient from "@effect/sql/SqlClient";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
 import * as Stream from "effect/Stream";
 
 // src/internal/runtime/driver-value-mapping.ts
 import * as Schema7 from "effect/Schema";
-
-// 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;
-  }
-  if (typeof value === "string" && value.trim() !== "") {
-    const parsed = Number(value);
-    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" && /^-?\d+$/.test(value.trim())) {
-    return BigInt(value.trim()).toString();
-  }
-  throw new Error("Expected an integer-like bigint value");
-};
-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 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 (/^\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);
-  }
-  const raw = expectString(value, "local time").trim();
-  if (/^\d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(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 (/^\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(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();
-  if (/^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(raw)) {
-    return raw.replace(" ", "T");
-  }
-  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);
-    }
-  }
-  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");
-};
-var isJsonValue = (value) => {
-  if (value === null) {
-    return true;
-  }
-  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;
-  }
-};
-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");
-  }
-  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 [key2, fieldDbType] of Object.entries(dbType.fields)) {
-      if (key2 in value) {
-        normalized[key2] = normalizeDbValue(fieldDbType, value[key2]);
-      }
-    }
-    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/runtime/driver-value-mapping.ts
 var runtimeTagOfDbType = (dbType) => {
   if (dbType === undefined) {
     return;
@@ -114273,6 +115011,20 @@ var findMapping = (context, key2) => {
   }
   return;
 };
+var isJsonDbType = (dbType) => {
+  if (dbType === undefined) {
+    return false;
+  }
+  if ("base" in dbType) {
+    return isJsonDbType(dbType.base);
+  }
+  if (!("variant" in dbType)) {
+    return false;
+  }
+  const variant = dbType.variant;
+  return variant === "json" || variant === "jsonb";
+};
+var schemaAccepts = (schema4, value) => schema4 !== undefined && Schema7.is(schema4)(value);
 var encodeWithSchema = (schema4, value) => {
   if (schema4 === undefined) {
     return { value, encoded: false };
@@ -114285,10 +115037,35 @@ var encodeWithSchema = (schema4, value) => {
     encoded: true
   };
 };
+var normalizeJsonDriverString = (value, context) => {
+  if (!isJsonDbType(context.dbType) || context.runtimeSchema === undefined) {
+    return;
+  }
+  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;
+    }
+  }
+  return;
+};
 var toDriverValue = (value, context) => {
   if (value === null) {
     return null;
   }
+  if (value instanceof Date && Number.isNaN(value.getTime())) {
+    throw new Error("Expected a valid Date value");
+  }
   const dbType = context.dbType;
   const encoded = encodeWithSchema(context.runtimeSchema, value);
   let current = encoded.value;
@@ -114296,6 +115073,9 @@ var toDriverValue = (value, context) => {
   if (custom3 !== undefined && dbType !== undefined) {
     return custom3(current, dbType);
   }
+  if (encoded.encoded && typeof current === "string" && isJsonDbType(dbType)) {
+    return current;
+  }
   return dbType === undefined || !encoded.encoded ? current : normalizeDbValue(dbType, current);
 };
 var fromDriverValue = (value, context) => {
@@ -114307,6 +115087,12 @@ var fromDriverValue = (value, context) => {
   if (custom3 !== undefined && dbType !== undefined) {
     return custom3(value, dbType);
   }
+  if (typeof value === "string") {
+    const normalizedJsonString = normalizeJsonDriverString(value, context);
+    if (normalizedJsonString !== undefined) {
+      return normalizedJsonString;
+    }
+  }
   return dbType === undefined ? value : normalizeDbValue(dbType, value);
 };
 var textCast = (sql) => `(${sql})::text`;
@@ -114346,12 +115132,13 @@ var renderJsonSelectSql = (sql, context) => {
 import * as Schema8 from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
 var schemaCache = new WeakMap;
+var FiniteNumberSchema = Schema8.Number.check(Schema8.isFinite());
 var runtimeSchemaForTag = (tag) => {
   switch (tag) {
     case "string":
       return Schema8.String;
     case "number":
-      return Schema8.Number;
+      return FiniteNumberSchema;
     case "bigintString":
       return BigIntStringSchema;
     case "boolean":
@@ -114373,14 +115160,11 @@ var runtimeSchemaForTag = (tag) => {
     case "decimalString":
       return DecimalStringSchema;
     case "bytes":
-      return Schema8.Uint8ArrayFromSelf;
+      return Schema8.Uint8Array;
     case "array":
       return Schema8.Array(Schema8.Unknown);
     case "record":
-      return Schema8.Record({
-        key: Schema8.String,
-        value: Schema8.Unknown
-      });
+      return Schema8.Record(Schema8.String, Schema8.Unknown);
     case "null":
       return Schema8.Null;
     case "unknown":
@@ -114418,22 +115202,18 @@ var unionAst = (asts) => {
   if (asts.length === 1) {
     return asts[0];
   }
-  return SchemaAST.Union.make(asts);
+  return new SchemaAST.Union(asts, "anyOf");
 };
 var propertyAstOf = (ast, key2) => {
   switch (ast._tag) {
-    case "Transformation":
-      return propertyAstOf(SchemaAST.typeAST(ast), key2);
-    case "Refinement":
-      return propertyAstOf(ast.from, key2);
     case "Suspend":
-      return propertyAstOf(ast.f(), key2);
-    case "TypeLiteral": {
+      return propertyAstOf(ast.thunk(), key2);
+    case "Objects": {
       const property = ast.propertySignatures.find((entry) => entry.name === key2);
       if (property !== undefined) {
         return property.type;
       }
-      const index4 = ast.indexSignatures.find((entry) => entry.parameter._tag === "StringKeyword");
+      const index4 = ast.indexSignatures.find((entry) => entry.parameter._tag === "String");
       return index4?.type;
     }
     case "Union": {
@@ -114449,21 +115229,17 @@ var propertyAstOf = (ast, key2) => {
 };
 var numberAstOf = (ast, index4) => {
   switch (ast._tag) {
-    case "Transformation":
-      return numberAstOf(SchemaAST.typeAST(ast), index4);
-    case "Refinement":
-      return numberAstOf(ast.from, index4);
     case "Suspend":
-      return numberAstOf(ast.f(), index4);
-    case "TupleType": {
+      return numberAstOf(ast.thunk(), index4);
+    case "Arrays": {
       const element = ast.elements[index4];
       if (element !== undefined) {
-        return element.type;
+        return element;
       }
       if (ast.rest.length === 0) {
         return;
       }
-      return unionAst(ast.rest.map((entry) => entry.type));
+      return unionAst(ast.rest);
     }
     case "Union": {
       const values2 = ast.types.flatMap((member) => {
@@ -114478,7 +115254,7 @@ var numberAstOf = (ast, index4) => {
 };
 var exactJsonSegments = (segments) => segments.every((segment) => segment.kind === "key" || segment.kind === "index");
 var schemaAstAtExactJsonPath = (schema4, segments) => {
-  let current = SchemaAST.typeAST(schema4.ast);
+  let current = schema4.ast;
   for (const segment of segments) {
     if (segment.kind === "key") {
       const property = propertyAstOf(current, segment.key);
@@ -114508,28 +115284,28 @@ var unionSchemas = (schemas) => {
   if (resolved.length === 1) {
     return resolved[0];
   }
-  return Schema8.Union(...resolved);
+  return Schema8.Union(resolved);
 };
 var firstSelectedExpression = (plan) => {
   const selection = getAst(plan).select;
   return flattenSelection(selection)[0]?.expression;
 };
 var isJsonCompatibleAst = (ast) => {
+  ast = SchemaAST.toType(ast);
   switch (ast._tag) {
-    case "StringKeyword":
-    case "NumberKeyword":
-    case "BooleanKeyword":
-    case "TupleType":
-    case "TypeLiteral":
+    case "String":
+    case "Number":
+    case "Boolean":
+    case "Null":
+    case "Arrays":
+    case "Objects":
       return true;
     case "Literal":
-      return ast.literal === null || typeof ast.literal === "string" || typeof ast.literal === "number" || typeof ast.literal === "boolean";
+      return typeof ast.literal === "string" || typeof ast.literal === "number" || typeof ast.literal === "boolean";
     case "Union":
       return ast.types.every(isJsonCompatibleAst);
-    case "Transformation":
-      return isJsonCompatibleAst(SchemaAST.typeAST(ast));
     case "Suspend":
-      return isJsonCompatibleAst(ast.f());
+      return isJsonCompatibleAst(ast.thunk());
     default:
       return false;
   }
@@ -114538,14 +115314,14 @@ var jsonCompatibleSchema = (schema4) => {
   if (schema4 === undefined) {
     return;
   }
-  const ast = SchemaAST.typeAST(schema4.ast);
+  const ast = SchemaAST.toType(schema4.ast);
   return isJsonCompatibleAst(ast) ? schema4 : JsonValueSchema;
 };
 var buildStructSchema = (entries, context) => {
   const fields2 = Object.fromEntries(entries.map((entry) => [entry.key, expressionRuntimeSchema(entry.value, context) ?? JsonValueSchema]));
   return Schema8.Struct(fields2);
 };
-var buildTupleSchema = (values2, context) => Schema8.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([
@@ -114636,7 +115412,7 @@ var deriveRuntimeSchema = (expression, context) => {
       return Schema8.String;
     case "count":
     case "jsonLength":
-      return Schema8.Number;
+      return FiniteNumberSchema;
     case "max":
     case "min":
       return expressionRuntimeSchema(ast.value, context);
@@ -114649,7 +115425,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) : Schema8.Number;
+      return ast.function === "over" && ast.value !== undefined ? expressionRuntimeSchema(ast.value, context) : FiniteNumberSchema;
     case "jsonGet":
     case "jsonPath":
     case "jsonAccess":
@@ -114742,24 +115518,31 @@ var hasWriteCapability = (plan) => {
   }
   return false;
 };
-var makeRowDecodeError = (rendered, projection, expression, raw, stage, cause, normalized) => ({
-  _tag: "RowDecodeError",
-  message: stage === "normalize" ? `Failed to normalize projection '${projection.alias}'` : `Failed to decode projection '${projection.alias}' against its runtime schema`,
-  dialect: rendered.dialect,
-  query: {
-    sql: rendered.sql,
-    params: rendered.params
-  },
-  projection: {
-    alias: projection.alias,
-    path: projection.path
-  },
-  dbType: expression[TypeId].dbType,
-  raw,
-  normalized,
-  stage,
-  cause
-});
+var makeRowDecodeError = (rendered, projection, expression, raw, stage, cause, normalized) => {
+  const schemaError = Schema9.isSchemaError(cause) ? {
+    message: cause.message,
+    issue: cause.issue
+  } : undefined;
+  return {
+    _tag: "RowDecodeError",
+    message: stage === "normalize" ? `Failed to normalize projection '${projection.alias}'` : `Failed to decode projection '${projection.alias}' against its runtime schema`,
+    dialect: rendered.dialect,
+    query: {
+      sql: rendered.sql,
+      params: rendered.params
+    },
+    projection: {
+      alias: projection.alias,
+      path: projection.path
+    },
+    dbType: expression[TypeId].dbType,
+    raw,
+    normalized,
+    stage,
+    cause,
+    ...schemaError === undefined ? {} : { schemaError }
+  };
+};
 var hasOptionalSourceDependency = (expression, scope) => {
   const state = expression[TypeId];
   return Object.keys(state.dependencies).some((sourceName) => !scope.absentSourceNames.has(sourceName) && scope.sourceModes.get(sourceName) === "optional");
@@ -114771,7 +115554,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";
     }
@@ -114784,6 +115567,13 @@ var effectiveRuntimeNullability = (expression, scope) => {
   }
   return hasOptionalSourceDependency(expression, scope) ? "maybe" : nullability;
 };
+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") {
@@ -114795,13 +115585,17 @@ var decodeProjectionValue = (rendered, projection, expression, raw, scope, drive
         driverValueMapping: expression[TypeId].driverValueMapping,
         valueMappings
       });
-    } catch (cause) {
-      throw makeRowDecodeError(rendered, projection, expression, raw, "normalize", cause);
+    } catch (cause2) {
+      throw makeRowDecodeError(rendered, projection, expression, raw, "normalize", cause2);
     }
   }
   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;
@@ -114809,49 +115603,51 @@ 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 (Schema9.is(schema4)(normalized)) {
     return normalized;
   }
-  try {
-    return Schema9.decodeUnknownSync(schema4)(normalized);
-  } catch (cause) {
-    throw makeRowDecodeError(rendered, projection, expression, raw, "schema", cause, normalized);
+  const decoded = Schema9.decodeUnknownExit(schema4)(normalized);
+  if (Exit.isSuccess(decoded)) {
+    return decoded.value;
   }
+  const cause = Option.match(Exit.findErrorOption(decoded), {
+    onNone: () => decoded.cause,
+    onSome: (schemaError) => schemaError
+  });
+  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`);
+      }
+      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;
   };
 };
-var decodeChunk = (rendered, plan, rows, options2 = {}) => {
-  const decodeRow = makeRowDecoder(rendered, plan, options2);
-  return Chunk.unsafeFromArray(Chunk.toReadonlyArray(rows).map((row) => decodeRow(row)));
-};
 var decodeRows = (rendered, plan, rows, options2 = {}) => {
   const decodeRow = makeRowDecoder(rendered, plan, options2);
   return rows.map((row) => decodeRow(row));
 };
-var make4 = (dialect, execute) => ({
+var make3 = (dialect, execute) => ({
   dialect,
   execute(plan) {
     return execute(plan);
@@ -114874,7 +115670,7 @@ function driver(dialect, executeOrHandlers) {
     }
   };
 }
-var streamFromSqlClient = (query) => Stream.unwrapScoped(Effect.flatMap(SqlClient.SqlClient, (sql) => Effect.flatMap(Effect.serviceOption(SqlClient.TransactionConnection), Option.match({
+var streamFromSqlClient = (query) => Stream.unwrap(Effect.flatMap(SqlClient.SqlClient, (sql) => Effect.flatMap(Effect.serviceOption(sql.transactionService), Option.match({
   onNone: () => sql.reserve,
   onSome: ([connection]) => Effect.succeed(connection)
 })).pipe(Effect.map((connection) => connection.executeStream(query.sql, [...query.params], undefined)))));
@@ -114883,16 +115679,42 @@ var withSavepoint = (effect) => Effect.flatMap(SqlClient.SqlClient, (sql) => sql
 
 // src/internal/renderer.ts
 var TypeId8 = Symbol.for("effect-qb/Renderer");
-function make5(dialect, render) {
+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 make4(dialect, render) {
   if (typeof render !== "function") {
     throw new Error(`Renderer.make requires an explicit render implementation for dialect: ${dialect}`);
   }
   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 ?? [],
@@ -114938,16 +115760,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;
@@ -115052,7 +115877,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) {
@@ -115087,30 +115951,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, {
@@ -115153,15 +116039,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":
@@ -115174,14 +116061,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);
@@ -115210,7 +116128,7 @@ 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);
@@ -115223,23 +116141,48 @@ var expressionDriverContext = (expression, state, dialect) => ({
   runtimeSchema: expression[TypeId].runtimeSchema,
   driverValueMapping: expression[TypeId].driverValueMapping
 });
-var renderJsonInputExpression = (expression, state, dialect) => renderJsonSelectSql(renderExpression(expression, state, dialect), expressionDriverContext(expression, state, dialect));
-var encodeArrayValues = (values2, column2, state, dialect) => values2.map((value) => toDriverValue(value, {
-  dialect: dialect.name,
-  valueMappings: state.valueMappings,
-  dbType: column2.metadata.dbType,
-  runtimeSchema: column2.schema,
-  driverValueMapping: column2.metadata.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");
@@ -115257,7 +116200,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)})`;
   }
@@ -115295,7 +116238,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);
@@ -115318,7 +116261,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);
@@ -115337,21 +116280,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;
     }
@@ -115381,29 +116325,29 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       return;
     }
     case "jsonToJson":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
         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(${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") {
@@ -115415,7 +116359,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonLength":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -115430,7 +116374,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonKeys":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -115444,7 +116388,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonStripNulls":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -115455,7 +116399,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") {
@@ -115467,17 +116411,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;
@@ -115488,13 +116432,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;
@@ -115510,7 +116462,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;
@@ -115541,23 +116493,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");
@@ -115575,13 +116519,16 @@ 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 }) => `${renderSelectSql(renderExpression(expression, state, dialect), expressionDriverContext(expression, state, dialect))} as ${dialect.quoteIdentifier(alias2)}`).join(", ");
   return {
@@ -115589,7 +116536,84 @@ var renderSelectionList = (selection, state, dialect, validateAggregation) => {
     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) {
@@ -115597,13 +116621,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)}`);
       }
@@ -115626,19 +116654,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(" ");
@@ -115646,28 +116680,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(encodeArrayValues(entry.values, fields2[entry.columnName], state, dialect), 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, targetSource.source[TypeId4].fields[entry.columnName][TypeId])).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 {
@@ -115676,22 +116722,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}`;
@@ -115700,15 +116753,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] : []
@@ -115737,7 +116802,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}`;
@@ -115746,6 +116815,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];
@@ -115754,7 +116830,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}`;
@@ -115775,7 +116853,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}`;
@@ -115784,12 +116866,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;
@@ -115802,6 +116889,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";
@@ -115829,32 +116919,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
@@ -115877,9 +116975,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,
@@ -115891,11 +117002,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;
@@ -115916,6 +117027,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);
@@ -115926,8 +117044,11 @@ 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":
+      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)}`;
@@ -115970,7 +117091,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":
@@ -115980,7 +117101,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":
@@ -115990,7 +117111,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":
@@ -116010,14 +117131,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)})`;
@@ -116026,15 +117159,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;
@@ -116069,7 +117202,8 @@ var renderMysqlPlan = (plan, options2 = {}) => {
     params: [],
     valueMappings: options2.valueMappings,
     ctes: [],
-    cteNames: new Set
+    cteNames: new Set,
+    cteSources: new Map
   };
   const rendered = renderQueryAst(getAst(plan), state, mysqlDialect);
   return {
@@ -116103,8 +117237,8 @@ var fromDriver = (renderer, sqlDriver, driverMode = "raw", valueMappings) => ({
   },
   stream(plan) {
     const rendered = renderer.render(plan);
-    return Stream2.mapError(Stream2.mapChunksEffect(sqlDriver.stream(rendered), (rows) => Effect2.try({
-      try: () => decodeChunk(rendered, plan, rows, { driverMode, valueMappings }),
+    return Stream2.mapError(Stream2.mapArrayEffect(sqlDriver.stream(rendered), (rows) => Effect2.try({
+      try: () => decodeRows(rendered, plan, rows, { driverMode, valueMappings }),
       catch: (error) => error
     })), (error) => {
       if (typeof error === "object" && error !== null && "_tag" in error && error._tag === "RowDecodeError") {
@@ -116119,13 +117253,13 @@ var sqlClientDriver = () => driver2({
   execute: (query) => Effect2.flatMap(SqlClient3.SqlClient, (sql) => sql.unsafe(query.sql, [...query.params])),
   stream: (query) => streamFromSqlClient(query)
 });
-function make6(options2 = {}) {
+function make5(options2 = {}) {
   if (options2.driver) {
-    return fromDriver(options2.renderer ?? make5("mysql", (plan) => renderMysqlPlan(plan, { valueMappings: options2.valueMappings })), options2.driver, options2.driverMode, options2.valueMappings);
+    return fromDriver(options2.renderer ?? make4("mysql", (plan) => renderMysqlPlan(plan, { valueMappings: options2.valueMappings })), options2.driver, options2.driverMode, options2.valueMappings);
   }
-  return fromDriver(options2.renderer ?? make5("mysql", (plan) => renderMysqlPlan(plan, { valueMappings: options2.valueMappings })), sqlClientDriver(), options2.driverMode, options2.valueMappings);
+  return fromDriver(options2.renderer ?? make4("mysql", (plan) => renderMysqlPlan(plan, { valueMappings: options2.valueMappings })), sqlClientDriver(), options2.driverMode, options2.valueMappings);
 }
-var custom3 = (execute) => make4("mysql", execute);
+var custom3 = (execute) => make3("mysql", execute);
 // src/mysql/query.ts
 var exports_query2 = {};
 __export(exports_query2, {
@@ -116221,14 +117355,17 @@ var from2 = exportedFrom;
 // src/mysql/table.ts
 var exports_table2 = {};
 __export(exports_table2, {
+  updateSchema: () => updateSchema3,
   unique: () => unique4,
+  selectSchema: () => selectSchema3,
   schema: () => schema4,
   primaryKey: () => primaryKey4,
   options: () => options2,
-  make: () => make7,
+  make: () => make6,
+  insertSchema: () => insertSchema3,
   index: () => index4,
   foreignKey: () => foreignKey3,
-  check: () => check2,
+  check: () => check3,
   alias: () => alias2,
   TypeId: () => TypeId10,
   OptionsSymbol: () => OptionsSymbol2,
@@ -116237,11 +117374,14 @@ __export(exports_table2, {
 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 make6 = (name, fields2, schemaName = undefined) => make(name, fields2, schemaName);
+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);
@@ -116251,16 +117391,19 @@ var primaryKey4 = primaryKey3;
 var unique4 = unique3;
 var index4 = index2;
 var foreignKey3 = (columns, target, referencedColumns) => foreignKey2(columns, target, referencedColumns);
-var check2 = check;
+var check3 = check2;
+var selectSchema3 = selectSchema2;
+var insertSchema3 = insertSchema2;
+var updateSchema3 = updateSchema2;
 // src/mysql/renderer.ts
 var exports_renderer2 = {};
 __export(exports_renderer2, {
   mysql: () => mysql,
-  make: () => make8,
+  make: () => make7,
   TypeId: () => TypeId8
 });
-var make8 = (options3 = {}) => make5("mysql", (plan) => renderMysqlPlan(plan, options3));
-var mysql = make8();
+var make7 = (options3 = {}) => make4("mysql", (plan) => renderMysqlPlan(plan, options3));
+var mysql = make7();
 export {
   exports_table2 as Table,
   exports_scalar as Scalar,