effect-qb 0.16.0 → 0.17.0

package/dist/postgres/metadata.js

@@ -176,6 +176,27 @@ var bindColumn = (tableName, columnName, column, baseTableName, schemaName) => {
 };
 
 // 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) {
@@ -203,6 +224,8 @@ var collectInlineOptions = (fields) => {
       });
     }
     if (column.metadata.references) {
+      validateReferentialAction(column.metadata.references.onUpdate);
+      validateReferentialAction(column.metadata.references.onDelete);
       const local = [columnName];
       options.push({
         kind: "foreignKey",
@@ -279,6 +302,8 @@ var validateOptions = (tableName, fields, 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`);
@@ -303,7 +328,7 @@ var validateOptions = (tableName, fields, 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`);
           }
         }
@@ -517,10 +542,13 @@ function make2(name, fields, schemaName) {
   const resolvedSchemaName = arguments.length >= 3 ? schemaName : "public";
   return makeTable(name, fields, [], name, "schema", resolvedSchemaName, arguments.length >= 3 ? "explicit" : "default");
 }
-var schema = (schemaName) => ({
-  schemaName,
-  table: (name, fields, ...options2) => applyDeclaredOptions(makeTable(name, fields, [], name, "schema", schemaName, "explicit"), options2)
-});
+var schema = (schemaName) => {
+  const table = (name, fields, ...options2) => applyDeclaredOptions(makeTable(name, fields, [], 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)]));
@@ -696,6 +724,9 @@ var normalize = (expression) => (() => {
   }
 })();
 
+// src/postgres/internal/sql-expression-renderer.ts
+import * as Schema5 from "effect/Schema";
+
 // src/internal/query.ts
 import { pipeArguments as pipeArguments4 } from "effect/Pipeable";
 
@@ -732,7 +763,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));
 };
