effect-qb 0.20.0 → 0.22.0

package/dist/sqlite.js

@@ -1752,14 +1752,46 @@ var narrowSqliteDriverErrorForReadQuery = (error) => {
     cause: error
   };
 };
-// src/sqlite/json.ts
-var exports_json = {};
-__export(exports_json, {
-  typeOf: () => typeOf,
-  stripNulls: () => stripNulls,
-  pathMatch: () => pathMatch,
-  length: () => length,
-  insert: () => insert
+// src/sqlite/function/index.ts
+var exports_function = {};
+__export(exports_function, {
+  window: () => exports_window,
+  upper: () => upper,
+  temporal: () => exports_temporal,
+  sum: () => sum,
+  string: () => exports_string,
+  rowNumber: () => rowNumber,
+  round: () => round2,
+  rank: () => rank,
+  over: () => over,
+  numeric: () => exports_numeric,
+  now: () => now,
+  modulo: () => modulo2,
+  min: () => min,
+  max: () => max,
+  lower: () => lower,
+  localTimestamp: () => localTimestamp,
+  localTime: () => localTime,
+  lastValue: () => lastValue2,
+  firstValue: () => firstValue2,
+  denseRank: () => denseRank,
+  currentTimestamp: () => currentTimestamp,
+  currentTime: () => currentTime,
+  currentDate: () => currentDate,
+  count: () => count,
+  core: () => exports_core,
+  concat: () => concat,
+  coalesce: () => coalesce,
+  call: () => call,
+  avg: () => avg,
+  aggregate: () => exports_aggregate
+});
+
+// src/sqlite/function/core.ts
+var exports_core = {};
+__export(exports_core, {
+  coalesce: () => coalesce,
+  call: () => call
 });
 
 // src/sqlite/internal/dsl.ts
@@ -2593,8 +2625,9 @@ var normalizeOffsetTime = (value) => {
     return `${formatLocalTime(validDate(value))}Z`;
   }
   const raw = expectString(value, "offset time").trim();
-  if (isValidOffsetTimeString(raw)) {
-    return raw;
+  const canonical = raw.replace(/([+-]\d{2})$/, "$1:00").replace(/([+-]\d{2})(\d{2})$/, "$1:$2");
+  if (isValidOffsetTimeString(canonical)) {
+    return canonical;
   }
   throw new Error("Expected an offset-time value");
 };
@@ -3652,6 +3685,14 @@ var castTargetGroupingKey = (target) => {
 };
 var escapeGroupingText = (value) => value.replace(/\\/g, "\\\\").replace(/,/g, "\\,").replace(/\|/g, "\\|").replace(/=/g, "\\=").replace(/>/g, "\\>");
 var functionCallNameGroupingKey = (name) => escapeGroupingText(name);
+var customSqlGroupingKey = (strings, values) => strings.map((part, index4) => {
+  const value = values[index4];
+  if (value === undefined) {
+    return escapeGroupingText(part);
+  }
+  const rendered = isExpression2(value) ? groupingKeyOfExpression(value) : `identifier:${value.parts.map(escapeGroupingText).join(".")}`;
+  return `${escapeGroupingText(part)}${rendered}`;
+}).join("|");
 var quantifiedComparisonGroupingName = (kind) => kind === "comparisonAny" ? "compareAny" : "compareAll";
 var caseGroupingKey = (branches, fallback) => {
   const typedBranches = branches;
@@ -3733,12 +3774,19 @@ var groupingKeyOfExpression = (expression) => {
       return `collate(${requiredExpressionGroupingKey("collate", ast.value)},${collationGroupingKey(ast.collation)})`;
     case "function":
       return `function(${functionCallNameGroupingKey(ast.name)},${functionCallArgsGroupingKey(ast.args)})`;
+    case "customSql":
+      return `customSql(${customSqlGroupingKey(ast.strings, ast.values)})`;
     case "isNull":
     case "isNotNull":
     case "not":
     case "upper":
     case "lower":
     case "count":
+    case "sum":
+    case "avg":
+    case "abs":
+    case "round":
+    case "negate":
     case "max":
     case "min":
       return `${ast.kind}(${requiredExpressionGroupingKey(ast.kind, ast.value)})`;
@@ -3759,6 +3807,11 @@ var groupingKeyOfExpression = (expression) => {
     case "contains":
     case "containedBy":
     case "overlaps":
+    case "add":
+    case "subtract":
+    case "multiply":
+    case "divide":
+    case "modulo":
       return `${ast.kind}(${requiredBinaryExpressionGroupingKey(ast.kind, ast.left, ast.right)})`;
     case "and":
     case "or":
@@ -3834,6 +3887,31 @@ var dedupeGroupedExpressions = (values) => {
   });
 };
 
+// src/internal/window-frame.ts
+var validateBoundary = (boundary) => {
+  if (typeof boundary === "object") {
+    const value = "preceding" in boundary ? boundary.preceding : boundary.following;
+    if (!Number.isSafeInteger(value) || value < 0) {
+      throw new Error("window frame offsets must be non-negative safe integers");
+    }
+  }
+};
+var validateWindowFrame = (frame) => {
+  if (frame === undefined) {
+    return;
+  }
+  validateBoundary(frame.start);
+  if (frame.end !== undefined) {
+    validateBoundary(frame.end);
+  }
+  if (frame.start === "unboundedFollowing") {
+    throw new Error("window frame cannot start with unbounded following");
+  }
+  if (frame.end === "unboundedPreceding") {
+    throw new Error("window frame cannot end with unbounded preceding");
+  }
+};
+
 // src/internal/dsl-transaction-ddl-runtime.ts
 var renderTransactionIsolationLevel = (isolationLevel) => {
   if (isolationLevel === undefined) {
@@ -5088,6 +5166,23 @@ var extractRequiredFromDialectInputRuntime = (value) => {
   const expression = toDialectExpression(value);
   return Object.keys(expression[TypeId].dependencies);
 };
+var normalizeWindowSpec = (spec) => {
+  validateWindowFrame(spec?.frame);
+  const partitionBy = [...spec?.partitionBy ?? []];
+  const orderBy = (spec?.orderBy ?? []).map((term) => {
+    const direction = term.direction ?? "asc";
+    return {
+      value: term.value,
+      direction
+    };
+  });
+  return {
+    partitionBy,
+    orderBy,
+    frame: spec?.frame
+  };
+};
+var mergeWindowExpressions = (value, partitionBy, orderBy) => value === undefined ? [...partitionBy, ...orderBy.map((term) => term.value)] : [value, ...partitionBy, ...orderBy.map((term) => term.value)];
 var extractRequiredFromDialectNumericInputRuntime = (value) => {
   const expression = toDialectNumericExpression(value);
   return Object.keys(expression[TypeId].dependencies);
@@ -5107,6 +5202,34 @@ var buildBinaryPredicate = (left, right, kind, nullability = "maybe") => {
     right: rightExpression
   });
 };
+var upper = (value) => {
+  const expression = toDialectStringExpression(value);
+  return makeExpression2({
+    runtime: "",
+    dbType: profile.textDb,
+    nullability: expression[TypeId].nullability,
+    dialect: profile.dialect,
+    kind: expression[TypeId].kind,
+    dependencies: expression[TypeId].dependencies
+  }, {
+    kind: "upper",
+    value: expression
+  });
+};
+var lower = (value) => {
+  const expression = toDialectStringExpression(value);
+  return makeExpression2({
+    runtime: "",
+    dbType: profile.textDb,
+    nullability: expression[TypeId].nullability,
+    dialect: profile.dialect,
+    kind: expression[TypeId].kind,
+    dependencies: expression[TypeId].dependencies
+  }, {
+    kind: "lower",
+    value: expression
+  });
+};
 var array2 = (element) => ({
   dialect: profile.dialect,
   kind: `${element.kind}[]`,
@@ -5592,6 +5715,127 @@ var jsonb = {
   pathExists: jsonPathExists,
   pathMatch: jsonPathMatch
 };
+var concat = (...values) => {
+  const expressions = values.map((value) => toDialectStringExpression(value));
+  return makeExpression2({
+    runtime: "",
+    dbType: profile.textDb,
+    nullability: mergeNullabilityManyRuntime(expressions),
+    dialect: expressions.find((value) => value[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile.dialect,
+    kind: mergeAggregationManyRuntime(expressions),
+    dependencies: mergeManyDependencies(expressions)
+  }, {
+    kind: "concat",
+    values: expressions
+  });
+};
+var count = (value) => {
+  const expression = toDialectExpression(value);
+  return makeExpression2({
+    runtime: undefined,
+    dbType: sqliteDatatypes.bigint(),
+    nullability: "never",
+    dialect: expression[TypeId].dialect,
+    kind: "aggregate",
+    dependencies: expression[TypeId].dependencies
+  }, {
+    kind: "count",
+    value: expression
+  });
+};
+var over = (value, spec = {}) => {
+  const normalized = normalizeWindowSpec(spec);
+  const expressions = mergeWindowExpressions(value, normalized.partitionBy, normalized.orderBy);
+  return makeExpression2({
+    runtime: undefined,
+    dbType: value[TypeId].dbType,
+    nullability: value[TypeId].nullability,
+    dialect: expressions.find((expression) => expression[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile.dialect,
+    kind: "window",
+    dependencies: mergeManyDependencies(expressions)
+  }, {
+    kind: "window",
+    function: "over",
+    value,
+    partitionBy: normalized.partitionBy,
+    orderBy: normalized.orderBy,
+    frame: normalized.frame
+  });
+};
+var buildNumberWindow = (kind, spec) => {
+  const normalized = normalizeWindowSpec(spec);
+  const expressions = mergeWindowExpressions(undefined, normalized.partitionBy, normalized.orderBy);
+  return makeExpression2({
+    runtime: undefined,
+    dbType: sqliteDatatypes.bigint(),
+    nullability: "never",
+    dialect: expressions.find((expression) => expression[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile.dialect,
+    kind: "window",
+    dependencies: mergeManyDependencies(expressions)
+  }, {
+    kind: "window",
+    function: kind,
+    partitionBy: normalized.partitionBy,
+    orderBy: normalized.orderBy,
+    frame: normalized.frame
+  });
+};
+var rowNumber = (spec) => buildNumberWindow("rowNumber", spec);
+var rank = (spec) => buildNumberWindow("rank", spec);
+var denseRank = (spec) => buildNumberWindow("denseRank", spec);
+var max = (value) => makeExpression2({
+  runtime: undefined,
+  dbType: value[TypeId].dbType,
+  nullability: "maybe",
+  dialect: value[TypeId].dialect,
+  kind: "aggregate",
+  dependencies: value[TypeId].dependencies
+}, {
+  kind: "max",
+  value
+});
+var min = (value) => makeExpression2({
+  runtime: undefined,
+  dbType: value[TypeId].dbType,
+  nullability: "maybe",
+  dialect: value[TypeId].dialect,
+  kind: "aggregate",
+  dependencies: value[TypeId].dependencies
+}, {
+  kind: "min",
+  value
+});
+var resolveCoalesceNullabilityRuntime = (values) => values.some((value) => value[TypeId].nullability === "never") ? "never" : values.some((value) => value[TypeId].nullability === "maybe") ? "maybe" : "always";
+var coalesce = (...values) => {
+  const expressions = values.map((value) => toDialectExpression(value));
+  const representative = expressions.find((value) => value[TypeId].nullability !== "always") ?? expressions[0];
+  return makeExpression2({
+    runtime: undefined,
+    dbType: representative[TypeId].dbType,
+    nullability: resolveCoalesceNullabilityRuntime(expressions),
+    dialect: expressions.find((value) => value[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile.dialect,
+    kind: mergeAggregationManyRuntime(expressions),
+    dependencies: mergeManyDependencies(expressions)
+  }, {
+    kind: "coalesce",
+    values: expressions
+  });
+};
+var call = (name, ...args) => {
+  const expressions = args.map((value) => toDialectExpression(value));
+  return makeExpression2({
+    runtime: undefined,
+    dbType: profile.textDb,
+    nullability: "maybe",
+    dialect: expressions.find((value) => value[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile.dialect,
+    kind: mergeAggregationManyRuntime(expressions),
+    dependencies: mergeManyDependencies(expressions)
+  }, {
+    kind: "function",
+    name,
+    args: expressions
+  });
+};
 var toMutationValueExpression = (value, column) => {
   const columnState = column[TypeId];
   const normalizeMutationValue = (candidate) => {
@@ -5882,135 +6126,1988 @@ var {
   normalizeColumnList,
   defaultIndexName
 });
-
-// src/sqlite/json.ts
-var insert = json.insert;
-var typeOf = json.typeOf;
-var length = json.length;
-var stripNulls = json.stripNulls;
-var pathMatch = json.pathMatch;
-// src/sqlite/executor.ts
-var exports_executor2 = {};
-__export(exports_executor2, {
-  withTransaction: () => withTransaction2,
-  make: () => make4,
-  driver: () => driver2,
-  custom: () => custom3
+// src/sqlite/function/string.ts
+var exports_string = {};
+__export(exports_string, {
+  upper: () => upper,
+  lower: () => lower,
+  concat: () => concat
 });
-import * as Effect2 from "effect/Effect";
-import * as SqlClient3 from "effect/unstable/sql/SqlClient";
-import * as Stream2 from "effect/Stream";
-
-// src/internal/executor.ts
-var exports_executor = {};
-__export(exports_executor, {
-  withTransaction: () => withTransaction,
-  streamFromSqlClient: () => streamFromSqlClient,
-  remapRows: () => remapRows,
-  makeRowDecoder: () => makeRowDecoder,
-  make: () => make3,
-  hasWriteCapability: () => hasWriteCapability,
-  fromSqlClient: () => fromSqlClient,
-  fromDriver: () => fromDriver,
-  driver: () => driver,
-  decodeRows: () => decodeRows,
-  decodeChunk: () => decodeChunk
+// src/sqlite/function/aggregate.ts
+var exports_aggregate = {};
+__export(exports_aggregate, {
+  sum: () => sum,
+  min: () => min,
+  max: () => max,
+  count: () => count,
+  avg: () => avg
 });
-import * as Chunk from "effect/Chunk";
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as Option from "effect/Option";
-import * as Schema9 from "effect/Schema";
-import * as SqlClient from "effect/unstable/sql/SqlClient";
-import * as Stream from "effect/Stream";
 
-// src/internal/runtime/driver-value-mapping.ts
-import * as Schema7 from "effect/Schema";
-var runtimeTagOfDbType = (dbType) => {
-  if (dbType === undefined) {
-    return;
-  }
-  if ("base" in dbType) {
-    return runtimeTagOfDbType(dbType.base);
-  }
-  if ("element" in dbType) {
-    return "array";
-  }
-  if ("fields" in dbType) {
-    return "record";
-  }
-  if ("variant" in dbType && dbType.variant === "json") {
-    return "json";
-  }
-  if ("variant" in dbType && (dbType.variant === "enum" || dbType.variant === "set")) {
-    return "string";
-  }
-  return dbType.runtime;
+// src/internal/dialect-numeric.ts
+var literal2 = (value, dbType, dialect) => makeExpression2({
+  runtime: value,
+  dbType,
+  driverValueMapping: dbType.driverValueMapping,
+  nullability: "never",
+  dialect,
+  kind: "scalar",
+  dependencies: {}
+}, {
+  kind: "literal",
+  value
+});
+var asExpression = (value, literalDb, dialect) => typeof value === "number" ? literal2(value, literalDb, dialect) : value;
+var modulo = (left, right, options2) => {
+  const leftExpression = asExpression(left, options2.literalDb, options2.dialect);
+  const rightExpression = asExpression(right, options2.literalDb, options2.dialect);
+  const values2 = [leftExpression, rightExpression];
+  return makeExpression2({
+    runtime: undefined,
+    dbType: options2.resultDb,
+    driverValueMapping: options2.resultDb.driverValueMapping,
+    nullability: options2.nullability,
+    dialect: options2.dialect,
+    kind: mergeAggregationManyRuntime(values2),
+    dependencies: mergeManyDependencies(values2)
+  }, {
+    kind: "modulo",
+    left: leftExpression,
+    right: rightExpression
+  });
 };
-var familyOfDbType = (dbType) => {
-  if (dbType === undefined) {
-    return;
+var round = (value, scale, options2) => {
+  const expression = asExpression(value, options2.literalDb, options2.dialect);
+  if (scale === undefined) {
+    return makeExpression2({
+      runtime: undefined,
+      dbType: options2.resultDb,
+      driverValueMapping: options2.resultDb.driverValueMapping,
+      nullability: options2.nullability,
+      dialect: options2.dialect,
+      kind: expression[TypeId].kind,
+      dependencies: expression[TypeId].dependencies
+    }, {
+      kind: "round",
+      value: expression
+    });
   }
-  if ("base" in dbType) {
-    return familyOfDbType(dbType.base);
+  if (!Number.isSafeInteger(scale)) {
+    throw new Error("round scale must be a safe integer");
   }
-  return dbType.family;
+  const scaleExpression = literal2(scale, options2.scaleDb, options2.dialect);
+  return makeExpression2({
+    runtime: undefined,
+    dbType: options2.resultDb,
+    driverValueMapping: options2.resultDb.driverValueMapping,
+    nullability: options2.nullability,
+    dialect: options2.dialect,
+    kind: expression[TypeId].kind,
+    dependencies: expression[TypeId].dependencies
+  }, {
+    kind: "function",
+    name: "round",
+    args: [expression, scaleExpression]
+  });
 };
-var mappingCandidates = (context) => {
-  const dbType = context.dbType;
-  const runtimeTag = runtimeTagOfDbType(dbType);
-  const family = familyOfDbType(dbType);
-  return [
-    context.driverValueMapping,
-    dbType?.driverValueMapping,
-    dbType === undefined ? undefined : context.valueMappings?.[dbType.kind],
-    family === undefined ? undefined : context.valueMappings?.[family],
-    runtimeTag === undefined ? undefined : context.valueMappings?.[runtimeTag]
-  ];
+var aggregate = (kind, value, options2) => {
+  const expression = asExpression(value, options2.literalDb, options2.dialect);
+  return makeExpression2({
+    runtime: undefined,
+    dbType: options2.resultDb,
+    driverValueMapping: options2.resultDb.driverValueMapping,
+    nullability: "maybe",
+    dialect: options2.dialect,
+    kind: "aggregate",
+    dependencies: expression[TypeId].dependencies
+  }, {
+    kind,
+    value: expression
+  });
 };
-var findMapping = (context, key2) => {
-  for (const candidate of mappingCandidates(context)) {
-    const value = candidate?.[key2];
-    if (value !== undefined) {
-      return value;
-    }
+var inputNullability = (value) => typeof value === "number" ? "never" : value[TypeId].nullability;
+var binaryInputNullability = (left, right) => {
+  const leftNullability = inputNullability(left);
+  const rightNullability = inputNullability(right);
+  if (leftNullability === "always" || rightNullability === "always") {
+    return "always";
   }
-  return;
+  return leftNullability === "maybe" || rightNullability === "maybe" ? "maybe" : "never";
 };
-var isJsonDbType = (dbType) => {
-  if (dbType === undefined) {
-    return false;
-  }
-  if ("base" in dbType) {
-    return isJsonDbType(dbType.base);
+var nullableForZeroDivisor = (left, right) => {
+  const merged = binaryInputNullability(left, right);
+  if (merged === "always") {
+    return "always";
   }
-  if (!("variant" in dbType)) {
-    return false;
+  if (typeof right === "number") {
+    return right === 0 ? "always" : merged;
   }
-  const variant = dbType.variant;
-  return variant === "json" || variant === "jsonb";
+  return "maybe";
 };
-var schemaAccepts = (schema2, value) => schema2 !== undefined && Schema7.is(schema2)(value);
-var encodeWithSchema = (schema2, value) => {
-  if (schema2 === undefined) {
-    return { value, encoded: false };
+
+// src/sqlite/function/aggregate.ts
+var baseDb = (db) => ("base" in db) ? baseDb(db.base) : db;
+var sumResultDb = (value) => {
+  if (typeof value === "number")
+    return sqliteDatatypes.double();
+  const db = baseDb(value[TypeId].dbType);
+  if (db.kind === "int" || db.kind === "integer") {
+    return sqliteDatatypes.integer();
   }
-  if (!Schema7.is(schema2)(value)) {
-    return { value, encoded: false };
+  if (db.kind === "bigint") {
+    return sqliteDatatypes.bigint();
   }
+  return sqliteDatatypes.double();
+};
+var sum = (value) => aggregate("sum", value, {
+  dialect: "sqlite",
+  literalDb: sqliteDatatypes.double(),
+  resultDb: sumResultDb(value)
+});
+var avg = (value) => aggregate("avg", value, {
+  dialect: "sqlite",
+  literalDb: sqliteDatatypes.double(),
+  resultDb: sqliteDatatypes.double()
+});
+// src/sqlite/function/numeric.ts
+var exports_numeric = {};
+__export(exports_numeric, {
+  round: () => round2,
+  modulo: () => modulo2
+});
+var baseDb2 = (db) => ("base" in db) ? baseDb2(db.base) : db;
+var category = (value) => {
+  if (typeof value === "number")
+    return "approximate";
+  const db = baseDb2(value[TypeId].dbType);
+  if (db.kind === "int" || db.kind === "integer")
+    return "integer";
+  if (db.kind === "bigint")
+    return "bigint";
+  if (db.kind === "numeric" || db.kind === "decimal")
+    return "exact";
+  return "approximate";
+};
+var moduloResultDb = (left, right) => {
+  const categories = [category(left), category(right)];
+  if (categories.every((value) => value === "integer" || value === "bigint")) {
+    return categories.includes("bigint") ? sqliteDatatypes.bigint() : sqliteDatatypes.integer();
+  }
+  return sqliteDatatypes.double();
+};
+var modulo2 = (left, right) => modulo(left, right, {
+  dialect: "sqlite",
+  literalDb: sqliteDatatypes.double(),
+  resultDb: moduloResultDb(left, right),
+  nullability: nullableForZeroDivisor(left, right)
+});
+function round2(value, scale) {
+  return round(value, scale, {
+    dialect: "sqlite",
+    literalDb: sqliteDatatypes.double(),
+    scaleDb: sqliteDatatypes.integer(),
+    resultDb: sqliteDatatypes.double(),
+    nullability: typeof value === "number" ? "never" : value[TypeId].nullability
+  });
+}
+// src/sqlite/function/window.ts
+var exports_window = {};
+__export(exports_window, {
+  rowNumber: () => rowNumber,
+  rank: () => rank,
+  over: () => over,
+  lastValue: () => lastValue2,
+  firstValue: () => firstValue2,
+  denseRank: () => denseRank
+});
+
+// src/internal/standard-dsl.ts
+import { pipeArguments as pipeArguments8 } from "effect/Pipeable";
+import * as Schema7 from "effect/Schema";
+
+// src/standard/datatypes/index.ts
+var exports_datatypes2 = {};
+__export(exports_datatypes2, {
+  standardDatatypes: () => standardDatatypes
+});
+
+// src/standard/datatypes/spec.ts
+var standardDatatypeFamilies = portableDatatypeFamilies;
+var standardDatatypeKinds = portableDatatypeKinds;
+
+// src/standard/datatypes/index.ts
+var withMetadata2 = (kind) => {
+  const kindSpec = standardDatatypeKinds[kind];
+  const familySpec = standardDatatypeFamilies[kindSpec.family];
   return {
-    value: Schema7.encodeUnknownSync(schema2)(value),
-    encoded: true
+    dialect: "standard",
+    kind,
+    family: kindSpec.family,
+    runtime: kindSpec.runtime,
+    compareGroup: familySpec?.compareGroup,
+    castTargets: familySpec?.castTargets,
+    implicitTargets: familySpec.implicitTargets,
+    traits: familySpec?.traits
   };
 };
-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;
+var standardDatatypeModule = {
+  custom: (kind) => ({
+    dialect: "standard",
+    kind
+  }),
+  uuid: () => ({
+    dialect: "standard",
+    kind: "uuid",
+    family: "uuid",
+    runtime: "string",
+    compareGroup: "uuid",
+    castTargets: ["uuid", "char", "varchar", "text"],
+    traits: {
+      textual: true
+    }
+  })
+};
+for (const kind of Object.keys(standardDatatypeKinds)) {
+  standardDatatypeModule[kind] = () => withMetadata2(kind);
+}
+standardDatatypeModule.json = () => ({
+  ...withMetadata2("json"),
+  driverValueMapping: {
+    toDriver: (value) => JSON.stringify(value)
+  }
+});
+var standardDatatypes = {
+  ...standardDatatypeModule
+};
+
+// src/internal/standard-dsl.ts
+var profile2 = {
+  dialect: "standard",
+  textDb: standardDatatypes.text(),
+  numericDb: standardDatatypes.real(),
+  boolDb: standardDatatypes.boolean(),
+  timestampDb: standardDatatypes.timestamp(),
+  nullDb: {
+    dialect: "standard",
+    kind: "null",
+    family: "null",
+    runtime: "unknown",
+    compareGroup: "null",
+    traits: {}
+  },
+  type: standardDatatypes
+};
+var ValuesInputProto2 = {
+  pipe() {
+    return pipeArguments8(this, arguments);
+  }
+};
+var literalSchemaOf2 = (value) => {
+  if (value === null || value instanceof Date) {
+    return;
+  }
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    return;
+  }
+  return Schema7.Literal(value);
+};
+var literal3 = (value) => makeExpression2({
+  runtime: undefined,
+  dbType: value === null ? profile2.nullDb : value instanceof Date ? profile2.timestampDb : typeof value === "string" ? profile2.textDb : typeof value === "number" ? profile2.numericDb : profile2.boolDb,
+  runtimeSchema: literalSchemaOf2(value),
+  nullability: value === null ? "always" : "never",
+  dialect: profile2.dialect,
+  kind: "scalar",
+  dependencies: {}
+}, {
+  kind: "literal",
+  value
+});
+var column = (name, dbType, nullable2 = false) => makeExpression2({
+  runtime: undefined,
+  dbType,
+  nullability: nullable2 ? "maybe" : "never",
+  dialect: profile2.dialect,
+  kind: "scalar",
+  dependencies: {}
+}, {
+  kind: "column",
+  tableName: "",
+  columnName: name
+});
+var toDialectExpression2 = (value) => {
+  if (value !== null && typeof value === "object" && TypeId in value) {
+    return value;
+  }
+  return literal3(value);
+};
+var retargetLiteralExpression2 = (value, target) => {
+  const ast = value[TypeId2];
+  if (ast.kind !== "literal") {
+    return value;
+  }
+  const targetState = target[TypeId];
+  return makeExpression2({
+    runtime: value[TypeId].runtime,
+    dbType: targetState.dbType,
+    runtimeSchema: targetState.runtimeSchema,
+    driverValueMapping: targetState.driverValueMapping,
+    nullability: value[TypeId].nullability,
+    dialect: targetState.dialect,
+    kind: "scalar",
+    dependencies: {}
+  }, ast);
+};
+var alignBinaryPredicateExpressions2 = (left, right) => {
+  const leftAst = left[TypeId2];
+  const rightAst = right[TypeId2];
+  if (leftAst.kind === "literal" && rightAst.kind !== "literal") {
+    return [retargetLiteralExpression2(left, right), right];
+  }
+  if (rightAst.kind === "literal" && leftAst.kind !== "literal") {
+    return [left, retargetLiteralExpression2(right, left)];
+  }
+  return [left, right];
+};
+var toDialectStringExpression2 = (value) => typeof value === "string" ? literal3(value) : value;
+var toDialectNumericExpression2 = (value) => typeof value === "number" ? literal3(value) : value;
+var flattenVariadicBooleanExpressions = (kind, values2) => {
+  const flattened = [];
+  for (const value of values2) {
+    const ast = value[TypeId2];
+    if (ast.kind === kind) {
+      flattened.push(...ast.values);
+    } else {
+      flattened.push(value);
+    }
+  }
+  return flattened;
+};
+var makeVariadicBooleanExpression = (kind, values2) => {
+  const expressions = flattenVariadicBooleanExpressions(kind, values2);
+  const expression = makeExpression2({
+    runtime: true,
+    dbType: profile2.boolDb,
+    nullability: mergeNullabilityManyRuntime(expressions),
+    dialect: expressions.find((value) => value[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile2.dialect,
+    kind: "scalar",
+    dependencies: mergeManyDependencies(expressions)
+  }, {
+    kind,
+    values: expressions
+  });
+  Object.defineProperty(expression, "pipe", {
+    configurable: true,
+    writable: true,
+    value() {
+      if (arguments.length === 0) {
+        return this;
+      }
+      const operations = Array.from(arguments);
+      if (operations.every((operation) => typeof operation !== "function")) {
+        const appended = operations.map((operation) => toDialectExpression2(operation));
+        return makeVariadicBooleanExpression(kind, [...expressions, ...appended]);
+      }
+      if (operations.every((operation) => typeof operation === "function")) {
+        return pipeArguments8(this, arguments);
+      }
+      const valuesForMixedPipe = (value) => {
+        if (typeof value !== "object" || value === null || !(TypeId in value)) {
+          return [];
+        }
+        const expression2 = value;
+        const ast = expression2[TypeId2];
+        if (ast.kind === kind) {
+          return ast.values;
+        }
+        return [expression2];
+      };
+      let current = this;
+      for (const operation of operations) {
+        if (typeof operation === "function") {
+          current = operation(current);
+          continue;
+        }
+        current = makeVariadicBooleanExpression(kind, [...valuesForMixedPipe(current), toDialectExpression2(operation)]);
+      }
+      return current;
+    }
+  });
+  return expression;
+};
+var extractRequiredFromDialectInputRuntime2 = (value) => {
+  const expression = toDialectExpression2(value);
+  return Object.keys(expression[TypeId].dependencies);
+};
+var normalizeWindowSpec2 = (spec) => {
+  if (spec?.frame !== undefined) {
+    throw new Error("over does not accept an explicit frame on the portable Function API; use a dialect Function.over helper");
+  }
+  validateWindowFrame(spec?.frame);
+  const partitionBy = [...spec?.partitionBy ?? []];
+  const orderBy2 = (spec?.orderBy ?? []).map((term) => {
+    const direction = term.direction ?? "asc";
+    return {
+      value: term.value,
+      direction
+    };
+  });
+  return {
+    partitionBy,
+    orderBy: orderBy2,
+    frame: spec?.frame
+  };
+};
+var mergeWindowExpressions2 = (value, partitionBy, orderBy2) => value === undefined ? [...partitionBy, ...orderBy2.map((term) => term.value)] : [value, ...partitionBy, ...orderBy2.map((term) => term.value)];
+var extractRequiredFromDialectNumericInputRuntime2 = (value) => {
+  const expression = toDialectNumericExpression2(value);
+  return Object.keys(expression[TypeId].dependencies);
+};
+var buildBinaryPredicate2 = (left, right, kind, nullability = "maybe") => {
+  const [leftExpression, rightExpression] = alignBinaryPredicateExpressions2(toDialectExpression2(left), toDialectExpression2(right));
+  return makeExpression2({
+    runtime: true,
+    dbType: profile2.boolDb,
+    nullability,
+    dialect: leftExpression[TypeId].dialect ?? rightExpression[TypeId].dialect,
+    kind: "scalar",
+    dependencies: mergeDependencies(leftExpression[TypeId].dependencies, rightExpression[TypeId].dependencies)
+  }, {
+    kind,
+    left: leftExpression,
+    right: rightExpression
+  });
+};
+var buildVariadicPredicate = (values2, kind) => {
+  const expressions = values2.map((value) => toDialectExpression2(value));
+  const [head, ...tail] = expressions;
+  const alignedExpressions = head !== undefined && (kind === "in" || kind === "notIn" || kind === "between") ? [head, ...tail.map((value) => retargetLiteralExpression2(value, head))] : expressions;
+  return makeExpression2({
+    runtime: true,
+    dbType: profile2.boolDb,
+    nullability: "maybe",
+    dialect: alignedExpressions.find((value) => value[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile2.dialect,
+    kind: "scalar",
+    dependencies: mergeManyDependencies(alignedExpressions)
+  }, {
+    kind,
+    values: alignedExpressions
+  });
+};
+var eq = (...args) => {
+  const left = args[0];
+  const right = args[1];
+  return buildBinaryPredicate2(left, right, "eq");
+};
+var neq = (...args) => {
+  const left = args[0];
+  const right = args[1];
+  return buildBinaryPredicate2(left, right, "neq");
+};
+var lt = (...args) => {
+  const left = args[0];
+  const right = args[1];
+  return buildBinaryPredicate2(left, right, "lt");
+};
+var lte = (...args) => {
+  const left = args[0];
+  const right = args[1];
+  return buildBinaryPredicate2(left, right, "lte");
+};
+var gt = (...args) => {
+  const left = args[0];
+  const right = args[1];
+  return buildBinaryPredicate2(left, right, "gt");
+};
+var gte = (...args) => {
+  const left = args[0];
+  const right = args[1];
+  return buildBinaryPredicate2(left, right, "gte");
+};
+var like = (...args) => {
+  const left = args[0];
+  const right = args[1];
+  return buildBinaryPredicate2(left, right, "like");
+};
+var ilike = (...args) => {
+  const left = args[0];
+  const right = args[1];
+  return buildBinaryPredicate2(left, right, "ilike");
+};
+var regexMatch = (...args) => {
+  const left = args[0];
+  const right = args[1];
+  return buildBinaryPredicate2(left, right, "regexMatch");
+};
+var regexIMatch = (...args) => {
+  const left = args[0];
+  const right = args[1];
+  return buildBinaryPredicate2(left, right, "regexIMatch");
+};
+var regexNotMatch = (...args) => {
+  const left = args[0];
+  const right = args[1];
+  return buildBinaryPredicate2(left, right, "regexNotMatch");
+};
+var regexNotIMatch = (...args) => {
+  const left = args[0];
+  const right = args[1];
+  return buildBinaryPredicate2(left, right, "regexNotIMatch");
+};
+var isDistinctFrom = (...args) => {
+  const left = args[0];
+  const right = args[1];
+  return buildBinaryPredicate2(left, right, "isDistinctFrom", "never");
+};
+var isNotDistinctFrom = (...args) => {
+  const left = args[0];
+  const right = args[1];
+  return buildBinaryPredicate2(left, right, "isNotDistinctFrom", "never");
+};
+var isNull = (value) => {
+  const expression = toDialectExpression2(value);
+  return makeExpression2({
+    runtime: true,
+    dbType: profile2.boolDb,
+    nullability: "never",
+    dialect: expression[TypeId].dialect,
+    kind: "scalar",
+    dependencies: expression[TypeId].dependencies
+  }, {
+    kind: "isNull",
+    value: expression
+  });
+};
+var isNotNull = (value) => {
+  const expression = toDialectExpression2(value);
+  return makeExpression2({
+    runtime: true,
+    dbType: profile2.boolDb,
+    nullability: "never",
+    dialect: expression[TypeId].dialect,
+    kind: "scalar",
+    dependencies: expression[TypeId].dependencies
+  }, {
+    kind: "isNotNull",
+    value: expression
+  });
+};
+var collate = (value, collation) => {
+  const expression = toDialectStringExpression2(value);
+  const normalizedCollation = typeof collation === "string" ? [collation] : collation;
+  return makeExpression2({
+    runtime: expression[TypeId].runtime,
+    dbType: expression[TypeId].dbType,
+    nullability: expression[TypeId].nullability,
+    dialect: expression[TypeId].dialect,
+    kind: expression[TypeId].kind,
+    dependencies: expression[TypeId].dependencies
+  }, {
+    kind: "collate",
+    value: expression,
+    collation: normalizedCollation
+  });
+};
+var cast = (value, target) => {
+  const expression = toDialectExpression2(value);
+  return makeExpression2({
+    runtime: undefined,
+    dbType: target,
+    runtimeSchema: undefined,
+    driverValueMapping: target.driverValueMapping,
+    nullability: expression[TypeId].nullability,
+    dialect: expression[TypeId].dialect,
+    kind: expression[TypeId].kind,
+    dependencies: expression[TypeId].dependencies
+  }, {
+    kind: "cast",
+    value: expression,
+    target
+  });
+};
+var custom3 = (kind) => ({
+  dialect: profile2.dialect,
+  kind
+});
+var driverValueMapping3 = (dbType, mapping) => ({
+  ...dbType,
+  driverValueMapping: mapping
+});
+var type2 = {
+  ...profile2.type,
+  custom: custom3,
+  driverValueMapping: driverValueMapping3
+};
+var makeJsonDb2 = (kind) => ({
+  dialect: profile2.dialect,
+  kind,
+  variant: kind === "jsonb" ? "jsonb" : "json"
+});
+var jsonDb2 = makeJsonDb2("json");
+var jsonbDb2 = makeJsonDb2("jsonb");
+var isExpressionValue2 = (value) => value !== null && typeof value === "object" && (TypeId in value);
+var isJsonExpressionValue2 = (value) => isExpressionValue2(value) && (() => {
+  const dbType = value[TypeId].dbType;
+  return dbType.variant === "json" || dbType.kind === "json" || dbType.kind === "jsonb";
+})();
+var isJsonPathValue2 = (value) => value !== null && typeof value === "object" && (TypeId3 in value);
+var normalizeJsonPathInput2 = (value) => isJsonPathValue2(value) ? value.segments : [value];
+var isExactJsonSegmentValue2 = (segment) => segment.kind === "key" || segment.kind === "index";
+var isExactJsonPathValue2 = (segments) => segments.every(isExactJsonSegmentValue2);
+var buildJsonNodeExpression2 = (expressions, state, ast) => withJsonPathAccess(makeExpression2({
+  runtime: state.runtime,
+  dbType: state.dbType,
+  nullability: state.nullability,
+  dialect: expressions.find((expression) => expression[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile2.dialect,
+  kind: mergeAggregationManyRuntime(expressions),
+  dependencies: mergeManyDependencies(expressions)
+}, ast));
+var jsonDbTypeOf2 = (base) => base[TypeId].dbType;
+var resolveJsonMergeDbType2 = (..._values) => jsonbDb2;
+var makeJsonLiteralExpression2 = (value, dbType = jsonDb2) => withJsonPathAccess(makeExpression2({
+  runtime: value,
+  dbType,
+  nullability: value === null ? "always" : "never",
+  dialect: profile2.dialect,
+  kind: "scalar",
+  dependencies: {}
+}, {
+  kind: "literal",
+  value
+}));
+var wrapJsonExpression2 = (value, kind, dbType) => buildJsonNodeExpression2([value], {
+  runtime: undefined,
+  dbType,
+  nullability: value[TypeId].nullability
+}, {
+  kind,
+  value
+});
+var toJsonValueExpression2 = (value, kind = "jsonToJson", dbType = jsonDb2) => {
+  if (isJsonExpressionValue2(value)) {
+    return value;
+  }
+  if (isExpressionValue2(value)) {
+    return wrapJsonExpression2(value, kind, dbType);
+  }
+  return makeJsonLiteralExpression2(value, dbType);
+};
+var jsonQueryExpression2 = (query) => toDialectStringExpression2(query);
+var jsonGet2 = (base, target) => {
+  const segments = normalizeJsonPathInput2(target);
+  const kind = isJsonPathValue2(target) ? isExactJsonPathValue2(segments) ? "jsonPath" : "jsonTraverse" : isExactJsonSegmentValue2(target) ? "jsonGet" : "jsonAccess";
+  return buildJsonNodeExpression2([base], {
+    runtime: undefined,
+    dbType: jsonDbTypeOf2(base),
+    nullability: undefined
+  }, {
+    kind,
+    base,
+    segments
+  });
+};
+var jsonText2 = (base, target) => {
+  const segments = normalizeJsonPathInput2(target);
+  const kind = isJsonPathValue2(target) ? isExactJsonPathValue2(segments) ? "jsonPathText" : "jsonTraverseText" : isExactJsonSegmentValue2(target) ? "jsonGetText" : "jsonAccessText";
+  return buildJsonNodeExpression2([base], {
+    runtime: undefined,
+    dbType: profile2.textDb,
+    nullability: undefined
+  }, {
+    kind,
+    base,
+    segments
+  });
+};
+var jsonAccess2 = (base, target) => {
+  const segments = normalizeJsonPathInput2(target);
+  return buildJsonNodeExpression2([base], {
+    runtime: undefined,
+    dbType: jsonDbTypeOf2(base),
+    nullability: undefined
+  }, {
+    kind: isJsonPathValue2(target) || segments.length > 1 ? "jsonTraverse" : "jsonAccess",
+    base,
+    segments
+  });
+};
+var jsonTraverse2 = (base, target) => {
+  const segments = normalizeJsonPathInput2(target);
+  return buildJsonNodeExpression2([base], {
+    runtime: undefined,
+    dbType: jsonDbTypeOf2(base),
+    nullability: undefined
+  }, {
+    kind: "jsonTraverse",
+    base,
+    segments
+  });
+};
+var jsonAccessText2 = (base, target) => {
+  const segments = normalizeJsonPathInput2(target);
+  return buildJsonNodeExpression2([base], {
+    runtime: undefined,
+    dbType: profile2.textDb,
+    nullability: undefined
+  }, {
+    kind: isJsonPathValue2(target) || segments.length > 1 ? "jsonTraverseText" : "jsonAccessText",
+    base,
+    segments
+  });
+};
+var jsonTraverseText2 = (base, target) => {
+  const segments = normalizeJsonPathInput2(target);
+  return buildJsonNodeExpression2([base], {
+    runtime: undefined,
+    dbType: profile2.textDb,
+    nullability: undefined
+  }, {
+    kind: "jsonTraverseText",
+    base,
+    segments
+  });
+};
+var jsonContains2 = (left, right) => buildBinaryPredicate2(left, toJsonValueExpression2(right), "contains");
+var jsonContainedBy2 = (left, right) => buildBinaryPredicate2(left, toJsonValueExpression2(right), "containedBy");
+var jsonHasKey2 = (base, key2) => buildJsonNodeExpression2([base], {
+  runtime: true,
+  dbType: profile2.boolDb,
+  nullability: "never"
+}, {
+  kind: "jsonHasKey",
+  base,
+  keys: [key2]
+});
+var jsonHasAnyKeys2 = (base, ...keys) => buildJsonNodeExpression2([base], {
+  runtime: true,
+  dbType: profile2.boolDb,
+  nullability: "never"
+}, {
+  kind: "jsonHasAnyKeys",
+  base,
+  keys
+});
+var jsonHasAllKeys2 = (base, ...keys) => buildJsonNodeExpression2([base], {
+  runtime: true,
+  dbType: profile2.boolDb,
+  nullability: "never"
+}, {
+  kind: "jsonHasAllKeys",
+  base,
+  keys
+});
+var jsonDelete2 = (base, target) => {
+  const segments = normalizeJsonPathInput2(target);
+  return buildJsonNodeExpression2([base], {
+    runtime: undefined,
+    dbType: jsonDbTypeOf2(base),
+    nullability: undefined
+  }, {
+    kind: isJsonPathValue2(target) ? "jsonDeletePath" : "jsonDelete",
+    base,
+    segments
+  });
+};
+var jsonRemove2 = (base, target) => {
+  const segments = normalizeJsonPathInput2(target);
+  return buildJsonNodeExpression2([base], {
+    runtime: undefined,
+    dbType: jsonDbTypeOf2(base),
+    nullability: undefined
+  }, {
+    kind: "jsonRemove",
+    base,
+    segments
+  });
+};
+var jsonSet2 = (base, target, next, options2 = {}) => {
+  const segments = normalizeJsonPathInput2(target);
+  const newValue = toJsonValueExpression2(next);
+  return buildJsonNodeExpression2([base, newValue], {
+    runtime: undefined,
+    dbType: jsonDbTypeOf2(base),
+    nullability: undefined
+  }, {
+    kind: "jsonSet",
+    base,
+    segments,
+    newValue,
+    createMissing: options2.createMissing ?? true
+  });
+};
+var jsonInsert2 = (base, target, next, options2 = {}) => {
+  const segments = normalizeJsonPathInput2(target);
+  const insert = toJsonValueExpression2(next);
+  const insertAfter = options2.insertAfter ?? false;
+  return buildJsonNodeExpression2([base, insert], {
+    runtime: undefined,
+    dbType: jsonDbTypeOf2(base),
+    nullability: undefined
+  }, {
+    kind: "jsonInsert",
+    base,
+    segments,
+    insert,
+    insertAfter
+  });
+};
+var jsonConcatAs2 = (dbType) => (left, right) => {
+  const leftExpression = toJsonValueExpression2(left);
+  const rightExpression = toJsonValueExpression2(right);
+  return buildJsonNodeExpression2([leftExpression, rightExpression], {
+    runtime: undefined,
+    dbType,
+    nullability: "maybe"
+  }, {
+    kind: "jsonConcat",
+    left: leftExpression,
+    right: rightExpression
+  });
+};
+var jsonMergeAs2 = (dbType) => (left, right) => {
+  const leftExpression = toJsonValueExpression2(left);
+  const rightExpression = toJsonValueExpression2(right);
+  return buildJsonNodeExpression2([leftExpression, rightExpression], {
+    runtime: undefined,
+    dbType,
+    nullability: "maybe"
+  }, {
+    kind: "jsonMerge",
+    left: leftExpression,
+    right: rightExpression
+  });
+};
+var jsonConcat2 = jsonConcatAs2(resolveJsonMergeDbType2());
+var jsonMerge2 = jsonMergeAs2(resolveJsonMergeDbType2());
+var jsonKeyExists2 = (base, key2) => buildJsonNodeExpression2([base], {
+  runtime: true,
+  dbType: profile2.boolDb,
+  nullability: "never"
+}, {
+  kind: "jsonKeyExists",
+  base,
+  keys: [key2]
+});
+var jsonBuildObjectAs2 = (dbType) => (shape) => {
+  const entries = Object.entries(shape).map(([key2, value]) => ({
+    key: key2,
+    value: toJsonValueExpression2(value)
+  }));
+  return buildJsonNodeExpression2(entries.map((entry) => entry.value), {
+    runtime: {},
+    dbType,
+    nullability: "never"
+  }, {
+    kind: "jsonBuildObject",
+    entries
+  });
+};
+var jsonBuildArrayAs2 = (dbType) => (...values2) => {
+  const expressions = values2.map((value) => toJsonValueExpression2(value));
+  return buildJsonNodeExpression2(expressions, {
+    runtime: [],
+    dbType,
+    nullability: "never"
+  }, {
+    kind: "jsonBuildArray",
+    values: expressions
+  });
+};
+var jsonBuildObject2 = jsonBuildObjectAs2(jsonDb2);
+var jsonBuildArray2 = jsonBuildArrayAs2(jsonDb2);
+var jsonbBuildObject2 = jsonBuildObjectAs2(jsonbDb2);
+var jsonbBuildArray2 = jsonBuildArrayAs2(jsonbDb2);
+var jsonToJson2 = (value) => toJsonValueExpression2(value, "jsonToJson", jsonDb2);
+var jsonToJsonb2 = (value) => toJsonValueExpression2(value, "jsonToJsonb", jsonbDb2);
+var jsonTypeOf2 = (base) => buildJsonNodeExpression2([base], {
+  runtime: undefined,
+  dbType: profile2.textDb,
+  nullability: base[TypeId].nullability
+}, {
+  kind: "jsonTypeOf",
+  value: base
+});
+var jsonLength2 = (base) => buildJsonNodeExpression2([base], {
+  runtime: undefined,
+  dbType: profile2.numericDb,
+  nullability: undefined
+}, {
+  kind: "jsonLength",
+  value: base
+});
+var jsonKeys2 = (base) => buildJsonNodeExpression2([base], {
+  runtime: undefined,
+  dbType: jsonDb2,
+  nullability: undefined
+}, {
+  kind: "jsonKeys",
+  value: base
+});
+var jsonPathExists2 = (base, query) => {
+  if (isJsonPathValue2(query)) {
+    return buildJsonNodeExpression2([base], {
+      runtime: true,
+      dbType: profile2.boolDb,
+      nullability: "never"
+    }, {
+      kind: "jsonPathExists",
+      base,
+      query
+    });
+  }
+  const queryExpression = jsonQueryExpression2(query);
+  return buildJsonNodeExpression2([base, queryExpression], {
+    runtime: true,
+    dbType: profile2.boolDb,
+    nullability: "never"
+  }, {
+    kind: "jsonPathExists",
+    base,
+    query: queryExpression
+  });
+};
+var jsonStripNulls2 = (base) => buildJsonNodeExpression2([base], {
+  runtime: undefined,
+  dbType: jsonDbTypeOf2(base),
+  nullability: undefined
+}, {
+  kind: "jsonStripNulls",
+  value: base
+});
+var jsonPathMatch2 = (base, query) => {
+  if (isJsonPathValue2(query)) {
+    return buildJsonNodeExpression2([base], {
+      runtime: true,
+      dbType: profile2.boolDb,
+      nullability: "never"
+    }, {
+      kind: "jsonPathMatch",
+      base,
+      query
+    });
+  }
+  const queryExpression = jsonQueryExpression2(query);
+  return buildJsonNodeExpression2([base, queryExpression], {
+    runtime: true,
+    dbType: profile2.boolDb,
+    nullability: "never"
+  }, {
+    kind: "jsonPathMatch",
+    base,
+    query: queryExpression
+  });
+};
+var json2 = {
+  key,
+  index,
+  wildcard,
+  slice,
+  descend,
+  path,
+  get: jsonGet2,
+  access: jsonAccess2,
+  traverse: jsonTraverse2,
+  text: jsonText2,
+  accessText: jsonAccessText2,
+  traverseText: jsonTraverseText2,
+  contains: jsonContains2,
+  containedBy: jsonContainedBy2,
+  hasKey: jsonHasKey2,
+  keyExists: jsonKeyExists2,
+  hasAnyKeys: jsonHasAnyKeys2,
+  hasAllKeys: jsonHasAllKeys2,
+  delete: jsonDelete2,
+  remove: jsonRemove2,
+  set: jsonSet2,
+  insert: jsonInsert2,
+  concat: jsonConcat2,
+  merge: jsonMerge2,
+  buildObject: jsonBuildObject2,
+  buildArray: jsonBuildArray2,
+  toJson: jsonToJson2,
+  toJsonb: jsonToJsonb2,
+  typeOf: jsonTypeOf2,
+  length: jsonLength2,
+  keys: jsonKeys2,
+  stripNulls: jsonStripNulls2,
+  pathExists: jsonPathExists2,
+  pathMatch: jsonPathMatch2
+};
+var jsonb2 = {
+  key,
+  index,
+  wildcard,
+  slice,
+  descend,
+  path,
+  get: jsonGet2,
+  access: jsonAccess2,
+  traverse: jsonTraverse2,
+  text: jsonText2,
+  accessText: jsonAccessText2,
+  traverseText: jsonTraverseText2,
+  contains: jsonContains2,
+  containedBy: jsonContainedBy2,
+  hasKey: jsonHasKey2,
+  keyExists: jsonKeyExists2,
+  hasAnyKeys: jsonHasAnyKeys2,
+  hasAllKeys: jsonHasAllKeys2,
+  delete: jsonDelete2,
+  remove: jsonRemove2,
+  set: jsonSet2,
+  insert: jsonInsert2,
+  concat: jsonConcatAs2(jsonbDb2),
+  merge: jsonMergeAs2(jsonbDb2),
+  buildObject: jsonbBuildObject2,
+  buildArray: jsonbBuildArray2,
+  toJsonb: jsonToJsonb2,
+  typeOf: jsonTypeOf2,
+  length: jsonLength2,
+  keys: jsonKeys2,
+  stripNulls: jsonStripNulls2,
+  pathExists: jsonPathExists2,
+  pathMatch: jsonPathMatch2
+};
+var and = (...values2) => makeVariadicBooleanExpression("and", values2.map((value) => toDialectExpression2(value)));
+var or = (...values2) => makeVariadicBooleanExpression("or", values2.map((value) => toDialectExpression2(value)));
+var not = (value) => {
+  const expression = toDialectExpression2(value);
+  return makeExpression2({
+    runtime: true,
+    dbType: profile2.boolDb,
+    nullability: expression[TypeId].nullability,
+    dialect: expression[TypeId].dialect,
+    kind: expression[TypeId].kind,
+    dependencies: expression[TypeId].dependencies
+  }, {
+    kind: "not",
+    value: expression
+  });
+};
+var in_ = (head, ...tail) => buildVariadicPredicate([head, ...tail], "in");
+var notIn = (head, ...tail) => buildVariadicPredicate([head, ...tail], "notIn");
+var between = (...values2) => buildVariadicPredicate(values2, "between");
+var contains = (...args) => {
+  const left = args[0];
+  const right = args[1];
+  return buildBinaryPredicate2(left, right, "contains");
+};
+var containedBy = (...args) => {
+  const left = args[0];
+  const right = args[1];
+  return buildBinaryPredicate2(left, right, "containedBy");
+};
+var overlaps = (...args) => {
+  const left = args[0];
+  const right = args[1];
+  return buildBinaryPredicate2(left, right, "overlaps");
+};
+var concat2 = (...values2) => {
+  const expressions = values2.map((value) => toDialectStringExpression2(value));
+  return makeExpression2({
+    runtime: "",
+    dbType: profile2.textDb,
+    nullability: mergeNullabilityManyRuntime(expressions),
+    dialect: expressions.find((value) => value[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile2.dialect,
+    kind: mergeAggregationManyRuntime(expressions),
+    dependencies: mergeManyDependencies(expressions)
+  }, {
+    kind: "concat",
+    values: expressions
+  });
+};
+var all_ = (...values2) => and(...values2);
+var any_ = (...values2) => or(...values2);
+var count2 = (value) => {
+  const expression = toDialectExpression2(value);
+  return makeExpression2({
+    runtime: undefined,
+    dbType: standardDatatypes.bigint(),
+    nullability: "never",
+    dialect: expression[TypeId].dialect,
+    kind: "aggregate",
+    dependencies: expression[TypeId].dependencies
+  }, {
+    kind: "count",
+    value: expression
+  });
+};
+var exists = (plan) => {
+  const dependencies = Object.fromEntries(currentRequiredList(plan[TypeId4].required).map((name) => [name, true]));
+  return makeExpression2({
+    runtime: true,
+    dbType: profile2.boolDb,
+    nullability: "never",
+    dialect: profile2.dialect,
+    kind: "scalar",
+    dependencies
+  }, {
+    kind: "exists",
+    plan
+  });
+};
+var scalar = (plan) => {
+  const dependencies = Object.fromEntries(currentRequiredList(plan[TypeId4].required).map((name) => [name, true]));
+  const expression = extractSingleSelectedExpressionRuntime(plan[TypeId4].selection);
+  return makeExpression2({
+    runtime: undefined,
+    dbType: expression[TypeId].dbType,
+    runtimeSchema: expression[TypeId].runtimeSchema,
+    driverValueMapping: expression[TypeId].driverValueMapping,
+    nullability: "maybe",
+    dialect: profile2.dialect,
+    kind: "scalar",
+    dependencies
+  }, {
+    kind: "scalarSubquery",
+    plan
+  });
+};
+var inSubquery = (left, plan) => {
+  const leftExpression = toDialectExpression2(left);
+  const dependencies = Object.fromEntries(currentRequiredList(plan[TypeId4].required).map((name) => [name, true]));
+  return makeExpression2({
+    runtime: true,
+    dbType: profile2.boolDb,
+    nullability: "maybe",
+    dialect: leftExpression[TypeId].dialect ?? profile2.dialect,
+    kind: leftExpression[TypeId].kind,
+    dependencies: mergeDependencies(leftExpression[TypeId].dependencies, dependencies)
+  }, {
+    kind: "inSubquery",
+    left: leftExpression,
+    plan
+  });
+};
+var quantifiedComparison = (left, plan, operator, quantifier) => {
+  const leftExpression = toDialectExpression2(left);
+  const dependencies = Object.fromEntries(currentRequiredList(plan[TypeId4].required).map((name) => [name, true]));
+  return makeExpression2({
+    runtime: true,
+    dbType: profile2.boolDb,
+    nullability: "maybe",
+    dialect: leftExpression[TypeId].dialect ?? profile2.dialect,
+    kind: leftExpression[TypeId].kind,
+    dependencies: mergeDependencies(leftExpression[TypeId].dependencies, dependencies)
+  }, renderQuantifiedComparisonAst(leftExpression, plan, operator, quantifier));
+};
+var compareAny = (left, plan, operator) => quantifiedComparison(left, plan, operator, "any");
+var compareAll = (left, plan, operator) => quantifiedComparison(left, plan, operator, "all");
+var over2 = (value, spec = {}) => {
+  const normalized = normalizeWindowSpec2(spec);
+  const expressions = mergeWindowExpressions2(value, normalized.partitionBy, normalized.orderBy);
+  return makeExpression2({
+    runtime: undefined,
+    dbType: value[TypeId].dbType,
+    nullability: value[TypeId].nullability,
+    dialect: expressions.find((expression) => expression[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile2.dialect,
+    kind: "window",
+    dependencies: mergeManyDependencies(expressions)
+  }, {
+    kind: "window",
+    function: "over",
+    value,
+    partitionBy: normalized.partitionBy,
+    orderBy: normalized.orderBy,
+    frame: normalized.frame
+  });
+};
+var buildNumberWindow2 = (kind, spec) => {
+  const normalized = normalizeWindowSpec2(spec);
+  const expressions = mergeWindowExpressions2(undefined, normalized.partitionBy, normalized.orderBy);
+  return makeExpression2({
+    runtime: undefined,
+    dbType: standardDatatypes.bigint(),
+    nullability: "never",
+    dialect: expressions.find((expression) => expression[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile2.dialect,
+    kind: "window",
+    dependencies: mergeManyDependencies(expressions)
+  }, {
+    kind: "window",
+    function: kind,
+    partitionBy: normalized.partitionBy,
+    orderBy: normalized.orderBy,
+    frame: normalized.frame
+  });
+};
+var rowNumber2 = (spec) => buildNumberWindow2("rowNumber", spec);
+var rank2 = (spec) => buildNumberWindow2("rank", spec);
+var denseRank2 = (spec) => buildNumberWindow2("denseRank", spec);
+var max2 = (value) => makeExpression2({
+  runtime: undefined,
+  dbType: value[TypeId].dbType,
+  nullability: "maybe",
+  dialect: value[TypeId].dialect,
+  kind: "aggregate",
+  dependencies: value[TypeId].dependencies
+}, {
+  kind: "max",
+  value
+});
+var min2 = (value) => makeExpression2({
+  runtime: undefined,
+  dbType: value[TypeId].dbType,
+  nullability: "maybe",
+  dialect: value[TypeId].dialect,
+  kind: "aggregate",
+  dependencies: value[TypeId].dependencies
+}, {
+  kind: "min",
+  value
+});
+var resolveCoalesceNullabilityRuntime2 = (values2) => values2.some((value) => value[TypeId].nullability === "never") ? "never" : values2.some((value) => value[TypeId].nullability === "maybe") ? "maybe" : "always";
+var coalesce2 = (...values2) => {
+  const expressions = values2.map((value) => toDialectExpression2(value));
+  const representative = expressions.find((value) => value[TypeId].nullability !== "always") ?? expressions[0];
+  return makeExpression2({
+    runtime: undefined,
+    dbType: representative[TypeId].dbType,
+    nullability: resolveCoalesceNullabilityRuntime2(expressions),
+    dialect: expressions.find((value) => value[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile2.dialect,
+    kind: mergeAggregationManyRuntime(expressions),
+    dependencies: mergeManyDependencies(expressions)
+  }, {
+    kind: "coalesce",
+    values: expressions
+  });
+};
+var resolveCaseNullabilityRuntime = (values2) => {
+  let sawNever = false;
+  let sawMaybe = false;
+  let sawAlways = false;
+  for (const value of values2) {
+    switch (value[TypeId].nullability) {
+      case "never":
+        sawNever = true;
+        break;
+      case "maybe":
+        sawMaybe = true;
+        break;
+      case "always":
+        sawAlways = true;
+        break;
+    }
+  }
+  return sawNever ? sawMaybe || sawAlways ? "maybe" : "never" : sawMaybe ? "maybe" : "always";
+};
+var finalizeCase = (branches, fallback) => {
+  const resultExpressions = [...branches.map((branch) => branch.then), fallback];
+  const allExpressions = [...branches.flatMap((branch) => [branch.when, branch.then]), fallback];
+  const representative = resultExpressions.find((value) => value[TypeId].nullability !== "always") ?? fallback;
+  return makeExpression2({
+    runtime: undefined,
+    dbType: representative[TypeId].dbType,
+    nullability: resolveCaseNullabilityRuntime(resultExpressions),
+    dialect: allExpressions.find((value) => value[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile2.dialect,
+    kind: mergeAggregationManyRuntime(allExpressions),
+    dependencies: mergeManyDependencies(allExpressions)
+  }, {
+    kind: "case",
+    branches: branches.map((branch) => ({
+      when: branch.when,
+      then: branch.then
+    })),
+    else: fallback
+  });
+};
+var case_ = () => {
+  const build = (branches) => ({
+    when(predicate, result) {
+      return build([
+        ...branches,
+        {
+          when: toDialectExpression2(predicate),
+          then: toDialectExpression2(result)
+        }
+      ]);
+    },
+    else(fallback) {
+      return finalizeCase(branches, toDialectExpression2(fallback));
+    }
+  });
+  return {
+    when(predicate, result) {
+      return build([{
+        when: toDialectExpression2(predicate),
+        then: toDialectExpression2(result)
+      }]);
+    }
+  };
+};
+var match = (value) => {
+  const subject = toDialectExpression2(value);
+  const build = (branches) => ({
+    when(compare, result) {
+      return build([
+        ...branches,
+        {
+          when: buildBinaryPredicate2(subject, compare, "eq"),
+          then: toDialectExpression2(result)
+        }
+      ]);
+    },
+    else(fallback) {
+      return finalizeCase(branches, toDialectExpression2(fallback));
+    }
+  });
+  return {
+    when(compare, result) {
+      const predicate = buildBinaryPredicate2(subject, compare, "eq");
+      return build([{
+        when: predicate,
+        then: toDialectExpression2(result)
+      }]);
+    }
+  };
+};
+var excluded = (value) => {
+  const ast = value[TypeId2];
+  return makeExpression2({
+    runtime: undefined,
+    dbType: value[TypeId].dbType,
+    runtimeSchema: value[TypeId].runtimeSchema,
+    driverValueMapping: value[TypeId].driverValueMapping,
+    nullability: value[TypeId].nullability,
+    dialect: profile2.dialect,
+    kind: "scalar",
+    dependencies: {}
+  }, {
+    kind: "excluded",
+    columnName: ast.columnName
+  });
+};
+var toMutationValueExpression2 = (value, column2) => {
+  const columnState = column2[TypeId];
+  const normalizeMutationValue = (candidate) => {
+    if (candidate === null && columnState.nullability !== "never") {
+      return null;
+    }
+    const runtimeSchemaAccepts = columnState.runtimeSchema !== undefined && Schema7.is(columnState.runtimeSchema)(candidate);
+    if (runtimeSchemaAccepts) {
+      return candidate;
+    }
+    const normalized = normalizeDbValue(columnState.dbType, candidate);
+    return columnState.runtimeSchema === undefined ? normalized : Schema7.decodeUnknownSync(columnState.runtimeSchema)(normalized);
+  };
+  if (value !== null && typeof value === "object" && TypeId in value) {
+    const expression = value;
+    const ast = expression[TypeId2];
+    if (ast.kind === "literal") {
+      const normalizedValue2 = normalizeMutationValue(ast.value);
+      return makeExpression2({
+        runtime: normalizedValue2,
+        dbType: columnState.dbType,
+        runtimeSchema: columnState.runtimeSchema,
+        driverValueMapping: columnState.driverValueMapping,
+        nullability: normalizedValue2 === null ? "always" : "never",
+        dialect: columnState.dialect,
+        kind: "scalar",
+        dependencies: {}
+      }, {
+        kind: "literal",
+        value: normalizedValue2
+      });
+    }
+    return retargetLiteralExpression2(value, column2);
+  }
+  const normalizedValue = normalizeMutationValue(value);
+  return makeExpression2({
+    runtime: normalizedValue,
+    dbType: columnState.dbType,
+    runtimeSchema: columnState.runtimeSchema,
+    driverValueMapping: columnState.driverValueMapping,
+    nullability: normalizedValue === null ? "always" : "never",
+    dialect: columnState.dialect,
+    kind: "scalar",
+    dependencies: {}
+  }, {
+    kind: "literal",
+    value: normalizedValue
+  });
+};
+var renderQuantifiedComparisonAst = (left, plan, operator, quantifier) => ({
+  kind: quantifier === "any" ? "comparisonAny" : "comparisonAll",
+  operator,
+  left,
+  plan
+});
+var targetSourceDetails2 = (table) => {
+  const sourceName = table[TypeId7].name;
+  const sourceBaseName = table[TypeId7].baseName;
+  return {
+    sourceName,
+    sourceBaseName
+  };
+};
+var sourceDetails2 = (source) => {
+  if (TypeId7 in source) {
+    return targetSourceDetails2(source);
+  }
+  const record2 = source;
+  return {
+    sourceName: record2.name,
+    sourceBaseName: record2.baseName
+  };
+};
+var makeColumnReferenceSelection2 = (alias2, selection) => {
+  const columns = {};
+  for (const [columnName, expression] of Object.entries(selection)) {
+    const state = expression[TypeId];
+    columns[columnName] = makeExpression2({
+      runtime: undefined,
+      dbType: state.dbType,
+      runtimeSchema: state.runtimeSchema,
+      driverValueMapping: state.driverValueMapping,
+      nullability: state.nullability,
+      dialect: state.dialect,
+      kind: "scalar",
+      dependencies: {
+        [alias2]: true
+      }
+    }, {
+      kind: "column",
+      tableName: alias2,
+      columnName
+    });
+  }
+  return columns;
+};
+var makeAliasedValuesSource = (rows, selection, alias2) => {
+  const columns = makeColumnReferenceSelection2(alias2, selection);
+  const source = {
+    kind: "values",
+    name: alias2,
+    baseName: alias2,
+    dialect: profile2.dialect,
+    rows,
+    columns
+  };
+  return Object.assign(source, columns);
+};
+var normalizeValuesRow2 = (row) => Object.fromEntries(Object.entries(row).map(([key2, value]) => [key2, toDialectExpression2(value)]));
+var normalizeUnnestColumns2 = (columns) => Object.fromEntries(Object.entries(columns).map(([key2, values2]) => [key2, values2.map((value) => toDialectExpression2(value))]));
+var normalizeMutationTargets2 = (target) => Array.isArray(target) ? target : [target];
+var mutationTargetClauses2 = (target) => normalizeMutationTargets2(target).map((table) => {
+  const { sourceName, sourceBaseName } = targetSourceDetails2(table);
+  return {
+    kind: "from",
+    tableName: sourceName,
+    baseTableName: sourceBaseName,
+    source: table
+  };
+});
+var mutationAvailableSources2 = (target, mode = "required") => Object.fromEntries(normalizeMutationTargets2(target).map((table) => {
+  const { sourceName, sourceBaseName } = targetSourceDetails2(table);
+  return [
+    sourceName,
+    {
+      name: sourceName,
+      mode,
+      baseName: sourceBaseName
+    }
+  ];
+}));
+var getMutationColumn2 = (columns, columnName) => columns[columnName];
+var buildMutationAssignments2 = (target, values2) => {
+  const targets = normalizeMutationTargets2(target);
+  if (targets.length === 1 && !Array.isArray(target)) {
+    const columns = target;
+    return Object.entries(values2).map(([columnName, value]) => ({
+      columnName,
+      value: toMutationValueExpression2(value, getMutationColumn2(columns, columnName))
+    }));
+  }
+  const valueMap = values2;
+  return targets.flatMap((table) => {
+    const targetName = table[TypeId7].name;
+    const scopedValues = valueMap[targetName] ?? {};
+    const columns = table;
+    return Object.entries(scopedValues).map(([columnName, value]) => ({
+      tableName: targetName,
+      columnName,
+      value: toMutationValueExpression2(value, getMutationColumn2(columns, columnName))
+    }));
+  });
+};
+var buildInsertValuesRows2 = (target, rows) => {
+  const firstRow = rows[0];
+  const firstColumns = Object.keys(firstRow);
+  const columns = firstColumns;
+  const normalizeRow = (row) => {
+    const assignments = buildMutationAssignments2(target, row);
+    return {
+      values: columns.map((columnName) => assignments.find((assignment) => assignment.columnName === columnName))
+    };
+  };
+  const normalizedRows = [
+    normalizeRow(rows[0]),
+    ...rows.slice(1).map(normalizeRow)
+  ];
+  const required = normalizedRows.flatMap((row) => row.values.flatMap((entry) => Object.keys(entry.value[TypeId].dependencies)));
+  return {
+    columns,
+    rows: normalizedRows,
+    required: required.filter((name, index4, list) => list.indexOf(name) === index4)
+  };
+};
+var normalizeInsertSelectColumns2 = (selection) => {
+  const columns = Object.keys(selection);
+  return columns;
+};
+var normalizeInsertUnnestValues2 = (target, values2) => {
+  const entries = Object.entries(values2);
+  const columns = entries.map(([columnName]) => columnName);
+  const normalized = entries.map(([columnName, items]) => ({
+    columnName,
+    values: items
+  }));
+  return {
+    columns,
+    values: normalized
+  };
+};
+var normalizeConflictColumns2 = (target, columnsInput) => {
+  const columns = normalizeColumnList(columnsInput);
+  return columns;
+};
+var buildConflictTarget2 = (target, input) => {
+  if (typeof input === "string" || Array.isArray(input)) {
+    return {
+      kind: "columns",
+      columns: normalizeConflictColumns2(target, input)
+    };
+  }
+  if (!Array.isArray(input) && "constraint" in input) {
+    return {
+      kind: "constraint",
+      name: input.constraint
+    };
+  }
+  const columnTarget = input;
+  return {
+    kind: "columns",
+    columns: normalizeConflictColumns2(target, columnTarget.columns),
+    where: columnTarget.where === undefined ? undefined : toDialectExpression2(columnTarget.where)
+  };
+};
+var defaultIndexName2 = (tableName, columns, unique3) => `${tableName}_${columns.join("_")}_${unique3 ? "uniq" : "idx"}`;
+function as(valueOrAlias, alias2) {
+  if (alias2 === undefined) {
+    return (value2) => as(value2, valueOrAlias);
+  }
+  const resolvedAlias = alias2;
+  const value = valueOrAlias;
+  if (typeof value !== "object" || value === null || TypeId in value) {
+    const expression = toDialectExpression2(value);
+    const projected = Object.create(Object.getPrototypeOf(expression));
+    const runtimeExpression = expression;
+    projected[TypeId] = runtimeExpression[TypeId];
+    projected[TypeId2] = runtimeExpression[TypeId2];
+    if ("schema" in runtimeExpression) {
+      projected.schema = runtimeExpression.schema;
+    }
+    projected[TypeId9] = {
+      alias: resolvedAlias
+    };
+    return projected;
+  }
+  if ("kind" in value && value.kind === "values" && !("name" in value)) {
+    const valuesInput = value;
+    return makeAliasedValuesSource(valuesInput.rows, valuesInput.selection, resolvedAlias);
+  }
+  return makeDerivedSource(value, resolvedAlias);
+}
+function with_(valueOrAlias, alias2) {
+  if (alias2 === undefined) {
+    return (value) => with_(value, valueOrAlias);
+  }
+  return makeCteSource(valueOrAlias, alias2);
+}
+function withRecursive_(valueOrAlias, alias2) {
+  if (alias2 === undefined) {
+    return (value) => withRecursive_(value, valueOrAlias);
+  }
+  return makeCteSource(valueOrAlias, alias2, true);
+}
+function lateral(valueOrAlias, alias2) {
+  if (alias2 === undefined) {
+    return (value) => lateral(value, valueOrAlias);
+  }
+  return makeLateralSource(valueOrAlias, alias2);
+}
+var {
+  values: values2,
+  unnest: unnest2,
+  generateSeries: generateSeries2,
+  select: select2,
+  groupBy: groupBy2,
+  returning: returning2
+} = makeDslQueryRuntime({
+  profile: profile2,
+  ValuesInputProto: ValuesInputProto2,
+  normalizeValuesRow: normalizeValuesRow2,
+  normalizeUnnestColumns: normalizeUnnestColumns2,
+  makeColumnReferenceSelection: makeColumnReferenceSelection2,
+  toDialectNumericExpression: toDialectNumericExpression2,
+  extractRequiredRuntime,
+  makePlan,
+  getAst,
+  getQueryState,
+  currentRequiredList,
+  dedupeGroupedExpressions
+});
+var {
+  buildSetOperation: buildSetOperation2,
+  where: where2,
+  from: from2,
+  having: having2,
+  crossJoin: crossJoin2,
+  join: join2,
+  orderBy: orderBy2,
+  lock: lock2,
+  distinct: distinct2,
+  limit: limit2,
+  offset: offset2
+} = makeDslPlanRuntime({
+  profile: profile2,
+  makePlan,
+  getAst,
+  getQueryState,
+  currentRequiredList,
+  toDialectExpression: toDialectExpression2,
+  toDialectNumericExpression: toDialectNumericExpression2,
+  extractRequiredFromDialectInputRuntime: extractRequiredFromDialectInputRuntime2,
+  extractRequiredFromDialectNumericInputRuntime: extractRequiredFromDialectNumericInputRuntime2,
+  formulaOfExpressionRuntime: formulaOfExpression,
+  assumeFormulaTrue,
+  trueFormula,
+  sourceDetails: sourceDetails2,
+  presenceWitnessesOfSourceLike,
+  attachInsertSource: (...args) => attachInsertSource2(args[0], args[1])
+});
+var union = (left, right) => buildSetOperation2("union", false, left, right);
+var unionAll = (left, right) => buildSetOperation2("union", true, left, right);
+var intersect = (left, right) => buildSetOperation2("intersect", false, left, right);
+var intersectAll = (left, right) => buildSetOperation2("intersect", true, left, right);
+var except = (left, right) => buildSetOperation2("except", false, left, right);
+var exceptAll = (left, right) => buildSetOperation2("except", true, left, right);
+var innerJoin = (table, on) => join2("inner", table, on);
+var leftJoin = (table, on) => join2("left", table, on);
+var rightJoin = (table, on) => join2("right", table, on);
+var fullJoin = (table, on) => join2("full", table, on);
+var distinctOn2 = {
+  __effect_qb_error__: "effect-qb: distinctOn(...) is only supported by the postgres dialect",
+  __effect_qb_dialect__: profile2.dialect,
+  __effect_qb_hint__: "Use postgres.Query.distinctOn(...) or regular distinct()/grouping logic"
+};
+var mutationRuntime2 = makeDslMutationRuntime({
+  profile: profile2,
+  makePlan,
+  getAst,
+  getQueryState,
+  currentRequiredList,
+  toDialectExpression: toDialectExpression2,
+  buildMutationAssignments: buildMutationAssignments2,
+  buildInsertValuesRows: buildInsertValuesRows2,
+  normalizeInsertUnnestValues: normalizeInsertUnnestValues2,
+  normalizeInsertSelectColumns: normalizeInsertSelectColumns2,
+  buildConflictTarget: buildConflictTarget2,
+  mutationTargetClauses: mutationTargetClauses2,
+  mutationAvailableSources: mutationAvailableSources2,
+  normalizeConflictColumns: normalizeConflictColumns2,
+  targetSourceDetails: targetSourceDetails2,
+  sourceDetails: sourceDetails2
+});
+var insert = (target, values3) => mutationRuntime2.insert(target, values3);
+var attachInsertSource2 = (plan, source) => mutationRuntime2.attachInsertSource(plan, source);
+var onConflict2 = (target, options2 = {}) => (plan) => mutationRuntime2.onConflict(target, options2)(plan);
+var update = (target, values3) => mutationRuntime2.update(target, values3);
+var upsert = (target, values3, conflictColumns, updateValues) => mutationRuntime2.upsert(target, values3, conflictColumns, updateValues);
+var delete_ = (target) => mutationRuntime2.delete_(target);
+var truncate = (target, options2 = {}) => mutationRuntime2.truncate(target, options2);
+var merge2 = (target, source, on, options2) => mutationRuntime2.merge(target, source, on, options2);
+var {
+  transaction: transaction2,
+  commit: commit2,
+  rollback: rollback2,
+  savepoint: savepoint2,
+  rollbackTo: rollbackTo2,
+  releaseSavepoint: releaseSavepoint2,
+  createTable: createTable2,
+  dropTable: dropTable2,
+  createIndex: createIndex2,
+  dropIndex: dropIndex2
+} = makeDslTransactionDdlRuntime({
+  profile: profile2,
+  makePlan,
+  targetSourceDetails: targetSourceDetails2,
+  normalizeColumnList,
+  defaultIndexName: defaultIndexName2
+});
+var {
+  values: exportedValues,
+  unnest: exportedUnnest,
+  select: exportedSelect,
+  from: exportedFrom,
+  insert: exportedInsert
+} = {
+  values: values2,
+  unnest: unnest2,
+  select: select2,
+  from: from2,
+  insert
+};
+
+// src/internal/analytics.ts
+var normalizeSpec = (spec) => {
+  validateWindowFrame(spec.frame);
+  return {
+    partitionBy: spec.partitionBy ?? [],
+    orderBy: spec.orderBy.map((term) => ({
+      value: term.value,
+      direction: term.direction ?? "asc"
+    })),
+    frame: spec.frame
+  };
+};
+var rejectExplicitPortableFrame = (functionName, spec) => {
+  if (spec.frame !== undefined) {
+    throw new Error(`${functionName} does not accept an explicit frame on the portable Function API; use a dialect Function helper`);
+  }
+};
+var windowExpression = (kind, value, spec, nullability, options2 = {}) => {
+  const normalized = normalizeSpec(spec);
+  const { fallbackDialect, ...astOptions } = options2;
+  const expressions = [
+    value,
+    ...normalized.partitionBy,
+    ...normalized.orderBy.map((term) => term.value),
+    ...options2.offset === undefined ? [] : [options2.offset],
+    ...options2.defaultValue === undefined ? [] : [options2.defaultValue]
+  ];
+  return makeExpression2({
+    runtime: undefined,
+    dbType: value[TypeId].dbType,
+    runtimeSchema: value[TypeId].runtimeSchema,
+    driverValueMapping: value[TypeId].driverValueMapping,
+    nullability,
+    dialect: expressions.find((entry) => entry[TypeId].dialect !== "standard")?.[TypeId].dialect ?? fallbackDialect ?? value[TypeId].dialect,
+    kind: "window",
+    dependencies: mergeManyDependencies(expressions)
+  }, {
+    kind: "window",
+    function: kind,
+    value,
+    ...astOptions,
+    ...normalized
+  });
+};
+var lag = (value, options2) => {
+  rejectExplicitPortableFrame("lag", options2.spec);
+  if (options2.offset !== undefined && (!Number.isSafeInteger(options2.offset) || options2.offset < 0)) {
+    throw new Error("lag offset must be a non-negative safe integer");
+  }
+  return windowExpression("lag", value, options2.spec, "maybe", {
+    ...options2.offset === undefined && options2.default === undefined ? {} : { offset: literal3(options2.offset ?? 1) },
+    ...options2.default === undefined ? {} : { defaultValue: literal3(options2.default) }
+  });
+};
+var lead = (value, options2) => {
+  rejectExplicitPortableFrame("lead", options2.spec);
+  if (options2.offset !== undefined && (!Number.isSafeInteger(options2.offset) || options2.offset < 0)) {
+    throw new Error("lead offset must be a non-negative safe integer");
+  }
+  return windowExpression("lead", value, options2.spec, "maybe", {
+    ...options2.offset === undefined && options2.default === undefined ? {} : { offset: literal3(options2.offset ?? 1) },
+    ...options2.default === undefined ? {} : { defaultValue: literal3(options2.default) }
+  });
+};
+var firstValue = (value, spec) => {
+  rejectExplicitPortableFrame("firstValue", spec);
+  return windowExpression("firstValue", value, spec, value[TypeId].nullability);
+};
+var lastValue = (value, spec) => {
+  rejectExplicitPortableFrame("lastValue", spec);
+  return windowExpression("lastValue", value, spec, value[TypeId].nullability);
+};
+var makeDialectFirstValue = (dialect) => (value, spec) => windowExpression("firstValue", value, spec, "maybe", { fallbackDialect: dialect });
+var makeDialectLastValue = (dialect) => (value, spec) => windowExpression("lastValue", value, spec, "maybe", { fallbackDialect: dialect });
+
+// src/sqlite/function/window.ts
+var firstValue2 = makeDialectFirstValue("sqlite");
+var lastValue2 = makeDialectLastValue("sqlite");
+// src/sqlite/function/temporal.ts
+var exports_temporal = {};
+__export(exports_temporal, {
+  now: () => now,
+  localTimestamp: () => localTimestamp,
+  localTime: () => localTime,
+  currentTimestamp: () => currentTimestamp,
+  currentTime: () => currentTime,
+  currentDate: () => currentDate
+});
+var makeTemporal = (name, dbType, runtimeSchema) => makeExpression2({
+  runtime: undefined,
+  dbType,
+  runtimeSchema,
+  nullability: "never",
+  dialect: "sqlite",
+  kind: "scalar",
+  dependencies: {}
+}, {
+  kind: "function",
+  name,
+  args: []
+});
+var currentDate = () => makeTemporal("current_date", sqliteDatatypes.date(), LocalDateStringSchema);
+var currentTime = () => makeTemporal("current_time", sqliteDatatypes.time(), LocalTimeStringSchema);
+var currentTimestamp = () => makeTemporal("current_timestamp", sqliteDatatypes.timestamp(), LocalDateTimeStringSchema);
+var localTime = () => makeTemporal("localtime", sqliteDatatypes.time(), LocalTimeStringSchema);
+var localTimestamp = () => makeTemporal("localtimestamp", sqliteDatatypes.timestamp(), LocalDateTimeStringSchema);
+var now = () => makeTemporal("now", sqliteDatatypes.timestamp(), LocalDateTimeStringSchema);
+// src/sqlite/json.ts
+var exports_json = {};
+__export(exports_json, {
+  typeOf: () => typeOf,
+  stripNulls: () => stripNulls,
+  pathMatch: () => pathMatch,
+  length: () => length,
+  insert: () => insert2
+});
+var insert2 = json.insert;
+var typeOf = json.typeOf;
+var length = json.length;
+var stripNulls = json.stripNulls;
+var pathMatch = json.pathMatch;
+// src/sqlite/executor.ts
+var exports_executor2 = {};
+__export(exports_executor2, {
+  withTransaction: () => withTransaction2,
+  nonEmpty: () => nonEmpty2,
+  make: () => make4,
+  exactlyOne: () => exactlyOne2,
+  driver: () => driver2,
+  custom: () => custom4,
+  atMostOne: () => atMostOne2
+});
+import * as Effect2 from "effect/Effect";
+import * as SqlClient3 from "effect/unstable/sql/SqlClient";
+import * as Stream2 from "effect/Stream";
+
+// src/internal/executor.ts
+var exports_executor = {};
+__export(exports_executor, {
+  withTransaction: () => withTransaction,
+  withResultContracts: () => withResultContracts,
+  streamFromSqlClient: () => streamFromSqlClient,
+  remapRows: () => remapRows,
+  nonEmpty: () => nonEmpty,
+  makeRowDecoder: () => makeRowDecoder,
+  make: () => make3,
+  hasWriteCapability: () => hasWriteCapability,
+  fromSqlClient: () => fromSqlClient,
+  fromDriver: () => fromDriver,
+  explainQuery: () => explainQuery,
+  exactlyOne: () => exactlyOne,
+  driver: () => driver,
+  decodeRows: () => decodeRows,
+  decodeChunk: () => decodeChunk,
+  atMostOne: () => atMostOne
+});
+import * as Chunk from "effect/Chunk";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Option from "effect/Option";
+import * as Schema10 from "effect/Schema";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+import * as Stream from "effect/Stream";
+
+// src/internal/runtime/driver-value-mapping.ts
+import * as Schema8 from "effect/Schema";
+var runtimeTagOfDbType = (dbType) => {
+  if (dbType === undefined) {
+    return;
+  }
+  if ("base" in dbType) {
+    return runtimeTagOfDbType(dbType.base);
+  }
+  if ("element" in dbType) {
+    return "array";
+  }
+  if ("fields" in dbType) {
+    return "record";
+  }
+  if ("variant" in dbType && dbType.variant === "json") {
+    return "json";
+  }
+  if ("variant" in dbType && (dbType.variant === "enum" || dbType.variant === "set")) {
+    return "string";
+  }
+  return dbType.runtime;
+};
+var familyOfDbType = (dbType) => {
+  if (dbType === undefined) {
+    return;
+  }
+  if ("base" in dbType) {
+    return familyOfDbType(dbType.base);
+  }
+  return dbType.family;
+};
+var mappingCandidates = (context) => {
+  const dbType = context.dbType;
+  const runtimeTag = runtimeTagOfDbType(dbType);
+  const family = familyOfDbType(dbType);
+  return [
+    context.driverValueMapping,
+    dbType?.driverValueMapping,
+    dbType === undefined ? undefined : context.valueMappings?.[dbType.kind],
+    family === undefined ? undefined : context.valueMappings?.[family],
+    runtimeTag === undefined ? undefined : context.valueMappings?.[runtimeTag]
+  ];
+};
+var findMapping = (context, key2) => {
+  for (const candidate of mappingCandidates(context)) {
+    const value = candidate?.[key2];
+    if (value !== undefined) {
+      return value;
+    }
+  }
+  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 && Schema8.is(schema2)(value);
+var encodeWithSchema = (schema2, value) => {
+  if (schema2 === undefined) {
+    return { value, encoded: false };
+  }
+  if (!Schema8.is(schema2)(value)) {
+    return { value, encoded: false };
+  }
+  return {
+    value: Schema8.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;
@@ -6035,9 +8132,9 @@ var toDriverValue = (value, context) => {
   const dbType = context.dbType;
   const encoded = encodeWithSchema(context.runtimeSchema, value);
   let current = encoded.value;
-  const custom3 = findMapping(context, "toDriver");
-  if (custom3 !== undefined && dbType !== undefined) {
-    return custom3(current, dbType);
+  const custom4 = findMapping(context, "toDriver");
+  if (custom4 !== undefined && dbType !== undefined) {
+    return custom4(current, dbType);
   }
   if (encoded.encoded && typeof current === "string" && isJsonDbType(dbType)) {
     return current;
@@ -6049,9 +8146,9 @@ var fromDriverValue = (value, context) => {
     return null;
   }
   const dbType = context.dbType;
-  const custom3 = findMapping(context, "fromDriver");
-  if (custom3 !== undefined && dbType !== undefined) {
-    return custom3(value, dbType);
+  const custom4 = findMapping(context, "fromDriver");
+  if (custom4 !== undefined && dbType !== undefined) {
+    return custom4(value, dbType);
   }
   if (typeof value === "string") {
     const normalizedJsonString = normalizeJsonDriverString(value, context);
@@ -6082,33 +8179,33 @@ var postgresJsonSql = (sql, dbType) => {
 };
 var renderSelectSql = (sql, context) => {
   const dbType = context.dbType;
-  const custom3 = findMapping(context, "selectSql");
-  return custom3 !== undefined && dbType !== undefined ? custom3(sql, dbType) : sql;
+  const custom4 = findMapping(context, "selectSql");
+  return custom4 !== undefined && dbType !== undefined ? custom4(sql, dbType) : sql;
 };
 var renderJsonSelectSql = (sql, context) => {
   const dbType = context.dbType;
-  const custom3 = findMapping(context, "jsonSelectSql");
-  if (custom3 !== undefined && dbType !== undefined) {
-    return custom3(sql, dbType);
+  const custom4 = findMapping(context, "jsonSelectSql");
+  if (custom4 !== undefined && dbType !== undefined) {
+    return custom4(sql, dbType);
   }
   return context.dialect === "postgres" && dbType !== undefined ? postgresJsonSql(sql, dbType) : sql;
 };
 
 // src/internal/runtime/schema.ts
-import * as Schema8 from "effect/Schema";
+import * as Schema9 from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
 var schemaCache = new WeakMap;
-var FiniteNumberSchema = Schema8.Number.check(Schema8.isFinite());
+var FiniteNumberSchema = Schema9.Number.check(Schema9.isFinite());
 var runtimeSchemaForTag = (tag) => {
   switch (tag) {
     case "string":
-      return Schema8.String;
+      return Schema9.String;
     case "number":
       return FiniteNumberSchema;
     case "bigintString":
       return BigIntStringSchema;
     case "boolean":
-      return Schema8.Boolean;
+      return Schema9.Boolean;
     case "json":
       return JsonValueSchema;
     case "localDate":
@@ -6126,13 +8223,13 @@ var runtimeSchemaForTag = (tag) => {
     case "decimalString":
       return DecimalStringSchema;
     case "bytes":
-      return Schema8.Uint8Array;
+      return Schema9.Uint8Array;
     case "array":
-      return Schema8.Array(Schema8.Unknown);
+      return Schema9.Array(Schema9.Unknown);
     case "record":
-      return Schema8.Record(Schema8.String, Schema8.Unknown);
+      return Schema9.Record(Schema9.String, Schema9.Unknown);
     case "null":
-      return Schema8.Null;
+      return Schema9.Null;
     case "unknown":
       return;
   }
@@ -6145,22 +8242,22 @@ var runtimeSchemaForDbType = (dbType) => {
     return runtimeSchemaForDbType(dbType.base);
   }
   if ("element" in dbType) {
-    return Schema8.Array(runtimeSchemaForDbType(dbType.element) ?? Schema8.Unknown);
+    return Schema9.Array(runtimeSchemaForDbType(dbType.element) ?? Schema9.Unknown);
   }
   if ("fields" in dbType) {
-    const fields2 = Object.fromEntries(Object.entries(dbType.fields).map(([key2, field]) => [key2, runtimeSchemaForDbType(field) ?? Schema8.Unknown]));
-    return Schema8.Struct(fields2);
+    const fields2 = Object.fromEntries(Object.entries(dbType.fields).map(([key2, field]) => [key2, runtimeSchemaForDbType(field) ?? Schema9.Unknown]));
+    return Schema9.Struct(fields2);
   }
   if ("variant" in dbType && dbType.variant === "json") {
     return JsonValueSchema;
   }
   if ("variant" in dbType && (dbType.variant === "enum" || dbType.variant === "set")) {
-    return Schema8.String;
+    return Schema9.String;
   }
   const runtimeTag = runtimeTagOfBaseDbType2(dbType);
   return runtimeTag === undefined ? undefined : runtimeSchemaForTag(runtimeTag);
 };
-var makeSchemaFromAst = (ast) => Schema8.make(ast);
+var makeSchemaFromAst = (ast) => Schema9.make(ast);
 var unionAst = (asts) => {
   if (asts.length === 0) {
     return;
@@ -6183,11 +8280,11 @@ var propertyAstOf = (ast, key2) => {
       return index4?.type;
     }
     case "Union": {
-      const values2 = ast.types.flatMap((member) => {
+      const values3 = ast.types.flatMap((member) => {
         const next = propertyAstOf(member, key2);
         return next === undefined ? [] : [next];
       });
-      return unionAst(values2);
+      return unionAst(values3);
     }
     default:
       return;
@@ -6208,11 +8305,11 @@ var numberAstOf = (ast, index4) => {
       return unionAst(ast.rest);
     }
     case "Union": {
-      const values2 = ast.types.flatMap((member) => {
+      const values3 = ast.types.flatMap((member) => {
         const next = numberAstOf(member, index4);
         return next === undefined ? [] : [next];
       });
-      return unionAst(values2);
+      return unionAst(values3);
     }
     default:
       return;
@@ -6250,7 +8347,7 @@ var unionSchemas = (schemas) => {
   if (resolved.length === 1) {
     return resolved[0];
   }
-  return Schema8.Union(resolved);
+  return Schema9.Union(resolved);
 };
 var firstSelectedExpression = (plan) => {
   const selection = getAst(plan).select;
@@ -6285,9 +8382,9 @@ var jsonCompatibleSchema = (schema2) => {
 };
 var buildStructSchema = (entries, context) => {
   const fields2 = Object.fromEntries(entries.map((entry) => [entry.key, expressionRuntimeSchema(entry.value, context) ?? JsonValueSchema]));
-  return Schema8.Struct(fields2);
+  return Schema9.Struct(fields2);
 };
-var buildTupleSchema = (values2, context) => Schema8.Tuple(values2.map((value) => expressionRuntimeSchema(value, context) ?? JsonValueSchema));
+var buildTupleSchema = (values3, context) => Schema9.Tuple(values3.map((value) => expressionRuntimeSchema(value, context) ?? JsonValueSchema));
 var deriveCaseSchema = (ast, context) => {
   if (context === undefined) {
     return unionSchemas([
@@ -6327,10 +8424,10 @@ var deriveRuntimeSchema = (expression, context) => {
       return state.runtimeSchema;
     case "literal":
       if (ast.value === null) {
-        return Schema8.Null;
+        return Schema9.Null;
       }
       if (typeof ast.value === "string" || typeof ast.value === "number" || typeof ast.value === "boolean") {
-        return Schema8.Literal(ast.value);
+        return Schema9.Literal(ast.value);
       }
       return runtimeSchemaForDbType(state.dbType);
     case "cast":
@@ -6366,7 +8463,7 @@ var deriveRuntimeSchema = (expression, context) => {
     case "jsonHasAllKeys":
     case "jsonPathExists":
     case "jsonPathMatch":
-      return Schema8.Boolean;
+      return Schema9.Boolean;
     case "upper":
     case "lower":
     case "concat":
@@ -6375,8 +8472,9 @@ var deriveRuntimeSchema = (expression, context) => {
     case "jsonAccessText":
     case "jsonTraverseText":
     case "jsonTypeOf":
-      return Schema8.String;
+      return Schema9.String;
     case "count":
+      return runtimeSchemaForDbType(state.dbType);
     case "jsonLength":
       return FiniteNumberSchema;
     case "max":
@@ -6391,7 +8489,7 @@ var deriveRuntimeSchema = (expression, context) => {
       return selection === undefined ? undefined : expressionRuntimeSchema(selection, context);
     }
     case "window":
-      return ast.function === "over" && ast.value !== undefined ? expressionRuntimeSchema(ast.value, context) : FiniteNumberSchema;
+      return ast.function === "over" && ast.value !== undefined ? expressionRuntimeSchema(ast.value, context) : runtimeSchemaForDbType(state.dbType);
     case "jsonGet":
     case "jsonPath":
     case "jsonAccess":
@@ -6423,7 +8521,7 @@ var deriveRuntimeSchema = (expression, context) => {
     case "jsonToJsonb":
       return jsonCompatibleSchema(expressionRuntimeSchema(ast.value, context));
     case "jsonKeys":
-      return Schema8.Array(Schema8.String);
+      return Schema9.Array(Schema9.String);
   }
 };
 var expressionRuntimeSchema = (expression, context) => {
@@ -6439,7 +8537,86 @@ var expressionRuntimeSchema = (expression, context) => {
   return resolved;
 };
 
+// src/internal/renderer.ts
+var TypeId10 = Symbol.for("effect-qb/Renderer");
+var projectionPathKey = (path2) => JSON.stringify(path2);
+var formatProjectionPath2 = (path2) => path2.join(".");
+var validateProjectionPathsMatchSelection = (plan, projections) => {
+  const expected = flattenSelection(getAst(plan).select);
+  const expectedPaths = new Set(expected.map((projection) => projectionPathKey(projection.path)));
+  const actualPaths = new Set(projections.map((projection) => projectionPathKey(projection.path)));
+  for (const projection of projections) {
+    if (!expectedPaths.has(projectionPathKey(projection.path))) {
+      throw new Error(`Projection path ${formatProjectionPath2(projection.path)} does not exist in the query selection`);
+    }
+  }
+  for (const projection of expected) {
+    if (!actualPaths.has(projectionPathKey(projection.path))) {
+      throw new Error(`Projection path ${formatProjectionPath2(projection.path)} is missing from rendered projections`);
+    }
+  }
+};
+function makeTrusted(dialect, render2) {
+  return makeRenderer(dialect, render2, false);
+}
+var makeRenderer = (dialect, render2, validate) => {
+  if (typeof render2 !== "function") {
+    throw new Error(`Renderer.make requires an explicit render implementation for dialect: ${dialect}`);
+  }
+  return {
+    dialect,
+    render(plan) {
+      const rendered = render2(plan);
+      const projections = rendered.projections ?? [];
+      if (validate) {
+        validateProjections(projections);
+        validateProjectionPathsMatchSelection(plan, projections);
+      }
+      return {
+        sql: rendered.sql,
+        params: rendered.params ?? [],
+        projections,
+        valueMappings: rendered.valueMappings,
+        dialect,
+        [TypeId10]: {
+          row: undefined,
+          dialect
+        }
+      };
+    }
+  };
+};
+
 // src/internal/executor.ts
+var atMostOne = (self) => Effect.flatMap(self, (rows) => rows.length <= 1 ? Effect.succeed(rows.length === 0 ? Option.none() : Option.some(rows[0])) : Effect.fail({
+  _tag: "ResultCardinalityError",
+  expected: "zeroOrOne",
+  actual: rows.length
+}));
+var exactlyOne = (self) => Effect.flatMap(self, (rows) => rows.length === 1 ? Effect.succeed(rows[0]) : Effect.fail({
+  _tag: "ResultCardinalityError",
+  expected: "exactlyOne",
+  actual: rows.length
+}));
+var nonEmpty = (self) => Effect.flatMap(self, (rows) => rows.length > 0 ? Effect.succeed(rows) : Effect.fail({
+  _tag: "ResultCardinalityError",
+  expected: "nonEmpty",
+  actual: 0
+}));
+var withResultContracts = (base) => {
+  const executeResult = base.executeResult ?? ((plan) => Effect.map(base.execute(plan), (rows) => ({ rows })));
+  return {
+    ...base,
+    executeResult,
+    prepare(plan) {
+      return {
+        execute: base.execute(plan),
+        executeResult: executeResult(plan),
+        stream: base.stream(plan)
+      };
+    }
+  };
+};
 var setPath2 = (target, path2, value) => {
   let current = target;
   for (let index4 = 0;index4 < path2.length - 1; index4++) {
@@ -6479,7 +8656,7 @@ var hasWriteCapability = (plan) => {
   if (ast.target && hasWriteCapabilityInSource(ast.target.source)) {
     return true;
   }
-  if ((ast.joins ?? []).some((join2) => hasWriteCapabilityInSource(join2.source))) {
+  if ((ast.joins ?? []).some((join3) => hasWriteCapabilityInSource(join3.source))) {
     return true;
   }
   return false;
@@ -6494,7 +8671,7 @@ var remapRows = (query, rows) => rows.map((row) => {
   return decoded;
 });
 var makeRowDecodeError = (rendered, projection, expression, raw, stage, cause, normalized) => {
-  const schemaError = Schema9.isSchemaError(cause) ? {
+  const schemaError = Schema10.isSchemaError(cause) ? {
     message: cause.message,
     issue: cause.issue
   } : undefined;
@@ -6548,7 +8725,7 @@ var dbTypeAllowsTopLevelJsonNull = (dbType) => {
   }
   return "variant" in dbType && dbType.variant === "json" || dbType.runtime === "json";
 };
-var schemaAcceptsNull = (schema2) => schema2 !== undefined && Schema9.is(schema2)(null);
+var schemaAcceptsNull = (schema2) => schema2 !== undefined && Schema10.is(schema2)(null);
 var decodeProjectionValue = (rendered, projection, expression, raw, scope, driverMode, valueMappings) => {
   let normalized = raw;
   if (driverMode === "raw") {
@@ -6584,10 +8761,10 @@ var decodeProjectionValue = (rendered, projection, expression, raw, scope, drive
   if (schema2 === undefined) {
     return normalized;
   }
-  if (Schema9.is(schema2)(normalized)) {
+  if (Schema10.is(schema2)(normalized)) {
     return normalized;
   }
-  const decoded = Schema9.decodeUnknownExit(schema2)(normalized);
+  const decoded = Schema10.decodeUnknownExit(schema2)(normalized);
   if (Exit.isSuccess(decoded)) {
     return decoded.value;
   }
@@ -6626,7 +8803,7 @@ var decodeRows = (rendered, plan, rows, options2 = {}) => {
   const decodeRow = makeRowDecoder(rendered, plan, options2);
   return rows.map((row) => decodeRow(row));
 };
-var make3 = (dialect, execute) => ({
+var make3 = (dialect, execute) => withResultContracts({
   dialect,
   execute(plan) {
     return execute(plan);
@@ -6646,23 +8823,81 @@ function driver(dialect, executeOrHandlers) {
         return Stream.unwrap(Effect.map(executeOrHandlers(query), (rows) => Stream.fromIterable(rows)));
       }
       return executeOrHandlers.stream(query);
-    }
+    },
+    ...typeof executeOrHandlers === "function" || executeOrHandlers.executeResult === undefined ? {} : { executeResult: executeOrHandlers.executeResult }
   };
 }
 var fromDriver = (renderer, sqlDriver) => {
-  const executor = {
+  const renderedCache = new WeakMap;
+  const render2 = (plan) => {
+    const cached = renderedCache.get(plan);
+    if (cached !== undefined) {
+      return cached;
+    }
+    const rendered = renderer.render(plan);
+    renderedCache.set(plan, rendered);
+    return rendered;
+  };
+  const executor = withResultContracts({
     dialect: renderer.dialect,
     execute(plan) {
-      const rendered = renderer.render(plan);
+      const rendered = render2(plan);
       return Effect.map(sqlDriver.execute(rendered), (rows) => remapRows(rendered, rows));
     },
+    executeResult(plan) {
+      const rendered = render2(plan);
+      const result = sqlDriver.executeResult ? sqlDriver.executeResult(rendered) : Effect.map(sqlDriver.execute(rendered), (rows) => ({ rows }));
+      return Effect.map(result, ({ rows, ...metadata }) => ({
+        ...metadata,
+        rows: remapRows(rendered, rows)
+      }));
+    },
     stream(plan) {
-      const rendered = renderer.render(plan);
+      const rendered = render2(plan);
       return Stream.mapArray(sqlDriver.stream(rendered), (rows) => remapRows(rendered, rows));
     }
-  };
+  });
   return executor;
 };
+var explainQuery = (query, options2 = {}) => {
+  const analyze = options2.analyze ?? false;
+  const format = options2.format ?? "text";
+  let prefix;
+  switch (query.dialect) {
+    case "postgres":
+      prefix = `explain (${[
+        ...analyze ? ["analyze true"] : [],
+        `format ${format}`
+      ].join(", ")}) `;
+      break;
+    case "mysql":
+      if (analyze && format === "json") {
+        throw new Error("MySQL EXPLAIN ANALYZE cannot be combined with JSON format");
+      }
+      prefix = analyze ? "explain analyze " : format === "json" ? "explain format=json " : "explain ";
+      break;
+    case "sqlite":
+      if (analyze || format === "json") {
+        throw new Error("SQLite EXPLAIN QUERY PLAN does not support analyze or JSON format");
+      }
+      prefix = "explain query plan ";
+      break;
+    default:
+      if (analyze || format === "json") {
+        throw new Error("Portable EXPLAIN only supports text plans without analyze");
+      }
+      prefix = "explain ";
+  }
+  return {
+    ...query,
+    sql: prefix + query.sql,
+    projections: [],
+    [TypeId10]: {
+      row: undefined,
+      dialect: query.dialect
+    }
+  };
+};
 var streamFromSqlClient = (query) => Stream.unwrap(Effect.flatMap(SqlClient.SqlClient, (sql) => Effect.flatMap(Effect.serviceOption(sql.transactionService), Option.match({
   onNone: () => sql.reserve,
   onSome: ([connection]) => Effect.succeed(connection)
@@ -6673,56 +8908,6 @@ var fromSqlClient = (renderer) => fromDriver(renderer, driver(renderer.dialect,
 }));
 var withTransaction = (effect) => Effect.flatMap(SqlClient.SqlClient, (sql) => sql.withTransaction(effect));
 
-// src/internal/renderer.ts
-var TypeId10 = Symbol.for("effect-qb/Renderer");
-var projectionPathKey = (path2) => JSON.stringify(path2);
-var formatProjectionPath2 = (path2) => path2.join(".");
-var validateProjectionPathsMatchSelection = (plan, projections) => {
-  const expected = flattenSelection(getAst(plan).select);
-  const expectedPaths = new Set(expected.map((projection) => projectionPathKey(projection.path)));
-  const actualPaths = new Set(projections.map((projection) => projectionPathKey(projection.path)));
-  for (const projection of projections) {
-    if (!expectedPaths.has(projectionPathKey(projection.path))) {
-      throw new Error(`Projection path ${formatProjectionPath2(projection.path)} does not exist in the query selection`);
-    }
-  }
-  for (const projection of expected) {
-    if (!actualPaths.has(projectionPathKey(projection.path))) {
-      throw new Error(`Projection path ${formatProjectionPath2(projection.path)} is missing from rendered projections`);
-    }
-  }
-};
-function makeTrusted(dialect, render2) {
-  return makeRenderer(dialect, render2, false);
-}
-var makeRenderer = (dialect, render2, validate) => {
-  if (typeof render2 !== "function") {
-    throw new Error(`Renderer.make requires an explicit render implementation for dialect: ${dialect}`);
-  }
-  return {
-    dialect,
-    render(plan) {
-      const rendered = render2(plan);
-      const projections = rendered.projections ?? [];
-      if (validate) {
-        validateProjections(projections);
-        validateProjectionPathsMatchSelection(plan, projections);
-      }
-      return {
-        sql: rendered.sql,
-        params: rendered.params ?? [],
-        projections,
-        valueMappings: rendered.valueMappings,
-        dialect,
-        [TypeId10]: {
-          row: undefined,
-          dialect
-        }
-      };
-    }
-  };
-};
-
 // src/internal/dialect.ts
 var quoteDoubleQuotedIdentifier = (value) => {
   return `"${value.replaceAll('"', '""')}"`;
@@ -6733,7 +8918,36 @@ var quoteBacktickIdentifier = (value) => {
 var renderDbTypeName = (value) => value;
 
 // src/internal/dialect-renderers/sqlite.ts
-import * as Schema10 from "effect/Schema";
+import * as Schema11 from "effect/Schema";
+
+// src/internal/custom-sql-renderer.ts
+var renderCustomSql = (node, state, dialect, renderExpression) => node.strings.map((part, index4) => {
+  const value = node.values[index4];
+  if (value === undefined) {
+    return part;
+  }
+  return part + (TypeId in value ? renderExpression(value, state, dialect) : value.parts.map((segment) => dialect.quoteIdentifier(segment)).join("."));
+}).join("");
+
+// src/internal/window-renderer.ts
+var renderBoundary = (boundary) => {
+  if (boundary === "unboundedPreceding") {
+    return "unbounded preceding";
+  }
+  if (boundary === "currentRow") {
+    return "current row";
+  }
+  if (boundary === "unboundedFollowing") {
+    return "unbounded following";
+  }
+  if ("preceding" in boundary) {
+    return `${boundary.preceding} preceding`;
+  }
+  return `${boundary.following} following`;
+};
+var renderWindowFrame = (frame) => frame.end === undefined ? `${frame.unit} ${renderBoundary(frame.start)}` : `${frame.unit} between ${renderBoundary(frame.start)} and ${renderBoundary(frame.end)}`;
+
+// src/internal/dialect-renderers/sqlite.ts
 var renderDbType = (dialect, dbType) => {
   return renderDbTypeName(renderPortableDatatypeDdlType(dialect.name, dbType.kind) ?? dbType.kind);
 };
@@ -6870,8 +9084,8 @@ var registerQuerySources = (ast, state) => {
   for (const source of ast.fromSources ?? []) {
     registerSourceReference(source.source, source.tableName, state);
   }
-  for (const join2 of ast.joins) {
-    registerSourceReference(join2.source, join2.tableName, state);
+  for (const join3 of ast.joins) {
+    registerSourceReference(join3.source, join3.tableName, state);
   }
   if (ast.into !== undefined) {
     registerSourceReference(ast.into.source, ast.into.tableName, state);
@@ -6886,23 +9100,23 @@ var registerQuerySources = (ast, state) => {
     registerSourceReference(ast.using.source, ast.using.tableName, state);
   }
 };
-var renderColumnDefinition = (dialect, state, columnName, column, tableName, casing) => {
+var renderColumnDefinition = (dialect, state, columnName, column2, tableName, casing) => {
   const expressionState = { ...state, casing, rowLocalColumns: true };
-  if (isArrayDbType(column.metadata.dbType)) {
+  if (isArrayDbType(column2.metadata.dbType)) {
     throw new Error("Unsupported sqlite array column options");
   }
   const clauses = [
     quoteColumn(columnName, state, dialect, tableName),
-    column.metadata.ddlType === undefined ? renderDbType(dialect, column.metadata.dbType) : renderDbTypeName(column.metadata.ddlType)
+    column2.metadata.ddlType === undefined ? renderDbType(dialect, column2.metadata.dbType) : renderDbTypeName(column2.metadata.ddlType)
   ];
-  if (column.metadata.identity) {
+  if (column2.metadata.identity) {
     throw new Error("Unsupported sqlite identity column options");
-  } else if (column.metadata.generatedValue) {
-    clauses.push(`generated always as (${renderDdlExpression(column.metadata.generatedValue, expressionState, dialect)}) stored`);
-  } else if (column.metadata.defaultValue) {
-    clauses.push(`default ${renderDdlExpression(column.metadata.defaultValue, expressionState, dialect)}`);
+  } else if (column2.metadata.generatedValue) {
+    clauses.push(`generated always as (${renderDdlExpression(column2.metadata.generatedValue, expressionState, dialect)}) stored`);
+  } else if (column2.metadata.defaultValue) {
+    clauses.push(`default ${renderDdlExpression(column2.metadata.defaultValue, expressionState, dialect)}`);
   }
-  if (!column.metadata.nullable) {
+  if (!column2.metadata.nullable) {
     clauses.push("not null");
   }
   return clauses.join(" ");
@@ -6912,7 +9126,7 @@ var renderCreateTableSql = (targetSource, state, dialect, ifNotExists) => {
   const table = targetSource.source;
   const tableCasing = casingForTable(table, state);
   const fields2 = table[TypeId7].fields;
-  const definitions = Object.entries(fields2).map(([columnName, column]) => renderColumnDefinition(dialect, state, columnName, column, targetSource.tableName, tableCasing));
+  const definitions = Object.entries(fields2).map(([columnName, column2]) => renderColumnDefinition(dialect, state, columnName, column2, targetSource.tableName, tableCasing));
   const options2 = table[OptionsSymbol];
   const tableOptions = Array.isArray(options2) ? options2 : [options2];
   validateOptions(table[TypeId7].name, fields2, tableOptions);
@@ -6925,17 +9139,17 @@ var renderCreateTableSql = (targetSource, state, dialect, ifNotExists) => {
         if (option2.deferrable || option2.initiallyDeferred) {
           throw new Error("Unsupported sqlite primary key constraint options");
         }
-        definitions.push(`${option2.name ? `constraint ${dialect.quoteIdentifier(applyCategory(tableCasing, "constraints", option2.name))} ` : ""}primary key (${option2.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ")})${option2.deferrable ? ` deferrable${option2.initiallyDeferred ? " initially deferred" : ""}` : ""}`);
+        definitions.push(`${option2.name ? `constraint ${dialect.quoteIdentifier(applyCategory(tableCasing, "constraints", option2.name))} ` : ""}primary key (${option2.columns.map((column2) => quoteColumn(column2, state, dialect, targetSource.tableName)).join(", ")})${option2.deferrable ? ` deferrable${option2.initiallyDeferred ? " initially deferred" : ""}` : ""}`);
         break;
       case "unique":
         if (option2.nullsNotDistinct || option2.deferrable || option2.initiallyDeferred) {
           throw new Error("Unsupported sqlite unique constraint options");
         }
-        definitions.push(`${option2.name ? `constraint ${dialect.quoteIdentifier(applyCategory(tableCasing, "constraints", option2.name))} ` : ""}unique${option2.nullsNotDistinct ? " nulls not distinct" : ""} (${option2.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ")})${option2.deferrable ? ` deferrable${option2.initiallyDeferred ? " initially deferred" : ""}` : ""}`);
+        definitions.push(`${option2.name ? `constraint ${dialect.quoteIdentifier(applyCategory(tableCasing, "constraints", option2.name))} ` : ""}unique${option2.nullsNotDistinct ? " nulls not distinct" : ""} (${option2.columns.map((column2) => quoteColumn(column2, state, dialect, targetSource.tableName)).join(", ")})${option2.deferrable ? ` deferrable${option2.initiallyDeferred ? " initially deferred" : ""}` : ""}`);
         break;
       case "foreignKey": {
         const reference = typeof option2.references === "function" ? option2.references() : option2.references;
-        definitions.push(`${option2.name ? `constraint ${dialect.quoteIdentifier(applyCategory(tableCasing, "constraints", option2.name))} ` : ""}foreign key (${option2.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ")}) references ${renderReferenceTable(reference, state, dialect)} (${reference.columns.map((column) => quoteReferenceColumn(column, reference, state, dialect)).join(", ")})${option2.onDelete !== undefined ? ` on delete ${renderReferentialAction(option2.onDelete)}` : ""}${option2.onUpdate !== undefined ? ` on update ${renderReferentialAction(option2.onUpdate)}` : ""}${option2.deferrable ? ` deferrable${option2.initiallyDeferred ? " initially deferred" : ""}` : ""}`);
+        definitions.push(`${option2.name ? `constraint ${dialect.quoteIdentifier(applyCategory(tableCasing, "constraints", option2.name))} ` : ""}foreign key (${option2.columns.map((column2) => quoteColumn(column2, state, dialect, targetSource.tableName)).join(", ")}) references ${renderReferenceTable(reference, state, dialect)} (${reference.columns.map((column2) => quoteReferenceColumn(column2, reference, state, dialect)).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":
@@ -6959,7 +9173,7 @@ var renderCreateIndexSql = (targetSource, ddl, state, dialect) => {
   const maybeIfNotExists = (dialect.name === "postgres" || dialect.name === "sqlite") && ifNotExists ? " if not exists" : "";
   const table = targetSource.source;
   const tableCasing = casingForTable(table, state);
-  return `create${unique3 ? " unique" : ""} index${maybeIfNotExists} ${dialect.quoteIdentifier(applyCategory(tableCasing, "indexes", name))} on ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} (${ddl.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ")})`;
+  return `create${unique3 ? " unique" : ""} index${maybeIfNotExists} ${dialect.quoteIdentifier(applyCategory(tableCasing, "indexes", name))} on ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} (${ddl.columns.map((column2) => quoteColumn(column2, state, dialect, targetSource.tableName)).join(", ")})`;
 };
 var renderDropIndexSql = (targetSource, ddl, state, dialect) => {
   const ifExists = normalizeStatementFlag(ddl.ifExists);
@@ -6987,7 +9201,7 @@ var unsupportedJsonFeature = (dialect, feature) => {
   throw error;
 };
 var extractJsonBase = (node) => node.value ?? node.base ?? node.input ?? node.left ?? node.target;
-var isJsonPathValue2 = (value) => value !== null && typeof value === "object" && (TypeId3 in value);
+var isJsonPathValue3 = (value) => value !== null && typeof value === "object" && (TypeId3 in value);
 var isOptionalJsonPathNumber = (value) => value === undefined || typeof value === "number" && Number.isFinite(value);
 var isJsonPathSegment = (segment) => {
   if (typeof segment === "string") {
@@ -7026,7 +9240,7 @@ var validateJsonPathSegments = (segments) => {
 };
 var extractJsonPathSegments = (node) => {
   const path2 = node.path ?? node.segments ?? node.keys;
-  if (isJsonPathValue2(path2)) {
+  if (isJsonPathValue3(path2)) {
     return validateJsonPathSegments(path2.segments);
   }
   if (Array.isArray(path2)) {
@@ -7051,7 +9265,7 @@ var extractJsonPathSegments = (node) => {
     }
     return [];
   }
-  if ("right" in node && isJsonPathValue2(node.right)) {
+  if ("right" in node && isJsonPathValue3(node.right)) {
     return validateJsonPathSegments(node.right.segments);
   }
   return [];
@@ -7161,24 +9375,24 @@ var renderJsonInputExpression = (expression, state, dialect) => {
   }
   return renderJsonSelectSql(renderExpression(expression, state, dialect), expressionDriverContext(expression, state, dialect));
 };
-var encodeArrayValues = (values2, column, state, dialect) => values2.map((value) => {
-  if (value === null && column.metadata.nullable) {
+var encodeArrayValues = (values3, column2, state, dialect) => values3.map((value) => {
+  if (value === null && column2.metadata.nullable) {
     return null;
   }
-  const runtimeSchemaAccepts = column.schema !== undefined && Schema10.is(column.schema)(value);
-  const normalizedValue = runtimeSchemaAccepts ? value : normalizeDbValue(column.metadata.dbType, value);
-  const encodedValue = column.schema === undefined || runtimeSchemaAccepts ? normalizedValue : Schema10.decodeUnknownSync(column.schema)(normalizedValue);
+  const runtimeSchemaAccepts = column2.schema !== undefined && Schema11.is(column2.schema)(value);
+  const normalizedValue = runtimeSchemaAccepts ? value : normalizeDbValue(column2.metadata.dbType, value);
+  const encodedValue = column2.schema === undefined || runtimeSchemaAccepts ? normalizedValue : Schema11.decodeUnknownSync(column2.schema)(normalizedValue);
   return toDriverValue(encodedValue, {
     dialect: dialect.name,
     valueMappings: state.valueMappings,
-    dbType: column.metadata.dbType,
-    runtimeSchema: column.schema,
-    driverValueMapping: column.metadata.driverValueMapping
+    dbType: column2.metadata.dbType,
+    runtimeSchema: column2.schema,
+    driverValueMapping: column2.metadata.driverValueMapping
   });
 });
 var renderPostgresJsonKind = (value) => value[TypeId].dbType.kind === "jsonb" ? "jsonb" : "json";
 var renderJsonOpaquePath = (value, state, dialect) => {
-  if (isJsonPathValue2(value)) {
+  if (isJsonPathValue3(value)) {
     const renderSegment = dialect.name === "sqlite" ? renderSqliteJsonPathSegment : renderJsonPathSegment;
     return dialect.renderLiteral(renderJsonPathStringLiteral(value.segments, renderSegment), state);
   }
@@ -7332,8 +9546,8 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       return;
     }
     case "jsonBuildArray": {
-      const values2 = ast.values;
-      const renderedValues = values2.map((value) => renderJsonInputExpression(value, state, dialect)).join(", ");
+      const values3 = ast.values;
+      const renderedValues = values3.map((value) => renderJsonInputExpression(value, state, dialect)).join(", ");
       if (dialect.name === "postgres") {
         return `${postgresExpressionKind === "jsonb" ? "jsonb" : "json"}_build_array(${renderedValues})`;
       }
@@ -7500,12 +9714,12 @@ var selectionProjections = (selection) => flattenSelection(selection).map(({ pat
   alias: alias2
 }));
 var renderMutationAssignment = (entry, state, dialect, targetTableName) => {
-  const column = entry.tableName && dialect.name === "sqlite" ? `${dialect.quoteIdentifier(casedTableReferenceName(entry.tableName, state))}.${quoteColumn(entry.columnName, state, dialect, entry.tableName)}` : quoteColumn(entry.columnName, state, dialect, targetTableName);
-  return `${column} = ${renderExpression(entry.value, state, dialect)}`;
+  const column2 = entry.tableName && dialect.name === "sqlite" ? `${dialect.quoteIdentifier(casedTableReferenceName(entry.tableName, state))}.${quoteColumn(entry.columnName, state, dialect, entry.tableName)}` : quoteColumn(entry.columnName, state, dialect, targetTableName);
+  return `${column2} = ${renderExpression(entry.value, state, dialect)}`;
 };
-var renderJoinSourcesForMutation = (joins, state, dialect) => joins.map((join2) => renderSourceReference(join2.source, join2.tableName, join2.baseTableName, state, dialect)).join(", ");
+var renderJoinSourcesForMutation = (joins, state, dialect) => joins.map((join3) => renderSourceReference(join3.source, join3.tableName, join3.baseTableName, state, dialect)).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((join2) => join2.kind === "cross" || !join2.on ? [] : [renderExpression(join2.on, state, dialect)]);
+var renderJoinPredicatesForMutation = (joins, state, dialect) => joins.flatMap((join3) => join3.kind === "cross" || !join3.on ? [] : [renderExpression(join3.on, state, dialect)]);
 var renderDeleteTargets = (targets, dialect) => targets.map((target) => dialect.quoteIdentifier(target.tableName)).join(", ");
 var renderTransactionClause = (clause, dialect) => {
   switch (clause.kind) {
@@ -7563,9 +9777,9 @@ var renderQueryAst = (ast, state, dialect, options2 = {}) => {
       if (ast.from) {
         clauses.push(`from ${renderSourceReference(ast.from.source, ast.from.tableName, ast.from.baseTableName, state, dialect)}`);
       }
-      for (const join2 of ast.joins) {
-        const source = renderSourceReference(join2.source, join2.tableName, join2.baseTableName, state, dialect);
-        clauses.push(join2.kind === "cross" ? `cross join ${source}` : `${join2.kind} join ${source} on ${renderExpression(join2.on, state, dialect)}`);
+      for (const join3 of ast.joins) {
+        const source = renderSourceReference(join3.source, join3.tableName, join3.baseTableName, state, dialect);
+        clauses.push(join3.kind === "cross" ? `cross join ${source}` : `${join3.kind} join ${source} on ${renderExpression(join3.on, state, dialect)}`);
       }
       if (ast.where.length > 0) {
         clauses.push(`where ${ast.where.map((entry) => renderExpression(entry.predicate, state, dialect)).join(" and ")}`);
@@ -7616,15 +9830,15 @@ var renderQueryAst = (ast, state, dialect, options2 = {}) => {
       const conflict = expectConflictClause(insertAst.conflict);
       sql = `insert into ${target}`;
       if (insertSource?.kind === "values") {
-        const columns = insertSource.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ");
+        const columns = insertSource.columns.map((column2) => quoteColumn(column2, state, dialect, targetSource.tableName)).join(", ");
         const rows = insertSource.rows.map((row) => `(${row.values.map((entry) => renderExpression(entry.value, targetCasingState, dialect)).join(", ")})`).join(", ");
         sql += ` (${columns}) values ${rows}`;
       } else if (insertSource?.kind === "query") {
-        const columns = insertSource.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ");
+        const columns = insertSource.columns.map((column2) => quoteColumn(column2, state, dialect, targetSource.tableName)).join(", ");
         const renderedQuery = renderQueryAst(getAst(insertSource.query), state, dialect);
         sql += ` (${columns}) ${renderedQuery.sql}`;
       } else if (insertSource?.kind === "unnest") {
-        const columns = insertSource.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ");
+        const columns = insertSource.columns.map((column2) => quoteColumn(column2, state, dialect, targetSource.tableName)).join(", ");
         if (dialect.name === "postgres") {
           const table = targetSource.source;
           const fields2 = table[TypeId7].fields;
@@ -7644,9 +9858,9 @@ var renderQueryAst = (ast, state, dialect, options2 = {}) => {
       } else {
         const insertValues = insertAst.values ?? [];
         const columns = insertValues.map((entry) => quoteColumn(entry.columnName, state, dialect, targetSource.tableName)).join(", ");
-        const values2 = insertValues.map((entry) => renderExpression(entry.value, targetCasingState, dialect)).join(", ");
+        const values3 = insertValues.map((entry) => renderExpression(entry.value, targetCasingState, dialect)).join(", ");
         if (insertValues.length > 0) {
-          sql += ` (${columns}) values (${values2})`;
+          sql += ` (${columns}) values (${values3})`;
         } else {
           sql += " default values";
         }
@@ -7655,7 +9869,7 @@ var renderQueryAst = (ast, state, dialect, options2 = {}) => {
         const conflictValueState = { ...targetCasingState, allowExcluded: true };
         const updateValues = (conflict.values ?? []).map((entry) => `${quoteColumn(entry.columnName, state, dialect, targetSource.tableName)} = ${renderExpression(entry.value, conflictValueState, dialect)}`).join(", ");
         if (dialect.name === "postgres" || dialect.name === "sqlite") {
-          const targetSql = conflict.target?.kind === "constraint" ? ` on conflict on constraint ${dialect.quoteIdentifier(applyCategory(targetCasingState.casing, "constraints", conflict.target.name))}` : conflict.target?.kind === "columns" ? ` on conflict (${conflict.target.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ")})${conflict.target.where ? ` where ${renderExpression(conflict.target.where, targetCasingState, dialect)}` : ""}` : " on conflict";
+          const targetSql = conflict.target?.kind === "constraint" ? ` on conflict on constraint ${dialect.quoteIdentifier(applyCategory(targetCasingState.casing, "constraints", conflict.target.name))}` : conflict.target?.kind === "columns" ? ` on conflict (${conflict.target.columns.map((column2) => quoteColumn(column2, state, dialect, targetSource.tableName)).join(", ")})${conflict.target.where ? ` where ${renderExpression(conflict.target.where, targetCasingState, dialect)}` : ""}` : " on conflict";
           sql += targetSql;
           sql += conflict.action === "doNothing" ? " do nothing" : ` do update set ${updateValues}${conflict.where ? ` where ${renderExpression(conflict.where, conflictValueState, dialect)}` : ""}`;
         } else if (conflict.action === "doNothing") {
@@ -7664,10 +9878,10 @@ var renderQueryAst = (ast, state, dialect, options2 = {}) => {
           sql += ` on duplicate key update ${updateValues}`;
         }
       }
-      const returning2 = renderSelectionList(insertAst.select, state, dialect);
-      projections = returning2.projections;
-      if (returning2.sql.length > 0) {
-        sql += ` returning ${returning2.sql}`;
+      const returning3 = renderSelectionList(insertAst.select, state, dialect);
+      projections = returning3.projections;
+      if (returning3.sql.length > 0) {
+        sql += ` returning ${returning3.sql}`;
       }
       break;
     }
@@ -7684,9 +9898,9 @@ var renderQueryAst = (ast, state, dialect, options2 = {}) => {
       if (dialect.name === "mysql") {
         const modifiers = "";
         const extraSources = renderFromSources(fromSources, state, dialect);
-        const joinSources = updateAst.joins.map((join2) => join2.kind === "full" ? (() => {
+        const joinSources = updateAst.joins.map((join3) => join3.kind === "full" ? (() => {
           throw new Error("Unsupported sqlite full join");
-        })() : join2.kind === "cross" ? `cross join ${renderSourceReference(join2.source, join2.tableName, join2.baseTableName, state, dialect)}` : `${join2.kind} join ${renderSourceReference(join2.source, join2.tableName, join2.baseTableName, state, dialect)} on ${renderExpression(join2.on, state, dialect)}`).join(" ");
+        })() : join3.kind === "cross" ? `cross join ${renderSourceReference(join3.source, join3.tableName, join3.baseTableName, state, dialect)}` : `${join3.kind} join ${renderSourceReference(join3.source, join3.tableName, join3.baseTableName, state, dialect)} on ${renderExpression(join3.on, state, dialect)}`).join(" ");
         const targetList = [
           ...targets.map((entry) => renderSourceReference(entry.source, entry.tableName, entry.baseTableName, state, dialect)),
           ...extraSources.length > 0 ? [extraSources] : []
@@ -7715,10 +9929,10 @@ var renderQueryAst = (ast, state, dialect, options2 = {}) => {
       if (dialect.name === "mysql" && updateAst.limit) {
         sql += ` limit ${renderSqliteMutationLimit(updateAst.limit, state, dialect)}`;
       }
-      const returning2 = renderSelectionList(updateAst.select, state, dialect);
-      projections = returning2.projections;
-      if (returning2.sql.length > 0) {
-        sql += ` returning ${returning2.sql}`;
+      const returning3 = renderSelectionList(updateAst.select, state, dialect);
+      projections = returning3.projections;
+      if (returning3.sql.length > 0) {
+        sql += ` returning ${returning3.sql}`;
       }
       break;
     }
@@ -7735,9 +9949,9 @@ var renderQueryAst = (ast, state, dialect, options2 = {}) => {
         const hasJoinedSources = deleteAst.joins.length > 0 || targets.length > 1;
         const targetList = renderDeleteTargets(targets, dialect);
         const fromSources = targets.map((entry) => renderSourceReference(entry.source, entry.tableName, entry.baseTableName, state, dialect)).join(", ");
-        const joinSources = deleteAst.joins.map((join2) => join2.kind === "full" ? (() => {
+        const joinSources = deleteAst.joins.map((join3) => join3.kind === "full" ? (() => {
           throw new Error("Unsupported sqlite full join");
-        })() : join2.kind === "cross" ? `cross join ${renderSourceReference(join2.source, join2.tableName, join2.baseTableName, state, dialect)}` : `${join2.kind} join ${renderSourceReference(join2.source, join2.tableName, join2.baseTableName, state, dialect)} on ${renderExpression(join2.on, state, dialect)}`).join(" ");
+        })() : join3.kind === "cross" ? `cross join ${renderSourceReference(join3.source, join3.tableName, join3.baseTableName, state, dialect)}` : `${join3.kind} join ${renderSourceReference(join3.source, join3.tableName, join3.baseTableName, state, dialect)} on ${renderExpression(join3.on, state, dialect)}`).join(" ");
         sql = hasJoinedSources ? `delete${modifiers} ${targetList} from ${fromSources}${joinSources.length > 0 ? ` ${joinSources}` : ""}` : `delete${modifiers} from ${fromSources}`;
       } else {
         if (dialect.name === "sqlite" && deleteAst.joins.length > 0) {
@@ -7761,10 +9975,10 @@ var renderQueryAst = (ast, state, dialect, options2 = {}) => {
       if (dialect.name === "mysql" && deleteAst.limit) {
         sql += ` limit ${renderSqliteMutationLimit(deleteAst.limit, state, dialect)}`;
       }
-      const returning2 = renderSelectionList(deleteAst.select, state, dialect);
-      projections = returning2.projections;
-      if (returning2.sql.length > 0) {
-        sql += ` returning ${returning2.sql}`;
+      const returning3 = renderSelectionList(deleteAst.select, state, dialect);
+      projections = returning3.projections;
+      if (returning3.sql.length > 0) {
+        sql += ` returning ${returning3.sql}`;
       }
       break;
     }
@@ -7780,25 +9994,25 @@ var renderQueryAst = (ast, state, dialect, options2 = {}) => {
       const mergeAst = ast;
       const targetSource = mergeAst.target;
       const usingSource = mergeAst.using;
-      const merge2 = mergeAst.merge;
-      sql = `merge into ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} using ${renderSourceReference(usingSource.source, usingSource.tableName, usingSource.baseTableName, state, dialect)} on ${renderExpression(merge2.on, state, dialect)}`;
-      if (merge2.whenMatched) {
+      const merge3 = mergeAst.merge;
+      sql = `merge into ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} using ${renderSourceReference(usingSource.source, usingSource.tableName, usingSource.baseTableName, state, dialect)} on ${renderExpression(merge3.on, state, dialect)}`;
+      if (merge3.whenMatched) {
         sql += " when matched";
-        if (merge2.whenMatched.predicate) {
-          sql += ` and ${renderExpression(merge2.whenMatched.predicate, state, dialect)}`;
+        if (merge3.whenMatched.predicate) {
+          sql += ` and ${renderExpression(merge3.whenMatched.predicate, state, dialect)}`;
         }
-        if (merge2.whenMatched.kind === "delete") {
+        if (merge3.whenMatched.kind === "delete") {
           sql += " then delete";
         } else {
-          sql += ` then update set ${merge2.whenMatched.values.map((entry) => `${dialect.quoteIdentifier(entry.columnName)} = ${renderExpression(entry.value, state, dialect)}`).join(", ")}`;
+          sql += ` then update set ${merge3.whenMatched.values.map((entry) => `${dialect.quoteIdentifier(entry.columnName)} = ${renderExpression(entry.value, state, dialect)}`).join(", ")}`;
         }
       }
-      if (merge2.whenNotMatched) {
+      if (merge3.whenNotMatched) {
         sql += " when not matched";
-        if (merge2.whenNotMatched.predicate) {
-          sql += ` and ${renderExpression(merge2.whenNotMatched.predicate, state, dialect)}`;
+        if (merge3.whenNotMatched.predicate) {
+          sql += ` and ${renderExpression(merge3.whenNotMatched.predicate, state, dialect)}`;
         }
-        sql += ` then insert (${merge2.whenNotMatched.values.map((entry) => dialect.quoteIdentifier(entry.columnName)).join(", ")}) values (${merge2.whenNotMatched.values.map((entry) => renderExpression(entry.value, state, dialect)).join(", ")})`;
+        sql += ` then insert (${merge3.whenNotMatched.values.map((entry) => dialect.quoteIdentifier(entry.columnName)).join(", ")}) values (${merge3.whenNotMatched.values.map((entry) => renderExpression(entry.value, state, dialect)).join(", ")})`;
       }
       break;
     }
@@ -7894,19 +10108,19 @@ var renderSourceReference = (source, tableName, baseTableName, state, dialect) =
     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;
+    const lateral2 = source;
     if (dialect.name === "sqlite") {
       throw new Error("Unsupported sqlite lateral source");
     }
-    return `lateral (${renderQueryAst(getAst(lateral.plan), nestedRenderState(state), dialect).sql}) as ${dialect.quoteIdentifier(lateral.name)}`;
+    return `lateral (${renderQueryAst(getAst(lateral2.plan), nestedRenderState(state), dialect).sql}) as ${dialect.quoteIdentifier(lateral2.name)}`;
   }
   if (typeof source === "object" && source !== null && source.kind === "values") {
-    const values2 = source;
-    return renderSelectRows(values2.rows, Object.keys(values2.columns));
+    const values3 = source;
+    return renderSelectRows(values3.rows, Object.keys(values3.columns));
   }
   if (typeof source === "object" && source !== null && source.kind === "unnest") {
-    const unnest2 = source;
-    return renderUnnestRows(unnest2.arrays, Object.keys(unnest2.columns));
+    const unnest3 = source;
+    return renderUnnestRows(unnest3.arrays, Object.keys(unnest3.columns));
   }
   if (typeof source === "object" && source !== null && source.kind === "tableFunction") {
     const tableFunction = source;
@@ -7968,6 +10182,8 @@ var renderExpression = (expression, state, dialect) => {
       return `cast(${renderExpression(expectValueExpression("cast", ast.value), state, dialect)} as ${renderCastType(dialect, ast.target)})`;
     case "function":
       return renderFunctionCall(ast.name, ast.args, state, dialect);
+    case "customSql":
+      return renderCustomSql(ast, state, dialect, renderExpression);
     case "eq":
       return renderBinaryExpression("eq", "=", ast.left, ast.right, state, dialect);
     case "neq":
@@ -7980,6 +10196,16 @@ var renderExpression = (expression, state, dialect) => {
       return renderBinaryExpression("gt", ">", ast.left, ast.right, state, dialect);
     case "gte":
       return renderBinaryExpression("gte", ">=", ast.left, ast.right, state, dialect);
+    case "add":
+      return renderBinaryExpression("add", "+", ast.left, ast.right, state, dialect);
+    case "subtract":
+      return renderBinaryExpression("subtract", "-", ast.left, ast.right, state, dialect);
+    case "multiply":
+      return renderBinaryExpression("multiply", "*", ast.left, ast.right, state, dialect);
+    case "divide":
+      return renderBinaryExpression("divide", "/", ast.left, ast.right, state, dialect);
+    case "modulo":
+      return renderBinaryExpression("modulo", "%", ast.left, ast.right, state, dialect);
     case "like":
       return renderBinaryExpression("like", "like", ast.left, ast.right, state, dialect);
     case "ilike": {
@@ -8053,6 +10279,16 @@ var renderExpression = (expression, state, dialect) => {
       return `lower(${renderExpression(expectValueExpression("lower", ast.value), state, dialect)})`;
     case "count":
       return `count(${renderExpression(expectValueExpression("count", ast.value), state, dialect)})`;
+    case "sum":
+      return `sum(${renderExpression(expectValueExpression("sum", ast.value), state, dialect)})`;
+    case "avg":
+      return `avg(${renderExpression(expectValueExpression("avg", ast.value), state, dialect)})`;
+    case "abs":
+      return `abs(${renderExpression(expectValueExpression("abs", ast.value), state, dialect)})`;
+    case "round":
+      return `round(${renderExpression(expectValueExpression("round", ast.value), state, dialect)})`;
+    case "negate":
+      return `(-${renderExpression(expectValueExpression("negate", ast.value), state, dialect)})`;
     case "max":
       return `max(${renderExpression(expectValueExpression("max", ast.value), state, dialect)})`;
     case "min":
@@ -8097,24 +10333,44 @@ var renderExpression = (expression, state, dialect) => {
     }
     case "window": {
       const partitionBy = ast.partitionBy;
-      const orderBy2 = ast.orderBy;
-      const clauses = [];
-      if (partitionBy.length > 0) {
-        clauses.push(`partition by ${partitionBy.map((value) => renderExpression(value, state, dialect)).join(", ")}`);
-      }
-      if (orderBy2.length > 0) {
-        clauses.push(`order by ${orderBy2.map((entry) => `${renderExpression(entry.value, state, dialect)} ${entry.direction}`).join(", ")}`);
-      }
-      const specification = clauses.join(" ");
+      const orderBy3 = ast.orderBy;
+      const renderSpecification = () => {
+        const clauses = [];
+        if (partitionBy.length > 0) {
+          clauses.push(`partition by ${partitionBy.map((value) => renderExpression(value, state, dialect)).join(", ")}`);
+        }
+        if (orderBy3.length > 0) {
+          clauses.push(`order by ${orderBy3.map((entry) => `${renderExpression(entry.value, state, dialect)} ${entry.direction}`).join(", ")}`);
+        }
+        if (ast.frame !== undefined) {
+          clauses.push(renderWindowFrame(ast.frame));
+        }
+        return clauses.join(" ");
+      };
       switch (ast.function) {
         case "rowNumber":
-          return `row_number() over (${specification})`;
+          return `row_number() over (${renderSpecification()})`;
         case "rank":
-          return `rank() over (${specification})`;
+          return `rank() over (${renderSpecification()})`;
         case "denseRank":
-          return `dense_rank() over (${specification})`;
+          return `dense_rank() over (${renderSpecification()})`;
         case "over":
-          return `${renderExpression(ast.value, state, dialect)} over (${specification})`;
+          return `${renderExpression(ast.value, state, dialect)} over (${renderSpecification()})`;
+        case "lag":
+        case "lead": {
+          const args = [renderExpression(ast.value, state, dialect)];
+          if (ast.offset !== undefined) {
+            args.push(renderExpression(ast.offset, state, dialect));
+          }
+          if (ast.defaultValue !== undefined) {
+            args.push(renderExpression(ast.defaultValue, state, dialect));
+          }
+          return `${ast.function}(${args.join(", ")}) over (${renderSpecification()})`;
+        }
+        case "firstValue":
+          return `first_value(${renderExpression(ast.value, state, dialect)}) over (${renderSpecification()})`;
+        case "lastValue":
+          return `last_value(${renderExpression(ast.value, state, dialect)}) over (${renderSpecification()})`;
       }
       break;
     }
@@ -8123,7 +10379,7 @@ var renderExpression = (expression, state, dialect) => {
 };
 
 // src/internal/dialect-renderers/postgres.ts
-import * as Schema11 from "effect/Schema";
+import * as Schema12 from "effect/Schema";
 var renderDbType2 = (dialect, dbType) => {
   return renderDbTypeName(renderPortableDatatypeDdlType(dialect.name, dbType.kind) ?? dbType.kind);
 };
@@ -8217,8 +10473,8 @@ var registerQuerySources2 = (ast, state) => {
   for (const source of ast.fromSources ?? []) {
     registerSourceReference2(source.source, source.tableName, state);
   }
-  for (const join2 of ast.joins) {
-    registerSourceReference2(join2.source, join2.tableName, state);
+  for (const join3 of ast.joins) {
+    registerSourceReference2(join3.source, join3.tableName, state);
   }
   if (ast.into !== undefined) {
     registerSourceReference2(ast.into.source, ast.into.tableName, state);
@@ -8273,26 +10529,26 @@ var renderDdlExpression2 = (expression, state, dialect) => {
     renderLiteral: renderPostgresDdlLiteral
   });
 };
-var renderColumnDefinition2 = (dialect, state, columnName, column, tableName, casing) => {
+var renderColumnDefinition2 = (dialect, state, columnName, column2, tableName, casing) => {
   const expressionState = { ...state, casing, rowLocalColumns: true };
-  if (dialect.name !== "postgres" && isArrayDbType2(column.metadata.dbType)) {
+  if (dialect.name !== "postgres" && isArrayDbType2(column2.metadata.dbType)) {
     throw new Error(`Unsupported ${dialect.name} array column options`);
   }
   const clauses = [
     quoteColumn2(columnName, state, dialect, tableName),
-    column.metadata.ddlType === undefined ? renderDbType2(dialect, column.metadata.dbType) : renderDbTypeName(column.metadata.ddlType)
+    column2.metadata.ddlType === undefined ? renderDbType2(dialect, column2.metadata.dbType) : renderDbTypeName(column2.metadata.ddlType)
   ];
-  if (column.metadata.identity) {
+  if (column2.metadata.identity) {
     if (dialect.name !== "postgres") {
       throw new Error(`Unsupported ${dialect.name} identity column options`);
     }
-    clauses.push(`generated ${column.metadata.identity.generation === "byDefault" ? "by default" : "always"} as identity`);
-  } else if (column.metadata.generatedValue) {
-    clauses.push(`generated always as (${renderDdlExpression2(column.metadata.generatedValue, expressionState, dialect)}) stored`);
-  } else if (column.metadata.defaultValue) {
-    clauses.push(`default ${renderDdlExpression2(column.metadata.defaultValue, expressionState, dialect)}`);
+    clauses.push(`generated ${column2.metadata.identity.generation === "byDefault" ? "by default" : "always"} as identity`);
+  } else if (column2.metadata.generatedValue) {
+    clauses.push(`generated always as (${renderDdlExpression2(column2.metadata.generatedValue, expressionState, dialect)}) stored`);
+  } else if (column2.metadata.defaultValue) {
+    clauses.push(`default ${renderDdlExpression2(column2.metadata.defaultValue, expressionState, dialect)}`);
   }
-  if (!column.metadata.nullable) {
+  if (!column2.metadata.nullable) {
     clauses.push("not null");
   }
   return clauses.join(" ");
@@ -8305,7 +10561,7 @@ var renderCreateTableSql2 = (targetSource, state, dialect, ifNotExists) => {
   const table = targetSource.source;
   const tableCasing = casingForTable2(table, state);
   const fields2 = table[TypeId7].fields;
-  const definitions = Object.entries(fields2).map(([columnName, column]) => renderColumnDefinition2(dialect, state, columnName, column, targetSource.tableName, tableCasing));
+  const definitions = Object.entries(fields2).map(([columnName, column2]) => renderColumnDefinition2(dialect, state, columnName, column2, targetSource.tableName, tableCasing));
   const options2 = table[OptionsSymbol];
   const tableOptions = Array.isArray(options2) ? options2 : [options2];
   validateOptions(table[TypeId7].name, fields2, tableOptions);
@@ -8318,20 +10574,20 @@ var renderCreateTableSql2 = (targetSource, state, dialect, ifNotExists) => {
         if (dialect.name !== "postgres" && (option2.deferrable || option2.initiallyDeferred)) {
           throw new Error(`Unsupported ${dialect.name} primary key constraint options`);
         }
-        definitions.push(`${option2.name ? `constraint ${dialect.quoteIdentifier(applyCategory(tableCasing, "constraints", option2.name))} ` : ""}primary key (${option2.columns.map((column) => quoteColumn2(column, state, dialect, targetSource.tableName)).join(", ")})${option2.deferrable ? ` deferrable${option2.initiallyDeferred ? " initially deferred" : ""}` : ""}`);
+        definitions.push(`${option2.name ? `constraint ${dialect.quoteIdentifier(applyCategory(tableCasing, "constraints", option2.name))} ` : ""}primary key (${option2.columns.map((column2) => quoteColumn2(column2, state, dialect, targetSource.tableName)).join(", ")})${option2.deferrable ? ` deferrable${option2.initiallyDeferred ? " initially deferred" : ""}` : ""}`);
         break;
       case "unique":
         if (dialect.name !== "postgres" && (option2.nullsNotDistinct || option2.deferrable || option2.initiallyDeferred)) {
           throw new Error(`Unsupported ${dialect.name} unique constraint options`);
         }
-        definitions.push(`${option2.name ? `constraint ${dialect.quoteIdentifier(applyCategory(tableCasing, "constraints", option2.name))} ` : ""}unique${option2.nullsNotDistinct ? " nulls not distinct" : ""} (${option2.columns.map((column) => quoteColumn2(column, state, dialect, targetSource.tableName)).join(", ")})${option2.deferrable ? ` deferrable${option2.initiallyDeferred ? " initially deferred" : ""}` : ""}`);
+        definitions.push(`${option2.name ? `constraint ${dialect.quoteIdentifier(applyCategory(tableCasing, "constraints", option2.name))} ` : ""}unique${option2.nullsNotDistinct ? " nulls not distinct" : ""} (${option2.columns.map((column2) => quoteColumn2(column2, state, dialect, targetSource.tableName)).join(", ")})${option2.deferrable ? ` deferrable${option2.initiallyDeferred ? " initially deferred" : ""}` : ""}`);
         break;
       case "foreignKey": {
         if (dialect.name !== "postgres" && (option2.deferrable || option2.initiallyDeferred)) {
           throw new Error(`Unsupported ${dialect.name} foreign key constraint options`);
         }
         const reference = typeof option2.references === "function" ? option2.references() : option2.references;
-        definitions.push(`${option2.name ? `constraint ${dialect.quoteIdentifier(applyCategory(tableCasing, "constraints", option2.name))} ` : ""}foreign key (${option2.columns.map((column) => quoteColumn2(column, state, dialect, targetSource.tableName)).join(", ")}) references ${renderReferenceTable2(reference, state, dialect)} (${reference.columns.map((column) => quoteReferenceColumn2(column, reference, state, dialect)).join(", ")})${option2.onDelete !== undefined ? ` on delete ${renderReferentialAction(option2.onDelete)}` : ""}${option2.onUpdate !== undefined ? ` on update ${renderReferentialAction(option2.onUpdate)}` : ""}${option2.deferrable ? ` deferrable${option2.initiallyDeferred ? " initially deferred" : ""}` : ""}`);
+        definitions.push(`${option2.name ? `constraint ${dialect.quoteIdentifier(applyCategory(tableCasing, "constraints", option2.name))} ` : ""}foreign key (${option2.columns.map((column2) => quoteColumn2(column2, state, dialect, targetSource.tableName)).join(", ")}) references ${renderReferenceTable2(reference, state, dialect)} (${reference.columns.map((column2) => quoteReferenceColumn2(column2, reference, state, dialect)).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":
@@ -8358,7 +10614,7 @@ var renderCreateIndexSql2 = (targetSource, ddl, state, dialect) => {
   const maybeIfNotExists = dialect.name === "postgres" && ifNotExists ? " if not exists" : "";
   const table = targetSource.source;
   const tableCasing = casingForTable2(table, state);
-  return `create${unique3 ? " unique" : ""} index${maybeIfNotExists} ${dialect.quoteIdentifier(applyCategory(tableCasing, "indexes", name))} on ${renderSourceReference2(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} (${ddl.columns.map((column) => quoteColumn2(column, state, dialect, targetSource.tableName)).join(", ")})`;
+  return `create${unique3 ? " unique" : ""} index${maybeIfNotExists} ${dialect.quoteIdentifier(applyCategory(tableCasing, "indexes", name))} on ${renderSourceReference2(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} (${ddl.columns.map((column2) => quoteColumn2(column2, state, dialect, targetSource.tableName)).join(", ")})`;
 };
 var renderDropIndexSql2 = (targetSource, ddl, state, dialect) => {
   const ifExists = normalizeStatementFlag(ddl.ifExists);
@@ -8397,6 +10653,15 @@ var renderBinaryExpression2 = (functionName, operator, left, right, state, diale
   const [leftExpression, rightExpression] = expectBinaryExpressions2(functionName, left, right);
   return `(${renderExpression2(leftExpression, state, dialect)} ${operator} ${renderExpression2(rightExpression, state, dialect)})`;
 };
+var renderNumericExpression = (expression, state, dialect) => {
+  const rendered = renderExpression2(expression, state, dialect);
+  const ast = expression[TypeId2];
+  return dialect.name === "postgres" && ast.kind === "literal" ? `cast(${rendered} as ${renderCastType2(dialect, expression[TypeId].dbType)})` : rendered;
+};
+var renderNumericBinaryExpression = (functionName, operator, left, right, state, dialect) => {
+  const [leftExpression, rightExpression] = expectBinaryExpressions2(functionName, left, right);
+  return `(${renderNumericExpression(leftExpression, state, dialect)} ${operator} ${renderNumericExpression(rightExpression, state, dialect)})`;
+};
 var postgresRangeSubtypeByKind = {
   int4range: "int4",
   int8range: "int8",
@@ -8437,7 +10702,7 @@ var unsupportedJsonFeature2 = (dialect, feature) => {
   throw error;
 };
 var extractJsonBase2 = (node) => node.value ?? node.base ?? node.input ?? node.left ?? node.target;
-var isJsonPathValue3 = (value) => value !== null && typeof value === "object" && (TypeId3 in value);
+var isJsonPathValue4 = (value) => value !== null && typeof value === "object" && (TypeId3 in value);
 var isOptionalJsonPathNumber2 = (value) => value === undefined || typeof value === "number" && Number.isFinite(value);
 var isJsonPathSegment2 = (segment) => {
   if (typeof segment === "string") {
@@ -8476,7 +10741,7 @@ var validateJsonPathSegments2 = (segments) => {
 };
 var extractJsonPathSegments2 = (node) => {
   const path2 = node.path ?? node.segments ?? node.keys;
-  if (isJsonPathValue3(path2)) {
+  if (isJsonPathValue4(path2)) {
     return validateJsonPathSegments2(path2.segments);
   }
   if (Array.isArray(path2)) {
@@ -8501,7 +10766,7 @@ var extractJsonPathSegments2 = (node) => {
     }
     return [];
   }
-  if ("right" in node && isJsonPathValue3(node.right)) {
+  if ("right" in node && isJsonPathValue4(node.right)) {
     return validateJsonPathSegments2(node.right.segments);
   }
   return [];
@@ -8585,24 +10850,24 @@ var expressionDriverContext2 = (expression, state, dialect) => ({
   driverValueMapping: expression[TypeId].driverValueMapping
 });
 var renderJsonInputExpression2 = (expression, state, dialect) => renderJsonSelectSql(renderExpression2(expression, state, dialect), expressionDriverContext2(expression, state, dialect));
-var encodeArrayValues2 = (values2, column, state, dialect) => values2.map((value) => {
-  if (value === null && column.metadata.nullable) {
+var encodeArrayValues2 = (values3, column2, state, dialect) => values3.map((value) => {
+  if (value === null && column2.metadata.nullable) {
     return null;
   }
-  const runtimeSchemaAccepts = column.schema !== undefined && Schema11.is(column.schema)(value);
-  const normalizedValue = runtimeSchemaAccepts ? value : normalizeDbValue(column.metadata.dbType, value);
-  const encodedValue = column.schema === undefined || runtimeSchemaAccepts ? normalizedValue : Schema11.decodeUnknownSync(column.schema)(normalizedValue);
+  const runtimeSchemaAccepts = column2.schema !== undefined && Schema12.is(column2.schema)(value);
+  const normalizedValue = runtimeSchemaAccepts ? value : normalizeDbValue(column2.metadata.dbType, value);
+  const encodedValue = column2.schema === undefined || runtimeSchemaAccepts ? normalizedValue : Schema12.decodeUnknownSync(column2.schema)(normalizedValue);
   return toDriverValue(encodedValue, {
     dialect: dialect.name,
     valueMappings: state.valueMappings,
-    dbType: column.metadata.dbType,
-    runtimeSchema: column.schema,
-    driverValueMapping: column.metadata.driverValueMapping
+    dbType: column2.metadata.dbType,
+    runtimeSchema: column2.schema,
+    driverValueMapping: column2.metadata.driverValueMapping
   });
 });
 var renderPostgresJsonKind2 = (value) => value[TypeId].dbType.kind === "jsonb" ? "jsonb" : "json";
 var renderJsonOpaquePath2 = (value, state, dialect) => {
-  if (isJsonPathValue3(value)) {
+  if (isJsonPathValue4(value)) {
     return dialect.renderLiteral(renderJsonPathStringLiteral2(value.segments), state);
   }
   if (typeof value === "string") {
@@ -8751,8 +11016,8 @@ var renderJsonExpression2 = (expression, ast, state, dialect) => {
       return;
     }
     case "jsonBuildArray": {
-      const values2 = ast.values;
-      const renderedValues = values2.map((value) => renderJsonInputExpression2(value, state, dialect)).join(", ");
+      const values3 = ast.values;
+      const renderedValues = values3.map((value) => renderJsonInputExpression2(value, state, dialect)).join(", ");
       if (dialect.name === "postgres") {
         return `${postgresExpressionKind === "jsonb" ? "jsonb" : "json"}_build_array(${renderedValues})`;
       }
@@ -8911,18 +11176,18 @@ var selectionProjections2 = (selection) => flattenSelection(selection).map(({ pa
   alias: alias2
 }));
 var renderMutationAssignment2 = (entry, state, dialect, targetTableName) => {
-  const column = entry.tableName && dialect.name === "mysql" ? `${dialect.quoteIdentifier(casedTableReferenceName2(entry.tableName, state))}.${quoteColumn2(entry.columnName, state, dialect, entry.tableName)}` : quoteColumn2(entry.columnName, state, dialect, targetTableName);
-  return `${column} = ${renderExpression2(entry.value, state, dialect)}`;
+  const column2 = entry.tableName && dialect.name === "mysql" ? `${dialect.quoteIdentifier(casedTableReferenceName2(entry.tableName, state))}.${quoteColumn2(entry.columnName, state, dialect, entry.tableName)}` : quoteColumn2(entry.columnName, state, dialect, targetTableName);
+  return `${column2} = ${renderExpression2(entry.value, state, dialect)}`;
 };
-var renderJoinSourcesForMutation2 = (joins, state, dialect) => joins.map((join2) => renderSourceReference2(join2.source, join2.tableName, join2.baseTableName, state, dialect)).join(", ");
+var renderJoinSourcesForMutation2 = (joins, state, dialect) => joins.map((join3) => renderSourceReference2(join3.source, join3.tableName, join3.baseTableName, state, dialect)).join(", ");
 var renderFromSources2 = (sources, state, dialect) => sources.map((source) => renderSourceReference2(source.source, source.tableName, source.baseTableName, state, dialect)).join(", ");
-var renderJoinPredicatesForMutation2 = (joins, state, dialect) => joins.flatMap((join2) => join2.kind === "cross" || !join2.on ? [] : [renderExpression2(join2.on, state, dialect)]);
+var renderJoinPredicatesForMutation2 = (joins, state, dialect) => joins.flatMap((join3) => join3.kind === "cross" || !join3.on ? [] : [renderExpression2(join3.on, state, dialect)]);
 var renderDeleteTargets2 = (targets, dialect) => targets.map((target) => dialect.quoteIdentifier(target.tableName)).join(", ");
-var renderMysqlMutationLock = (lock2, statement) => {
-  if (!lock2) {
+var renderMysqlMutationLock = (lock3, statement) => {
+  if (!lock3) {
     return "";
   }
-  switch (lock2.mode) {
+  switch (lock3.mode) {
     case "lowPriority":
       return " low_priority";
     case "ignore":
@@ -8982,12 +11247,12 @@ var assertSupportedMutationReturning = (dialect, selection) => {
     throw new Error("Unsupported standard returning");
   }
 };
-var validateDistinctOnOrdering = (distinctOn2, orderBy2) => {
-  if (distinctOn2 === undefined || distinctOn2.length === 0 || orderBy2.length === 0) {
+var validateDistinctOnOrdering = (distinctOn3, orderBy3) => {
+  if (distinctOn3 === undefined || distinctOn3.length === 0 || orderBy3.length === 0) {
     return;
   }
-  const remainingDistinctKeys = new Set(distinctOn2.map(groupingKeyOfExpression));
-  for (const order of orderBy2) {
+  const remainingDistinctKeys = new Set(distinctOn3.map(groupingKeyOfExpression));
+  for (const order of orderBy3) {
     const key2 = groupingKeyOfExpression(order.value);
     if (remainingDistinctKeys.has(key2)) {
       remainingDistinctKeys.delete(key2);
@@ -9015,12 +11280,12 @@ var renderQueryAst2 = (ast, state, dialect, options2 = {}) => {
       if (ast.from) {
         clauses.push(`from ${renderSourceReference2(ast.from.source, ast.from.tableName, ast.from.baseTableName, state, dialect)}`);
       }
-      for (const join2 of ast.joins) {
-        if (dialect.name === "standard" && join2.kind === "full") {
+      for (const join3 of ast.joins) {
+        if (dialect.name === "standard" && join3.kind === "full") {
           throw new Error("Unsupported standard full join");
         }
-        const source = renderSourceReference2(join2.source, join2.tableName, join2.baseTableName, state, dialect);
-        clauses.push(join2.kind === "cross" ? `cross join ${source}` : `${join2.kind} join ${source} on ${renderExpression2(join2.on, state, dialect)}`);
+        const source = renderSourceReference2(join3.source, join3.tableName, join3.baseTableName, state, dialect);
+        clauses.push(join3.kind === "cross" ? `cross join ${source}` : `${join3.kind} join ${source} on ${renderExpression2(join3.on, state, dialect)}`);
       }
       if (ast.where.length > 0) {
         clauses.push(`where ${ast.where.map((entry) => renderExpression2(entry.predicate, state, dialect)).join(" and ")}`);
@@ -9074,15 +11339,15 @@ var renderQueryAst2 = (ast, state, dialect, options2 = {}) => {
       const conflict = expectConflictClause(insertAst.conflict);
       sql = `insert into ${target}`;
       if (insertSource?.kind === "values") {
-        const columns = insertSource.columns.map((column) => quoteColumn2(column, state, dialect, targetSource.tableName)).join(", ");
+        const columns = insertSource.columns.map((column2) => quoteColumn2(column2, state, dialect, targetSource.tableName)).join(", ");
         const rows = insertSource.rows.map((row) => `(${row.values.map((entry) => renderExpression2(entry.value, targetCasingState, dialect)).join(", ")})`).join(", ");
         sql += ` (${columns}) values ${rows}`;
       } else if (insertSource?.kind === "query") {
-        const columns = insertSource.columns.map((column) => quoteColumn2(column, state, dialect, targetSource.tableName)).join(", ");
+        const columns = insertSource.columns.map((column2) => quoteColumn2(column2, state, dialect, targetSource.tableName)).join(", ");
         const renderedQuery = renderQueryAst2(getAst(insertSource.query), state, dialect);
         sql += ` (${columns}) ${renderedQuery.sql}`;
       } else if (insertSource?.kind === "unnest") {
-        const columns = insertSource.columns.map((column) => quoteColumn2(column, state, dialect, targetSource.tableName)).join(", ");
+        const columns = insertSource.columns.map((column2) => quoteColumn2(column2, state, dialect, targetSource.tableName)).join(", ");
         if (dialect.name === "postgres") {
           const table = targetSource.source;
           const fields2 = table[TypeId7].fields;
@@ -9096,9 +11361,9 @@ var renderQueryAst2 = (ast, state, dialect, options2 = {}) => {
       } else {
         const insertValues = insertAst.values ?? [];
         const columns = insertValues.map((entry) => quoteColumn2(entry.columnName, state, dialect, targetSource.tableName)).join(", ");
-        const values2 = insertValues.map((entry) => renderExpression2(entry.value, targetCasingState, dialect)).join(", ");
+        const values3 = insertValues.map((entry) => renderExpression2(entry.value, targetCasingState, dialect)).join(", ");
         if (insertValues.length > 0) {
-          sql += ` (${columns}) values (${values2})`;
+          sql += ` (${columns}) values (${values3})`;
         } else {
           sql += " default values";
         }
@@ -9110,7 +11375,7 @@ var renderQueryAst2 = (ast, state, dialect, options2 = {}) => {
         const conflictValueState = { ...targetCasingState, allowExcluded: true };
         const updateValues = (conflict.values ?? []).map((entry) => `${quoteColumn2(entry.columnName, state, dialect, targetSource.tableName)} = ${renderExpression2(entry.value, conflictValueState, dialect)}`).join(", ");
         if (dialect.name === "postgres") {
-          const targetSql = conflict.target?.kind === "constraint" ? ` on conflict on constraint ${dialect.quoteIdentifier(applyCategory(targetCasingState.casing, "constraints", conflict.target.name))}` : conflict.target?.kind === "columns" ? ` on conflict (${conflict.target.columns.map((column) => quoteColumn2(column, state, dialect, targetSource.tableName)).join(", ")})${conflict.target.where ? ` where ${renderExpression2(conflict.target.where, targetCasingState, dialect)}` : ""}` : " on conflict";
+          const targetSql = conflict.target?.kind === "constraint" ? ` on conflict on constraint ${dialect.quoteIdentifier(applyCategory(targetCasingState.casing, "constraints", conflict.target.name))}` : conflict.target?.kind === "columns" ? ` on conflict (${conflict.target.columns.map((column2) => quoteColumn2(column2, state, dialect, targetSource.tableName)).join(", ")})${conflict.target.where ? ` where ${renderExpression2(conflict.target.where, targetCasingState, dialect)}` : ""}` : " on conflict";
           sql += targetSql;
           sql += conflict.action === "doNothing" ? " do nothing" : ` do update set ${updateValues}${conflict.where ? ` where ${renderExpression2(conflict.where, conflictValueState, dialect)}` : ""}`;
         } else if (conflict.action === "doNothing") {
@@ -9120,10 +11385,10 @@ var renderQueryAst2 = (ast, state, dialect, options2 = {}) => {
         }
       }
       assertSupportedMutationReturning(dialect, insertAst.select);
-      const returning2 = renderSelectionList2(insertAst.select, state, dialect);
-      projections = returning2.projections;
-      if (returning2.sql.length > 0) {
-        sql += ` returning ${returning2.sql}`;
+      const returning3 = renderSelectionList2(insertAst.select, state, dialect);
+      projections = returning3.projections;
+      if (returning3.sql.length > 0) {
+        sql += ` returning ${returning3.sql}`;
       }
       break;
     }
@@ -9140,7 +11405,7 @@ var renderQueryAst2 = (ast, state, dialect, options2 = {}) => {
       if (dialect.name === "mysql") {
         const modifiers = renderMysqlMutationLock(updateAst.lock, "update");
         const extraSources = renderFromSources2(fromSources, state, dialect);
-        const joinSources = updateAst.joins.map((join2) => join2.kind === "cross" ? `cross join ${renderSourceReference2(join2.source, join2.tableName, join2.baseTableName, state, dialect)}` : `${join2.kind} join ${renderSourceReference2(join2.source, join2.tableName, join2.baseTableName, state, dialect)} on ${renderExpression2(join2.on, state, dialect)}`).join(" ");
+        const joinSources = updateAst.joins.map((join3) => join3.kind === "cross" ? `cross join ${renderSourceReference2(join3.source, join3.tableName, join3.baseTableName, state, dialect)}` : `${join3.kind} join ${renderSourceReference2(join3.source, join3.tableName, join3.baseTableName, state, dialect)} on ${renderExpression2(join3.on, state, dialect)}`).join(" ");
         const targetList = [
           ...targets.map((entry) => renderSourceReference2(entry.source, entry.tableName, entry.baseTableName, state, dialect)),
           ...extraSources.length > 0 ? [extraSources] : []
@@ -9170,10 +11435,10 @@ var renderQueryAst2 = (ast, state, dialect, options2 = {}) => {
         sql += ` limit ${renderExpression2(updateAst.limit, state, dialect)}`;
       }
       assertSupportedMutationReturning(dialect, updateAst.select);
-      const returning2 = renderSelectionList2(updateAst.select, state, dialect);
-      projections = returning2.projections;
-      if (returning2.sql.length > 0) {
-        sql += ` returning ${returning2.sql}`;
+      const returning3 = renderSelectionList2(updateAst.select, state, dialect);
+      projections = returning3.projections;
+      if (returning3.sql.length > 0) {
+        sql += ` returning ${returning3.sql}`;
       }
       break;
     }
@@ -9190,7 +11455,7 @@ var renderQueryAst2 = (ast, state, dialect, options2 = {}) => {
         const hasJoinedSources = deleteAst.joins.length > 0 || targets.length > 1;
         const targetList = renderDeleteTargets2(targets, dialect);
         const fromSources = targets.map((entry) => renderSourceReference2(entry.source, entry.tableName, entry.baseTableName, state, dialect)).join(", ");
-        const joinSources = deleteAst.joins.map((join2) => join2.kind === "cross" ? `cross join ${renderSourceReference2(join2.source, join2.tableName, join2.baseTableName, state, dialect)}` : `${join2.kind} join ${renderSourceReference2(join2.source, join2.tableName, join2.baseTableName, state, dialect)} on ${renderExpression2(join2.on, state, dialect)}`).join(" ");
+        const joinSources = deleteAst.joins.map((join3) => join3.kind === "cross" ? `cross join ${renderSourceReference2(join3.source, join3.tableName, join3.baseTableName, state, dialect)}` : `${join3.kind} join ${renderSourceReference2(join3.source, join3.tableName, join3.baseTableName, state, dialect)} on ${renderExpression2(join3.on, state, dialect)}`).join(" ");
         sql = hasJoinedSources ? `delete${modifiers} ${targetList} from ${fromSources}${joinSources.length > 0 ? ` ${joinSources}` : ""}` : `delete${modifiers} from ${fromSources}`;
       } else {
         sql = `delete from ${target}`;
@@ -9212,10 +11477,10 @@ var renderQueryAst2 = (ast, state, dialect, options2 = {}) => {
         sql += ` limit ${renderExpression2(deleteAst.limit, state, dialect)}`;
       }
       assertSupportedMutationReturning(dialect, deleteAst.select);
-      const returning2 = renderSelectionList2(deleteAst.select, state, dialect);
-      projections = returning2.projections;
-      if (returning2.sql.length > 0) {
-        sql += ` returning ${returning2.sql}`;
+      const returning3 = renderSelectionList2(deleteAst.select, state, dialect);
+      projections = returning3.projections;
+      if (returning3.sql.length > 0) {
+        sql += ` returning ${returning3.sql}`;
       }
       break;
     }
@@ -9224,10 +11489,10 @@ var renderQueryAst2 = (ast, state, dialect, options2 = {}) => {
       if (dialect.name === "standard") {
         throw new Error("Unsupported standard truncate statement");
       }
-      const truncate = expectTruncateClause(truncateAst.truncate);
+      const truncate2 = expectTruncateClause(truncateAst.truncate);
       const targetSource = truncateAst.target;
-      const restartIdentity = truncate.restartIdentity;
-      const cascade = truncate.cascade;
+      const restartIdentity = truncate2.restartIdentity;
+      const cascade = truncate2.cascade;
       sql = `truncate table ${renderSourceReference2(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)}`;
       if (restartIdentity) {
         sql += " restart identity";
@@ -9244,27 +11509,27 @@ var renderQueryAst2 = (ast, state, dialect, options2 = {}) => {
       const mergeAst = ast;
       const targetSource = mergeAst.target;
       const usingSource = mergeAst.using;
-      const merge2 = mergeAst.merge;
-      sql = `merge into ${renderSourceReference2(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} using ${renderSourceReference2(usingSource.source, usingSource.tableName, usingSource.baseTableName, state, dialect)} on ${renderExpression2(merge2.on, state, dialect)}`;
-      if (merge2.whenMatched) {
-        const matchedKind = merge2.whenMatched.kind === "delete" ? "delete" : "update";
+      const merge3 = mergeAst.merge;
+      sql = `merge into ${renderSourceReference2(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} using ${renderSourceReference2(usingSource.source, usingSource.tableName, usingSource.baseTableName, state, dialect)} on ${renderExpression2(merge3.on, state, dialect)}`;
+      if (merge3.whenMatched) {
+        const matchedKind = merge3.whenMatched.kind === "delete" ? "delete" : "update";
         sql += " when matched";
-        if (merge2.whenMatched.predicate) {
-          sql += ` and ${renderExpression2(merge2.whenMatched.predicate, state, dialect)}`;
+        if (merge3.whenMatched.predicate) {
+          sql += ` and ${renderExpression2(merge3.whenMatched.predicate, state, dialect)}`;
         }
         if (matchedKind === "delete") {
           sql += " then delete";
         } else {
-          const matchedUpdate = merge2.whenMatched;
+          const matchedUpdate = merge3.whenMatched;
           sql += ` then update set ${matchedUpdate.values.map((entry) => `${quoteColumn2(entry.columnName, state, dialect, targetSource.tableName)} = ${renderExpression2(entry.value, state, dialect)}`).join(", ")}`;
         }
       }
-      if (merge2.whenNotMatched) {
+      if (merge3.whenNotMatched) {
         sql += " when not matched";
-        if (merge2.whenNotMatched.predicate) {
-          sql += ` and ${renderExpression2(merge2.whenNotMatched.predicate, state, dialect)}`;
+        if (merge3.whenNotMatched.predicate) {
+          sql += ` and ${renderExpression2(merge3.whenNotMatched.predicate, state, dialect)}`;
         }
-        sql += ` then insert (${merge2.whenNotMatched.values.map((entry) => quoteColumn2(entry.columnName, state, dialect, targetSource.tableName)).join(", ")}) values (${merge2.whenNotMatched.values.map((entry) => renderExpression2(entry.value, state, dialect)).join(", ")})`;
+        sql += ` then insert (${merge3.whenNotMatched.values.map((entry) => quoteColumn2(entry.columnName, state, dialect, targetSource.tableName)).join(", ")}) values (${merge3.whenNotMatched.values.map((entry) => renderExpression2(entry.value, state, dialect)).join(", ")})`;
       }
       break;
     }
@@ -9355,19 +11620,19 @@ var renderSourceReference2 = (source, tableName, baseTableName, state, dialect)
     return `(${renderQueryAst2(getAst(derived.plan), nestedRenderState2(state), dialect).sql}) as ${dialect.quoteIdentifier(derived.name)}`;
   }
   if (typeof source === "object" && source !== null && "kind" in source && source.kind === "lateral") {
-    const lateral = source;
+    const lateral2 = source;
     if (dialect.name === "standard") {
       throw new Error("Unsupported standard lateral source");
     }
-    return `lateral (${renderQueryAst2(getAst(lateral.plan), nestedRenderState2(state), dialect).sql}) as ${dialect.quoteIdentifier(lateral.name)}`;
+    return `lateral (${renderQueryAst2(getAst(lateral2.plan), nestedRenderState2(state), dialect).sql}) as ${dialect.quoteIdentifier(lateral2.name)}`;
   }
   if (typeof source === "object" && source !== null && source.kind === "values") {
-    const values2 = source;
-    return renderSelectRows(values2.rows, Object.keys(values2.columns));
+    const values3 = source;
+    return renderSelectRows(values3.rows, Object.keys(values3.columns));
   }
   if (typeof source === "object" && source !== null && source.kind === "unnest") {
-    const unnest2 = source;
-    return renderUnnestRows(unnest2.arrays, Object.keys(unnest2.columns));
+    const unnest3 = source;
+    return renderUnnestRows(unnest3.arrays, Object.keys(unnest3.columns));
   }
   if (typeof source === "object" && source !== null && source.kind === "tableFunction") {
     const tableFunction = source;
@@ -9431,6 +11696,8 @@ var renderExpression2 = (expression, state, dialect) => {
       return `(${renderExpression2(expectValueExpression2("collate", ast.value), state, dialect)} collate ${renderCollation(ast.collation)})`;
     case "function":
       return renderFunctionCall2(ast.name, ast.args, state, dialect);
+    case "customSql":
+      return renderCustomSql(ast, state, dialect, renderExpression2);
     case "eq":
       return renderBinaryExpression2("eq", "=", ast.left, ast.right, state, dialect);
     case "neq":
@@ -9443,6 +11710,16 @@ var renderExpression2 = (expression, state, dialect) => {
       return renderBinaryExpression2("gt", ">", ast.left, ast.right, state, dialect);
     case "gte":
       return renderBinaryExpression2("gte", ">=", ast.left, ast.right, state, dialect);
+    case "add":
+      return renderNumericBinaryExpression("add", "+", ast.left, ast.right, state, dialect);
+    case "subtract":
+      return renderNumericBinaryExpression("subtract", "-", ast.left, ast.right, state, dialect);
+    case "multiply":
+      return renderNumericBinaryExpression("multiply", "*", ast.left, ast.right, state, dialect);
+    case "divide":
+      return renderNumericBinaryExpression("divide", "/", ast.left, ast.right, state, dialect);
+    case "modulo":
+      return renderNumericBinaryExpression("modulo", "%", ast.left, ast.right, state, dialect);
     case "like":
       return renderBinaryExpression2("like", "like", ast.left, ast.right, state, dialect);
     case "ilike": {
@@ -9536,6 +11813,16 @@ var renderExpression2 = (expression, state, dialect) => {
       return `lower(${renderExpression2(expectValueExpression2("lower", ast.value), state, dialect)})`;
     case "count":
       return `count(${renderExpression2(expectValueExpression2("count", ast.value), state, dialect)})`;
+    case "sum":
+      return `sum(${renderNumericExpression(expectValueExpression2("sum", ast.value), state, dialect)})`;
+    case "avg":
+      return `avg(${renderNumericExpression(expectValueExpression2("avg", ast.value), state, dialect)})`;
+    case "abs":
+      return `abs(${renderNumericExpression(expectValueExpression2("abs", ast.value), state, dialect)})`;
+    case "round":
+      return `round(${renderNumericExpression(expectValueExpression2("round", ast.value), state, dialect)})`;
+    case "negate":
+      return `(-${renderNumericExpression(expectValueExpression2("negate", ast.value), state, dialect)})`;
     case "max":
       return `max(${renderExpression2(expectValueExpression2("max", ast.value), state, dialect)})`;
     case "min":
@@ -9580,24 +11867,44 @@ var renderExpression2 = (expression, state, dialect) => {
     }
     case "window": {
       const partitionBy = ast.partitionBy;
-      const orderBy2 = ast.orderBy;
-      const clauses = [];
-      if (partitionBy.length > 0) {
-        clauses.push(`partition by ${partitionBy.map((value) => renderExpression2(value, state, dialect)).join(", ")}`);
-      }
-      if (orderBy2.length > 0) {
-        clauses.push(`order by ${orderBy2.map((entry) => `${renderExpression2(entry.value, state, dialect)} ${entry.direction}`).join(", ")}`);
-      }
-      const specification = clauses.join(" ");
+      const orderBy3 = ast.orderBy;
+      const renderSpecification = () => {
+        const clauses = [];
+        if (partitionBy.length > 0) {
+          clauses.push(`partition by ${partitionBy.map((value) => renderExpression2(value, state, dialect)).join(", ")}`);
+        }
+        if (orderBy3.length > 0) {
+          clauses.push(`order by ${orderBy3.map((entry) => `${renderExpression2(entry.value, state, dialect)} ${entry.direction}`).join(", ")}`);
+        }
+        if (ast.frame !== undefined) {
+          clauses.push(renderWindowFrame(ast.frame));
+        }
+        return clauses.join(" ");
+      };
       switch (ast.function) {
         case "rowNumber":
-          return `row_number() over (${specification})`;
+          return `row_number() over (${renderSpecification()})`;
         case "rank":
-          return `rank() over (${specification})`;
+          return `rank() over (${renderSpecification()})`;
         case "denseRank":
-          return `dense_rank() over (${specification})`;
+          return `dense_rank() over (${renderSpecification()})`;
         case "over":
-          return `${renderExpression2(ast.value, state, dialect)} over (${specification})`;
+          return `${renderExpression2(ast.value, state, dialect)} over (${renderSpecification()})`;
+        case "lag":
+        case "lead": {
+          const args = [renderExpression2(ast.value, state, dialect)];
+          if (ast.offset !== undefined) {
+            args.push(renderExpression2(ast.offset, state, dialect));
+          }
+          if (ast.defaultValue !== undefined) {
+            args.push(renderExpression2(ast.defaultValue, state, dialect));
+          }
+          return `${ast.function}(${args.join(", ")}) over (${renderSpecification()})`;
+        }
+        case "firstValue":
+          return `first_value(${renderExpression2(ast.value, state, dialect)}) over (${renderSpecification()})`;
+        case "lastValue":
+          return `last_value(${renderExpression2(ast.value, state, dialect)}) over (${renderSpecification()})`;
       }
       break;
     }
@@ -9630,8 +11937,8 @@ var standardDialect = {
     const renderedBase = schemaName && schemaName !== "public" ? `${quoteIdentifier(schemaName)}.${quoteIdentifier(baseTableName)}` : quoteIdentifier(baseTableName);
     return tableName === baseTableName ? renderedBase : `${renderedBase} as ${quoteIdentifier(tableName)}`;
   },
-  renderConcat(values2) {
-    return `(${values2.join(" || ")})`;
+  renderConcat(values3) {
+    return `(${values3.join(" || ")})`;
   },
   renderQueryAst: renderQueryAst2,
   renderExpression: renderExpression2
@@ -9660,8 +11967,8 @@ var sqliteDialect = {
     const renderedBase = schemaName && schemaName !== "public" ? `${quoteIdentifier2(schemaName)}.${quoteIdentifier2(baseTableName)}` : quoteIdentifier2(baseTableName);
     return tableName === baseTableName ? renderedBase : `${renderedBase} as ${quoteIdentifier2(tableName)}`;
   },
-  renderConcat(values2) {
-    return `(${values2.join(" || ")})`;
+  renderConcat(values3) {
+    return `(${values3.join(" || ")})`;
   },
   renderQueryAst,
   renderExpression
@@ -9696,40 +12003,65 @@ var renderSqlitePlan = (plan, options2 = {}) => {
 };
 
 // src/sqlite/executor.ts
+var atMostOne2 = atMostOne;
+var exactlyOne2 = exactlyOne;
+var nonEmpty2 = nonEmpty;
 var withTransaction2 = withTransaction;
 function driver2(dialectOrExecute, maybeExecute) {
   const executeOrHandlers = typeof dialectOrExecute === "string" ? maybeExecute : dialectOrExecute;
   return typeof executeOrHandlers === "function" ? driver("sqlite", executeOrHandlers) : driver("sqlite", executeOrHandlers);
 }
-var fromDriver2 = (renderer, sqlDriver, driverMode = "raw", valueMappings) => ({
-  dialect: "sqlite",
-  execute(plan) {
-    const rendered = renderer.render(plan);
-    return Effect2.mapError(Effect2.flatMap(sqlDriver.execute(rendered), (rows) => Effect2.try({
-      try: () => decodeRows(rendered, plan, rows, { driverMode, valueMappings }),
-      catch: (error) => error
-    })), (error) => {
-      if (typeof error === "object" && error !== null && "_tag" in error && error._tag === "RowDecodeError") {
-        return error;
-      }
-      const normalized = normalizeSqliteDriverError(error, rendered);
-      return hasWriteCapability(plan) ? normalized : narrowSqliteDriverErrorForReadQuery(normalized);
-    });
-  },
-  stream(plan) {
+var fromDriver2 = (renderer, sqlDriver, driverMode = "raw", valueMappings) => {
+  const renderedCache = new WeakMap;
+  const render2 = (plan) => {
+    const cached = renderedCache.get(plan);
+    if (cached !== undefined) {
+      return cached;
+    }
     const rendered = renderer.render(plan);
-    return Stream2.mapError(Stream2.mapArrayEffect(sqlDriver.stream(rendered), (rows) => Effect2.try({
-      try: () => decodeRows(rendered, plan, rows, { driverMode, valueMappings }),
-      catch: (error) => error
-    })), (error) => {
-      if (typeof error === "object" && error !== null && "_tag" in error && error._tag === "RowDecodeError") {
-        return error;
-      }
-      const normalized = normalizeSqliteDriverError(error, rendered);
-      return hasWriteCapability(plan) ? normalized : narrowSqliteDriverErrorForReadQuery(normalized);
-    });
-  }
-});
+    renderedCache.set(plan, rendered);
+    return rendered;
+  };
+  const mapExecutionError = (error, rendered, plan) => {
+    if (typeof error === "object" && error !== null && "_tag" in error && error._tag === "RowDecodeError") {
+      return error;
+    }
+    const normalized = normalizeSqliteDriverError(error, rendered);
+    return hasWriteCapability(plan) ? normalized : narrowSqliteDriverErrorForReadQuery(normalized);
+  };
+  return withResultContracts({
+    dialect: "sqlite",
+    execute(plan) {
+      const rendered = render2(plan);
+      return Effect2.mapError(Effect2.flatMap(sqlDriver.execute(rendered), (rows) => Effect2.try({
+        try: () => decodeRows(rendered, plan, rows, { driverMode, valueMappings }),
+        catch: (error) => error
+      })), (error) => mapExecutionError(error, rendered, plan));
+    },
+    executeResult(plan) {
+      const rendered = render2(plan);
+      const result = sqlDriver.executeResult ? sqlDriver.executeResult(rendered) : Effect2.map(sqlDriver.execute(rendered), (rows) => ({ rows }));
+      return Effect2.mapError(Effect2.flatMap(result, ({ rows, ...metadata }) => Effect2.try({
+        try: () => ({
+          ...metadata,
+          rows: decodeRows(rendered, plan, rows, { driverMode, valueMappings })
+        }),
+        catch: (error) => error
+      })), (error) => mapExecutionError(error, rendered, plan));
+    },
+    stream(plan) {
+      const rendered = render2(plan);
+      return Stream2.mapError(Stream2.mapArrayEffect(sqlDriver.stream(rendered), (rows) => Effect2.try({
+        try: () => decodeRows(rendered, plan, rows, { driverMode, valueMappings }),
+        catch: (error) => error
+      })), (error) => mapExecutionError(error, rendered, plan));
+    },
+    explain(plan, options2) {
+      const rendered = explainQuery(render2(plan), options2);
+      return Effect2.mapError(sqlDriver.execute(rendered), (error) => mapExecutionError(error, rendered, plan));
+    }
+  });
+};
 var sqlClientDriver = () => driver2({
   execute: (query) => Effect2.flatMap(SqlClient3.SqlClient, (sql) => sql.unsafe(query.sql, [...query.params])),
   stream: (query) => Stream2.unwrap(Effect2.map(Effect2.flatMap(SqlClient3.SqlClient, (sql) => sql.unsafe(query.sql, [...query.params])), (rows) => Stream2.fromIterable(rows)))
@@ -9740,25 +12072,25 @@ function make4(options2 = {}) {
   }
   return fromDriver2(options2.renderer ?? makeTrusted("sqlite", (plan) => renderSqlitePlan(plan, { valueMappings: options2.valueMappings })), sqlClientDriver(), options2.driverMode, options2.valueMappings);
 }
-var custom3 = (execute) => make3("sqlite", execute);
+var custom4 = (execute) => make3("sqlite", execute);
 // src/sqlite/query-extension.ts
 var exports_query_extension = {};
 __export(exports_query_extension, {
   onConflict: () => onConflict
 });
 // src/sqlite/type.ts
-var custom4 = (kind) => ({
+var custom5 = (kind) => ({
   dialect: "sqlite",
   kind
 });
-var driverValueMapping3 = (dbType, mapping) => ({
+var driverValueMapping4 = (dbType, mapping) => ({
   ...dbType,
   driverValueMapping: mapping
 });
-var type2 = {
+var type3 = {
   ...pickDatatypeConstructors(sqliteDatatypes, sqliteSpecificDatatypeKeys),
-  custom: custom4,
-  driverValueMapping: driverValueMapping3
+  custom: custom5,
+  driverValueMapping: driverValueMapping4
 };
 // src/sqlite/renderer.ts
 var exports_renderer2 = {};
@@ -9767,10 +12099,10 @@ __export(exports_renderer2, {
   make: () => make5,
   TypeId: () => TypeId10
 });
-import { pipeArguments as pipeArguments8 } from "effect/Pipeable";
+import { pipeArguments as pipeArguments9 } from "effect/Pipeable";
 var RendererProto = {
   pipe() {
-    return pipeArguments8(this, arguments);
+    return pipeArguments9(this, arguments);
   }
 };
 var makeWithState = (state = {}) => {
@@ -9788,10 +12120,11 @@ var makeWithState = (state = {}) => {
 var make5 = (options2 = {}) => makeWithState({ valueMappings: options2.valueMappings });
 var sqlite = make5();
 export {
-  type2 as Type,
+  type3 as Type,
   exports_renderer2 as Renderer,
   exports_query_extension as Query,
   exports_json as Json,
+  exports_function as Function,
   exports_executor2 as Executor,
   exports_errors as Errors,
   exports_datatypes as Datatypes,