effect-qb 0.21.0 → 0.22.0

package/dist/postgres.js

@@ -2639,6 +2639,33 @@ var sqliteSpecificDatatypeKeys = [
 ];
 var pickDatatypeConstructors = (module, keys) => Object.fromEntries(keys.map((key2) => [key2, module[key2]]));
 
+// src/internal/custom-sql-renderer.ts
+var renderCustomSql = (node, state, dialect, renderExpression2) => node.strings.map((part, index3) => {
+  const value = node.values[index3];
+  if (value === undefined) {
+    return part;
+  }
+  return part + (TypeId2 in value ? renderExpression2(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/dsl-plan-runtime.ts
 var renderSelectLockMode = (mode) => mode === "update" ? "for update" : "for share";
 var renderMysqlMutationLockMode = (mode, _statement) => {
@@ -3804,8 +3831,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");
 };
@@ -4245,6 +4273,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, index3) => {
+  const value = values[index3];
+  if (value === undefined) {
+    return escapeGroupingText(part);
+  }
+  const rendered = isExpression3(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;
@@ -4326,12 +4362,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)})`;
@@ -4352,6 +4395,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":
@@ -4701,6 +4749,15 @@ var renderBinaryExpression = (functionName, operator, left, right, state, dialec
   const [leftExpression, rightExpression] = expectBinaryExpressions(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[TypeId3];
+  return dialect.name === "postgres" && ast.kind === "literal" ? `cast(${rendered} as ${renderCastType(dialect, expression[TypeId2].dbType)})` : rendered;
+};
+var renderNumericBinaryExpression = (functionName, operator, left, right, state, dialect) => {
+  const [leftExpression, rightExpression] = expectBinaryExpressions(functionName, left, right);
+  return `(${renderNumericExpression(leftExpression, state, dialect)} ${operator} ${renderNumericExpression(rightExpression, state, dialect)})`;
+};
 var postgresRangeSubtypeByKind = {
   int4range: "int4",
   int8range: "int8",
@@ -5735,6 +5792,8 @@ var renderExpression2 = (expression, state, dialect) => {
       return `(${renderExpression2(expectValueExpression("collate", ast.value), state, dialect)} collate ${renderCollation(ast.collation)})`;
     case "function":
       return renderFunctionCall(ast.name, ast.args, state, dialect);
+    case "customSql":
+      return renderCustomSql(ast, state, dialect, renderExpression2);
     case "eq":
       return renderBinaryExpression("eq", "=", ast.left, ast.right, state, dialect);
     case "neq":
@@ -5747,6 +5806,16 @@ var renderExpression2 = (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 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 renderBinaryExpression("like", "like", ast.left, ast.right, state, dialect);
     case "ilike": {
@@ -5840,6 +5909,16 @@ var renderExpression2 = (expression, state, dialect) => {
       return `lower(${renderExpression2(expectValueExpression("lower", ast.value), state, dialect)})`;
     case "count":
       return `count(${renderExpression2(expectValueExpression("count", ast.value), state, dialect)})`;
+    case "sum":
+      return `sum(${renderNumericExpression(expectValueExpression("sum", ast.value), state, dialect)})`;
+    case "avg":
+      return `avg(${renderNumericExpression(expectValueExpression("avg", ast.value), state, dialect)})`;
+    case "abs":
+      return `abs(${renderNumericExpression(expectValueExpression("abs", ast.value), state, dialect)})`;
+    case "round":
+      return `round(${renderNumericExpression(expectValueExpression("round", ast.value), state, dialect)})`;
+    case "negate":
+      return `(-${renderNumericExpression(expectValueExpression("negate", ast.value), state, dialect)})`;
     case "max":
       return `max(${renderExpression2(expectValueExpression("max", ast.value), state, dialect)})`;
     case "min":
@@ -5885,23 +5964,43 @@ var renderExpression2 = (expression, state, dialect) => {
     case "window": {
       const partitionBy = ast.partitionBy;
       const orderBy = ast.orderBy;
-      const clauses = [];
-      if (partitionBy.length > 0) {
-        clauses.push(`partition by ${partitionBy.map((value) => renderExpression2(value, state, dialect)).join(", ")}`);
-      }
-      if (orderBy.length > 0) {
-        clauses.push(`order by ${orderBy.map((entry) => `${renderExpression2(entry.value, state, dialect)} ${entry.direction}`).join(", ")}`);
-      }
-      const specification = clauses.join(" ");
+      const renderSpecification = () => {
+        const clauses = [];
+        if (partitionBy.length > 0) {
+          clauses.push(`partition by ${partitionBy.map((value) => renderExpression2(value, state, dialect)).join(", ")}`);
+        }
+        if (orderBy.length > 0) {
+          clauses.push(`order by ${orderBy.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;
     }
@@ -9822,16 +9921,45 @@ var narrowPostgresDriverErrorForReadQuery = (error) => {
 // src/postgres/function/index.ts
 var exports_function = {};
 __export(exports_function, {
+  window: () => exports_window,
   uuidGenerateV4: () => uuidGenerateV4,
+  upper: () => upper,
+  temporal: () => exports_temporal,
+  sum: () => sum,
+  string: () => exports_string,
+  rowNumber: () => rowNumber,
+  round: () => round2,
+  rank: () => rank,
+  over: () => over,
+  numeric: () => exports_numeric,
+  now: () => now,
   nextVal: () => nextVal2,
-  core: () => exports_core
+  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,
+  call: () => call,
+  avg: () => avg,
+  aggregate: () => exports_aggregate
 });
 
 // src/postgres/function/core.ts
 var exports_core = {};
 __export(exports_core, {
   uuidGenerateV4: () => uuidGenerateV4,
-  nextVal: () => nextVal2
+  nextVal: () => nextVal2,
+  call: () => call
 });
 
 // src/postgres/internal/dsl.ts
@@ -9951,6 +10079,31 @@ var resolveImplicationScope = (available, initialAssumptions) => {
   };
 };
 
+// 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-query-runtime.ts
 var makeDslQueryRuntime = (ctx) => {
   const values = (rows) => {
@@ -10239,6 +10392,23 @@ var extractRequiredFromDialectInputRuntime = (value) => {
   const expression = toDialectExpression(value);
   return Object.keys(expression[TypeId2].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[TypeId2].dependencies);
@@ -10258,6 +10428,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[TypeId2].nullability,
+    dialect: profile.dialect,
+    kind: expression[TypeId2].kind,
+    dependencies: expression[TypeId2].dependencies
+  }, {
+    kind: "upper",
+    value: expression
+  });
+};
+var lower = (value) => {
+  const expression = toDialectStringExpression(value);
+  return makeExpression2({
+    runtime: "",
+    dbType: profile.textDb,
+    nullability: expression[TypeId2].nullability,
+    dialect: profile.dialect,
+    kind: expression[TypeId2].kind,
+    dependencies: expression[TypeId2].dependencies
+  }, {
+    kind: "lower",
+    value: expression
+  });
+};
 var cast = (value, target) => {
   const expression = toDialectExpression(value);
   return makeExpression2({
@@ -10760,6 +10958,111 @@ var jsonb2 = {
   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[TypeId2].dialect !== undefined)?.[TypeId2].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: postgresDatatypes.int8(),
+    nullability: "never",
+    dialect: expression[TypeId2].dialect,
+    kind: "aggregate",
+    dependencies: expression[TypeId2].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[TypeId2].dbType,
+    nullability: value[TypeId2].nullability,
+    dialect: expressions.find((expression) => expression[TypeId2].dialect !== undefined)?.[TypeId2].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: postgresDatatypes.int8(),
+    nullability: "never",
+    dialect: expressions.find((expression) => expression[TypeId2].dialect !== undefined)?.[TypeId2].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[TypeId2].dbType,
+  nullability: "maybe",
+  dialect: value[TypeId2].dialect,
+  kind: "aggregate",
+  dependencies: value[TypeId2].dependencies
+}, {
+  kind: "max",
+  value
+});
+var min = (value) => makeExpression2({
+  runtime: undefined,
+  dbType: value[TypeId2].dbType,
+  nullability: "maybe",
+  dialect: value[TypeId2].dialect,
+  kind: "aggregate",
+  dependencies: value[TypeId2].dependencies
+}, {
+  kind: "min",
+  value
+});
+var call = (name2, ...args) => {
+  const expressions = args.map((value) => toDialectExpression(value));
+  return makeExpression2({
+    runtime: undefined,
+    dbType: profile.textDb,
+    nullability: "maybe",
+    dialect: expressions.find((value) => value[TypeId2].dialect !== undefined)?.[TypeId2].dialect ?? profile.dialect,
+    kind: mergeAggregationManyRuntime(expressions),
+    dependencies: mergeManyDependencies(expressions)
+  }, {
+    kind: "function",
+    name: name2,
+    args: expressions
+  });
+};
 var uuidGenerateV4 = () => makeExpression2({
   runtime: undefined,
   dbType: postgresDatatypes.uuid(),
@@ -11095,87 +11398,1967 @@ var quoteIdentifier4 = (value) => `"${value.replaceAll('"', '""')}"`;
 var renderIdentifier2 = (value) => safeUnquotedIdentifier2.test(value) ? value : quoteIdentifier4(value);
 var renderQualifiedSequenceName = (value) => value.schemaName === undefined || value.schemaName === "public" ? renderIdentifier2(value.name) : `${renderIdentifier2(value.schemaName)}.${renderIdentifier2(value.name)}`;
 var nextVal2 = (value) => nextVal(isSequenceDefinition(value) ? cast(literal(renderQualifiedSequenceName(value)), type.regclass()) : value);
-// src/postgres/json-extension.ts
-var exports_json_extension = {};
-__export(exports_json_extension, {
-  stripNulls: () => stripNulls2,
-  pathMatch: () => pathMatch2
+// src/postgres/function/string.ts
+var exports_string = {};
+__export(exports_string, {
+  upper: () => upper,
+  lower: () => lower,
+  concat: () => concat
+});
+// src/postgres/function/aggregate.ts
+var exports_aggregate = {};
+__export(exports_aggregate, {
+  sum: () => sum,
+  min: () => min,
+  max: () => max,
+  count: () => count,
+  avg: () => avg
 });
 
-// src/postgres/json.ts
-var emptyPath = path();
-var isObjectLike2 = (value) => (typeof value === "object" || typeof value === "function") && value !== null;
-var isExpression5 = (value) => isObjectLike2(value) && (TypeId2 in value);
-var isPath = (value) => isObjectLike2(value) && (TypeId4 in value);
-var isSegment = (value) => isObjectLike2(value) && (SegmentTypeId in value);
-var isTarget = (value) => isPath(value) || isSegment(value);
-var normalizeSegment2 = (segment) => {
-  switch (segment.kind) {
-    case "key":
-      return key(segment.key);
-    case "index":
-      return index(segment.index);
-    case "wildcard":
-      return wildcard();
-    case "slice":
-      return slice(segment.start, segment.end);
-    case "descend":
-      return descend();
+// 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 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[TypeId2].kind,
+      dependencies: expression[TypeId2].dependencies
+    }, {
+      kind: "round",
+      value: expression
+    });
+  }
+  if (!Number.isSafeInteger(scale)) {
+    throw new Error("round scale must be a safe integer");
   }
+  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[TypeId2].kind,
+    dependencies: expression[TypeId2].dependencies
+  }, {
+    kind: "function",
+    name: "round",
+    args: [expression, scaleExpression]
+  });
 };
-var normalizeTarget = (target) => isPath(target) ? path(...target.segments.map(normalizeSegment2)) : normalizeSegment2(target);
-var accessKinds2 = new Set([
-  "jsonGet",
-  "jsonPath",
-  "jsonAccess",
-  "jsonTraverse",
-  "jsonGetText",
-  "jsonPathText",
-  "jsonAccessText",
-  "jsonTraverseText"
-]);
-var accessPathOf2 = (value) => {
-  const segments = [];
-  let base = value;
-  while (isExpression5(base)) {
-    const ast = base[TypeId3];
-    if (typeof ast.kind !== "string" || !accessKinds2.has(ast.kind) || !isExpression5(ast.base) || !Array.isArray(ast.segments)) {
-      break;
-    }
-    segments.unshift(...ast.segments.map(normalizeSegment2));
-    base = ast.base;
+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[TypeId2].dependencies
+  }, {
+    kind,
+    value: expression
+  });
+};
+var inputNullability = (value) => typeof value === "number" ? "never" : value[TypeId2].nullability;
+var binaryInputNullability = (left, right) => {
+  const leftNullability = inputNullability(left);
+  const rightNullability = inputNullability(right);
+  if (leftNullability === "always" || rightNullability === "always") {
+    return "always";
   }
-  return segments.length === 0 ? undefined : {
-    base,
-    path: path(...segments)
+  return leftNullability === "maybe" || rightNullability === "maybe" ? "maybe" : "never";
+};
+var nullableForZeroDivisor = (left, right) => {
+  const merged = binaryInputNullability(left, right);
+  if (merged === "always") {
+    return "always";
+  }
+  if (typeof right === "number") {
+    return right === 0 ? "always" : merged;
+  }
+  return "maybe";
+};
+
+// src/postgres/function/aggregate.ts
+var baseDb = (db) => ("base" in db) ? baseDb(db.base) : db;
+var category = (value) => {
+  if (typeof value === "number")
+    return "float8";
+  const db = baseDb(value[TypeId2].dbType);
+  if (db.dialect === "standard") {
+    if (db.kind === "int" || db.kind === "integer")
+      return "int4";
+    if (db.kind === "bigint")
+      return "int8";
+    if (db.kind === "numeric" || db.kind === "decimal")
+      return "numeric";
+    return "float4";
+  }
+  return db.kind;
+};
+var sumResultDb = (value) => {
+  const valueCategory = category(value);
+  if (valueCategory === "int2" || valueCategory === "int4") {
+    return postgresDatatypes.int8();
+  }
+  if (valueCategory === "int8" || valueCategory === "numeric") {
+    return postgresDatatypes.numeric();
+  }
+  return valueCategory === "float4" ? postgresDatatypes.float4() : postgresDatatypes.float8();
+};
+var avgResultDb = (value) => {
+  const valueCategory = category(value);
+  return valueCategory === "float4" || valueCategory === "float8" ? postgresDatatypes.float8() : postgresDatatypes.numeric();
+};
+var sum = (value) => aggregate("sum", value, {
+  dialect: "postgres",
+  literalDb: postgresDatatypes.float8(),
+  resultDb: sumResultDb(value)
+});
+var avg = (value) => aggregate("avg", value, {
+  dialect: "postgres",
+  literalDb: postgresDatatypes.float8(),
+  resultDb: avgResultDb(value)
+});
+// src/postgres/function/numeric.ts
+var exports_numeric = {};
+__export(exports_numeric, {
+  round: () => round2,
+  modulo: () => modulo2
+});
+var baseDb2 = (db) => ("base" in db) ? baseDb2(db.base) : db;
+var moduloCategory = (value) => {
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value) || value < -2147483648 || value > 2147483647) {
+      throw new Error("postgres modulo number literals must fit a signed int4");
+    }
+    return "int4";
+  }
+  const db = baseDb2(value[TypeId2].dbType);
+  if (db.dialect === "standard") {
+    if (db.kind === "bigint")
+      return "int8";
+    if (db.kind === "numeric" || db.kind === "decimal")
+      return "numeric";
+    return "int4";
+  }
+  return db.kind;
+};
+var moduloResultDb = (left, right) => {
+  const categories = [moduloCategory(left), moduloCategory(right)];
+  if (categories.includes("numeric"))
+    return postgresDatatypes.numeric();
+  if (categories.includes("int8"))
+    return postgresDatatypes.int8();
+  if (categories.includes("int4"))
+    return postgresDatatypes.int4();
+  return postgresDatatypes.int2();
+};
+var roundCategory = (value) => {
+  if (typeof value === "number")
+    return "approximate";
+  const db = baseDb2(value[TypeId2].dbType);
+  if (db.kind === "numeric" || db.kind === "decimal")
+    return "exact";
+  if (db.kind === "int" || db.kind === "integer" || db.kind === "bigint" || db.kind === "int2" || db.kind === "int4" || db.kind === "int8") {
+    return "integer";
+  }
+  return "approximate";
+};
+var modulo2 = (left, right) => modulo(left, right, {
+  dialect: "postgres",
+  literalDb: postgresDatatypes.int4(),
+  resultDb: moduloResultDb(left, right),
+  nullability: binaryInputNullability(left, right)
+});
+var roundRuntime = (value, scale) => {
+  const category2 = roundCategory(value);
+  if (scale !== undefined && category2 === "approximate") {
+    throw new Error("postgres round with a scale requires a numeric or integer input");
+  }
+  const resultDb = scale !== undefined || category2 === "exact" ? postgresDatatypes.numeric() : postgresDatatypes.float8();
+  return round(value, scale, {
+    dialect: "postgres",
+    literalDb: postgresDatatypes.float8(),
+    scaleDb: postgresDatatypes.int4(),
+    resultDb,
+    nullability: typeof value === "number" ? "never" : value[TypeId2].nullability
+  });
+};
+var round2 = roundRuntime;
+// src/postgres/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 pipeArguments9 } from "effect/Pipeable";
+import * as Schema10 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 {
+    dialect: "standard",
+    kind,
+    family: kindSpec.family,
+    runtime: kindSpec.runtime,
+    compareGroup: familySpec?.compareGroup,
+    castTargets: familySpec?.castTargets,
+    implicitTargets: familySpec.implicitTargets,
+    traits: familySpec?.traits
   };
 };