@@ -982,9 +1024,10 @@ var analyzeFormula = (formula) => freezeContext(analyzeStack(emptyContext(), [{
 var astOf = (value) => value[TypeId3];
 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) {
@@ -1008,7 +1051,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;
@@ -1463,13 +1506,1300 @@ var path = (...segments) => ({
   segments
 });
 
+// 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 isRecord = (value) => typeof value === "object" && value !== null;
+  const isPlan = (value) => isRecord(value) && (TypeId in value);
+  const hasColumnRecord = (value) => isRecord(value.columns);
+  const sourceRequiredList = (source) => typeof source === "object" && source !== null && ("required" in source) ? ctx.currentRequiredList(source.required) : [];
+  const isAliasedSource = (source) => {
+    if (!isRecord(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 isRecord(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[TypeId].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[TypeId];
+    const leftAst = ctx.getAst(left);
+    const basePlan = leftAst.kind === "set" ? leftAst.setBase ?? left : left;
+    const leftOperations = leftAst.kind === "set" ? [...leftAst.setOperations ?? []] : [];
+    return ctx.makePlan({
+      selection: leftState.selection,
+      required: undefined,
+      available: {},
+      dialect: leftState.dialect ?? right[TypeId].dialect
+    }, {
+      kind: "set",
+      select: leftState.selection,
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: [],
+      setBase: basePlan,
+      setOperations: [
+        ...leftOperations,
+        {
+          kind,
+          all,
+          query: right
+        }
+      ]
+    }, undefined, undefined, "set");
+  };
+  const where = (predicate) => (plan) => {
+    const current = plan[TypeId];
+    const currentAst = ctx.getAst(plan);
+    const currentQuery = ctx.getQueryState(plan);
+    const predicateExpression = ctx.toDialectExpression(predicate);
+    const predicateRequired = ctx.extractRequiredFromDialectInputRuntime(predicate);
+    return ctx.makePlan({
+      selection: current.selection,
+      required: [...ctx.currentRequiredList(current.required), ...predicateRequired].filter((name, index3, values) => !(name in current.available) && values.indexOf(name) === index3),
+      available: current.available,
+      dialect: current.dialect ?? predicateExpression[TypeId2].dialect
+    }, {
+      ...currentAst,
+      where: [...currentAst.where, {
+        kind: "where",
+        predicate: predicateExpression
+      }]
+    }, ctx.assumeFormulaTrue(currentQuery.assumptions, ctx.formulaOfExpressionRuntime(predicateExpression)), currentQuery.capabilities, currentQuery.statement);
+  };
+  const from = (source) => (plan) => {
+    const current = plan[TypeId];
+    const currentAst = ctx.getAst(plan);
+    const currentQuery = ctx.getQueryState(plan);
+    if (currentQuery.statement === "insert") {
+      return ctx.attachInsertSource(plan, source);
+    }
+    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), ...sourceRequired].filter((name, index3, values) => !(name in nextAvailable) && values.indexOf(name) === index3),
+        available: nextAvailable,
+        dialect: current.dialect
+      }, {
+        ...currentAst,
+        from: {
+          kind: "from",
+          tableName: sourceName,
+          baseTableName: sourceBaseName,
+          source: sourceLike
+        }
+      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
+    }
+    if (currentQuery.statement === "update") {
+      const nextAvailable = {
+        ...current.available,
+        [sourceName]: {
+          name: sourceName,
+          mode: "required",
+          baseName: sourceBaseName,
+          _presentFormula: ctx.trueFormula(),
+          _presenceWitnesses: presenceWitnesses
+        }
+      };
+      return ctx.makePlan({
+        selection: current.selection,
+        required: [...ctx.currentRequiredList(current.required), ...sourceRequired].filter((name, index3, values) => !(name in nextAvailable) && values.indexOf(name) === index3),
+        available: nextAvailable,
+        dialect: current.dialect
+      }, {
+        ...currentAst,
+        fromSources: [
+          ...currentAst.fromSources ?? [],
+          {
+            kind: "from",
+            tableName: sourceName,
+            baseTableName: sourceBaseName,
+            source: sourceLike
+          }
+        ]
+      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
+    }
+    throw new Error(`from(...) is not supported for ${currentQuery.statement} statements`);
+  };
+  const having = (predicate) => (plan) => {
+    const current = plan[TypeId];
+    const currentAst = ctx.getAst(plan);
+    const currentQuery = ctx.getQueryState(plan);
+    const predicateExpression = ctx.toDialectExpression(predicate);
+    const predicateRequired = ctx.extractRequiredFromDialectInputRuntime(predicate);
+    return ctx.makePlan({
+      selection: current.selection,
+      required: [...ctx.currentRequiredList(current.required), ...predicateRequired].filter((name, index3, values) => !(name in current.available) && values.indexOf(name) === index3),
+      available: current.available,
+      dialect: current.dialect ?? predicateExpression[TypeId2].dialect
+    }, {
+      ...currentAst,
+      having: [...currentAst.having, {
+        kind: "having",
+        predicate: predicateExpression
+      }]
+    }, ctx.assumeFormulaTrue(currentQuery.assumptions, ctx.formulaOfExpressionRuntime(predicateExpression)), currentQuery.capabilities, currentQuery.statement);
+  };
+  const crossJoin = (table) => (plan) => {
+    const current = plan[TypeId];
+    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]: {
+        name: sourceName,
+        mode: "required",
+        baseName: sourceBaseName,
+        _presentFormula: ctx.trueFormula(),
+        _presenceWitnesses: presenceWitnesses
+      }
+    };
+    return ctx.makePlan({
+      selection: current.selection,
+      required: [...ctx.currentRequiredList(current.required), ...sourceRequired].filter((name, index3, values) => !(name in nextAvailable) && values.indexOf(name) === index3),
+      available: nextAvailable,
+      dialect: current.dialect ?? table[TypeId]?.dialect ?? table.dialect
+    }, {
+      ...currentAst,
+      joins: [...currentAst.joins, {
+        kind: "cross",
+        tableName: sourceName,
+        baseTableName: sourceBaseName,
+        source: table
+      }]
+    }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
+  };
+  const join = (kind, table, on) => (plan) => {
+    const current = plan[TypeId];
+    const currentAst = ctx.getAst(plan);
+    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",
+      baseName: source.baseName,
+      _presentFormula: source._presentFormula,
+      _presenceWitnesses: source._presenceWitnesses
+    }])) : current.available;
+    const nextAvailable = {
+      ...baseAvailable,
+      [sourceName]: {
+        name: sourceName,
+        mode: kind === "left" || kind === "full" ? "optional" : "required",
+        baseName: sourceBaseName,
+        _presentFormula: kind === "inner" || kind === "left" ? onFormula : ctx.trueFormula(),
+        _presenceWitnesses: presenceWitnesses
+      }
+    };
+    return ctx.makePlan({
+      selection: current.selection,
+      required: [...ctx.currentRequiredList(current.required), ...sourceRequired, ...ctx.extractRequiredFromDialectInputRuntime(on)].filter((name, index3, values) => !(name in nextAvailable) && values.indexOf(name) === index3),
+      available: nextAvailable,
+      dialect: current.dialect ?? table.dialect ?? onExpression[TypeId2].dialect
+    }, {
+      ...currentAst,
+      joins: [...currentAst.joins, {
+        kind,
+        tableName: sourceName,
+        baseTableName: sourceBaseName,
+        source: table,
+        on: onExpression
+      }]
+    }, 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[TypeId];
+    const currentAst = ctx.getAst(plan);
+    const currentQuery = ctx.getQueryState(plan);
+    const expression = ctx.toDialectExpression(value);
+    const required = ctx.extractRequiredFromDialectInputRuntime(value);
+    return ctx.makePlan({
+      selection: current.selection,
+      required: [...ctx.currentRequiredList(current.required), ...required].filter((name, index3, values) => !(name in current.available) && values.indexOf(name) === index3),
+      available: current.available,
+      dialect: current.dialect ?? expression[TypeId2].dialect
+    }, {
+      ...currentAst,
+      orderBy: [...currentAst.orderBy, {
+        kind: "orderBy",
+        value: expression,
+        direction
+      }]
+    }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
+  };
+  const lock = (mode, options2 = {}) => (plan) => {
+    const current = plan[TypeId];
+    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,
+      available: current.available,
+      dialect: current.dialect
+    }, {
+      ...currentAst,
+      lock: {
+        kind: "lock",
+        mode,
+        nowait: options2.nowait ?? false,
+        skipLocked: options2.skipLocked ?? false
+      }
+    }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
+  };
+  const distinct = () => (plan) => {
+    const current = plan[TypeId];
+    const currentAst = ctx.getAst(plan);
+    const currentQuery = ctx.getQueryState(plan);
+    return ctx.makePlan({
+      selection: current.selection,
+      required: current.required,
+      available: current.available,
+      dialect: current.dialect
+    }, {
+      ...currentAst,
+      distinct: true
+    }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
+  };
+  const limit = (value) => (plan) => {
+    const current = plan[TypeId];
+    const currentAst = ctx.getAst(plan);
+    const currentQuery = ctx.getQueryState(plan);
+    const expression = ctx.toDialectNumericExpression(value);
+    const required = ctx.extractRequiredFromDialectNumericInputRuntime(value);
+    return ctx.makePlan({
+      selection: current.selection,
+      required: [...ctx.currentRequiredList(current.required), ...required].filter((name, index3, values) => !(name in current.available) && values.indexOf(name) === index3),
+      available: current.available,
+      dialect: current.dialect ?? expression[TypeId2].dialect
+    }, {
+      ...currentAst,
+      limit: expression
+    }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
+  };
+  const offset = (value) => (plan) => {
+    const current = plan[TypeId];
+    const currentAst = ctx.getAst(plan);
+    const currentQuery = ctx.getQueryState(plan);
+    const expression = ctx.toDialectNumericExpression(value);
+    const required = ctx.extractRequiredFromDialectNumericInputRuntime(value);
+    return ctx.makePlan({
+      selection: current.selection,
+      required: [...ctx.currentRequiredList(current.required), ...required].filter((name, index3, values) => !(name in current.available) && values.indexOf(name) === index3),
+      available: current.available,
+      dialect: current.dialect ?? expression[TypeId2].dialect
+    }, {
+      ...currentAst,
+      offset: expression
+    }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
+  };
+  return {
+    buildSetOperation,
+    where,
+    from,
+    having,
+    crossJoin,
+    join,
+    orderBy,
+    lock,
+    distinct,
+    limit,
+    offset
+  };
+};
+
+// 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 isRecord = (value) => typeof value === "object" && value !== null;
+  const isTableTarget = (target) => typeof target === "object" && target !== null && (TypeId4 in target) && (TypeId in target);
+  const hasColumnRecord = (value) => isRecord(value.columns);
+  const isAliasedSource = (source) => {
+    if (!isRecord(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 isRecord(source.plan) && TypeId in source.plan && hasColumnRecord(source);
+      case "values":
+        return Array.isArray(source.rows) && hasColumnRecord(source);
+      case "unnest":
+        return isRecord(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" || !(TypeId2 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[TypeId2].dependencies));
+    const insertState = values === undefined ? "missing" : "ready";
+    return ctx.makePlan({
+      selection: {},
+      required: required.filter((name, index3, list) => name !== sourceName && list.indexOf(name) === index3),
+      available: {
+        [sourceName]: {
+          name: sourceName,
+          mode: "required",
+          baseName: sourceBaseName
+        }
+      },
+      dialect: target[TypeId].dialect
+    }, {
+      kind: "insert",
+      select: {},
+      into: {
+        kind: "from",
+        tableName: sourceName,
+        baseTableName: sourceBaseName,
+        source: target
+      },
+      values: assignments,
+      conflict: undefined,
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "write", "insert", target, insertState);
+  };
+  const attachInsertSource = (plan, source) => {
+    const current = plan[TypeId];
+    const currentAst = ctx.getAst(plan);
+    const currentQuery = ctx.getQueryState(plan);
+    const target = currentQuery.target;
+    const sourceName = currentAst.into.tableName;
+    if (typeof source === "object" && source !== null && "kind" in source && source.kind === "values") {
+      const normalized = ctx.buildInsertValuesRows(target, source.rows);
+      return ctx.makePlan({
+        selection: current.selection,
+        required: normalized.required.filter((name) => name !== sourceName),
+        available: current.available,
+        dialect: current.dialect
+      }, {
+        ...currentAst,
+        values: [],
+        insertSource: {
+          kind: "values",
+          columns: normalized.columns,
+          rows: normalized.rows
+        }
+      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement, currentQuery.target, "ready");
+    }
+    if (typeof source === "object" && source !== null && "kind" in source && source.kind === "unnest") {
+      const normalized = ctx.normalizeInsertUnnestValues(target, source.values);
+      return ctx.makePlan({
+        selection: current.selection,
+        required: [],
+        available: current.available,
+        dialect: current.dialect
+      }, {
+        ...currentAst,
+        values: [],
+        insertSource: {
+          kind: "unnest",
+          columns: normalized.columns,
+          values: normalized.values
+        }
+      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement, currentQuery.target, "ready");
+    }
+    const sourcePlan = source;
+    const selection = sourcePlan[TypeId].selection;
+    assertInsertSelectSource(sourcePlan, selection);
+    const columns = ctx.normalizeInsertSelectColumns(selection);
+    return ctx.makePlan({
+      selection: current.selection,
+      required: ctx.currentRequiredList(sourcePlan[TypeId].required),
+      available: current.available,
+      dialect: current.dialect
+    }, {
+      ...currentAst,
+      values: [],
+      insertSource: {
+        kind: "query",
+        columns,
+        query: sourcePlan
+      }
+    }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement, currentQuery.target, "ready");
+  };
+  const onConflict = (target, options2 = {}) => (plan) => {
+    const current = plan[TypeId];
+    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[TypeId2].dependencies)),
+      ...updateWhere ? Object.keys(updateWhere[TypeId2].dependencies) : [],
+      ...targetWhere ? Object.keys(targetWhere[TypeId2].dependencies) : []
+    ].filter((name, index3, list) => !(name in current.available) && list.indexOf(name) === index3);
+    return ctx.makePlan({
+      selection: current.selection,
+      required,
+      available: current.available,
+      dialect: current.dialect
+    }, {
+      ...currentAst,
+      conflict: {
+        kind: "conflict",
+        target: conflictTarget,
+        action: updateAssignments.length === 0 ? "doNothing" : "doUpdate",
+        values: updateAssignments.length === 0 ? undefined : updateAssignments,
+        where: updateWhere
+      }
+    }, 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));
+    const required = assignments.flatMap((entry) => Object.keys(entry.value[TypeId2].dependencies)).filter((name, index3, list) => !targetNames.has(name) && list.indexOf(name) === index3);
+    return ctx.makePlan({
+      selection: {},
+      required,
+      available: ctx.mutationAvailableSources(target),
+      dialect: primaryTarget.source[TypeId].dialect
+    }, {
+      kind: "update",
+      select: {},
+      target: primaryTarget,
+      targets,
+      set: assignments,
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, 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[TypeId2].dependencies)),
+      ...updateAssignments.flatMap((entry) => Object.keys(entry.value[TypeId2].dependencies))
+    ];
+    return ctx.makePlan({
+      selection: {},
+      required: required.filter((name, index3, list) => name !== sourceName && list.indexOf(name) === index3),
+      available: {
+        [sourceName]: {
+          name: sourceName,
+          mode: "required",
+          baseName: sourceBaseName
+        }
+      },
+      dialect: target[TypeId].dialect
+    }, {
+      kind: "insert",
+      select: {},
+      into: {
+        kind: "from",
+        tableName: sourceName,
+        baseTableName: sourceBaseName,
+        source: target
+      },
+      values: assignments,
+      conflict: {
+        kind: "conflict",
+        target: {
+          kind: "columns",
+          columns: ctx.normalizeConflictColumns(target, conflictColumns)
+        },
+        action: updateAssignments.length > 0 ? "doUpdate" : "doNothing",
+        values: updateAssignments.length > 0 ? updateAssignments : undefined
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, 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: {},
+      required: [],
+      available: ctx.mutationAvailableSources(target),
+      dialect: primaryTarget.source[TypeId].dialect
+    }, {
+      kind: "delete",
+      select: {},
+      target: primaryTarget,
+      targets,
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "write", "delete");
+  };
+  const truncate = (target, options2 = {}) => {
+    assertMutationTargets(target, "truncate");
+    const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
+    return ctx.makePlan({
+      selection: {},
+      required: [],
+      available: {},
+      dialect: target[TypeId].dialect
+    }, {
+      kind: "truncate",
+      select: {},
+      target: {
+        kind: "from",
+        tableName: sourceName,
+        baseTableName: sourceBaseName,
+        source: target
+      },
+      truncate: {
+        kind: "truncate",
+        restartIdentity: options2.restartIdentity ?? false,
+        cascade: options2.cascade ?? false
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, 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;
+    if (matched && "delete" in matched && "update" in matched) {
+      throw new Error("merge whenMatched cannot specify both update and delete");
+    }
+    const matchedPredicate = matched?.predicate ? ctx.toDialectExpression(matched.predicate) : undefined;
+    const matchedAssignments = matched && "update" in matched && matched.update ? ctx.buildMutationAssignments(target, matched.update) : [];
+    const notMatchedPredicate = notMatched?.predicate ? ctx.toDialectExpression(notMatched.predicate) : undefined;
+    const notMatchedAssignments = notMatched ? ctx.buildMutationAssignments(target, notMatched.values) : [];
+    const required = [
+      ...Object.keys(onExpression[TypeId2].dependencies),
+      ...matchedAssignments.flatMap((entry) => Object.keys(entry.value[TypeId2].dependencies)),
+      ...notMatchedAssignments.flatMap((entry) => Object.keys(entry.value[TypeId2].dependencies)),
+      ...matchedPredicate ? Object.keys(matchedPredicate[TypeId2].dependencies) : [],
+      ...notMatchedPredicate ? Object.keys(notMatchedPredicate[TypeId2].dependencies) : []
+    ].filter((name, index3, values) => name !== targetName && name !== usingName && values.indexOf(name) === index3);
+    return ctx.makePlan({
+      selection: {},
+      required,
+      available: {
+        [targetName]: {
+          name: targetName,
+          mode: "required",
+          baseName: targetBaseName
+        },
+        [usingName]: {
+          name: usingName,
+          mode: "required",
+          baseName: usingBaseName
+        }
+      },
+      dialect: target[TypeId].dialect
+    }, {
+      kind: "merge",
+      select: {},
+      target: {
+        kind: "from",
+        tableName: targetName,
+        baseTableName: targetBaseName,
+        source: target
+      },
+      using: {
+        kind: "from",
+        tableName: usingName,
+        baseTableName: usingBaseName,
+        source
+      },
+      merge: {
+        kind: "merge",
+        on: onExpression,
+        whenMatched: matched ? "delete" in matched && matched.delete ? {
+          kind: "delete",
+          predicate: matchedPredicate
+        } : {
+          kind: "update",
+          values: matchedAssignments,
+          predicate: matchedPredicate
+        } : undefined,
+        whenNotMatched: notMatched ? {
+          kind: "insert",
+          values: notMatchedAssignments,
+          predicate: notMatchedPredicate
+        } : undefined
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "write", "merge");
+  };
+  return {
+    insert,
+    attachInsertSource,
+    onConflict,
+    update,
+    upsert,
+    delete_,
+    truncate,
+    merge
+  };
+};
+
+// 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 isRecord = (value) => typeof value === "object" && value !== null;
+  const assertTableTarget = (target, apiName) => {
+    if (!isRecord(target) || !(TypeId4 in target) || !(TypeId in target)) {
+      throw new Error(`${apiName}(...) requires a table target`);
+    }
+  };
+  const validateIndexColumns = (target, columns) => {
+    const fields = target[TypeId4]?.fields;
+    if (fields === undefined) {
+      return;
+    }
+    for (const columnName of columns) {
+      if (!(columnName in fields)) {
+        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",
+      select: {},
+      transaction: {
+        kind: "transaction",
+        isolationLevel: options2.isolationLevel,
+        readOnly: options2.readOnly
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "transaction", "transaction");
+  };
+  const commit = () => ctx.makePlan({
+    selection: {},
+    required: [],
+    available: {},
+    dialect: ctx.profile.dialect
+  }, {
+    kind: "commit",
+    select: {},
+    transaction: {
+      kind: "commit"
+    },
+    where: [],
+    having: [],
+    joins: [],
+    groupBy: [],
+    orderBy: []
+  }, undefined, "transaction", "commit");
+  const rollback = () => ctx.makePlan({
+    selection: {},
+    required: [],
+    available: {},
+    dialect: ctx.profile.dialect
+  }, {
+    kind: "rollback",
+    select: {},
+    transaction: {
+      kind: "rollback"
+    },
+    where: [],
+    having: [],
+    joins: [],
+    groupBy: [],
+    orderBy: []
+  }, undefined, "transaction", "rollback");
+  const savepoint = (name) => ctx.makePlan({
+    selection: {},
+    required: [],
+    available: {},
+    dialect: ctx.profile.dialect
+  }, {
+    kind: "savepoint",
+    select: {},
+    transaction: {
+      kind: "savepoint",
+      name
+    },
+    where: [],
+    having: [],
+    joins: [],
+    groupBy: [],
+    orderBy: []
+  }, undefined, "transaction", "savepoint");
+  const rollbackTo = (name) => ctx.makePlan({
+    selection: {},
+    required: [],
+    available: {},
+    dialect: ctx.profile.dialect
+  }, {
+    kind: "rollbackTo",
+    select: {},
+    transaction: {
+      kind: "rollbackTo",
+      name
+    },
+    where: [],
+    having: [],
+    joins: [],
+    groupBy: [],
+    orderBy: []
+  }, undefined, "transaction", "rollbackTo");
+  const releaseSavepoint = (name) => ctx.makePlan({
+    selection: {},
+    required: [],
+    available: {},
+    dialect: ctx.profile.dialect
+  }, {
+    kind: "releaseSavepoint",
+    select: {},
+    transaction: {
+      kind: "releaseSavepoint",
+      name
+    },
+    where: [],
+    having: [],
+    joins: [],
+    groupBy: [],
+    orderBy: []
+  }, undefined, "transaction", "releaseSavepoint");
+  const createTable = (target, options2 = {}) => {
+    assertTableTarget(target, "createTable");
+    const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
+    return ctx.makePlan({
+      selection: {},
+      required: [],
+      available: {},
+      dialect: target[TypeId].dialect
+    }, {
+      kind: "createTable",
+      select: {},
+      target: {
+        kind: "from",
+        tableName: sourceName,
+        baseTableName: sourceBaseName,
+        source: target
+      },
+      ddl: {
+        kind: "createTable",
+        ifNotExists: options2.ifNotExists ?? false
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "ddl", "createTable");
+  };
+  const dropTable = (target, options2 = {}) => {
+    assertTableTarget(target, "dropTable");
+    const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
+    return ctx.makePlan({
+      selection: {},
+      required: [],
+      available: {},
+      dialect: target[TypeId].dialect
+    }, {
+      kind: "dropTable",
+      select: {},
+      target: {
+        kind: "from",
+        tableName: sourceName,
+        baseTableName: sourceBaseName,
+        source: target
+      },
+      ddl: {
+        kind: "dropTable",
+        ifExists: options2.ifExists ?? false
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, 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: {},
+      required: [],
+      available: {},
+      dialect: target[TypeId].dialect
+    }, {
+      kind: "createIndex",
+      select: {},
+      target: {
+        kind: "from",
+        tableName: sourceName,
+        baseTableName: sourceBaseName,
+        source: target
+      },
+      ddl: {
+        kind: "createIndex",
+        name: options2.name ?? ctx.defaultIndexName(sourceBaseName, normalizedColumns, options2.unique ?? false),
+        columns: normalizedColumns,
+        unique: options2.unique ?? false,
+        ifNotExists: options2.ifNotExists ?? false
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, 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: {},
+      required: [],
+      available: {},
+      dialect: target[TypeId].dialect
+    }, {
+      kind: "dropIndex",
+      select: {},
+      target: {
+        kind: "from",
+        tableName: sourceName,
+        baseTableName: sourceBaseName,
+        source: target
+      },
+      ddl: {
+        kind: "dropIndex",
+        name: options2.name ?? ctx.defaultIndexName(sourceBaseName, normalizedColumns, false),
+        ifExists: options2.ifExists ?? false
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "ddl", "dropIndex");
+  };
+  return {
+    transaction,
+    commit,
+    rollback,
+    savepoint,
+    rollbackTo,
+    releaseSavepoint,
+    createTable,
+    dropTable,
+    createIndex,
+    dropIndex
+  };
+};
+
 // src/internal/runtime/driver-value-mapping.ts
+import * as Schema4 from "effect/Schema";
+
+// src/internal/runtime/value.ts
 import * as Schema3 from "effect/Schema";
+var brandString = (pattern2, brand4) => Schema3.String.pipe(Schema3.pattern(pattern2), Schema3.brand(brand4));
+var localDatePattern = /^(\d{4})-(\d{2})-(\d{2})$/;
+var isValidLocalDateString = (value) => {
+  const match = localDatePattern.exec(value);
+  if (match === null) {
+    return false;
+  }
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const parsed = new Date(Date.UTC(year, month - 1, day));
+  parsed.setUTCFullYear(year);
+  return parsed.getUTCFullYear() === year && parsed.getUTCMonth() === month - 1 && parsed.getUTCDate() === day;
+};
+var localTimePattern = /^(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?$/;
+var isValidLocalTimeString = (value) => {
+  const match = localTimePattern.exec(value);
+  if (match === null) {
+    return false;
+  }
+  const hour = Number(match[1]);
+  const minute = Number(match[2]);
+  const second = Number(match[3]);
+  return hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59 && second >= 0 && second <= 59;
+};
+var offsetPattern = /^(?:Z|[+-](\d{2}):(\d{2}))$/;
+var isValidOffset = (value) => {
+  const match = offsetPattern.exec(value);
+  if (match === null) {
+    return false;
+  }
+  if (value === "Z") {
+    return true;
+  }
+  const hour = Number(match[1]);
+  const minute = Number(match[2]);
+  return hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59;
+};
+var offsetTimePattern = /^(\d{2}:\d{2}:\d{2}(?:\.\d+)?)(Z|[+-]\d{2}:\d{2})$/;
+var isValidOffsetTimeString = (value) => {
+  const match = offsetTimePattern.exec(value);
+  return match !== null && isValidLocalTimeString(match[1]) && isValidOffset(match[2]);
+};
+var localDateTimePattern = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}(?:\.\d+)?)$/;
+var isValidLocalDateTimeString = (value) => {
+  const match = localDateTimePattern.exec(value);
+  return match !== null && isValidLocalDateString(match[1]) && isValidLocalTimeString(match[2]);
+};
+var instantPattern = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}(?:\.\d+)?)(Z|[+-]\d{2}:\d{2})$/;
+var isValidInstantString = (value) => {
+  const match = instantPattern.exec(value);
+  return match !== null && isValidLocalDateString(match[1]) && isValidLocalTimeString(match[2]) && isValidOffset(match[3]);
+};
+var LocalDateStringSchema = Schema3.String.pipe(Schema3.pattern(localDatePattern), Schema3.filter(isValidLocalDateString), Schema3.brand("LocalDateString"));
+var LocalTimeStringSchema = Schema3.String.pipe(Schema3.pattern(localTimePattern), Schema3.filter(isValidLocalTimeString), Schema3.brand("LocalTimeString"));
+var OffsetTimeStringSchema = Schema3.String.pipe(Schema3.pattern(offsetTimePattern), Schema3.filter(isValidOffsetTimeString), Schema3.brand("OffsetTimeString"));
+var LocalDateTimeStringSchema = Schema3.String.pipe(Schema3.pattern(localDateTimePattern), Schema3.filter(isValidLocalDateTimeString), Schema3.brand("LocalDateTimeString"));
+var InstantStringSchema = Schema3.String.pipe(Schema3.pattern(instantPattern), Schema3.filter(isValidInstantString), Schema3.brand("InstantString"));
+var YearStringSchema = brandString(/^\d{4}$/, "YearString");
+var canonicalizeBigIntString = (input) => {
+  const trimmed = input.trim();
+  if (!/^-?\d+$/.test(trimmed)) {
+    throw new Error("Expected an integer-like bigint value");
+  }
+  return BigInt(trimmed).toString();
+};
+var isCanonicalBigIntString = (value) => {
+  try {
+    return canonicalizeBigIntString(value) === value;
+  } catch {
+    return false;
+  }
+};
+var canonicalizeDecimalString = (input) => {
+  const trimmed = input.trim();
+  const match = /^([+-]?)(\d+)(?:\.(\d+))?$/.exec(trimmed);
+  if (match === null) {
+    throw new Error("Expected a decimal string");
+  }
+  const sign = match[1] === "-" ? "-" : "";
+  const integer = match[2].replace(/^0+(?=\d)/, "") || "0";
+  const fraction = (match[3] ?? "").replace(/0+$/, "");
+  if (fraction.length === 0) {
+    if (integer === "0") {
+      return "0";
+    }
+    return `${sign}${integer}`;
+  }
+  return `${sign}${integer}.${fraction}`;
+};
+var isCanonicalDecimalString = (value) => {
+  try {
+    return canonicalizeDecimalString(value) === value;
+  } catch {
+    return false;
+  }
+};
+var BigIntStringSchema = Schema3.String.pipe(Schema3.filter(isCanonicalBigIntString), Schema3.brand("BigIntString"));
+var DecimalStringSchema = Schema3.String.pipe(Schema3.filter(isCanonicalDecimalString), Schema3.brand("DecimalString"));
+var JsonValueSchema = Schema3.suspend(() => Schema3.Union(Schema3.String, Schema3.Number.pipe(Schema3.finite()), Schema3.Boolean, Schema3.Null, Schema3.Array(JsonValueSchema), Schema3.Record({
+  key: Schema3.String,
+  value: JsonValueSchema
+})));
+var JsonPrimitiveSchema = Schema3.Union(Schema3.String, Schema3.Number.pipe(Schema3.finite()), Schema3.Boolean, Schema3.Null);
 
 // src/internal/runtime/normalize.ts
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isPlainRecord = (value) => {
+  if (!isRecord(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) => `${value.getUTCFullYear()}-${pad(value.getUTCMonth() + 1)}-${pad(value.getUTCDate())}`;
+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())}`;
@@ -1489,12 +2819,14 @@ var expectString = (value, label) => {
   }
   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" && value.trim() !== "") {
-    const parsed = Number(value);
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    const parsed = finiteNumberStringPattern.test(trimmed) ? Number(trimmed) : Number.NaN;
     if (Number.isFinite(parsed)) {
       return parsed;
     }
@@ -1534,25 +2866,11 @@ var normalizeBigIntString = (value) => {
   if (typeof value === "number" && Number.isSafeInteger(value)) {
     return BigInt(value).toString();
   }
-  if (typeof value === "string" && /^-?\d+$/.test(value.trim())) {
-    return BigInt(value.trim()).toString();
+  if (typeof value === "string") {
+    return canonicalizeBigIntString(value);
   }
   throw new Error("Expected an integer-like bigint value");
 };
-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) {
-    return `${sign}${integer}`;
-  }
-  return `${sign}${integer}.${fraction}`;
-};
 var normalizeDecimalString = (value) => {
   if (typeof value === "string") {
     return canonicalizeDecimalString(value);
@@ -1571,12 +2889,15 @@ var normalizeLocalDate = (value) => {
     return formatLocalDate(value);
   }
   const raw = expectString(value, "local date").trim();
-  if (/^\d{4}-\d{2}-\d{2}$/.test(raw)) {
+  if (isValidLocalDateString(raw)) {
     return raw;
   }
-  const parsed = new Date(raw);
-  if (!Number.isNaN(parsed.getTime())) {
-    return formatLocalDate(parsed);
+  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");
 };
@@ -1585,7 +2906,7 @@ var normalizeLocalTime = (value) => {
     return formatLocalTime(value);
   }
   const raw = expectString(value, "local time").trim();
-  if (/^\d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(raw)) {
+  if (isValidLocalTimeString(raw)) {
     return raw;
   }
   throw new Error("Expected a local-time value");
@@ -1595,7 +2916,7 @@ var normalizeOffsetTime = (value) => {
     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)) {
+  if (isValidOffsetTimeString(raw)) {
     return raw;
   }
   throw new Error("Expected an offset-time value");
@@ -1605,11 +2926,13 @@ var normalizeLocalDateTime = (value) => {
     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");
+  const canonicalLocalDateTime = raw.replace(" ", "T");
+  if (isValidLocalDateTimeString(canonicalLocalDateTime)) {
+    return canonicalLocalDateTime;
   }
-  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);
+  const canonicalInstant = raw.replace(" ", "T").replace(/z$/, "Z");
+  if (isValidInstantString(canonicalInstant)) {
+    const parsed = new Date(canonicalInstant);
     if (!Number.isNaN(parsed.getTime())) {
       return formatLocalDateTime(parsed);
     }
@@ -1624,7 +2947,11 @@ var normalizeInstant = (value) => {
   if (!/[zZ]|[+-]\d{2}:\d{2}$/.test(raw)) {
     throw new Error("Instant values require a timezone offset");
   }
-  const parsed = new Date(raw);
+  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");
   }
@@ -1656,25 +2983,33 @@ var isJsonValue = (value) => {
   }
   switch (typeof value) {
     case "string":
-    case "number":
     case "boolean":
       return true;
+    case "number":
+      return Number.isFinite(value);
     case "object":
       if (Array.isArray(value)) {
         return value.every(isJsonValue);
       }
-      return isRecord(value) && Object.values(value).every(isJsonValue);
+      return isPlainRecord(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;
+    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;
     }
-    throw new Error("Parsed JSON value is not a valid JSON runtime");
   }
   if (isJsonValue(value)) {
     return value;
@@ -1809,22 +3144,61 @@ 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 = (schema2, value) => schema2 !== undefined && Schema4.is(schema2)(value);
 var encodeWithSchema = (schema2, value) => {
   if (schema2 === undefined) {
     return { value, encoded: false };
   }
-  if (!Schema3.is(schema2)(value)) {
+  if (!Schema4.is(schema2)(value)) {
     return { value, encoded: false };
   }
   return {
-    value: Schema3.encodeUnknownSync(schema2)(value),
+    value: Schema4.encodeUnknownSync(schema2)(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;
@@ -1832,6 +3206,9 @@ var toDriverValue = (value, context) => {
   if (custom !== undefined && dbType !== undefined) {
     return custom(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) => {
@@ -1843,6 +3220,12 @@ var fromDriverValue = (value, context) => {
   if (custom !== undefined && dbType !== undefined) {
     return custom(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`;
@@ -1930,6 +3313,20 @@ var validateProjections = (projections) => {
 };
 
 // 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()}`;
@@ -1948,15 +3345,62 @@ var literalGroupingKey = (value) => {
       return `literal:${JSON.stringify(value)}`;
   }
 };
+var isExpression2 = (value) => value !== null && typeof value === "object" && (TypeId2 in value);
+var expressionGroupingKey = (value) => isExpression2(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" && (TypeId7 in value);
+var jsonOpaquePathGroupingKey = (value) => {
+  if (isJsonPath(value)) {
+    return `jsonpath:${jsonPathGroupingKey(value.segments)}`;
+  }
+  if (typeof value === "string") {
+    return `jsonpath:${escapeGroupingText(value)}`;
+  }
+  if (isExpression2(value)) {
+    return `jsonpath:${groupingKeyOfExpression(value)}`;
+  }
+  return "jsonpath:unknown";
+};
+var jsonEntryGroupingKey = (entry) => `${escapeGroupingText(entry.key)}=>${groupingKeyOfExpression(entry.value)}`;
 var groupingKeyOfExpression = (expression) => {
   const ast = expression[TypeId3];
   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":
@@ -1974,8 +3418,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":
@@ -1987,6 +3438,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");
   }
@@ -2004,15 +3503,15 @@ var dedupeGroupedExpressions = (values) => {
 };
 
 // src/internal/aggregation-validation.ts
-var isExpression2 = (value) => typeof value === "object" && value !== null && (TypeId2 in value);
+var isExpression3 = (value) => typeof value === "object" && value !== null && (TypeId2 in value);
 var selectionHasAggregate = (selection) => {
-  if (isExpression2(selection)) {
+  if (isExpression3(selection)) {
     return selection[TypeId2].kind === "aggregate";
   }
   return Object.values(selection).some((value) => selectionHasAggregate(value));
 };
 var isGroupedSelectionValid = (selection, groupedExpressions) => {
-  if (isExpression2(selection)) {
+  if (isExpression3(selection)) {
     const aggregation = selection[TypeId2].kind;
     if (aggregation === "aggregate") {
       return true;
@@ -2065,7 +3564,46 @@ var renderCastType = (dialect, dbType) => {
       return dbType.kind;
   }
 };
-var renderDdlExpression = (expression, state, dialect) => isSchemaExpression(expression) ? render(expression) : renderExpression(expression, state, dialect);
+var renderPostgresDdlString = (value) => `'${value.replaceAll("'", "''")}'`;
+var renderPostgresDdlBytes = (value) => `decode('${Array.from(value, (byte) => byte.toString(16).padStart(2, "0")).join("")}', 'hex')`;
+var renderPostgresDdlLiteral = (value, state, context = {}) => {
+  const driverValue = toDriverValue(value, {
+    dialect: "postgres",
+    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 renderPostgresDdlString(driverValue);
+    case "object":
+      if (driverValue instanceof Uint8Array) {
+        return renderPostgresDdlBytes(driverValue);
+      }
+      break;
+  }
+  throw new Error("Unsupported postgres DDL literal value");
+};
+var renderDdlExpression = (expression, state, dialect) => {
+  if (isSchemaExpression(expression)) {
+    return render(expression);
+  }
+  return renderExpression(expression, state, {
+    ...dialect,
+    renderLiteral: renderPostgresDdlLiteral
+  });
+};
 var renderColumnDefinition = (dialect, state, columnName, column) => {
   const clauses = [
     dialect.quoteIdentifier(columnName),
@@ -2097,14 +3635,16 @@ var renderCreateTableSql = (targetSource, state, dialect, ifNotExists) => {
         break;
       case "foreignKey": {
         const reference = option2.references();
-        definitions.push(`${option2.name ? `constraint ${dialect.quoteIdentifier(option2.name)} ` : ""}foreign key (${option2.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")}) references ${dialect.renderTableReference(reference.tableName, reference.tableName, reference.schemaName)} (${reference.columns.map((column) => dialect.quoteIdentifier(column)).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((column) => dialect.quoteIdentifier(column)).join(", ")}) references ${dialect.renderTableReference(reference.tableName, reference.tableName, reference.schemaName)} (${reference.columns.map((column) => dialect.quoteIdentifier(column)).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(", ")})`;
@@ -2113,10 +3653,56 @@ var renderCreateIndexSql = (targetSource, ddl, state, dialect) => {
   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((column) => dialect.quoteIdentifier(column)).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" && (TypeId2 in value);
-var isJsonDbType = (dbType) => dbType.kind === "jsonb" || dbType.kind === "json" || ("variant" in dbType) && dbType.variant === "json";
-var isJsonExpression = (value) => isExpression3(value) && isJsonDbType(value[TypeId2].dbType);
+var renderDropIndexSql = (targetSource, ddl, state, dialect) => {
+  if (dialect.name === "postgres") {
+    const schemaName = typeof targetSource.source === "object" && targetSource.source !== null && TypeId4 in targetSource.source ? targetSource.source[TypeId4].schemaName : undefined;
+    const indexName = schemaName === undefined || schemaName === "public" ? dialect.quoteIdentifier(ddl.name) : `${dialect.quoteIdentifier(schemaName)}.${dialect.quoteIdentifier(ddl.name)}`;
+    return `drop index${ddl.ifExists ? " if exists" : ""} ${indexName}`;
+  }
+  return `drop index ${dialect.quoteIdentifier(ddl.name)} on ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)}`;
+};
+var isExpression4 = (value) => value !== null && typeof value === "object" && (TypeId2 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[TypeId2].dbType);
+var postgresRangeSubtypeByKind = {
+  int4range: "int4",
+  int8range: "int8",
+  numrange: "numeric",
+  tsrange: "timestamp",
+  tstzrange: "timestamptz",
+  daterange: "date",
+  int4multirange: "int4",
+  int8multirange: "int8",
+  nummultirange: "numeric",
+  tsmultirange: "timestamp",
+  tstzmultirange: "timestamptz",
+  datemultirange: "date"
+};
+var postgresRangeSubtypeKey = (dbType) => {
+  if ("base" in dbType) {
+    return postgresRangeSubtypeKey(dbType.base);
+  }
+  if ("subtype" in dbType) {
+    return postgresRangeSubtypeKey(dbType.subtype) ?? dbType.subtype.kind;
+  }
+  return postgresRangeSubtypeByKind[dbType.kind];
+};
+var assertCompatiblePostgresRangeOperands = (left, right) => {
+  const leftKey = postgresRangeSubtypeKey(left[TypeId2].dbType);
+  const rightKey = postgresRangeSubtypeKey(right[TypeId2].dbType);
+  if (leftKey !== undefined && rightKey !== undefined && leftKey !== rightKey) {
+    throw new Error("Incompatible postgres range operands");
+  }
+};
 var unsupportedJsonFeature = (dialect, feature) => {
   const error = new Error(`Unsupported JSON feature for ${dialect.name}: ${feature}`);
   Object.assign(error, {
@@ -2159,15 +3745,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":
@@ -2210,13 +3797,13 @@ var renderPostgresJsonAccessStep = (segment, textMode, state, dialect) => {
     case "key":
       return `${textMode ? "->>" : "->"} ${dialect.renderLiteral(segment.key, state)}`;
     case "index":
-      return `${textMode ? "->>" : "->"} ${dialect.renderLiteral(String(segment.index), state)}`;
+      return `${textMode ? "->>" : "->"} ${dialect.renderLiteral(segment.index, state)}`;
     default:
       throw new Error("Postgres exact JSON access requires key/index segments");
   }
 };
 var renderPostgresJsonValue = (value, state, dialect) => {
-  if (!isExpression3(value)) {
+  if (!isExpression4(value)) {
     throw new Error("Expected a JSON expression");
   }
   const rendered = renderExpression(value, state, dialect);
@@ -2234,13 +3821,21 @@ var expressionDriverContext = (expression, state, dialect) => ({
   driverValueMapping: expression[TypeId2].driverValueMapping
 });
 var renderJsonInputExpression = (expression, state, dialect) => renderJsonSelectSql(renderExpression(expression, state, dialect), expressionDriverContext(expression, state, dialect));
-var encodeArrayValues = (values, column, state, dialect) => values.map((value) => toDriverValue(value, {
-  dialect: dialect.name,
-  valueMappings: state.valueMappings,
-  dbType: column.metadata.dbType,
-  runtimeSchema: column.schema,
-  driverValueMapping: column.metadata.driverValueMapping
-}));
+var encodeArrayValues = (values, column, state, dialect) => values.map((value) => {
+  if (value === null && column.metadata.nullable) {
+    return null;
+  }
+  const runtimeSchemaAccepts = column.schema !== undefined && Schema5.is(column.schema)(value);
+  const normalizedValue = runtimeSchemaAccepts ? value : normalizeDbValue(column.metadata.dbType, value);
+  const encodedValue = column.schema === undefined || runtimeSchemaAccepts ? normalizedValue : Schema5.decodeUnknownSync(column.schema)(normalizedValue);
+  return toDriverValue(encodedValue, {
+    dialect: dialect.name,
+    valueMappings: state.valueMappings,
+    dbType: column.metadata.dbType,
+    runtimeSchema: column.schema,
+    driverValueMapping: column.metadata.driverValueMapping
+  });
+});
 var renderPostgresJsonKind = (value) => value[TypeId2].dbType.kind === "jsonb" ? "jsonb" : "json";
 var renderJsonOpaquePath = (value, state, dialect) => {
   if (isJsonPathValue(value)) {
@@ -2249,7 +3844,7 @@ var renderJsonOpaquePath = (value, state, dialect) => {
   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");
@@ -2267,7 +3862,7 @@ var renderFunctionCall = (name, args, state, dialect) => {
     if (source === undefined) {
       throw new Error("Unsupported SQL extract expression");
     }
-    const fieldRuntime = isExpression3(field) && field[TypeId2].dbType.kind === "text" && typeof field[TypeId2].runtime === "string" ? field[TypeId2].runtime : undefined;
+    const fieldRuntime = isExpression4(field) && field[TypeId2].dbType.kind === "text" && typeof field[TypeId2].runtime === "string" ? field[TypeId2].runtime : undefined;
     const renderedField = fieldRuntime ?? renderExpression(field, state, dialect);
     return `extract(${renderedField} from ${renderExpression(source, state, dialect)})`;
   }
@@ -2305,7 +3900,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);
@@ -2328,7 +3923,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);
@@ -2354,7 +3949,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     }
     case "jsonConcat":
     case "jsonMerge": {
-      if (!isExpression3(ast.left) || !isExpression3(ast.right)) {
+      if (!isExpression4(ast.left) || !isExpression4(ast.right)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -2391,7 +3986,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       return;
     }
     case "jsonToJson":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -2402,7 +3997,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonToJsonb":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -2413,7 +4008,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonTypeOf":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -2425,7 +4020,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonLength":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -2440,21 +4035,21 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonKeys":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
         const baseSql = renderExpression(base, state, dialect);
         const typeOf = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_typeof`;
         const objectKeys = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_object_keys`;
-        return `(case when ${typeOf}(${baseSql}) = 'object' then array(select ${objectKeys}(${baseSql})) else null end)`;
+        return `(case when ${typeOf}(${baseSql}) = 'object' then to_json(array(select ${objectKeys}(${baseSql}))) else null end)`;
       }
       if (dialect.name === "mysql") {
         return `json_keys(${renderExpression(base, state, dialect)})`;
       }
       return;
     case "jsonStripNulls":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -2465,14 +4060,14 @@ 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") {
         const baseSql = renderPostgresJsonValue(base, state, dialect);
         if (segments.length === 1 && (segments[0].kind === "key" || segments[0].kind === "index")) {
           const segment = segments[0];
-          return `(${baseSql} - ${segment.kind === "key" ? dialect.renderLiteral(segment.key, state) : dialect.renderLiteral(String(segment.index), state)})`;
+          return `(${baseSql} - ${segment.kind === "key" ? dialect.renderLiteral(segment.key, state) : dialect.renderLiteral(segment.index, state)})`;
         }
         return `(${baseSql} #- ${renderPostgresJsonPathArray(segments, state, dialect)})`;
       }
@@ -2483,11 +4078,11 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     }
     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;
@@ -2504,7 +4099,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       return;
     }
     case "jsonPathExists": {
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       const path2 = ast.path ?? ast.query ?? ast.right;
@@ -2520,7 +4115,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;
@@ -2547,6 +4142,11 @@ var renderJoinSourcesForMutation = (joins, state, dialect) => joins.map((join) =
 var renderFromSources = (sources, state, dialect) => sources.map((source) => renderSourceReference(source.source, source.tableName, source.baseTableName, state, dialect)).join(", ");
 var renderJoinPredicatesForMutation = (joins, state, dialect) => joins.flatMap((join) => join.kind === "cross" || !join.on ? [] : [renderExpression(join.on, state, dialect)]);
 var renderDeleteTargets = (targets, dialect) => targets.map((target) => dialect.quoteIdentifier(target.tableName)).join(", ");
+var assertMergeActionKind = (kind, allowed) => {
+  if (typeof kind !== "string" || !allowed.includes(kind)) {
+    throw new Error("Unsupported merge action kind");
+  }
+};
 var renderMysqlMutationLock = (lock, statement) => {
   if (!lock) {
     return "";
@@ -2566,8 +4166,9 @@ 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");
@@ -2585,13 +4186,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 {
@@ -2599,7 +4203,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, index3) => key2 !== rightKeys[index3])) {
+    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) {
@@ -2607,8 +4288,9 @@ 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)}`);
@@ -2636,19 +4318,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(" ");
@@ -2656,28 +4344,34 @@ 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((column) => dialect.quoteIdentifier(column)).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((column) => dialect.quoteIdentifier(column)).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((column) => dialect.quoteIdentifier(column)).join(", ");
-        const renderedQuery = renderQueryAst(getAst(insertAst.insertSource.query), state, dialect);
+      } else if (insertSource?.kind === "query") {
+        const columns = insertSource.columns.map((column) => dialect.quoteIdentifier(column)).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((column) => dialect.quoteIdentifier(column)).join(", ");
+      } else if (insertSource?.kind === "unnest") {
+        const columns = insertSource.columns.map((column) => dialect.quoteIdentifier(column)).join(", ");
         if (dialect.name === "postgres") {
           const table = targetSource.source;
           const fields = table[TypeId4].fields;
-          const rendered = unnestSource.values.map((entry) => `cast(${dialect.renderLiteral(encodeArrayValues(entry.values, fields[entry.columnName], state, dialect), state)} as ${renderCastType(dialect, fields[entry.columnName].metadata.dbType)}[])`).join(", ");
+          const rendered = insertSource.values.map((entry) => `cast(${dialect.renderLiteral(encodeArrayValues(entry.values, fields[entry.columnName], state, dialect), state)} as ${renderCastType(dialect, fields[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 }, (_, index3) => `(${unnestSource.values.map((entry) => dialect.renderLiteral(entry.values[index3], state, targetSource.source[TypeId4].fields[entry.columnName][TypeId2])).join(", ")})`).join(", ");
+          const rowCount = insertSource.values[0]?.values.length ?? 0;
+          const rows = Array.from({ length: rowCount }, (_, index3) => `(${insertSource.values.map((entry) => dialect.renderLiteral(entry.values[index3], state, targetSource.source[TypeId4].fields[entry.columnName][TypeId2])).join(", ")})`).join(", ");
           sql += ` (${columns}) values ${rows}`;
         }
       } else {
@@ -2689,13 +4383,16 @@ var renderQueryAst = (ast, state, dialect) => {
           sql += " default 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.action === "doNothing" && conflict.where) {
+          throw new Error("conflict action predicates require update assignments");
+        }
+        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((column) => dialect.quoteIdentifier(column)).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((column) => dialect.quoteIdentifier(column)).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}`;
@@ -2710,10 +4407,29 @@ 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.orderBy.length > 0) {
+        throw new Error("orderBy(...) is not supported for update statements");
+      }
+      if (updateAst.limit) {
+        throw new Error("limit(...) is not supported for update statements");
+      }
+      if (updateAst.offset) {
+        throw new Error("offset(...) is not supported for update statements");
+      }
+      if (updateAst.lock) {
+        throw new Error("lock(...) 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");
@@ -2756,6 +4472,22 @@ 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.orderBy.length > 0 && dialect.name === "postgres") {
+        throw new Error("orderBy(...) is not supported for delete statements");
+      }
+      if (deleteAst.limit && dialect.name === "postgres") {
+        throw new Error("limit(...) is not supported for delete statements");
+      }
+      if (deleteAst.offset) {
+        throw new Error("offset(...) is not supported for delete statements");
+      }
+      if (deleteAst.lock) {
+        throw new Error("lock(...) 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];
@@ -2794,12 +4526,14 @@ var renderQueryAst = (ast, state, dialect) => {
     }
     case "truncate": {
       const truncateAst = ast;
+      assertNoStatementQueryClauses(truncateAst, "truncate");
+      const truncate = expectTruncateClause(truncateAst.truncate);
       const targetSource = truncateAst.target;
       sql = `truncate table ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)}`;
-      if (truncateAst.truncate?.restartIdentity) {
+      if (truncate.restartIdentity) {
         sql += " restart identity";
       }
-      if (truncateAst.truncate?.cascade) {
+      if (truncate.cascade) {
         sql += " cascade";
       }
       break;
@@ -2812,8 +4546,18 @@ var renderQueryAst = (ast, state, dialect) => {
       const targetSource = mergeAst.target;
       const usingSource = mergeAst.using;
       const merge = mergeAst.merge;
+      if (merge.kind !== "merge") {
+        throw new Error("Unsupported merge statement kind");
+      }
+      if (Object.keys(mergeAst.select).length > 0) {
+        throw new Error("returning(...) is not supported for merge statements");
+      }
+      if (!merge.whenMatched && !merge.whenNotMatched) {
+        throw new Error("merge statements require at least one action");
+      }
       sql = `merge into ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} using ${renderSourceReference(usingSource.source, usingSource.tableName, usingSource.baseTableName, state, dialect)} on ${renderExpression(merge.on, state, dialect)}`;
       if (merge.whenMatched) {
+        assertMergeActionKind(merge.whenMatched.kind, ["update", "delete"]);
         sql += " when matched";
         if (merge.whenMatched.predicate) {
           sql += ` and ${renderExpression(merge.whenMatched.predicate, state, dialect)}`;
@@ -2821,14 +4565,21 @@ var renderQueryAst = (ast, state, dialect) => {
         if (merge.whenMatched.kind === "delete") {
           sql += " then delete";
         } else {
+          if (merge.whenMatched.values.length === 0) {
+            throw new Error("merge update actions require at least one assignment");
+          }
           sql += ` then update set ${merge.whenMatched.values.map((entry) => `${dialect.quoteIdentifier(entry.columnName)} = ${renderExpression(entry.value, state, dialect)}`).join(", ")}`;
         }
       }
       if (merge.whenNotMatched) {
+        assertMergeActionKind(merge.whenNotMatched.kind, ["insert"]);
         sql += " when not matched";
         if (merge.whenNotMatched.predicate) {
           sql += ` and ${renderExpression(merge.whenNotMatched.predicate, state, dialect)}`;
         }
+        if (merge.whenNotMatched.values.length === 0) {
+          throw new Error("merge insert actions require at least one value");
+        }
         sql += ` then insert (${merge.whenNotMatched.values.map((entry) => dialect.quoteIdentifier(entry.columnName)).join(", ")}) values (${merge.whenNotMatched.values.map((entry) => renderExpression(entry.value, state, dialect)).join(", ")})`;
       }
       break;
@@ -2839,32 +4590,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
@@ -2887,9 +4646,14 @@ 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 rendered = renderQueryAst(getAst(cte.plan), state, dialect, { emitCtes: false });
       state.ctes.push({
         name: cte.name,
         sql: rendered.sql,
@@ -2901,11 +4665,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 lateral = source;
-    return `lateral (${renderQueryAst(getAst(lateral.plan), state, dialect).sql}) as ${dialect.quoteIdentifier(lateral.name)}`;
+    return `lateral (${renderQueryAst(getAst(lateral.plan), nestedRenderState(state), dialect).sql}) as ${dialect.quoteIdentifier(lateral.name)}`;
   }
   if (typeof source === "object" && source !== null && source.kind === "values") {
     const values = source;
@@ -2926,6 +4690,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[TypeId3];
   const jsonSql = renderJsonExpression(expression, rawAst, state, dialect);
@@ -2936,8 +4707,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[TypeId2]);
     case "excluded":
       return dialect.name === "mysql" ? `values(${dialect.quoteIdentifier(ast.columnName)})` : `excluded.${dialect.quoteIdentifier(ast.columnName)}`;
@@ -2977,6 +4751,7 @@ var renderExpression = (expression, state, dialect) => {
       return dialect.name === "mysql" ? `(${renderExpression(ast.left, state, dialect)} <=> ${renderExpression(ast.right, state, dialect)})` : `(${renderExpression(ast.left, state, dialect)} is not distinct from ${renderExpression(ast.right, state, dialect)})`;
     case "contains":
       if (dialect.name === "postgres") {
+        assertCompatiblePostgresRangeOperands(ast.left, ast.right);
         const left = isJsonExpression(ast.left) ? renderPostgresJsonValue(ast.left, state, dialect) : renderExpression(ast.left, state, dialect);
         const right = isJsonExpression(ast.right) ? renderPostgresJsonValue(ast.right, state, dialect) : renderExpression(ast.right, state, dialect);
         return `(${left} @> ${right})`;
@@ -2987,6 +4762,7 @@ var renderExpression = (expression, state, dialect) => {
       throw new Error("Unsupported container operator for SQL rendering");
     case "containedBy":
       if (dialect.name === "postgres") {
+        assertCompatiblePostgresRangeOperands(ast.left, ast.right);
         const left = isJsonExpression(ast.left) ? renderPostgresJsonValue(ast.left, state, dialect) : renderExpression(ast.left, state, dialect);
         const right = isJsonExpression(ast.right) ? renderPostgresJsonValue(ast.right, state, dialect) : renderExpression(ast.right, state, dialect);
         return `(${left} <@ ${right})`;
@@ -2997,6 +4773,7 @@ var renderExpression = (expression, state, dialect) => {
       throw new Error("Unsupported container operator for SQL rendering");
     case "overlaps":
       if (dialect.name === "postgres") {
+        assertCompatiblePostgresRangeOperands(ast.left, ast.right);
         const left = isJsonExpression(ast.left) ? renderPostgresJsonValue(ast.left, state, dialect) : renderExpression(ast.left, state, dialect);
         const right = isJsonExpression(ast.right) ? renderPostgresJsonValue(ast.right, state, dialect) : renderExpression(ast.right, state, dialect);
         return `(${left} && ${right})`;
@@ -3022,14 +4799,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)})`;
@@ -3038,15 +4827,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;
@@ -3131,7 +4920,8 @@ var inlineLiteralDialect = {
 var renderDdlExpressionSql = (expression) => isSchemaExpression(expression) ? render(expression) : renderExpression(expression, {
   params: [],
   ctes: [],
-  cteNames: new Set
+  cteNames: new Set,
+  cteSources: new Map
 }, inlineLiteralDialect);
 var stripRedundantOuterParens = (value) => {
   let current = value.trim();
@@ -3182,10 +4972,14 @@ var normalizeDdlExpressionSql = (expression) => {
 };
 
 // src/postgres/schema-management.ts
-import * as Schema4 from "effect/Schema";
+import * as Schema6 from "effect/Schema";
 import { pipeArguments as pipeArguments5 } from "effect/Pipeable";
 var EnumTypeId = Symbol.for("effect-qb/SchemaManagement/Enum");
 var SequenceTypeId = Symbol.for("effect-qb/SchemaManagement/Sequence");
+var safeUnquotedIdentifier = /^[a-z_][a-z0-9_$]*$/;
+var quoteIdentifier2 = (value) => `"${value.replaceAll('"', '""')}"`;
+var renderIdentifier = (value) => safeUnquotedIdentifier.test(value) ? value : quoteIdentifier2(value);
+var renderQualifiedTypeName = (name, schemaName) => schemaName === undefined || schemaName === "public" ? renderIdentifier(name) : `${renderIdentifier(schemaName)}.${renderIdentifier(name)}`;
 var EnumProto = {
   pipe() {
     return pipeArguments5(this, arguments);
@@ -3196,13 +4990,13 @@ var EnumProto = {
   type() {
     return {
       dialect: "postgres",
-      kind: this.qualifiedName(),
+      kind: renderQualifiedTypeName(this.name, this.schemaName),
       variant: "enum"
     };
   },
   column() {
-    const values = this.values.map((value) => Schema4.Literal(value));
-    return makeColumnDefinition(values.length === 1 ? values[0] : Schema4.Union(...values), {
+    const values = this.values.map((value) => Schema6.Literal(value));
+    return makeColumnDefinition(values.length === 1 ? values[0] : Schema6.Union(...values), {
       dbType: this.type(),
       nullable: false,
       hasDefault: false,
@@ -3210,7 +5004,7 @@ var EnumProto = {
       primaryKey: false,
       unique: false,
       references: undefined,
-      ddlType: this.qualifiedName(),
+      ddlType: renderQualifiedTypeName(this.name, this.schemaName),
       identity: undefined,
       enum: {
         name: this.name,
@@ -3311,17 +5105,17 @@ var fromDiscoveredValues = (values) => {
   const enums = new Map;
   for (const value of values) {
     if (isEnumDefinition(value)) {
-      enums.set(enumKey(value.schemaName, value.name), toEnumModel(value));
+      enums.set(modelIdentityKey(value.schemaName, value.name), toEnumModel(value));
     } else if (isTableDefinition(value)) {
       for (const enumModel of enumModelsOfTable(value)) {
-        const key2 = enumKey(enumModel.schemaName, enumModel.name);
+        const key2 = modelIdentityKey(enumModel.schemaName, enumModel.name);
         const existing = enums.get(key2);
         if (existing === undefined) {
           enums.set(key2, enumModel);
           continue;
         }
         if (JSON.stringify(existing.values) !== JSON.stringify(enumModel.values)) {
-          throw new Error(`Conflicting enum definitions discovered for '${key2}'`);
+          throw new Error(`Conflicting enum definitions discovered for '${enumKey(enumModel.schemaName, enumModel.name)}'`);
         }
       }
     }
@@ -3334,6 +5128,7 @@ var fromDiscoveredValues = (values) => {
 };
 var tableKey = (schemaName, name) => `${schemaName ?? "public"}.${name}`;
 var enumKey = (schemaName, name) => `${schemaName ?? "public"}.${name}`;
+var modelIdentityKey = (schemaName, name) => JSON.stringify([schemaName ?? "public", name]);
 export {
   toTableModel,
   toEnumModel,