-var jsonGetDirect = (base, target) => json.get(base, normalizeTarget(target));
-var jsonTextDirect = (base, target) => json.text(base, normalizeTarget(target));
-var jsonbGetDirect = (base, target) => jsonb2.get(base, normalizeTarget(target));
-var jsonbTextDirect = (base, target) => jsonb2.text(base, normalizeTarget(target));
-var jsonbSegmentOperation = (segment) => Object.assign((base) => jsonbGetDirect(base, segment), segment);
-var json2 = {
-  get: (...args) => {
-    if (args.length === 1) {
-      const [first] = args;
-      if (isTarget(first)) {
-        return (base) => jsonGetDirect(base, first);
-      }
-      return first;
-    }
-    return jsonGetDirect(args[0], args[1]);
-  },
-  access: (base, target) => json.access(base, normalizeTarget(target)),
-  traverse: (base, target) => json.traverse(base, normalizeTarget(target)),
-  text: (...args) => {
-    if (args.length === 1) {
-      const [first] = args;
-      if (isTarget(first)) {
-        return (base) => jsonTextDirect(base, first);
-      }
-      const access = isExpression5(first) ? accessPathOf2(first) : undefined;
-      return access === undefined ? json.text(first, emptyPath) : jsonTextDirect(access.base, access.path);
+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 pipeArguments9(this, arguments);
+  }
+};
+var literalSchemaOf2 = (value) => {
+  if (value === null || value instanceof Date) {
+    return;
+  }
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    return;
+  }
+  return Schema10.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 = (name2, dbType, nullable2 = false) => makeExpression2({
+  runtime: undefined,
+  dbType,
+  nullability: nullable2 ? "maybe" : "never",
+  dialect: profile2.dialect,
+  kind: "scalar",
+  dependencies: {}
+}, {
+  kind: "column",
+  tableName: "",
+  columnName: name2
+});
+var toDialectExpression2 = (value) => {
+  if (value !== null && typeof value === "object" && TypeId2 in value) {
+    return value;
+  }
+  return literal3(value);
+};
+var retargetLiteralExpression2 = (value, target) => {
+  const ast = value[TypeId3];
+  if (ast.kind !== "literal") {
+    return value;
+  }
+  const targetState = target[TypeId2];
+  return makeExpression2({
+    runtime: value[TypeId2].runtime,
+    dbType: targetState.dbType,
+    runtimeSchema: targetState.runtimeSchema,
+    driverValueMapping: targetState.driverValueMapping,
+    nullability: value[TypeId2].nullability,
+    dialect: targetState.dialect,
+    kind: "scalar",
+    dependencies: {}
+  }, ast);
+};
+var alignBinaryPredicateExpressions2 = (left, right) => {
+  const leftAst = left[TypeId3];
+  const rightAst = right[TypeId3];
+  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[TypeId3];
+    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[TypeId2].dialect !== undefined)?.[TypeId2].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 pipeArguments9(this, arguments);
+      }
+      const valuesForMixedPipe = (value) => {
+        if (typeof value !== "object" || value === null || !(TypeId2 in value)) {
+          return [];
+        }
+        const expression2 = value;
+        const ast = expression2[TypeId3];
+        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[TypeId2].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[TypeId2].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[TypeId2].dialect ?? rightExpression[TypeId2].dialect,
+    kind: "scalar",
+    dependencies: mergeDependencies(leftExpression[TypeId2].dependencies, rightExpression[TypeId2].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[TypeId2].dialect !== undefined)?.[TypeId2].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[TypeId2].dialect,
+    kind: "scalar",
+    dependencies: expression[TypeId2].dependencies
+  }, {
+    kind: "isNull",
+    value: expression
+  });
+};
+var isNotNull = (value) => {
+  const expression = toDialectExpression2(value);
+  return makeExpression2({
+    runtime: true,
+    dbType: profile2.boolDb,
+    nullability: "never",
+    dialect: expression[TypeId2].dialect,
+    kind: "scalar",
+    dependencies: expression[TypeId2].dependencies
+  }, {
+    kind: "isNotNull",
+    value: expression
+  });
+};
+var collate = (value, collation) => {
+  const expression = toDialectStringExpression2(value);
+  const normalizedCollation = typeof collation === "string" ? [collation] : collation;
+  return makeExpression2({
+    runtime: expression[TypeId2].runtime,
+    dbType: expression[TypeId2].dbType,
+    nullability: expression[TypeId2].nullability,
+    dialect: expression[TypeId2].dialect,
+    kind: expression[TypeId2].kind,
+    dependencies: expression[TypeId2].dependencies
+  }, {
+    kind: "collate",
+    value: expression,
+    collation: normalizedCollation
+  });
+};
+var cast2 = (value, target) => {
+  const expression = toDialectExpression2(value);
+  return makeExpression2({
+    runtime: undefined,
+    dbType: target,
+    runtimeSchema: undefined,
+    driverValueMapping: target.driverValueMapping,
+    nullability: expression[TypeId2].nullability,
+    dialect: expression[TypeId2].dialect,
+    kind: expression[TypeId2].kind,
+    dependencies: expression[TypeId2].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" && (TypeId2 in value);
+var isJsonExpressionValue2 = (value) => isExpressionValue2(value) && (() => {
+  const dbType = value[TypeId2].dbType;
+  return dbType.variant === "json" || dbType.kind === "json" || dbType.kind === "jsonb";
+})();
+var isJsonPathValue3 = (value) => value !== null && typeof value === "object" && (TypeId4 in value);
+var normalizeJsonPathInput2 = (value) => isJsonPathValue3(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[TypeId2].dialect !== undefined)?.[TypeId2].dialect ?? profile2.dialect,
+  kind: mergeAggregationManyRuntime(expressions),
+  dependencies: mergeManyDependencies(expressions)
+}, ast));
+var jsonDbTypeOf2 = (base) => base[TypeId2].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[TypeId2].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 = isJsonPathValue3(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 = isJsonPathValue3(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: isJsonPathValue3(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: isJsonPathValue3(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: isJsonPathValue3(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[TypeId2].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 (isJsonPathValue3(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 (isJsonPathValue3(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 jsonb3 = {
+  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[TypeId2].nullability,
+    dialect: expression[TypeId2].dialect,
+    kind: expression[TypeId2].kind,
+    dependencies: expression[TypeId2].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[TypeId2].dialect !== undefined)?.[TypeId2].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[TypeId2].dialect,
+    kind: "aggregate",
+    dependencies: expression[TypeId2].dependencies
+  }, {
+    kind: "count",
+    value: expression
+  });
+};
+var exists = (plan) => {
+  const dependencies = Object.fromEntries(currentRequiredList(plan[TypeId].required).map((name2) => [name2, 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[TypeId].required).map((name2) => [name2, true]));
+  const expression = extractSingleSelectedExpressionRuntime(plan[TypeId].selection);
+  return makeExpression2({
+    runtime: undefined,
+    dbType: expression[TypeId2].dbType,
+    runtimeSchema: expression[TypeId2].runtimeSchema,
+    driverValueMapping: expression[TypeId2].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[TypeId].required).map((name2) => [name2, true]));
+  return makeExpression2({
+    runtime: true,
+    dbType: profile2.boolDb,
+    nullability: "maybe",
+    dialect: leftExpression[TypeId2].dialect ?? profile2.dialect,
+    kind: leftExpression[TypeId2].kind,
+    dependencies: mergeDependencies(leftExpression[TypeId2].dependencies, dependencies)
+  }, {
+    kind: "inSubquery",
+    left: leftExpression,
+    plan
+  });
+};
+var quantifiedComparison = (left, plan, operator, quantifier) => {
+  const leftExpression = toDialectExpression2(left);
+  const dependencies = Object.fromEntries(currentRequiredList(plan[TypeId].required).map((name2) => [name2, true]));
+  return makeExpression2({
+    runtime: true,
+    dbType: profile2.boolDb,
+    nullability: "maybe",
+    dialect: leftExpression[TypeId2].dialect ?? profile2.dialect,
+    kind: leftExpression[TypeId2].kind,
+    dependencies: mergeDependencies(leftExpression[TypeId2].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[TypeId2].dbType,
+    nullability: value[TypeId2].nullability,
+    dialect: expressions.find((expression) => expression[TypeId2].dialect !== undefined)?.[TypeId2].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[TypeId2].dialect !== undefined)?.[TypeId2].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[TypeId2].dbType,
+  nullability: "maybe",
+  dialect: value[TypeId2].dialect,
+  kind: "aggregate",
+  dependencies: value[TypeId2].dependencies
+}, {
+  kind: "max",
+  value
+});
+var min2 = (value) => makeExpression2({
+  runtime: undefined,
+  dbType: value[TypeId2].dbType,
+  nullability: "maybe",
+  dialect: value[TypeId2].dialect,
+  kind: "aggregate",
+  dependencies: value[TypeId2].dependencies
+}, {
+  kind: "min",
+  value
+});
+var resolveCoalesceNullabilityRuntime = (values2) => values2.some((value) => value[TypeId2].nullability === "never") ? "never" : values2.some((value) => value[TypeId2].nullability === "maybe") ? "maybe" : "always";
+var coalesce = (...values2) => {
+  const expressions = values2.map((value) => toDialectExpression2(value));
+  const representative = expressions.find((value) => value[TypeId2].nullability !== "always") ?? expressions[0];
+  return makeExpression2({
+    runtime: undefined,
+    dbType: representative[TypeId2].dbType,
+    nullability: resolveCoalesceNullabilityRuntime(expressions),
+    dialect: expressions.find((value) => value[TypeId2].dialect !== undefined)?.[TypeId2].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[TypeId2].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[TypeId2].nullability !== "always") ?? fallback;
+  return makeExpression2({
+    runtime: undefined,
+    dbType: representative[TypeId2].dbType,
+    nullability: resolveCaseNullabilityRuntime(resultExpressions),
+    dialect: allExpressions.find((value) => value[TypeId2].dialect !== undefined)?.[TypeId2].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[TypeId3];
+  return makeExpression2({
+    runtime: undefined,
+    dbType: value[TypeId2].dbType,
+    runtimeSchema: value[TypeId2].runtimeSchema,
+    driverValueMapping: value[TypeId2].driverValueMapping,
+    nullability: value[TypeId2].nullability,
+    dialect: profile2.dialect,
+    kind: "scalar",
+    dependencies: {}
+  }, {
+    kind: "excluded",
+    columnName: ast.columnName
+  });
+};
+var toMutationValueExpression2 = (value, column2) => {
+  const columnState = column2[TypeId2];
+  const normalizeMutationValue = (candidate) => {
+    if (candidate === null && columnState.nullability !== "never") {
+      return null;
+    }
+    const runtimeSchemaAccepts = columnState.runtimeSchema !== undefined && Schema10.is(columnState.runtimeSchema)(candidate);
+    if (runtimeSchemaAccepts) {
+      return candidate;
+    }
+    const normalized = normalizeDbValue(columnState.dbType, candidate);
+    return columnState.runtimeSchema === undefined ? normalized : Schema10.decodeUnknownSync(columnState.runtimeSchema)(normalized);
+  };
+  if (value !== null && typeof value === "object" && TypeId2 in value) {
+    const expression = value;
+    const ast = expression[TypeId3];
+    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[TypeId2];
+    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[TypeId2].dependencies)));
+  return {
+    columns,
+    rows: normalizedRows,
+    required: required.filter((name2, index5, list) => list.indexOf(name2) === index5)
+  };
+};
+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, unique4) => `${tableName}_${columns.join("_")}_${unique4 ? "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 || TypeId2 in value) {
+    const expression = toDialectExpression2(value);
+    const projected = Object.create(Object.getPrototypeOf(expression));
+    const runtimeExpression = expression;
+    projected[TypeId2] = runtimeExpression[TypeId2];
+    projected[TypeId3] = runtimeExpression[TypeId3];
+    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[TypeId2].dbType,
+    runtimeSchema: value[TypeId2].runtimeSchema,
+    driverValueMapping: value[TypeId2].driverValueMapping,
+    nullability,
+    dialect: expressions.find((entry) => entry[TypeId2].dialect !== "standard")?.[TypeId2].dialect ?? fallbackDialect ?? value[TypeId2].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[TypeId2].nullability);
+};
+var lastValue = (value, spec) => {
+  rejectExplicitPortableFrame("lastValue", spec);
+  return windowExpression("lastValue", value, spec, value[TypeId2].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/postgres/function/window.ts
+var firstValue2 = makeDialectFirstValue("postgres");
+var lastValue2 = makeDialectLastValue("postgres");
+// src/postgres/function/temporal.ts
+var exports_temporal = {};
+__export(exports_temporal, {
+  now: () => now,
+  localTimestamp: () => localTimestamp,
+  localTime: () => localTime,
+  currentTimestamp: () => currentTimestamp,
+  currentTime: () => currentTime,
+  currentDate: () => currentDate
+});
+var makeTemporal = (name2, dbType, runtimeSchema) => makeExpression2({
+  runtime: undefined,
+  dbType,
+  runtimeSchema,
+  nullability: "never",
+  dialect: "postgres",
+  kind: "scalar",
+  dependencies: {}
+}, {
+  kind: "function",
+  name: name2,
+  args: []
+});
+var now = () => makeTemporal("now", postgresDatatypes.timestamptz(), InstantStringSchema);
+var currentDate = () => makeTemporal("current_date", postgresDatatypes.date(), LocalDateStringSchema);
+var currentTime = () => makeTemporal("current_time", postgresDatatypes.timetz(), OffsetTimeStringSchema);
+var currentTimestamp = () => makeTemporal("current_timestamp", postgresDatatypes.timestamptz(), InstantStringSchema);
+var localTime = () => makeTemporal("localtime", postgresDatatypes.time(), LocalTimeStringSchema);
+var localTimestamp = () => makeTemporal("localtimestamp", postgresDatatypes.timestamp(), LocalDateTimeStringSchema);
+// src/postgres/json-extension.ts
+var exports_json_extension = {};
+__export(exports_json_extension, {
+  stripNulls: () => stripNulls2,
+  pathMatch: () => pathMatch2
+});
+
+// src/postgres/json.ts
+var emptyPath = path();
+var isObjectLike2 = (value) => (typeof value === "object" || typeof value === "function") && value !== null;
+var isExpression5 = (value) => isObjectLike2(value) && (TypeId2 in value);
+var isPath = (value) => isObjectLike2(value) && (TypeId4 in value);
+var isSegment = (value) => isObjectLike2(value) && (SegmentTypeId in value);
+var isTarget = (value) => isPath(value) || isSegment(value);
+var normalizeSegment2 = (segment) => {
+  switch (segment.kind) {
+    case "key":
+      return key(segment.key);
+    case "index":
+      return index(segment.index);
+    case "wildcard":
+      return wildcard();
+    case "slice":
+      return slice(segment.start, segment.end);
+    case "descend":
+      return descend();
+  }
+};
+var normalizeTarget = (target) => isPath(target) ? path(...target.segments.map(normalizeSegment2)) : normalizeSegment2(target);
+var accessKinds2 = new Set([
+  "jsonGet",
+  "jsonPath",
+  "jsonAccess",
+  "jsonTraverse",
+  "jsonGetText",
+  "jsonPathText",
+  "jsonAccessText",
+  "jsonTraverseText"
+]);
+var accessPathOf2 = (value) => {
+  const segments = [];
+  let base = value;
+  while (isExpression5(base)) {
+    const ast = base[TypeId3];
+    if (typeof ast.kind !== "string" || !accessKinds2.has(ast.kind) || !isExpression5(ast.base) || !Array.isArray(ast.segments)) {
+      break;
+    }
+    segments.unshift(...ast.segments.map(normalizeSegment2));
+    base = ast.base;
+  }
+  return segments.length === 0 ? undefined : {
+    base,
+    path: path(...segments)
+  };
+};
+var jsonGetDirect = (base, target) => json.get(base, normalizeTarget(target));
+var jsonTextDirect = (base, target) => json.text(base, normalizeTarget(target));
+var jsonbGetDirect = (base, target) => jsonb2.get(base, normalizeTarget(target));
+var jsonbTextDirect = (base, target) => jsonb2.text(base, normalizeTarget(target));
+var jsonbSegmentOperation = (segment) => Object.assign((base) => jsonbGetDirect(base, segment), segment);
+var json3 = {
+  get: (...args) => {
+    if (args.length === 1) {
+      const [first] = args;
+      if (isTarget(first)) {
+        return (base) => jsonGetDirect(base, first);
+      }
+      return first;
+    }
+    return jsonGetDirect(args[0], args[1]);
+  },
+  access: (base, target) => json.access(base, normalizeTarget(target)),
+  traverse: (base, target) => json.traverse(base, normalizeTarget(target)),
+  text: (...args) => {
+    if (args.length === 1) {
+      const [first] = args;
+      if (isTarget(first)) {
+        return (base) => jsonTextDirect(base, first);
+      }
+      const access = isExpression5(first) ? accessPathOf2(first) : undefined;
+      return access === undefined ? json.text(first, emptyPath) : jsonTextDirect(access.base, access.path);
     }
     return jsonTextDirect(args[0], args[1]);
   },
@@ -11192,7 +13375,7 @@ var json2 = {
   delete: (base, target) => json.delete(base, normalizeTarget(target)),
   remove: (base, target) => json.remove(base, normalizeTarget(target))
 };
-var jsonb3 = {
+var jsonb4 = {
   key: (value) => jsonbSegmentOperation(key(value)),
   index: (value) => jsonbSegmentOperation(index(value)),
   wildcard: () => jsonbSegmentOperation(wildcard()),
@@ -11342,26 +13525,26 @@ var jsonb3 = {
   },
   pathMatch: (base, query) => jsonb2.pathMatch(base, query)
 };
-var get = json2.get;
-var access = json2.access;
-var traverse = json2.traverse;
-var text = json2.text;
-var accessText = json2.accessText;
-var traverseText = json2.traverseText;
-var buildObject = json2.buildObject;
-var buildArray = json2.buildArray;
-var toJson = json2.toJson;
-var typeOf = json2.typeOf;
-var length = json2.length;
-var keys = json2.keys;
-var stripNulls = json2.stripNulls;
-var pathMatch = json2.pathMatch;
-var delete_ = json2.delete;
-var remove = json2.remove;
+var get = json3.get;
+var access = json3.access;
+var traverse = json3.traverse;
+var text = json3.text;
+var accessText = json3.accessText;
+var traverseText = json3.traverseText;
+var buildObject = json3.buildObject;
+var buildArray = json3.buildArray;
+var toJson = json3.toJson;
+var typeOf = json3.typeOf;
+var length = json3.length;
+var keys = json3.keys;
+var stripNulls = json3.stripNulls;
+var pathMatch = json3.pathMatch;
+var delete_2 = json3.delete;
+var remove = json3.remove;
 
 // src/postgres/json-extension.ts
-var stripNulls2 = json2.stripNulls;
-var pathMatch2 = json2.pathMatch;
+var stripNulls2 = json3.stripNulls;
+var pathMatch2 = json3.pathMatch;
 // src/postgres/jsonb.ts
 var exports_jsonb = {};
 __export(exports_jsonb, {
@@ -11377,68 +13560,71 @@ __export(exports_jsonb, {
   remove: () => remove2,
   pathMatch: () => pathMatch3,
   pathExists: () => pathExists,
-  merge: () => merge2,
+  merge: () => merge3,
   length: () => length2,
   keys: () => keys2,
   keyExists: () => keyExists,
   key: () => key2,
-  jsonb: () => jsonb3,
-  insert: () => insert,
+  jsonb: () => jsonb4,
+  insert: () => insert2,
   index: () => index5,
   hasKey: () => hasKey,
   hasAnyKeys: () => hasAnyKeys,
   hasAllKeys: () => hasAllKeys,
   get: () => get2,
   descend: () => descend2,
-  delete_: () => delete_2,
-  delete: () => delete_2,
-  contains: () => contains,
-  containedBy: () => containedBy,
-  concat: () => concat,
+  delete_: () => delete_3,
+  delete: () => delete_3,
+  contains: () => contains2,
+  containedBy: () => containedBy2,
+  concat: () => concat3,
   buildObject: () => buildObject2,
   buildArray: () => buildArray2,
   accessText: () => accessText2,
   access: () => access2
 });
-var key2 = jsonb3.key;
-var index5 = jsonb3.index;
-var wildcard2 = jsonb3.wildcard;
-var slice2 = jsonb3.slice;
-var descend2 = jsonb3.descend;
-var get2 = jsonb3.get;
-var access2 = jsonb3.access;
-var traverse2 = jsonb3.traverse;
-var text2 = jsonb3.text;
-var accessText2 = jsonb3.accessText;
-var traverseText2 = jsonb3.traverseText;
-var contains = jsonb3.contains;
-var containedBy = jsonb3.containedBy;
-var hasKey = jsonb3.hasKey;
-var keyExists = jsonb3.keyExists;
-var hasAnyKeys = jsonb3.hasAnyKeys;
-var hasAllKeys = jsonb3.hasAllKeys;
-var delete_2 = jsonb3.delete;
-var remove2 = jsonb3.remove;
-var set2 = jsonb3.set;
-var insert = jsonb3.insert;
-var concat = jsonb3.concat;
-var merge2 = jsonb3.merge;
-var buildObject2 = jsonb3.buildObject;
-var buildArray2 = jsonb3.buildArray;
-var toJsonb = jsonb3.toJsonb;
-var typeOf2 = jsonb3.typeOf;
-var length2 = jsonb3.length;
-var keys2 = jsonb3.keys;
-var stripNulls3 = jsonb3.stripNulls;
-var pathExists = jsonb3.pathExists;
-var pathMatch3 = jsonb3.pathMatch;
+var key2 = jsonb4.key;
+var index5 = jsonb4.index;
+var wildcard2 = jsonb4.wildcard;
+var slice2 = jsonb4.slice;
+var descend2 = jsonb4.descend;
+var get2 = jsonb4.get;
+var access2 = jsonb4.access;
+var traverse2 = jsonb4.traverse;
+var text2 = jsonb4.text;
+var accessText2 = jsonb4.accessText;
+var traverseText2 = jsonb4.traverseText;
+var contains2 = jsonb4.contains;
+var containedBy2 = jsonb4.containedBy;
+var hasKey = jsonb4.hasKey;
+var keyExists = jsonb4.keyExists;
+var hasAnyKeys = jsonb4.hasAnyKeys;
+var hasAllKeys = jsonb4.hasAllKeys;
+var delete_3 = jsonb4.delete;
+var remove2 = jsonb4.remove;
+var set2 = jsonb4.set;
+var insert2 = jsonb4.insert;
+var concat3 = jsonb4.concat;
+var merge3 = jsonb4.merge;
+var buildObject2 = jsonb4.buildObject;
+var buildArray2 = jsonb4.buildArray;
+var toJsonb = jsonb4.toJsonb;
+var typeOf2 = jsonb4.typeOf;
+var length2 = jsonb4.length;
+var keys2 = jsonb4.keys;
+var stripNulls3 = jsonb4.stripNulls;
+var pathExists = jsonb4.pathExists;
+var pathMatch3 = jsonb4.pathMatch;
 // src/postgres/executor.ts
 var exports_executor2 = {};
 __export(exports_executor2, {
   withTransaction: () => withTransaction2,
+  nonEmpty: () => nonEmpty2,
   make: () => make4,
+  exactlyOne: () => exactlyOne2,
   driver: () => driver2,
-  custom: () => custom3
+  custom: () => custom4,
+  atMostOne: () => atMostOne2
 });
 import * as Effect2 from "effect/Effect";
 import * as SqlClient3 from "effect/unstable/sql/SqlClient";
@@ -11448,40 +13634,45 @@ import * as Stream2 from "effect/Stream";
 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
+  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 Schema11 from "effect/Schema";
+import * as Schema12 from "effect/Schema";
 import * as SqlClient from "effect/unstable/sql/SqlClient";
 import * as Stream from "effect/Stream";
 
 // src/internal/runtime/schema.ts
-import * as Schema10 from "effect/Schema";
+import * as Schema11 from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
 var schemaCache = new WeakMap;
-var FiniteNumberSchema = Schema10.Number.check(Schema10.isFinite());
+var FiniteNumberSchema = Schema11.Number.check(Schema11.isFinite());
 var runtimeSchemaForTag = (tag) => {
   switch (tag) {
     case "string":
-      return Schema10.String;
+      return Schema11.String;
     case "number":
       return FiniteNumberSchema;
     case "bigintString":
       return BigIntStringSchema;
     case "boolean":
-      return Schema10.Boolean;
+      return Schema11.Boolean;
     case "json":
       return JsonValueSchema;
     case "localDate":
@@ -11499,13 +13690,13 @@ var runtimeSchemaForTag = (tag) => {
     case "decimalString":
       return DecimalStringSchema;
     case "bytes":
-      return Schema10.Uint8Array;
+      return Schema11.Uint8Array;
     case "array":
-      return Schema10.Array(Schema10.Unknown);
+      return Schema11.Array(Schema11.Unknown);
     case "record":
-      return Schema10.Record(Schema10.String, Schema10.Unknown);
+      return Schema11.Record(Schema11.String, Schema11.Unknown);
     case "null":
-      return Schema10.Null;
+      return Schema11.Null;
     case "unknown":
       return;
   }
@@ -11518,22 +13709,22 @@ var runtimeSchemaForDbType = (dbType) => {
     return runtimeSchemaForDbType(dbType.base);
   }
   if ("element" in dbType) {
-    return Schema10.Array(runtimeSchemaForDbType(dbType.element) ?? Schema10.Unknown);
+    return Schema11.Array(runtimeSchemaForDbType(dbType.element) ?? Schema11.Unknown);
   }
   if ("fields" in dbType) {
-    const fields2 = Object.fromEntries(Object.entries(dbType.fields).map(([key3, field]) => [key3, runtimeSchemaForDbType(field) ?? Schema10.Unknown]));
-    return Schema10.Struct(fields2);
+    const fields2 = Object.fromEntries(Object.entries(dbType.fields).map(([key3, field]) => [key3, runtimeSchemaForDbType(field) ?? Schema11.Unknown]));
+    return Schema11.Struct(fields2);
   }
   if ("variant" in dbType && dbType.variant === "json") {
     return JsonValueSchema;
   }
   if ("variant" in dbType && (dbType.variant === "enum" || dbType.variant === "set")) {
-    return Schema10.String;
+    return Schema11.String;
   }
   const runtimeTag = runtimeTagOfBaseDbType2(dbType);
   return runtimeTag === undefined ? undefined : runtimeSchemaForTag(runtimeTag);
 };
-var makeSchemaFromAst = (ast) => Schema10.make(ast);
+var makeSchemaFromAst = (ast) => Schema11.make(ast);
 var unionAst = (asts) => {
   if (asts.length === 0) {
     return;
@@ -11556,11 +13747,11 @@ var propertyAstOf = (ast, key3) => {
       return index6?.type;
     }
     case "Union": {
-      const values2 = ast.types.flatMap((member) => {
+      const values3 = ast.types.flatMap((member) => {
         const next = propertyAstOf(member, key3);
         return next === undefined ? [] : [next];
       });
-      return unionAst(values2);
+      return unionAst(values3);
     }
     default:
       return;
@@ -11581,11 +13772,11 @@ var numberAstOf = (ast, index6) => {
       return unionAst(ast.rest);
     }
     case "Union": {
-      const values2 = ast.types.flatMap((member) => {
+      const values3 = ast.types.flatMap((member) => {
         const next = numberAstOf(member, index6);
         return next === undefined ? [] : [next];
       });
-      return unionAst(values2);
+      return unionAst(values3);
     }
     default:
       return;
@@ -11623,7 +13814,7 @@ var unionSchemas = (schemas) => {
   if (resolved.length === 1) {
     return resolved[0];
   }
-  return Schema10.Union(resolved);
+  return Schema11.Union(resolved);
 };
 var firstSelectedExpression = (plan) => {
   const selection = getAst(plan).select;
@@ -11658,9 +13849,9 @@ var jsonCompatibleSchema = (schema2) => {
 };
 var buildStructSchema = (entries, context) => {
   const fields2 = Object.fromEntries(entries.map((entry) => [entry.key, expressionRuntimeSchema(entry.value, context) ?? JsonValueSchema]));
-  return Schema10.Struct(fields2);
+  return Schema11.Struct(fields2);
 };
-var buildTupleSchema = (values2, context) => Schema10.Tuple(values2.map((value) => expressionRuntimeSchema(value, context) ?? JsonValueSchema));
+var buildTupleSchema = (values3, context) => Schema11.Tuple(values3.map((value) => expressionRuntimeSchema(value, context) ?? JsonValueSchema));
 var deriveCaseSchema = (ast, context) => {
   if (context === undefined) {
     return unionSchemas([
@@ -11700,10 +13891,10 @@ var deriveRuntimeSchema = (expression, context) => {
       return state.runtimeSchema;
     case "literal":
       if (ast.value === null) {
-        return Schema10.Null;
+        return Schema11.Null;
       }
       if (typeof ast.value === "string" || typeof ast.value === "number" || typeof ast.value === "boolean") {
-        return Schema10.Literal(ast.value);
+        return Schema11.Literal(ast.value);
       }
       return runtimeSchemaForDbType(state.dbType);
     case "cast":
@@ -11739,7 +13930,7 @@ var deriveRuntimeSchema = (expression, context) => {
     case "jsonHasAllKeys":
     case "jsonPathExists":
     case "jsonPathMatch":
-      return Schema10.Boolean;
+      return Schema11.Boolean;
     case "upper":
     case "lower":
     case "concat":
@@ -11748,8 +13939,9 @@ var deriveRuntimeSchema = (expression, context) => {
     case "jsonAccessText":
     case "jsonTraverseText":
     case "jsonTypeOf":
-      return Schema10.String;
+      return Schema11.String;
     case "count":
+      return runtimeSchemaForDbType(state.dbType);
     case "jsonLength":
       return FiniteNumberSchema;
     case "max":
@@ -11764,7 +13956,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":
@@ -11796,7 +13988,7 @@ var deriveRuntimeSchema = (expression, context) => {
     case "jsonToJsonb":
       return jsonCompatibleSchema(expressionRuntimeSchema(ast.value, context));
     case "jsonKeys":
-      return Schema10.Array(Schema10.String);
+      return Schema11.Array(Schema11.String);
   }
 };
 var expressionRuntimeSchema = (expression, context) => {
@@ -11812,7 +14004,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 index6 = 0;index6 < path2.length - 1; index6++) {
@@ -11852,7 +14123,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;
@@ -11867,7 +14138,7 @@ var remapRows = (query, rows) => rows.map((row) => {
   return decoded;
 });
 var makeRowDecodeError = (rendered, projection, expression, raw, stage, cause, normalized) => {
-  const schemaError = Schema11.isSchemaError(cause) ? {
+  const schemaError = Schema12.isSchemaError(cause) ? {
     message: cause.message,
     issue: cause.issue
   } : undefined;
@@ -11921,7 +14192,7 @@ var dbTypeAllowsTopLevelJsonNull = (dbType) => {
   }
   return "variant" in dbType && dbType.variant === "json" || dbType.runtime === "json";
 };
-var schemaAcceptsNull = (schema2) => schema2 !== undefined && Schema11.is(schema2)(null);
+var schemaAcceptsNull = (schema2) => schema2 !== undefined && Schema12.is(schema2)(null);
 var decodeProjectionValue = (rendered, projection, expression, raw, scope, driverMode, valueMappings) => {
   let normalized = raw;
   if (driverMode === "raw") {
@@ -11957,10 +14228,10 @@ var decodeProjectionValue = (rendered, projection, expression, raw, scope, drive
   if (schema2 === undefined) {
     return normalized;
   }
-  if (Schema11.is(schema2)(normalized)) {
+  if (Schema12.is(schema2)(normalized)) {
     return normalized;
   }
-  const decoded = Schema11.decodeUnknownExit(schema2)(normalized);
+  const decoded = Schema12.decodeUnknownExit(schema2)(normalized);
   if (Exit.isSuccess(decoded)) {
     return decoded.value;
   }
@@ -11999,7 +14270,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);
@@ -12019,23 +14290,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)
@@ -12046,56 +14375,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/postgres/internal/renderer.ts
 var renderPostgresPlan = (plan, options2 = {}) => {
   const state = {
@@ -12117,42 +14396,74 @@ var renderPostgresPlan = (plan, options2 = {}) => {
 };
 
 // src/postgres/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("postgres", executeOrHandlers) : driver("postgres", executeOrHandlers);
 }
-var fromDriver2 = (renderer, sqlDriver, driverMode = "raw", valueMappings) => ({
-  dialect: "postgres",
-  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 = normalizePostgresDriverError(error, rendered);
-      return hasWriteCapability(plan) ? normalized : narrowPostgresDriverErrorForReadQuery(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 = normalizePostgresDriverError(error, rendered);
-      return hasWriteCapability(plan) ? normalized : narrowPostgresDriverErrorForReadQuery(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 = normalizePostgresDriverError(error, rendered);
+    return hasWriteCapability(plan) ? normalized : narrowPostgresDriverErrorForReadQuery(normalized);
+  };
+  return withResultContracts({
+    dialect: "postgres",
+    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])),
+  executeResult: (query) => Effect2.flatMap(SqlClient3.SqlClient, (sql) => Effect2.map(sql.unsafe(query.sql, [...query.params]).raw, (raw) => {
+    const result = raw;
+    return {
+      rows: result.rows ?? [],
+      ...typeof result.rowCount === "number" ? { affectedRows: result.rowCount } : {}
+    };
+  })),
   stream: (query) => streamFromSqlClient(query)
 });
 function make4(options2 = {}) {
@@ -12161,16 +14472,16 @@ function make4(options2 = {}) {
   }
   return fromDriver2(options2.renderer ?? makeTrusted("postgres", (plan) => renderPostgresPlan(plan, { valueMappings: options2.valueMappings })), sqlClientDriver(), options2.driverMode, options2.valueMappings);
 }
-var custom3 = (execute) => make3("postgres", execute);
+var custom4 = (execute) => make3("postgres", execute);
 // src/postgres/query-extension.ts
 var exports_query_extension = {};
 __export(exports_query_extension, {
   onConflict: () => onConflict,
-  generateSeries: () => generateSeries2,
+  generateSeries: () => generateSeries3,
   distinctOn: () => distinctOn
 });
 // src/postgres/query.ts
-var generateSeries2 = generateSeries;
+var generateSeries3 = generateSeries;
 // src/postgres/type.ts
 var array4 = (element) => ({
   dialect: "postgres",
@@ -12202,15 +14513,15 @@ var enum_2 = (kind) => ({
   kind,
   variant: "enum"
 });
-var custom4 = (kind) => ({
+var custom5 = (kind) => ({
   dialect: "postgres",
   kind
 });
-var driverValueMapping3 = (dbType, mapping) => ({
+var driverValueMapping4 = (dbType, mapping) => ({
   ...dbType,
   driverValueMapping: mapping
 });
-var type2 = {
+var type3 = {
   ...pickDatatypeConstructors(postgresDatatypes, postgresSpecificDatatypeKeys),
   array: array4,
   range: range2,
@@ -12218,8 +14529,8 @@ var type2 = {
   record: record2,
   domain: domain2,
   enum: enum_2,
-  custom: custom4,
-  driverValueMapping: driverValueMapping3
+  custom: custom5,
+  driverValueMapping: driverValueMapping4
 };
 // src/postgres/schema-expression.ts
 var exports_schema_expression2 = {};
@@ -12240,7 +14551,7 @@ var exports_schema = {};
 __export(exports_schema, {
   make: () => make6
 });
-import { pipeArguments as pipeArguments9 } from "effect/Pipeable";
+import { pipeArguments as pipeArguments10 } from "effect/Pipeable";
 
 // src/standard/table.ts
 var exports_table2 = {};
@@ -12285,7 +14596,7 @@ var updateSchema3 = updateSchema2;
 // src/postgres/schema.ts
 var SchemaProto = {
   pipe() {
-    return pipeArguments9(this, arguments);
+    return pipeArguments10(this, arguments);
   }
 };
 var make6 = (schemaName, options3 = {}) => {
@@ -12299,7 +14610,7 @@ var make6 = (schemaName, options3 = {}) => {
     }
     return options3.casing === undefined ? table : withCasing(table, options3.casing);
   };
-  namespace.enum = (name2, values3) => enumType(applyCategory(options3.casing, "types", name2), values3, physicalSchemaName);
+  namespace.enum = (name2, values4) => enumType(applyCategory(options3.casing, "types", name2), values4, physicalSchemaName);
   namespace.sequence = (name2) => sequence(applyCategory(options3.casing, "sequences", name2), physicalSchemaName);
   namespace.withSchema = (table) => withSchema(table, schemaName, options3.casing);
   namespace[TypeId6] = {
@@ -12346,7 +14657,7 @@ var nullsNotDistinct = (option3) => mapOption(option3, (spec) => ({
 // src/postgres/index.ts
 var exports_postgres = {};
 __export(exports_postgres, {
-  where: () => where2,
+  where: () => where3,
   using: () => using,
   uniqueIndex: () => uniqueIndex,
   keys: () => keys3,
@@ -12385,18 +14696,18 @@ var include = (columns) => (option3) => optionFromTable({
   ...resolveOption(option3, table),
   include: selectedColumnList(columns(table))
 }));
-var where2 = (predicate) => (option3) => mapOption(option3, (spec) => ({
+var where3 = (predicate) => (option3) => mapOption(option3, (spec) => ({
   ...spec,
   predicate
 }));
-var key3 = (column2, options3) => (option3) => optionFromTable({
+var key3 = (column3, options3) => (option3) => optionFromTable({
   ...option3.option,
   columns: undefined,
   keys: []
 }, (table) => ({
   ...resolveOption(option3, table),
   columns: undefined,
-  keys: [normalizeIndexKey({ column: column2(table), ...options3 })]
+  keys: [normalizeIndexKey({ column: column3(table), ...options3 })]
 }));
 var keys3 = (keys4) => (option3) => optionFromTable({
   ...option3.option,
@@ -12441,10 +14752,10 @@ __export(exports_renderer2, {
   make: () => make7,
   TypeId: () => TypeId10
 });
-import { pipeArguments as pipeArguments10 } from "effect/Pipeable";
+import { pipeArguments as pipeArguments11 } from "effect/Pipeable";
 var RendererProto = {
   pipe() {
-    return pipeArguments10(this, arguments);
+    return pipeArguments11(this, arguments);
   }
 };
 var makeWithState = (state = {}) => {
@@ -12465,7 +14776,7 @@ export {
   sequence,
   enumType as enum,
   exports_unique as Unique,
-  type2 as Type,
+  type3 as Type,
   exports_schema_expression2 as SchemaExpression,
   exports_schema as Schema,
   exports_renderer2 as Renderer,