effect-qb 0.14.0 → 0.16.0

package/src/{internal/mysql-query.ts → mysql/internal/dsl.ts}

@@ -1,14 +1,14 @@
 import { pipeArguments } from "effect/Pipeable"
 import * as Schema from "effect/Schema"
 
-import { mysqlDatatypes } from "../mysql/datatypes/index.js"
-
-import * as Expression from "./expression.js"
-import * as Plan from "./plan.js"
-import * as Table from "./table.js"
-import type { CastTargetError, OperandCompatibilityError } from "./coercion-errors.js"
-import type { RuntimeOfDbType } from "./coercion-analysis.js"
-import type { CanCastDbType, CanCompareDbTypes, CanContainDbTypes, CanTextuallyCoerceDbType } from "./coercion-rules.js"
+import { mysqlDatatypes } from "../datatypes/index.js"
+
+import * as Expression from "../../internal/scalar.js"
+import * as Plan from "../../internal/row-set.js"
+import * as Table from "../../internal/table.js"
+import type { CastTargetError, OperandCompatibilityError } from "../../internal/coercion/errors.js"
+import type { RuntimeOfDbType } from "../../internal/coercion/analysis.js"
+import type { CanCastDbType, CanCompareDbTypes, CanContainDbTypes, CanTextuallyCoerceDbType } from "../../internal/coercion/rules.js"
 import {
   currentRequiredList,
   extractRequiredRuntime,
@@ -21,15 +21,12 @@ import {
   mergeAggregationRuntime,
   mergeDependencies,
   mergeManyDependencies,
-  mergeManySources,
   mergeNullabilityManyRuntime,
-  mergeSources,
   type AddAvailable,
   type AddAvailableMany,
   type AvailableAfterJoin,
   type AddExpressionRequired,
   type AddJoinRequired,
-  type AggregationOf,
   type AssumptionsOfPlan,
   type AvailableOfPlan,
   type CapabilitiesOfPlan,
@@ -43,6 +40,7 @@ import {
   type ExpressionInput,
   type ExtractDialect,
   type ExtractRequired,
+  type FactsOfPlan,
   type GroupByInput,
   type GroupedOfPlan,
   type GroupedKeysFromValues,
@@ -58,6 +56,8 @@ import {
   type PlanDialectOf,
   type PresenceWitnessKeysOfSource,
   type PredicateInput,
+  type PredicateStateOfPlan,
+  type KindOf,
   type QueryPlan,
   type OutputOfSelection,
   type ScalarOutputOfPlan,
@@ -80,7 +80,6 @@ import {
   type MergeCapabilities,
   type MutationTargetInput,
   type MutationValuesInput,
-  type SourceOf,
   type SourceDialectOf,
   type SourceLike,
   type SourceNameOf,
@@ -89,6 +88,7 @@ import {
   type ValuesInput,
   type AnyValuesSource,
   type AnyUnnestSource,
+  type AnyTableFunctionSource,
   type UnnestSource,
   type TableFunctionSource,
   type StringExpressionInput,
@@ -98,14 +98,13 @@ import {
   type MutationTargetTuple,
   type TupleDependencies,
   type TupleDialect,
-  type TupleSource,
   type ResultRow
-} from "./query.js"
-import * as ExpressionAst from "./expression-ast.js"
-import { presenceWitnessesOfSourceLike } from "./implication-runtime.js"
-import type { JsonNode } from "./json/ast.js"
-import type { JsonPathUsageError } from "./json/errors.js"
-import * as JsonPath from "./json/path.js"
+} from "../../internal/query.js"
+import * as ExpressionAst from "../../internal/expression-ast.js"
+import { presenceWitnessesOfSourceLike } from "../../internal/implication-runtime.js"
+import type { JsonNode } from "../../internal/json/ast.js"
+import type { JsonPathUsageError } from "../../internal/json/errors.js"
+import * as JsonPath from "../../internal/json/path.js"
 import type {
   JsonConcatResult,
   JsonDeleteAtPath,
@@ -119,16 +118,20 @@ import type {
   JsonTypeName,
   JsonValueAtPath,
   NormalizeJsonLiteral
-} from "./json/types.js"
-import type { AssumeTrue } from "./predicate-analysis.js"
-import type { FormulaOfPredicate } from "./predicate-normalize.js"
-import type { TrueFormula } from "./predicate-formula.js"
-import { assumeFormulaTrue, formulaOfExpression as formulaOfExpressionRuntime, trueFormula } from "./predicate-runtime.js"
-import { dedupeGroupedExpressions } from "./grouping-key.js"
-import { makeCteSource, makeDerivedSource, makeLateralSource } from "./derived-table.js"
-import * as ProjectionAlias from "./projection-alias.js"
-import * as QueryAst from "./query-ast.js"
-import { normalizeColumnList } from "./table-options.js"
+} from "../../internal/json/types.js"
+import type { AssumePredicateStateTrue, EmptyFacts, PredicateStateFacts, PredicateStateFormula } from "../../internal/predicate/analysis.js"
+import type { FormulaOfPredicate } from "../../internal/predicate/normalize.js"
+import type { TrueFormula } from "../../internal/predicate/formula.js"
+import { assumeFormulaTrue, formulaOfExpression as formulaOfExpressionRuntime, trueFormula } from "../../internal/predicate/runtime.js"
+import { dedupeGroupedExpressions } from "../../internal/grouping-key.js"
+import { makeDslMutationRuntime } from "../../internal/dsl-mutation-runtime.js"
+import { makeDslPlanRuntime } from "../../internal/dsl-plan-runtime.js"
+import { makeDslQueryRuntime } from "../../internal/dsl-query-runtime.js"
+import { makeDslTransactionDdlRuntime } from "../../internal/dsl-transaction-ddl-runtime.js"
+import { makeCteSource, makeDerivedSource, makeLateralSource } from "../../internal/derived-table.js"
+import * as ProjectionAlias from "../../internal/projection-alias.js"
+import * as QueryAst from "../../internal/query-ast.js"
+import { normalizeColumnList } from "../../internal/table-options.js"
 
 /**
  * Dialect-specific DB type profile used to specialize the shared query
@@ -190,7 +193,7 @@ type DialectLiteralExpression<
   BoolDb extends Expression.DbType.Any,
   TimestampDb extends Expression.DbType.Any,
   NullDb extends Expression.DbType.Any
-> = Expression.Expression<
+> = Expression.Scalar<
   DialectLiteralRuntime<Value, TimestampDb>,
   DialectLiteralDbType<Value, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
   LiteralNullability<Value>,
@@ -325,15 +328,13 @@ type CastResult<
   BoolDb extends Expression.DbType.Any,
   TimestampDb extends Expression.DbType.Any,
   NullDb extends Expression.DbType.Any
-> = Expression.Expression<
+> = Expression.Scalar<
   RuntimeOfDbType<Target>,
   Target,
   Expression.NullabilityOf<DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
   Dialect,
-  AggregationOf<DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-  SourceOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-  DependenciesOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-  Expression.SourceNullabilityOf<DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
+  KindOf<DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
+  DependenciesOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
 > & {
   readonly [ExpressionAst.TypeId]: ExpressionAst.CastNode<
     DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
@@ -370,17 +371,39 @@ type ComparableGuard<
   TimestampDb extends Expression.DbType.Any,
   NullDb extends Expression.DbType.Any,
   Operator extends string
-> = CanCompareDbTypes<
-  DialectDbTypeOfInput<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-  DialectDbTypeOfInput<Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-  Dialect
-> extends true ? true : OperandCompatibilityError<
-  Operator,
-  DialectDbTypeOfInput<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-  DialectDbTypeOfInput<Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+> = 0 extends (1 & Left)
+  ? true
+  : 0 extends (1 & Right)
+    ? true
+    : DialectDbTypeOfInput<
+  Left,
   Dialect,
-  "the same db type family"
->
+  TextDb,
+  NumericDb,
+  BoolDb,
+  TimestampDb,
+  NullDb
+> extends infer LeftDb extends Expression.DbType.Any
+  ? DialectDbTypeOfInput<
+    Right,
+    Dialect,
+    TextDb,
+    NumericDb,
+    BoolDb,
+    TimestampDb,
+    NullDb
+  > extends infer RightDb extends Expression.DbType.Any
+    ? CanCompareDbTypes<LeftDb, RightDb, Dialect> extends true
+      ? true
+      : OperandCompatibilityError<
+        Operator,
+        LeftDb,
+        RightDb,
+        Dialect,
+        "the same db type family"
+      >
+    : never
+  : never
 
 type TextGuard<
   Value extends ExpressionInput,
@@ -465,9 +488,10 @@ type ComparableArgs<
   TimestampDb extends Expression.DbType.Any,
   NullDb extends Expression.DbType.Any,
   Operator extends string
-> = ComparableGuard<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, Operator> extends true
-  ? readonly [left: Left, right: Right]
-  : readonly [ComparableGuard<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, Operator>]
+> = readonly [
+  left: Left,
+  right: Right & ComparableInput<NoInfer<Left>, NoInfer<Right>, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, Operator>
+]
 
 type ContainmentGuard<
   Left extends ExpressionInput,
@@ -515,11 +539,10 @@ type TextArgs<
   TimestampDb extends Expression.DbType.Any,
   NullDb extends Expression.DbType.Any,
   Operator extends string
-> = TextGuard<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, Operator> extends true
-  ? TextGuard<Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, Operator> extends true
-    ? readonly [left: Left, right: Right]
-    : readonly [TextGuard<Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, Operator>]
-  : readonly [TextGuard<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, Operator>]
+> = readonly [
+  left: Left & TextInput<NoInfer<Left>, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, Operator>,
+  right: Right & TextInput<NoInfer<Right>, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, Operator>
+]
 
 type MembershipArgs<
   Values extends readonly [ExpressionInput, ExpressionInput, ...ExpressionInput[]],
@@ -590,17 +613,6 @@ type BetweenArgs<
       "between"
     >]
 
-/** Provenance carried by a dialect-specialized scalar input. */
-type SourceOfDialectInput<
-  Value extends ExpressionInput,
-  Dialect extends string,
-  TextDb extends Expression.DbType.Any,
-  NumericDb extends Expression.DbType.Any,
-  BoolDb extends Expression.DbType.Any,
-  TimestampDb extends Expression.DbType.Any,
-  NullDb extends Expression.DbType.Any
-> = SourceOf<DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
-
 /** Dialect carried by a dialect-specialized scalar input. */
 type DialectOfDialectInput<
   Value extends ExpressionInput,
@@ -634,17 +646,6 @@ type RequiredFromDialectInput<
   NullDb extends Expression.DbType.Any
 > = RequiredFromDependencies<DependenciesOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
 
-/** Provenance carried by a dialect-specialized string input. */
-type SourceOfDialectStringInput<
-  Value extends ExpressionInput,
-  Dialect extends string,
-  TextDb extends Expression.DbType.Any,
-  NumericDb extends Expression.DbType.Any,
-  BoolDb extends Expression.DbType.Any,
-  TimestampDb extends Expression.DbType.Any,
-  NullDb extends Expression.DbType.Any
-> = SourceOf<DialectAsStringExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
-
 /** Dialect carried by a dialect-specialized string input. */
 type DialectOfDialectStringInput<
   Value extends ExpressionInput,
@@ -714,9 +715,9 @@ type RequiredFromDialectNumericInput<
 /** Folds aggregation kinds across a tuple of expressions. */
 type MergeAggregationTuple<
   Values extends readonly Expression.Any[],
-  Current extends Expression.AggregationKind = "scalar"
+  Current extends Expression.ScalarKind = "scalar"
 > = Values extends readonly [infer Head extends Expression.Any, ...infer Tail extends readonly Expression.Any[]]
-  ? MergeAggregationTuple<Tail, MergeAggregation<Current, AggregationOf<Head>>>
+  ? MergeAggregationTuple<Tail, MergeAggregation<Current, KindOf<Head>>>
   : Current
 
 /** Result nullability for binary `coalesce(...)`. */
@@ -763,6 +764,18 @@ type DialectExpressionTuple<
   readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
 }
 
+type DialectExpressionArray<
+  Values extends readonly ExpressionInput[],
+  Dialect extends string,
+  TextDb extends Expression.DbType.Any,
+  NumericDb extends Expression.DbType.Any,
+  BoolDb extends Expression.DbType.Any,
+  TimestampDb extends Expression.DbType.Any,
+  NullDb extends Expression.DbType.Any
+> = DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> extends infer Tuple extends readonly Expression.Any[]
+  ? Tuple
+  : never
+
 /** Normalized expression tuple for generic string operator inputs. */
 type DialectStringExpressionTuple<
   Values extends readonly ExpressionInput[],
@@ -779,7 +792,7 @@ type DialectStringExpressionTuple<
 /** Names of sources already available to a plan. */
 type AvailableNames<Available extends Record<string, Plan.AnySource>> = Extract<keyof Available, string>
 
-type PlanAssumptionsAfterWhere<
+type PlanPredicateStateAfterWhere<
   PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
   Predicate extends PredicateInput,
   Dialect extends string,
@@ -788,12 +801,34 @@ type PlanAssumptionsAfterWhere<
   BoolDb extends Expression.DbType.Any,
   TimestampDb extends Expression.DbType.Any,
   NullDb extends Expression.DbType.Any
-> = AssumeTrue<
-  AssumptionsOfPlan<PlanValue>,
+> = AssumePredicateStateTrue<
+  PredicateStateOfPlan<PlanValue>,
   DialectAsExpression<Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
 >
 
-type PlanAssumptionsAfterHaving<
+type PlanAssumptionsAfterWhere<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
+  Predicate extends PredicateInput,
+  Dialect extends string,
+  TextDb extends Expression.DbType.Any,
+  NumericDb extends Expression.DbType.Any,
+  BoolDb extends Expression.DbType.Any,
+  TimestampDb extends Expression.DbType.Any,
+  NullDb extends Expression.DbType.Any
+> = PredicateStateFormula<PlanPredicateStateAfterWhere<PlanValue, Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
+
+type PlanFactsAfterWhere<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
+  Predicate extends PredicateInput,
+  Dialect extends string,
+  TextDb extends Expression.DbType.Any,
+  NumericDb extends Expression.DbType.Any,
+  BoolDb extends Expression.DbType.Any,
+  TimestampDb extends Expression.DbType.Any,
+  NullDb extends Expression.DbType.Any
+> = PredicateStateFacts<PlanPredicateStateAfterWhere<PlanValue, Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
+
+type PlanPredicateStateAfterHaving<
   PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
   Predicate extends HavingPredicateInput,
   Dialect extends string,
@@ -802,12 +837,34 @@ type PlanAssumptionsAfterHaving<
   BoolDb extends Expression.DbType.Any,
   TimestampDb extends Expression.DbType.Any,
   NullDb extends Expression.DbType.Any
-> = AssumeTrue<
-  AssumptionsOfPlan<PlanValue>,
+> = AssumePredicateStateTrue<
+  PredicateStateOfPlan<PlanValue>,
   DialectAsExpression<Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
 >
 
-type PlanAssumptionsAfterJoin<
+type PlanAssumptionsAfterHaving<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
+  Predicate extends HavingPredicateInput,
+  Dialect extends string,
+  TextDb extends Expression.DbType.Any,
+  NumericDb extends Expression.DbType.Any,
+  BoolDb extends Expression.DbType.Any,
+  TimestampDb extends Expression.DbType.Any,
+  NullDb extends Expression.DbType.Any
+> = PredicateStateFormula<PlanPredicateStateAfterHaving<PlanValue, Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
+
+type PlanFactsAfterHaving<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
+  Predicate extends HavingPredicateInput,
+  Dialect extends string,
+  TextDb extends Expression.DbType.Any,
+  NumericDb extends Expression.DbType.Any,
+  BoolDb extends Expression.DbType.Any,
+  TimestampDb extends Expression.DbType.Any,
+  NullDb extends Expression.DbType.Any
+> = PredicateStateFacts<PlanPredicateStateAfterHaving<PlanValue, Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
+
+type PlanPredicateStateAfterJoin<
   PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
   Predicate extends PredicateInput,
   Kind extends QueryAst.JoinKind,
@@ -818,11 +875,35 @@ type PlanAssumptionsAfterJoin<
   TimestampDb extends Expression.DbType.Any,
   NullDb extends Expression.DbType.Any
 > = Kind extends "inner"
-  ? AssumeTrue<
-      AssumptionsOfPlan<PlanValue>,
+  ? AssumePredicateStateTrue<
+      PredicateStateOfPlan<PlanValue>,
       DialectAsExpression<Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
     >
-  : AssumptionsOfPlan<PlanValue>
+  : PredicateStateOfPlan<PlanValue>
+
+type PlanAssumptionsAfterJoin<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
+  Predicate extends PredicateInput,
+  Kind extends QueryAst.JoinKind,
+  Dialect extends string,
+  TextDb extends Expression.DbType.Any,
+  NumericDb extends Expression.DbType.Any,
+  BoolDb extends Expression.DbType.Any,
+  TimestampDb extends Expression.DbType.Any,
+  NullDb extends Expression.DbType.Any
+> = PredicateStateFormula<PlanPredicateStateAfterJoin<PlanValue, Predicate, Kind, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
+
+type PlanFactsAfterJoin<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
+  Predicate extends PredicateInput,
+  Kind extends QueryAst.JoinKind,
+  Dialect extends string,
+  TextDb extends Expression.DbType.Any,
+  NumericDb extends Expression.DbType.Any,
+  BoolDb extends Expression.DbType.Any,
+  TimestampDb extends Expression.DbType.Any,
+  NullDb extends Expression.DbType.Any
+> = PredicateStateFacts<PlanPredicateStateAfterJoin<PlanValue, Predicate, Kind, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
 
 type ScalarSubqueryInput<
   PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
@@ -836,20 +917,16 @@ type AstBackedExpression<
   Db extends Expression.DbType.Any,
   Nullable extends Expression.Nullability,
   Dialect extends string,
-  Aggregation extends Expression.AggregationKind,
-  Source,
-  Dependencies extends Expression.SourceDependencies,
-  Ast extends ExpressionAst.Any,
-  SourceNullability extends Expression.SourceNullabilityMode = "propagate"
-> = Expression.Expression<
+  Aggregation extends Expression.ScalarKind,
+  Dependencies extends Expression.BindingId,
+  Ast extends ExpressionAst.Any
+> = Expression.Scalar<
   Runtime,
   Db,
   Nullable,
   Dialect,
   Aggregation,
-  Source,
-  Dependencies,
-  SourceNullability
+  Dependencies
 > & {
   readonly [ExpressionAst.TypeId]: Ast
 }
@@ -882,8 +959,7 @@ type VariadicBooleanExpression<
   BoolDb,
   MergeNullabilityTuple<Values>,
   TupleDialect<Values>,
-  MergeAggregationTuple<Values>,
-  TupleSource<Values>,
+  "scalar",
   TupleDependencies<Values>,
   ExpressionAst.VariadicNode<Kind, Values>
 > & {
@@ -915,32 +991,26 @@ type JsonExpression<
   Db extends Expression.DbType.Any,
   Nullability extends Expression.Nullability,
   Dialect extends string,
-  Aggregation extends Expression.AggregationKind,
-  Source,
-  Dependencies extends Expression.SourceDependencies,
-  Ast extends ExpressionAst.Any,
-  SourceNullability extends Expression.SourceNullabilityMode = "propagate"
+  Aggregation extends Expression.ScalarKind,
+  Dependencies extends Expression.BindingId,
+  Ast extends ExpressionAst.Any
 > = AstBackedExpression<
   Runtime,
   Db,
   Nullability,
   Dialect,
   Aggregation,
-  Source,
   Dependencies,
-  Ast,
-  SourceNullability
+  Ast
 >
 
-type JsonExpressionLike<Runtime = unknown> = Expression.Expression<
+type JsonExpressionLike<Runtime = unknown> = Expression.Scalar<
   Runtime,
   Expression.DbType.Json<any, any>,
   Expression.Nullability,
   string,
-  Expression.AggregationKind,
-  any,
-  Expression.SourceDependencies,
-  Expression.SourceNullabilityMode
+  Expression.ScalarKind,
+  Expression.BindingId
 >
 
 type JsonDbOfExpression<Value extends JsonExpressionLike<any>> = Expression.DbTypeOf<Value>
@@ -1100,8 +1170,8 @@ type CaseResultTupleWithElse<
 > = [...CaseResultTuple<Branches>, Else]
 
 type MergeAggregationUnion<Value extends Expression.Any> =
-  Extract<AggregationOf<Value>, "window"> extends never
-    ? Extract<AggregationOf<Value>, "aggregate"> extends never ? "scalar" : "aggregate"
+  Extract<KindOf<Value>, "window"> extends never
+    ? Extract<KindOf<Value>, "aggregate"> extends never ? "scalar" : "aggregate"
     : "window"
 
 type CaseNullabilityOfUnion<Value extends Expression.Any> =
@@ -1149,10 +1219,8 @@ type CaseBuilder<
     CaseNullabilityOfUnion<CaseResultTupleWithElse<Branches, DialectAsExpression<Else, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>[number]>,
     TupleDialect<CaseAllTuple<Branches, DialectAsExpression<Else, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>>,
     MergeAggregationTuple<CaseAllTuple<Branches, DialectAsExpression<Else, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>>,
-    TupleSource<CaseAllTuple<Branches, DialectAsExpression<Else, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>>,
     TupleDependencies<CaseAllTuple<Branches, DialectAsExpression<Else, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>>,
-    ExpressionAst.CaseNode<CaseAstBranches<Branches>, DialectAsExpression<Else, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-    "resolved"
+    ExpressionAst.CaseNode<CaseAstBranches<Branches>, DialectAsExpression<Else, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
   >
 }
 
@@ -1167,7 +1235,7 @@ type MatchBuilder<
   NullDb extends Expression.DbType.Any
 > = {
   when<Compare extends ExpressionInput, Then extends ExpressionInput>(
-    compare: Compare & ComparableInput<Subject, Compare, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "match">,
+    compare: Compare & ComparableInput<NoInfer<Subject>, NoInfer<Compare>, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "match">,
     result: Then
   ): MatchBuilder<
     Subject,
@@ -1190,10 +1258,8 @@ type MatchBuilder<
     CaseNullabilityOfUnion<CaseResultTupleWithElse<Branches, DialectAsExpression<Else, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>[number]>,
     TupleDialect<CaseAllTuple<Branches, DialectAsExpression<Else, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>>,
     MergeAggregationTuple<CaseAllTuple<Branches, DialectAsExpression<Else, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>>,
-    TupleSource<CaseAllTuple<Branches, DialectAsExpression<Else, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>>,
     TupleDependencies<CaseAllTuple<Branches, DialectAsExpression<Else, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>>,
-    ExpressionAst.CaseNode<CaseAstBranches<Branches>, DialectAsExpression<Else, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-    "resolved"
+    ExpressionAst.CaseNode<CaseAstBranches<Branches>, DialectAsExpression<Else, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
   >
 }
 
@@ -1232,7 +1298,7 @@ type MatchStarter<
   NullDb extends Expression.DbType.Any
 > = {
   when<Compare extends ExpressionInput, Then extends ExpressionInput>(
-    compare: Compare & ComparableInput<Subject, Compare, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "match">,
+    compare: Compare & ComparableInput<NoInfer<Subject>, NoInfer<Compare>, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "match">,
     result: Then
   ): MatchBuilder<
     Subject,
@@ -1249,15 +1315,13 @@ type MatchStarter<
   >
 }
 
-type WindowPartitionInput = Expression.Expression<
+type WindowPartitionInput = Expression.Scalar<
   any,
   Expression.DbType.Any,
   Expression.Nullability,
   string,
   "scalar",
-  any,
-  Expression.SourceDependencies,
-  Expression.SourceNullabilityMode
+  Expression.BindingId
 >
 
 type WindowOrderInput = WindowPartitionInput
@@ -1316,12 +1380,6 @@ type WindowDialectOf<
   OrderBy extends readonly WindowOrderTermInput[]
 > = DialectOf<Value> | TupleDialect<PartitionBy> | TupleDialect<WindowOrderExpressionTuple<OrderBy>>
 
-type WindowSourceOf<
-  Value extends Expression.Any,
-  PartitionBy extends readonly WindowPartitionInput[],
-  OrderBy extends readonly WindowOrderTermInput[]
-> = SourceOf<Value> | TupleSource<PartitionBy> | TupleSource<WindowOrderExpressionTuple<OrderBy>>
-
 type WindowDependenciesOf<
   Value extends Expression.Any,
   PartitionBy extends readonly WindowPartitionInput[],
@@ -1337,11 +1395,6 @@ type NumberWindowDialectOf<
   OrderBy extends readonly WindowOrderTermInput[]
 > = TupleDialect<PartitionBy> | TupleDialect<WindowOrderExpressionTuple<OrderBy>>
 
-type NumberWindowSourceOf<
-  PartitionBy extends readonly WindowPartitionInput[],
-  OrderBy extends readonly WindowOrderTermInput[]
-> = TupleSource<PartitionBy> | TupleSource<WindowOrderExpressionTuple<OrderBy>>
-
 type NumberWindowDependenciesOf<
   PartitionBy extends readonly WindowPartitionInput[],
   OrderBy extends readonly WindowOrderTermInput[]
@@ -1360,10 +1413,8 @@ type WindowedExpression<
   Expression.NullabilityOf<Value>,
   WindowDialectOf<Value, PartitionBy, OrderBy>,
   "window",
-  WindowSourceOf<Value, PartitionBy, OrderBy>,
   WindowDependenciesOf<Value, PartitionBy, OrderBy>,
-  WindowNodeOf<"over", Value, PartitionBy, OrderBy>,
-  "resolved"
+  WindowNodeOf<"over", Value, PartitionBy, OrderBy>
 >
 
 type NumberWindowExpression<
@@ -1376,10 +1427,8 @@ type NumberWindowExpression<
   "never",
   NumberWindowDialectOf<PartitionBy, OrderBy>,
   "window",
-  NumberWindowSourceOf<PartitionBy, OrderBy>,
   NumberWindowDependenciesOf<PartitionBy, OrderBy>,
-  WindowNodeOf<Kind, undefined, PartitionBy, OrderBy>,
-  "resolved"
+  WindowNodeOf<Kind, undefined, PartitionBy, OrderBy>
 >
 
 /**
@@ -1389,22 +1438,33 @@ type NumberWindowExpression<
  * that manufacture new expressions are specialized to the supplied dialect DB
  * types instead of relying on the Postgres-default root module.
  */
-export const mysqlQuery = (() => {
 type Dialect = "mysql"
-type TextDb = Expression.DbType.MySqlText
-type NumericDb = Expression.DbType.MySqlDouble
-type BoolDb = Expression.DbType.MySqlBool
-type TimestampDb = Expression.DbType.MySqlTimestamp
-type NullDb = Expression.DbType.Base<"mysql", "null">
+type TextDb = ReturnType<typeof mysqlDatatypes.text>
+type NumericDb = ReturnType<typeof mysqlDatatypes.double>
+type BoolDb = ReturnType<typeof mysqlDatatypes.boolean>
+type TimestampDb = ReturnType<typeof mysqlDatatypes.timestamp>
+type NullDb = Expression.DbType.Base<"mysql", "null"> & {
+  readonly family: "null"
+  readonly runtime: "unknown"
+  readonly compareGroup: "null"
+  readonly traits: {}
+}
 type TypeWitnesses = typeof mysqlDatatypes
 
 const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, TypeWitnesses> = {
   dialect: "mysql",
-  textDb: { dialect: "mysql", kind: "text" } as TextDb,
-  numericDb: { dialect: "mysql", kind: "double" } as NumericDb,
-  boolDb: { dialect: "mysql", kind: "boolean" } as BoolDb,
-  timestampDb: { dialect: "mysql", kind: "timestamp" } as TimestampDb,
-  nullDb: { dialect: "mysql", kind: "null" } as NullDb,
+  textDb: mysqlDatatypes.text() as TextDb,
+  numericDb: mysqlDatatypes.double() as NumericDb,
+  boolDb: mysqlDatatypes.boolean() as BoolDb,
+  timestampDb: mysqlDatatypes.timestamp() as TimestampDb,
+  nullDb: {
+    dialect: "mysql",
+    kind: "null",
+    family: "null",
+    runtime: "unknown",
+    compareGroup: "null",
+    traits: {}
+  } as NullDb,
   type: mysqlDatatypes
 }
   const ValuesInputProto = {
@@ -1437,9 +1497,8 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       runtimeSchema: literalSchemaOf(value),
       nullability: (value === null ? "always" : "never") as LiteralNullability<Value>,
       dialect: profile.dialect as Dialect,
-      aggregation: "scalar",
-      source: undefined as never,
-      sourceNullability: "propagate" as const,
+      kind: "scalar",
+
       dependencies: {}
     }, {
       kind: "literal",
@@ -1453,15 +1512,13 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     name: Name,
     dbType: Db,
     nullable = false
-  ): Expression.Expression<
+  ): Expression.Scalar<
     Expression.RuntimeOfDbType<Db> | null,
     Db,
     Expression.Nullability,
     Dialect,
     "scalar",
-    never,
-    {},
-    "resolved"
+    never
   > & {
     readonly [ExpressionAst.TypeId]: ExpressionAst.ColumnNode<"", Name>
   } =>
@@ -1470,23 +1527,20 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       dbType,
       nullability: (nullable ? "maybe" : "never") as typeof nullable extends true ? "maybe" : "never",
       dialect: profile.dialect as Dialect,
-      aggregation: "scalar",
-      source: undefined as never,
-      sourceNullability: "resolved" as const,
+      kind: "scalar",
+
       dependencies: {}
     }, {
       kind: "column",
       tableName: "",
       columnName: name
-    }) as Expression.Expression<
+    }) as Expression.Scalar<
       Expression.RuntimeOfDbType<Db> | null,
       Db,
       Expression.Nullability,
       Dialect,
       "scalar",
-      never,
-      {},
-      "resolved"
+      never
     > & {
       readonly [ExpressionAst.TypeId]: ExpressionAst.ColumnNode<"", Name>
     }
@@ -1508,6 +1562,42 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     >
   }
 
+  const retargetLiteralExpression = (
+    value: Expression.Any,
+    target: Expression.Any
+  ): Expression.Any => {
+    const ast = (value as unknown as { readonly [ExpressionAst.TypeId]: ExpressionAst.Any })[ExpressionAst.TypeId]
+    if (ast.kind !== "literal") {
+      return value
+    }
+    const targetState = target[Expression.TypeId]
+    return makeExpression({
+      runtime: value[Expression.TypeId].runtime,
+      dbType: targetState.dbType,
+      runtimeSchema: targetState.runtimeSchema,
+      driverValueMapping: targetState.driverValueMapping,
+      nullability: value[Expression.TypeId].nullability,
+      dialect: targetState.dialect,
+      kind: "scalar",
+      dependencies: {}
+    }, ast)
+  }
+
+  const alignBinaryPredicateExpressions = (
+    left: Expression.Any,
+    right: Expression.Any
+  ): readonly [Expression.Any, Expression.Any] => {
+    const leftAst = (left as unknown as { readonly [ExpressionAst.TypeId]: ExpressionAst.Any })[ExpressionAst.TypeId]
+    const rightAst = (right as unknown as { readonly [ExpressionAst.TypeId]: ExpressionAst.Any })[ExpressionAst.TypeId]
+    if (leftAst.kind === "literal" && rightAst.kind !== "literal") {
+      return [retargetLiteralExpression(left, right), right]
+    }
+    if (rightAst.kind === "literal" && leftAst.kind !== "literal") {
+      return [left, retargetLiteralExpression(right, left)]
+    }
+    return [left, right]
+  }
+
   const toDialectStringExpression = <Value extends StringExpressionInput>(
     value: Value
   ): DialectAsStringExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> =>
@@ -1554,10 +1644,9 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       dbType: profile.boolDb as BoolDb,
       nullability: mergeNullabilityManyRuntime(expressions) as MergeNullabilityTuple<Values>,
       dialect: (expressions.find((value) => value[Expression.TypeId].dialect !== undefined)?.[Expression.TypeId].dialect ?? profile.dialect) as TupleDialect<Values>,
-      aggregation: mergeAggregationManyRuntime(expressions) as MergeAggregationTuple<Values>,
-      source: mergeManySources(expressions) as TupleSource<Values>,
-      sourceNullability: "propagate" as const,
-      dependencies: mergeManyDependencies(expressions) as TupleDependencies<Values>
+      kind: "scalar",
+
+      dependencies: mergeManyDependencies(expressions)
     }, {
       kind,
       values: expressions
@@ -1624,39 +1713,32 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     return Object.keys(expression[Expression.TypeId].dependencies)
   }
 
-  type BinaryPredicateExpression<
-    Left extends ExpressionInput,
-    Right extends ExpressionInput,
-    Kind extends ExpressionAst.BinaryKind,
-    Nullability extends Expression.Nullability = "maybe",
-    SourceNullability extends Expression.SourceNullabilityMode = "propagate"
-  > = AstBackedExpression<
-    boolean,
-    BoolDb,
-    Nullability,
-    DialectOfDialectInput<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> | DialectOfDialectInput<Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-    MergeAggregation<
-      AggregationOf<DialectAsExpression<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-      AggregationOf<DialectAsExpression<Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
-    >,
-    SourceOfDialectInput<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> | SourceOfDialectInput<Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-    DependencyRecord<
-      RequiredFromDialectInput<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> |
-      RequiredFromDialectInput<Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
-    >,
-    ExpressionAst.BinaryNode<
-      Kind,
-      DialectAsExpression<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-      DialectAsExpression<Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
-    >,
-    SourceNullability
+type BinaryPredicateExpression<
+  Left extends ExpressionInput,
+  Right extends ExpressionInput,
+  Kind extends ExpressionAst.BinaryKind,
+  Nullability extends Expression.Nullability = "maybe"
+> = AstBackedExpression<
+  boolean,
+  BoolDb,
+  Nullability,
+  DialectOfDialectInput<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> | DialectOfDialectInput<Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+  "scalar",
+  DependencyRecord<
+    RequiredFromDialectInput<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> |
+    RequiredFromDialectInput<Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+  >,
+  ExpressionAst.BinaryNode<
+    Kind,
+    DialectAsExpression<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+    DialectAsExpression<Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
   >
+>
 
   type SubqueryPredicateExpression<
     Dialect extends string,
-    Aggregation extends Expression.AggregationKind,
-    Source,
-    Dependencies extends Expression.SourceDependencies,
+    Aggregation extends Expression.ScalarKind,
+    Dependencies extends Expression.BindingId,
     Ast extends ExpressionAst.Any
   > = AstBackedExpression<
     boolean,
@@ -1664,7 +1746,6 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     "maybe",
     Dialect,
     Aggregation,
-    Source,
     Dependencies,
     Ast
   >
@@ -1672,47 +1753,42 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
   type VariadicPredicateExpression<
     Values extends readonly ExpressionInput[],
     Kind extends ExpressionAst.VariadicKind
-  > = AstBackedExpression<
-    boolean,
-    BoolDb,
-    "maybe",
-    TupleDialect<DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-    MergeAggregationTuple<DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-    TupleSource<DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-    TupleDependencies<DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-    ExpressionAst.VariadicNode<Kind, DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
-  >
+> = AstBackedExpression<
+  boolean,
+  BoolDb,
+  "maybe",
+  TupleDialect<DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
+  "scalar",
+  TupleDependencies<DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
+  ExpressionAst.VariadicNode<Kind, DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
+>
 
   const buildBinaryPredicate = <
     Left extends ExpressionInput,
     Right extends ExpressionInput,
     Kind extends ExpressionAst.BinaryKind,
     Nullability extends Expression.Nullability = "maybe",
-    SourceNullability extends Expression.SourceNullabilityMode = "propagate"
+    SourceNullability extends string = "propagate"
   >(
     left: Left,
     right: Right,
     kind: Kind,
     nullability: Nullability = "maybe" as Nullability,
-    sourceNullability: SourceNullability = "propagate" as SourceNullability
   ): any => {
-    const leftExpression = toDialectExpression(left)
-    const rightExpression = toDialectExpression(right)
+    const [leftExpression, rightExpression] = alignBinaryPredicateExpressions(
+      toDialectExpression(left),
+      toDialectExpression(right)
+    )
     return (makeExpression as any)({
       runtime: true as boolean,
       dbType: profile.boolDb as BoolDb,
       nullability,
       dialect: (leftExpression[Expression.TypeId].dialect ?? rightExpression[Expression.TypeId].dialect) as DialectOfDialectInput<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> | DialectOfDialectInput<Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-      aggregation: mergeAggregationRuntime(
-        leftExpression[Expression.TypeId].aggregation,
-        rightExpression[Expression.TypeId].aggregation
-      ) as MergeAggregation<AggregationOf<DialectAsExpression<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>, AggregationOf<DialectAsExpression<Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>>,
-      source: mergeSources(leftExpression[Expression.TypeId].source, rightExpression[Expression.TypeId].source) as SourceOfDialectInput<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> | SourceOfDialectInput<Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-      sourceNullability,
+      kind: "scalar",
       dependencies: mergeDependencies(
         leftExpression[Expression.TypeId].dependencies,
         rightExpression[Expression.TypeId].dependencies
-      ) as DependencyRecord<RequiredFromDialectInput<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> | RequiredFromDialectInput<Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
+      )
     } as any, {
       kind,
       left: leftExpression,
@@ -1725,18 +1801,21 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     kind: ExpressionAst.VariadicKind
   ): Expression.Any => {
     const expressions = values.map((value) => toDialectExpression(value as any)) as readonly Expression.Any[]
+    const [head, ...tail] = expressions
+    const alignedExpressions = (head !== undefined && (kind === "in" || kind === "notIn" || kind === "between"))
+      ? [head, ...tail.map((value) => retargetLiteralExpression(value, head))]
+      : expressions
     return makeExpression({
       runtime: true as boolean,
       dbType: profile.boolDb as BoolDb,
       nullability: "maybe",
-      dialect: (expressions.find((value) => value[Expression.TypeId].dialect !== undefined)?.[Expression.TypeId].dialect ?? profile.dialect) as Dialect,
-      aggregation: mergeAggregationManyRuntime(expressions) as Expression.AggregationKind,
-      source: mergeManySources(expressions),
-      sourceNullability: "propagate" as const,
-      dependencies: mergeManyDependencies(expressions)
+      dialect: (alignedExpressions.find((value) => value[Expression.TypeId].dialect !== undefined)?.[Expression.TypeId].dialect ?? profile.dialect) as Dialect,
+      kind: "scalar",
+
+      dependencies: mergeManyDependencies(alignedExpressions)
     }, {
       kind,
-      values: expressions
+      values: alignedExpressions
     })
   }
 
@@ -1746,7 +1825,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
   >(
     ...args: ComparableArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "eq">
   ): BinaryPredicateExpression<Left, Right, "eq"> => {
-    const [left, right] = args as [Left, Right]
+    const [left, right] = args as unknown as [Left, Right]
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "eq")
   }
 
@@ -1756,7 +1835,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
   >(
     ...args: ComparableArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "neq">
   ): BinaryPredicateExpression<Left, Right, "neq"> => {
-    const [left, right] = args as [Left, Right]
+    const [left, right] = args as unknown as [Left, Right]
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "neq")
   }
 
@@ -1766,7 +1845,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
   >(
     ...args: ComparableArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "lt">
   ): BinaryPredicateExpression<Left, Right, "lt"> => {
-    const [left, right] = args as [Left, Right]
+    const [left, right] = args as unknown as [Left, Right]
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "lt")
   }
 
@@ -1776,7 +1855,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
   >(
     ...args: ComparableArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "lte">
   ): BinaryPredicateExpression<Left, Right, "lte"> => {
-    const [left, right] = args as [Left, Right]
+    const [left, right] = args as unknown as [Left, Right]
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "lte")
   }
 
@@ -1786,7 +1865,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
   >(
     ...args: ComparableArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "gt">
   ): BinaryPredicateExpression<Left, Right, "gt"> => {
-    const [left, right] = args as [Left, Right]
+    const [left, right] = args as unknown as [Left, Right]
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "gt")
   }
 
@@ -1796,7 +1875,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
   >(
     ...args: ComparableArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "gte">
   ): BinaryPredicateExpression<Left, Right, "gte"> => {
-    const [left, right] = args as [Left, Right]
+    const [left, right] = args as unknown as [Left, Right]
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "gte")
   }
 
@@ -1806,7 +1885,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
   >(
     ...args: TextArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "like">
   ): BinaryPredicateExpression<Left, Right, "like"> => {
-    const [left, right] = args as [Left, Right]
+    const [left, right] = args as unknown as [Left, Right]
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "like")
   }
 
@@ -1816,7 +1895,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
   >(
     ...args: TextArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "ilike">
   ): BinaryPredicateExpression<Left, Right, "ilike"> => {
-    const [left, right] = args as [Left, Right]
+    const [left, right] = args as unknown as [Left, Right]
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "ilike")
   }
 
@@ -1826,7 +1905,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
   >(
     ...args: TextArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "regexMatch">
   ): BinaryPredicateExpression<Left, Right, "regexMatch"> => {
-    const [left, right] = args as [Left, Right]
+    const [left, right] = args as unknown as [Left, Right]
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "regexMatch")
   }
 
@@ -1836,7 +1915,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
   >(
     ...args: TextArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "regexIMatch">
   ): BinaryPredicateExpression<Left, Right, "regexIMatch"> => {
-    const [left, right] = args as [Left, Right]
+    const [left, right] = args as unknown as [Left, Right]
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "regexIMatch")
   }
 
@@ -1846,7 +1925,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
   >(
     ...args: TextArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "regexNotMatch">
   ): BinaryPredicateExpression<Left, Right, "regexNotMatch"> => {
-    const [left, right] = args as [Left, Right]
+    const [left, right] = args as unknown as [Left, Right]
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "regexNotMatch")
   }
 
@@ -1856,7 +1935,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
   >(
     ...args: TextArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "regexNotIMatch">
   ): BinaryPredicateExpression<Left, Right, "regexNotIMatch"> => {
-    const [left, right] = args as [Left, Right]
+    const [left, right] = args as unknown as [Left, Right]
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "regexNotIMatch")
   }
 
@@ -1865,9 +1944,9 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     Right extends ExpressionInput
   >(
     ...args: ComparableArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "isDistinctFrom">
-  ): BinaryPredicateExpression<Left, Right, "isDistinctFrom", "never", "resolved"> => {
-    const [left, right] = args as [Left, Right]
-    return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "isDistinctFrom", "never", "resolved")
+  ): BinaryPredicateExpression<Left, Right, "isDistinctFrom", "never"> => {
+    const [left, right] = args as unknown as [Left, Right]
+    return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "isDistinctFrom", "never")
   }
 
   const isNotDistinctFrom = <
@@ -1875,9 +1954,9 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     Right extends ExpressionInput
   >(
     ...args: ComparableArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "isNotDistinctFrom">
-  ): BinaryPredicateExpression<Left, Right, "isNotDistinctFrom", "never", "resolved"> => {
-    const [left, right] = args as [Left, Right]
-    return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "isNotDistinctFrom", "never", "resolved")
+  ): BinaryPredicateExpression<Left, Right, "isNotDistinctFrom", "never"> => {
+    const [left, right] = args as unknown as [Left, Right]
+    return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "isNotDistinctFrom", "never")
   }
 
   const isNull = <Value extends ExpressionInput>(
@@ -1887,11 +1966,9 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     BoolDb,
     "never",
     DialectOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-    AggregationOf<DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-    SourceOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+    "scalar",
     DependenciesOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-    ExpressionAst.UnaryNode<"isNull", DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-    "resolved"
+    ExpressionAst.UnaryNode<"isNull", DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
   > => {
     const expression = toDialectExpression(value)
     return makeExpression({
@@ -1899,10 +1976,9 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       dbType: profile.boolDb as BoolDb,
       nullability: "never",
       dialect: expression[Expression.TypeId].dialect,
-      aggregation: expression[Expression.TypeId].aggregation as AggregationOf<DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-      source: expression[Expression.TypeId].source as SourceOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-      sourceNullability: "resolved" as const,
-      dependencies: expression[Expression.TypeId].dependencies as DependenciesOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+      kind: "scalar",
+
+      dependencies: expression[Expression.TypeId].dependencies
     }, {
       kind: "isNull",
       value: expression
@@ -1916,11 +1992,9 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     BoolDb,
     "never",
     DialectOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-    AggregationOf<DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-    SourceOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+    "scalar",
     DependenciesOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-    ExpressionAst.UnaryNode<"isNotNull", DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-    "resolved"
+    ExpressionAst.UnaryNode<"isNotNull", DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
   > => {
     const expression = toDialectExpression(value)
     return makeExpression({
@@ -1928,10 +2002,9 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       dbType: profile.boolDb as BoolDb,
       nullability: "never",
       dialect: expression[Expression.TypeId].dialect,
-      aggregation: expression[Expression.TypeId].aggregation as AggregationOf<DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-      source: expression[Expression.TypeId].source as SourceOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-      sourceNullability: "resolved" as const,
-      dependencies: expression[Expression.TypeId].dependencies as DependenciesOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+      kind: "scalar",
+
+      dependencies: expression[Expression.TypeId].dependencies
     }, {
       kind: "isNotNull",
       value: expression
@@ -1945,8 +2018,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     TextDb,
     NullabilityOfDialectStringInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
     DialectOfDialectStringInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-    AggregationOf<DialectAsStringExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-    SourceOfDialectStringInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+    KindOf<DialectAsStringExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
     DependenciesOfDialectStringInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
     ExpressionAst.UnaryNode<"upper", DialectAsStringExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
   > => {
@@ -1956,10 +2028,9 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       dbType: profile.textDb as TextDb,
       nullability: expression[Expression.TypeId].nullability as NullabilityOfDialectStringInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
       dialect: expression[Expression.TypeId].dialect,
-      aggregation: expression[Expression.TypeId].aggregation as AggregationOf<DialectAsStringExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-      source: expression[Expression.TypeId].source as SourceOfDialectStringInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-      sourceNullability: "propagate" as const,
-      dependencies: expression[Expression.TypeId].dependencies as DependenciesOfDialectStringInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+      kind: expression[Expression.TypeId].kind as KindOf<DialectAsStringExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
+
+      dependencies: expression[Expression.TypeId].dependencies
     }, {
       kind: "upper",
       value: expression
@@ -1973,8 +2044,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     TextDb,
     NullabilityOfDialectStringInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
     DialectOfDialectStringInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-    AggregationOf<DialectAsStringExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-    SourceOfDialectStringInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+    KindOf<DialectAsStringExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
     DependenciesOfDialectStringInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
     ExpressionAst.UnaryNode<"lower", DialectAsStringExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
   > => {
@@ -1984,10 +2054,9 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       dbType: profile.textDb as TextDb,
       nullability: expression[Expression.TypeId].nullability as NullabilityOfDialectStringInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
       dialect: expression[Expression.TypeId].dialect,
-      aggregation: expression[Expression.TypeId].aggregation as AggregationOf<DialectAsStringExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-      source: expression[Expression.TypeId].source as SourceOfDialectStringInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-      sourceNullability: "propagate" as const,
-      dependencies: expression[Expression.TypeId].dependencies as DependenciesOfDialectStringInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+      kind: expression[Expression.TypeId].kind as KindOf<DialectAsStringExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
+
+      dependencies: expression[Expression.TypeId].dependencies
     }, {
       kind: "lower",
       value: expression
@@ -2015,11 +2084,11 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       runtime: undefined as unknown as RuntimeOfDbType<Target>,
       dbType: target as Target,
       runtimeSchema: undefined,
+      driverValueMapping: (target as Expression.DbType.Any).driverValueMapping,
       nullability: expression[Expression.TypeId].nullability,
       dialect: expression[Expression.TypeId].dialect,
-      aggregation: expression[Expression.TypeId].aggregation,
-      source: expression[Expression.TypeId].source,
-      sourceNullability: expression[Expression.TypeId].sourceNullability,
+      kind: expression[Expression.TypeId].kind,
+
       dependencies: expression[Expression.TypeId].dependencies
     }, {
       kind: "cast",
@@ -2095,6 +2164,14 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     kind
   })
 
+  const driverValueMapping = <Db extends Expression.DbType.Any>(
+    dbType: Db,
+    mapping: Expression.DriverValueMapping
+  ): Db => ({
+    ...dbType,
+    driverValueMapping: mapping
+  })
+
   const type = {
     ...profile.type,
     array,
@@ -2104,7 +2181,8 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     domain,
     enum: enum_,
     set,
-    custom
+    custom,
+    driverValueMapping
   }
 
   const makeJsonDb = <Kind extends string>(
@@ -2143,15 +2221,13 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     Runtime,
     Db extends Expression.DbType.Any,
     Nullability extends Expression.Nullability,
-    Ast extends ExpressionAst.Any,
-    SourceNullability extends Expression.SourceNullabilityMode = "propagate"
+    Ast extends ExpressionAst.Any
   >(
     expressions: readonly Expression.Any[],
     state: {
       readonly runtime: Runtime
       readonly dbType: Db
       readonly nullability: Nullability
-      readonly sourceNullability?: SourceNullability
     },
     ast: Ast
   ): AstBackedExpression<
@@ -2160,29 +2236,24 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     Nullability,
     TupleDialect<typeof expressions>,
     MergeAggregationTuple<typeof expressions>,
-    TupleSource<typeof expressions>,
     TupleDependencies<typeof expressions>,
-    Ast,
-    SourceNullability
+    Ast
   > => makeExpression({
     runtime: state.runtime,
     dbType: state.dbType,
     nullability: state.nullability,
     dialect: (expressions.find((expression) => expression[Expression.TypeId].dialect !== undefined)?.[Expression.TypeId].dialect ?? profile.dialect) as TupleDialect<typeof expressions>,
-    aggregation: mergeAggregationManyRuntime(expressions) as MergeAggregationTuple<typeof expressions>,
-    source: mergeManySources(expressions) as TupleSource<typeof expressions>,
-    sourceNullability: (state.sourceNullability ?? "propagate") as SourceNullability,
-    dependencies: mergeManyDependencies(expressions) as TupleDependencies<typeof expressions>
+    kind: mergeAggregationManyRuntime(expressions) as MergeAggregationTuple<typeof expressions>,
+
+    dependencies: mergeManyDependencies(expressions)
   }, ast) as AstBackedExpression<
     Runtime,
     Db,
     Nullability,
     TupleDialect<typeof expressions>,
     MergeAggregationTuple<typeof expressions>,
-    TupleSource<typeof expressions>,
     TupleDependencies<typeof expressions>,
-    Ast,
-    SourceNullability
+    Ast
   >
 
   const jsonDbTypeOf = <Base extends JsonExpressionLike<any>>(
@@ -2204,9 +2275,8 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     dbType,
     nullability: (value === null ? "always" : "never") as JsonNullabilityOf<Value>,
     dialect: profile.dialect as Dialect,
-    aggregation: "scalar",
-    source: undefined as never,
-    sourceNullability: "resolved" as const,
+    kind: "scalar",
+
     dependencies: {}
   }, {
     kind: "literal",
@@ -2223,7 +2293,6 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       runtime: undefined as unknown as JsonRuntime<Expression.RuntimeOf<typeof value>>,
       dbType,
       nullability: value[Expression.TypeId].nullability as JsonNullabilityOf<JsonRuntime<Expression.RuntimeOf<typeof value>>>,
-      sourceNullability: value[Expression.TypeId].sourceNullability
     },
     {
       kind,
@@ -2259,8 +2328,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     JsonDbOfExpression<Base>,
     JsonNullabilityOf<JsonPathOutputOf<Expression.RuntimeOf<Base>, Target, "json.get">>,
     DialectOf<Base>,
-    AggregationOf<Base>,
-    SourceOf<Base>,
+    KindOf<Base>,
     DependenciesOf<Base>,
     JsonNode
   > => {
@@ -2285,8 +2353,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       JsonDbOfExpression<Base>,
       JsonNullabilityOf<JsonPathOutputOf<Expression.RuntimeOf<Base>, Target, "json.get">>,
       DialectOf<Base>,
-      AggregationOf<Base>,
-      SourceOf<Base>,
+      KindOf<Base>,
       DependenciesOf<Base>,
       JsonNode
     >
@@ -2304,8 +2371,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     TextDb,
     JsonNullabilityOf<JsonPathOutputOf<Expression.RuntimeOf<Base>, Target, "json.text">>,
     DialectOf<Base>,
-    AggregationOf<Base>,
-    SourceOf<Base>,
+    KindOf<Base>,
     DependenciesOf<Base>,
     JsonNode
   > => {
@@ -2332,8 +2398,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       TextDb,
       JsonNullabilityOf<JsonPathOutputOf<Expression.RuntimeOf<Base>, Target, "json.text">>,
       DialectOf<Base>,
-      AggregationOf<Base>,
-      SourceOf<Base>,
+      KindOf<Base>,
       DependenciesOf<Base>,
       JsonNode
     >
@@ -2461,7 +2526,6 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       runtime: true as boolean,
       dbType: profile.boolDb as BoolDb,
       nullability: "never" as const,
-      sourceNullability: "resolved" as const
     },
     {
       kind: "jsonHasKey",
@@ -2482,7 +2546,6 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       runtime: true as boolean,
       dbType: profile.boolDb as BoolDb,
       nullability: "never" as const,
-      sourceNullability: "resolved" as const
     },
     {
       kind: "jsonHasAnyKeys",
@@ -2503,7 +2566,6 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       runtime: true as boolean,
       dbType: profile.boolDb as BoolDb,
       nullability: "never" as const,
-      sourceNullability: "resolved" as const
     },
     {
       kind: "jsonHasAllKeys",
@@ -2523,8 +2585,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     JsonDbOfExpression<Base>,
     JsonNullabilityOf<JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.delete">>,
     DialectOf<Base>,
-    AggregationOf<Base>,
-    SourceOf<Base>,
+    KindOf<Base>,
     DependenciesOf<Base>,
     JsonNode
   > => {
@@ -2546,8 +2607,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       JsonDbOfExpression<Base>,
       JsonNullabilityOf<JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.delete">>,
       DialectOf<Base>,
-      AggregationOf<Base>,
-      SourceOf<Base>,
+      KindOf<Base>,
       DependenciesOf<Base>,
       JsonNode
     >
@@ -2564,8 +2624,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     JsonDbOfExpression<Base>,
     JsonNullabilityOf<JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.remove">>,
     DialectOf<Base>,
-    AggregationOf<Base>,
-    SourceOf<Base>,
+    KindOf<Base>,
     DependenciesOf<Base>,
     JsonNode
   > => {
@@ -2587,8 +2646,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       JsonDbOfExpression<Base>,
       JsonNullabilityOf<JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.remove">>,
       DialectOf<Base>,
-      AggregationOf<Base>,
-      SourceOf<Base>,
+      KindOf<Base>,
       DependenciesOf<Base>,
       JsonNode
     >
@@ -2610,8 +2668,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     JsonDbOfExpression<Base>,
     JsonNullabilityOf<JsonSetOutputOf<Expression.RuntimeOf<Base>, Target, Next, "json.set">>,
     DialectOf<Base>,
-    AggregationOf<Base>,
-    SourceOf<Base>,
+    KindOf<Base>,
     DependenciesOf<Base>,
     JsonNode
   > => {
@@ -2636,8 +2693,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       JsonDbOfExpression<Base>,
       JsonNullabilityOf<JsonSetOutputOf<Expression.RuntimeOf<Base>, Target, Next, "json.set">>,
       DialectOf<Base>,
-      AggregationOf<Base>,
-      SourceOf<Base>,
+      KindOf<Base>,
       DependenciesOf<Base>,
       JsonNode
     >
@@ -2660,8 +2716,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     JsonDbOfExpression<Base>,
     JsonNullabilityOf<JsonInsertOutputOf<Expression.RuntimeOf<Base>, Target, Next, InsertAfter, "json.insert">>,
     DialectOf<Base>,
-    AggregationOf<Base>,
-    SourceOf<Base>,
+    KindOf<Base>,
     DependenciesOf<Base>,
     JsonNode
   > => {
@@ -2687,8 +2742,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       JsonDbOfExpression<Base>,
       JsonNullabilityOf<JsonInsertOutputOf<Expression.RuntimeOf<Base>, Target, Next, InsertAfter, "json.insert">>,
       DialectOf<Base>,
-      AggregationOf<Base>,
-      SourceOf<Base>,
+      KindOf<Base>,
       DependenciesOf<Base>,
       JsonNode
     >
@@ -2709,9 +2763,8 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     Db,
     "maybe",
     Dialect,
-    Expression.AggregationKind,
+    Expression.ScalarKind,
     never,
-    {},
     JsonNode
   > => {
     const leftExpression = toJsonValueExpression(left)
@@ -2733,9 +2786,8 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       Db,
       "maybe",
       Dialect,
-      Expression.AggregationKind,
+      Expression.ScalarKind,
       never,
-      {},
       JsonNode
     >
   }
@@ -2783,7 +2835,6 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       runtime: true as boolean,
       dbType: profile.boolDb as BoolDb,
       nullability: "never" as const,
-      sourceNullability: "resolved" as const
     },
     {
       kind: "jsonKeyExists",
@@ -2811,7 +2862,6 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
         runtime: {} as JsonObjectOutput<Shape>,
         dbType,
         nullability: "never" as const,
-        sourceNullability: "resolved" as const
       },
       {
         kind: "jsonBuildObject",
@@ -2836,7 +2886,6 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
         runtime: [] as JsonArrayOutput<Values>,
         dbType,
         nullability: "never" as const,
-        sourceNullability: "resolved" as const
       },
       {
         kind: "jsonBuildArray",
@@ -2857,9 +2906,8 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     JsonDb<Dialect>,
     JsonNullabilityOf<JsonOutputOfInput<Value>>,
     string,
-    Expression.AggregationKind,
-    unknown,
-    Expression.SourceDependencies,
+    Expression.ScalarKind,
+    Expression.BindingId,
     JsonNode
   >
 
@@ -2870,9 +2918,8 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     JsonDb<Dialect, JsonbKindForDialect<Dialect>>,
     JsonNullabilityOf<JsonOutputOfInput<Value>>,
     string,
-    Expression.AggregationKind,
-    unknown,
-    Expression.SourceDependencies,
+    Expression.ScalarKind,
+    Expression.BindingId,
     JsonNode
   >
 
@@ -2932,7 +2979,6 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
           runtime: true as boolean,
           dbType: profile.boolDb as BoolDb,
           nullability: "never" as const,
-          sourceNullability: "resolved" as const
         },
         {
           kind: "jsonPathExists",
@@ -2948,7 +2994,6 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
         runtime: true as boolean,
         dbType: profile.boolDb as BoolDb,
         nullability: "never" as const,
-        sourceNullability: "resolved" as const
       },
       {
         kind: "jsonPathExists",
@@ -2984,7 +3029,6 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
           runtime: true as boolean,
           dbType: profile.boolDb as BoolDb,
           nullability: "never" as const,
-          sourceNullability: "resolved" as const
         },
         {
           kind: "jsonPathMatch",
@@ -3000,7 +3044,6 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
         runtime: true as boolean,
         dbType: profile.boolDb as BoolDb,
         nullability: "never" as const,
-        sourceNullability: "resolved" as const
       },
       {
         kind: "jsonPathMatch",
@@ -3084,12 +3127,12 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
   }
 
   const and = <
-    Values extends readonly [ExpressionInput, ...ExpressionInput[]]
+    const Values extends readonly [ExpressionInput, ...ExpressionInput[]]
   >(
     ...values: Values
   ): VariadicBooleanExpression<
     "and",
-    { readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[],
+    DialectExpressionArray<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
     Dialect,
     TextDb,
     NumericDb,
@@ -3099,16 +3142,16 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
   > =>
     makeVariadicBooleanExpression(
       "and",
-      values.map((value) => toDialectExpression(value)) as { readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]
+      values.map((value) => toDialectExpression(value)) as unknown as DialectExpressionArray<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
     )
 
   const or = <
-    Values extends readonly [ExpressionInput, ...ExpressionInput[]]
+    const Values extends readonly [ExpressionInput, ...ExpressionInput[]]
   >(
     ...values: Values
   ): VariadicBooleanExpression<
     "or",
-    { readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[],
+    DialectExpressionArray<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
     Dialect,
     TextDb,
     NumericDb,
@@ -3118,7 +3161,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
   > =>
     makeVariadicBooleanExpression(
       "or",
-      values.map((value) => toDialectExpression(value)) as { readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]
+      values.map((value) => toDialectExpression(value)) as unknown as DialectExpressionArray<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
     )
 
   const not = <Value extends ExpressionInput>(
@@ -3128,8 +3171,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     BoolDb,
     Expression.NullabilityOf<DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
     DialectOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-    AggregationOf<DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-    SourceOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+    KindOf<DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
     DependenciesOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
     ExpressionAst.UnaryNode<"not", DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
   > => {
@@ -3139,10 +3181,9 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       dbType: profile.boolDb as BoolDb,
       nullability: expression[Expression.TypeId].nullability as Expression.NullabilityOf<DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
       dialect: expression[Expression.TypeId].dialect,
-      aggregation: expression[Expression.TypeId].aggregation as AggregationOf<DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-      source: expression[Expression.TypeId].source as SourceOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-      sourceNullability: "propagate" as const,
-      dependencies: expression[Expression.TypeId].dependencies as DependenciesOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+      kind: expression[Expression.TypeId].kind as KindOf<DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
+
+      dependencies: expression[Expression.TypeId].dependencies
     }, {
       kind: "not",
       value: expression
@@ -3156,8 +3197,8 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     head: Head,
     ...tail: {
       readonly [K in keyof Tail]: Tail[K] & ComparableInput<
-        Head,
-        Tail[K],
+        NoInfer<Head>,
+        NoInfer<Tail[K]>,
         Dialect,
         TextDb,
         NumericDb,
@@ -3177,8 +3218,8 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     head: Head,
     ...tail: {
       readonly [K in keyof Tail]: Tail[K] & ComparableInput<
-        Head,
-        Tail[K],
+        NoInfer<Head>,
+        NoInfer<Tail[K]>,
         Dialect,
         TextDb,
         NumericDb,
@@ -3240,7 +3281,6 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     MergeNullabilityTuple<DialectStringExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
     TupleDialect<DialectStringExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
     MergeAggregationTuple<DialectStringExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-    TupleSource<DialectStringExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
     TupleDependencies<DialectStringExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
     ExpressionAst.VariadicNode<"concat", DialectStringExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
   > => {
@@ -3250,10 +3290,9 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       dbType: profile.textDb as TextDb,
       nullability: mergeNullabilityManyRuntime(expressions) as MergeNullabilityTuple<DialectStringExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
       dialect: (expressions.find((value) => value[Expression.TypeId].dialect !== undefined)?.[Expression.TypeId].dialect ?? profile.dialect) as TupleDialect<DialectStringExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-      aggregation: mergeAggregationManyRuntime(expressions) as MergeAggregationTuple<DialectStringExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-      source: mergeManySources(expressions) as TupleSource<DialectStringExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-      sourceNullability: "propagate" as const,
-      dependencies: mergeManyDependencies(expressions) as TupleDependencies<DialectStringExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
+      kind: mergeAggregationManyRuntime(expressions) as MergeAggregationTuple<DialectStringExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
+
+      dependencies: mergeManyDependencies(expressions)
     }, {
       kind: "concat",
       values: expressions
@@ -3263,7 +3302,6 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       MergeNullabilityTuple<DialectStringExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
       TupleDialect<DialectStringExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
       MergeAggregationTuple<DialectStringExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-      TupleSource<DialectStringExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
       TupleDependencies<DialectStringExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
       ExpressionAst.VariadicNode<"concat", DialectStringExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
     >
@@ -3289,10 +3327,8 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     "never",
     DialectOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
     "aggregate",
-    SourceOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
     DependenciesOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-    ExpressionAst.UnaryNode<"count", DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-    "resolved"
+    ExpressionAst.UnaryNode<"count", DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
   > => {
     const expression = toDialectExpression(value)
     return makeExpression({
@@ -3300,10 +3336,9 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       dbType: profile.numericDb as NumericDb,
       nullability: "never",
       dialect: expression[Expression.TypeId].dialect,
-      aggregation: "aggregate",
-      source: expression[Expression.TypeId].source as SourceOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-      sourceNullability: "resolved" as const,
-      dependencies: expression[Expression.TypeId].dependencies as DependenciesOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+      kind: "aggregate",
+
+      dependencies: expression[Expression.TypeId].dependencies
     }, {
       kind: "count",
       value: expression
@@ -3320,10 +3355,8 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     "never",
     Dialect,
     "scalar",
-    never,
     DependencyRecord<OutstandingOfPlan<PlanValue>>,
-    ExpressionAst.ExistsNode<PlanValue>,
-    "resolved"
+    ExpressionAst.ExistsNode<PlanValue>
   > => {
     const dependencies = Object.fromEntries(
       currentRequiredList(plan[Plan.TypeId].required).map((name) => [name, true] as const)
@@ -3333,9 +3366,8 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       dbType: profile.boolDb as BoolDb,
       nullability: "never",
       dialect: profile.dialect as Dialect,
-      aggregation: "scalar",
-      source: undefined as never,
-      sourceNullability: "resolved" as const,
+      kind: "scalar",
+
       dependencies
     }, {
       kind: "exists",
@@ -3353,10 +3385,8 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     "maybe",
     Dialect,
     "scalar",
-    never,
     DependencyRecord<OutstandingOfPlan<PlanValue>>,
-    ExpressionAst.ScalarSubqueryNode<PlanValue>,
-    "resolved"
+    ExpressionAst.ScalarSubqueryNode<PlanValue>
   > => {
     const dependencies = Object.fromEntries(
       currentRequiredList(plan[Plan.TypeId].required).map((name) => [name, true] as const)
@@ -3365,11 +3395,12 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     return makeExpression({
       runtime: undefined as Expression.RuntimeOf<ScalarOutputOfPlan<PlanValue>> | null,
       dbType: expression[Expression.TypeId].dbType as Expression.DbTypeOf<ScalarOutputOfPlan<PlanValue>>,
+      runtimeSchema: expression[Expression.TypeId].runtimeSchema,
+      driverValueMapping: expression[Expression.TypeId].driverValueMapping,
       nullability: "maybe",
       dialect: profile.dialect as Dialect,
-      aggregation: "scalar",
-      source: undefined as never,
-      sourceNullability: "resolved" as const,
+      kind: "scalar",
+
       dependencies
     }, {
       kind: "scalarSubquery",
@@ -3407,8 +3438,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     )
   ): SubqueryPredicateExpression<
     Dialect,
-    AggregationOf<DialectAsExpression<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-    SourceOfDialectInput<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+    KindOf<DialectAsExpression<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
     DependencyRecord<RequiredFromDialectInput<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> | OutstandingOfPlan<PlanValue>>,
     ExpressionAst.InSubqueryNode<
       DialectAsExpression<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
@@ -3424,12 +3454,9 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       dbType: profile.boolDb as BoolDb,
       nullability: "maybe",
       dialect: (leftExpression[Expression.TypeId].dialect ?? profile.dialect) as Dialect,
-      aggregation: leftExpression[Expression.TypeId].aggregation as AggregationOf<DialectAsExpression<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-      source: leftExpression[Expression.TypeId].source as SourceOfDialectInput<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-      sourceNullability: "propagate" as const,
-      dependencies: mergeDependencies(leftExpression[Expression.TypeId].dependencies, dependencies) as DependencyRecord<
-        RequiredFromDialectInput<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> | OutstandingOfPlan<PlanValue>
-      >
+      kind: leftExpression[Expression.TypeId].kind as KindOf<DialectAsExpression<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
+
+      dependencies: mergeDependencies(leftExpression[Expression.TypeId].dependencies, dependencies)
     }, {
       kind: "inSubquery",
       left: leftExpression,
@@ -3457,12 +3484,9 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       dbType: profile.boolDb as BoolDb,
       nullability: "maybe",
       dialect: (leftExpression[Expression.TypeId].dialect ?? profile.dialect) as Dialect,
-      aggregation: leftExpression[Expression.TypeId].aggregation as AggregationOf<DialectAsExpression<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-      source: leftExpression[Expression.TypeId].source as SourceOfDialectInput<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-      sourceNullability: "propagate" as const,
-      dependencies: mergeDependencies(leftExpression[Expression.TypeId].dependencies, dependencies) as DependencyRecord<
-        RequiredFromDialectInput<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> | OutstandingOfPlan<PlanValue>
-      >
+      kind: leftExpression[Expression.TypeId].kind as KindOf<DialectAsExpression<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
+
+      dependencies: mergeDependencies(leftExpression[Expression.TypeId].dependencies, dependencies)
     }, renderQuantifiedComparisonAst(leftExpression, plan, operator, quantifier) as ExpressionAst.QuantifiedComparisonNode<
       Quantifier extends "any" ? "comparisonAny" : "comparisonAll",
       Operator,
@@ -3492,15 +3516,13 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
   ): Expression.Any => quantifiedComparison(left, plan, operator, "all") as Expression.Any
 
   const over = <
-    Value extends Expression.Expression<
+    Value extends Expression.Scalar<
       any,
       Expression.DbType.Any,
       Expression.Nullability,
       string,
       "aggregate",
-      any,
-      Expression.SourceDependencies,
-      Expression.SourceNullabilityMode
+      Expression.BindingId
     >,
     PartitionBy extends readonly WindowPartitionInput[] = [],
     OrderBy extends readonly WindowOrderTermInput[] = []
@@ -3515,10 +3537,9 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       dbType: value[Expression.TypeId].dbType as Expression.DbTypeOf<Value>,
       nullability: value[Expression.TypeId].nullability as Expression.NullabilityOf<Value>,
       dialect: (expressions.find((expression) => expression[Expression.TypeId].dialect !== undefined)?.[Expression.TypeId].dialect ?? profile.dialect) as WindowDialectOf<Value, PartitionBy, OrderBy>,
-      aggregation: "window",
-      source: mergeManySources(expressions) as WindowSourceOf<Value, PartitionBy, OrderBy>,
-      sourceNullability: "resolved" as const,
-      dependencies: mergeManyDependencies(expressions) as WindowDependenciesOf<Value, PartitionBy, OrderBy>
+      kind: "window",
+
+      dependencies: mergeManyDependencies(expressions)
     }, {
       kind: "window",
       function: "over",
@@ -3543,13 +3564,12 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       dbType: profile.numericDb as Expression.DbType.Any,
       nullability: "never",
       dialect: (expressions.find((expression) => expression[Expression.TypeId].dialect !== undefined)?.[Expression.TypeId].dialect ?? profile.dialect) as NumberWindowDialectOf<PartitionBy, OrderBy>,
-      aggregation: "window",
-      source: mergeManySources(expressions) as NumberWindowSourceOf<PartitionBy, OrderBy>,
-      sourceNullability: "resolved" as const,
-      dependencies: mergeManyDependencies(expressions) as NumberWindowDependenciesOf<PartitionBy, OrderBy>
-    }, {
       kind: "window",
-      function: kind,
+
+      dependencies: mergeManyDependencies(expressions)
+    }, {
+      kind: "window",
+      function: kind,
       partitionBy: normalized.partitionBy,
       orderBy: normalized.orderBy
     })
@@ -3587,20 +3607,17 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     "maybe",
     DialectOf<Value>,
     "aggregate",
-    SourceOf<Value>,
     DependenciesOf<Value>,
-    ExpressionAst.UnaryNode<"max", Value>,
-    "resolved"
+    ExpressionAst.UnaryNode<"max", Value>
   > =>
     makeExpression({
       runtime: undefined as Expression.RuntimeOf<Value>,
       dbType: value[Expression.TypeId].dbType as Expression.DbTypeOf<Value>,
       nullability: "maybe",
       dialect: value[Expression.TypeId].dialect,
-      aggregation: "aggregate",
-      source: value[Expression.TypeId].source as SourceOf<Value>,
-      sourceNullability: "resolved" as const,
-      dependencies: value[Expression.TypeId].dependencies as DependenciesOf<Value>
+      kind: "aggregate",
+
+      dependencies: value[Expression.TypeId].dependencies
     }, {
       kind: "max",
       value
@@ -3614,20 +3631,17 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     "maybe",
     DialectOf<Value>,
     "aggregate",
-    SourceOf<Value>,
     DependenciesOf<Value>,
-    ExpressionAst.UnaryNode<"min", Value>,
-    "resolved"
+    ExpressionAst.UnaryNode<"min", Value>
   > =>
     makeExpression({
       runtime: undefined as Expression.RuntimeOf<Value>,
       dbType: value[Expression.TypeId].dbType as Expression.DbTypeOf<Value>,
       nullability: "maybe",
       dialect: value[Expression.TypeId].dialect,
-      aggregation: "aggregate",
-      source: value[Expression.TypeId].source as SourceOf<Value>,
-      sourceNullability: "resolved" as const,
-      dependencies: value[Expression.TypeId].dependencies as DependenciesOf<Value>
+      kind: "aggregate",
+
+      dependencies: value[Expression.TypeId].dependencies
     }, {
       kind: "min",
       value
@@ -3652,10 +3666,8 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     CoalesceNullabilityTuple<DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
     TupleDialect<DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
     MergeAggregationTuple<DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-    TupleSource<DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
     TupleDependencies<DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-    ExpressionAst.VariadicNode<"coalesce", DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-    "resolved"
+    ExpressionAst.VariadicNode<"coalesce", DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
   > => {
     const expressions = values.map((value) => toDialectExpression(value)) as readonly Expression.Any[]
     const representative = expressions.find((value) =>
@@ -3665,10 +3677,9 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       dbType: representative[Expression.TypeId].dbType as any,
       nullability: resolveCoalesceNullabilityRuntime(expressions) as any,
       dialect: (expressions.find((value) => value[Expression.TypeId].dialect !== undefined)?.[Expression.TypeId].dialect ?? profile.dialect) as any,
-      aggregation: mergeAggregationManyRuntime(expressions) as any,
-      source: mergeManySources(expressions) as any,
-      sourceNullability: "resolved" as const,
-      dependencies: mergeManyDependencies(expressions) as any
+      kind: mergeAggregationManyRuntime(expressions) as any,
+
+      dependencies: mergeManyDependencies(expressions)
     }, {
       kind: "coalesce",
       values: expressions
@@ -3678,10 +3689,8 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       CoalesceNullabilityTuple<DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
       TupleDialect<DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
       MergeAggregationTuple<DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-      TupleSource<DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
       TupleDependencies<DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-      ExpressionAst.VariadicNode<"coalesce", DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-      "resolved"
+      ExpressionAst.VariadicNode<"coalesce", DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
     >
   }
 
@@ -3698,9 +3707,8 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       dbType: profile.textDb,
       nullability: "maybe",
       dialect: (expressions.find((value) => value[Expression.TypeId].dialect !== undefined)?.[Expression.TypeId].dialect ?? profile.dialect) as Dialect,
-      aggregation: mergeAggregationManyRuntime(expressions),
-      source: mergeManySources(expressions),
-      sourceNullability: "resolved" as const,
+      kind: mergeAggregationManyRuntime(expressions),
+
       dependencies: mergeManyDependencies(expressions)
     }, {
       kind: "function",
@@ -3709,25 +3717,22 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     }) as Expression.Any
   }
 
-  const uuidGenerateV4 = (): Expression.Expression<
+  const uuidGenerateV4 = (): Expression.Scalar<
     string,
-    Expression.DbType.PgUuid,
+    Expression.DbType.Base<"mysql", "uuid">,
     "never",
     Dialect,
     "scalar",
-    never,
-    {},
-    "resolved"
+    never
   > & {
     readonly [ExpressionAst.TypeId]: ExpressionAst.FunctionCallNode<"uuid_generate_v4", readonly []>
   } => makeExpression({
     runtime: undefined as unknown as string,
-    dbType: { dialect: "postgres", kind: "uuid" } as Expression.DbType.PgUuid,
+    dbType: mysqlDatatypes.uuid(),
     nullability: "never",
     dialect: profile.dialect as Dialect,
-    aggregation: "scalar",
-    source: undefined as never,
-    sourceNullability: "resolved" as const,
+    kind: "scalar",
+
     dependencies: {}
   }, {
     kind: "function",
@@ -3737,25 +3742,22 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
 
   const nextVal = <Value extends ExpressionInput>(
     value: Value
-  ): Expression.Expression<
-    Expression.RuntimeOfDbType<Expression.DbType.PgInt8>,
-    Expression.DbType.PgInt8,
+  ): Expression.Scalar<
+    Expression.RuntimeOfDbType<Expression.DbType.Base<"mysql", "bigint">>,
+    Expression.DbType.Base<"mysql", "bigint">,
     "never",
     Dialect,
     "scalar",
-    never,
-    {},
-    "resolved"
+    never
   > & {
     readonly [ExpressionAst.TypeId]: ExpressionAst.FunctionCallNode<"nextval", readonly [Expression.Any]>
   } => makeExpression({
-    runtime: undefined as unknown as Expression.RuntimeOfDbType<Expression.DbType.PgInt8>,
-    dbType: { dialect: "postgres", kind: "int8" } as Expression.DbType.PgInt8,
+    runtime: undefined as unknown as Expression.RuntimeOfDbType<Expression.DbType.Base<"mysql", "bigint">>,
+    dbType: mysqlDatatypes.bigint(),
     nullability: "never",
     dialect: profile.dialect as Dialect,
-    aggregation: "scalar",
-    source: undefined as never,
-    sourceNullability: "resolved" as const,
+    kind: "scalar",
+
     dependencies: {}
   }, {
     kind: "function",
@@ -3805,9 +3807,8 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       dbType: representative[Expression.TypeId].dbType,
       nullability: resolveCaseNullabilityRuntime(resultExpressions),
       dialect: (allExpressions.find((value) => value[Expression.TypeId].dialect !== undefined)?.[Expression.TypeId].dialect ?? profile.dialect),
-      aggregation: mergeAggregationManyRuntime(allExpressions),
-      source: mergeManySources(allExpressions),
-      sourceNullability: "resolved" as const,
+      kind: mergeAggregationManyRuntime(allExpressions),
+
       dependencies: mergeManyDependencies(allExpressions)
     }, {
       kind: "case",
@@ -3912,15 +3913,13 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
   }
 
   const excluded = <
-    Value extends Expression.Expression<
+    Value extends Expression.Scalar<
       any,
       Expression.DbType.Any,
       Expression.Nullability,
       string,
       "scalar",
-      any,
-      Expression.SourceDependencies,
-      Expression.SourceNullabilityMode
+      Expression.BindingId
     >
   >(
     value: Value
@@ -3931,9 +3930,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     Dialect,
     "scalar",
     never,
-    {},
-    ExpressionAst.ExcludedNode<AstOf<Value> extends ExpressionAst.ColumnNode<any, infer ColumnName extends string> ? ColumnName : string>,
-    "resolved"
+    ExpressionAst.ExcludedNode<AstOf<Value> extends ExpressionAst.ColumnNode<any, infer ColumnName extends string> ? ColumnName : string>
   > => {
     const ast = ((value as unknown) as Expression.Any & { readonly [ExpressionAst.TypeId]: ExpressionAst.Any })[ExpressionAst.TypeId]
     if (ast.kind !== "column") {
@@ -3943,11 +3940,11 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       runtime: undefined as Expression.RuntimeOf<Value>,
       dbType: value[Expression.TypeId].dbType as Expression.DbTypeOf<Value>,
       runtimeSchema: value[Expression.TypeId].runtimeSchema,
+      driverValueMapping: value[Expression.TypeId].driverValueMapping,
       nullability: value[Expression.TypeId].nullability as Expression.NullabilityOf<Value>,
       dialect: profile.dialect as Dialect,
-      aggregation: "scalar",
-      source: undefined as never,
-      sourceNullability: "resolved" as const,
+      kind: "scalar",
+
       dependencies: {}
     }, {
       kind: "excluded",
@@ -3959,9 +3956,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
       Dialect,
       "scalar",
       never,
-      {},
-      ExpressionAst.ExcludedNode<AstOf<Value> extends ExpressionAst.ColumnNode<any, infer ColumnName extends string> ? ColumnName : string>,
-      "resolved"
+      ExpressionAst.ExcludedNode<AstOf<Value> extends ExpressionAst.ColumnNode<any, infer ColumnName extends string> ? ColumnName : string>
     >
   }
 
@@ -3970,16 +3965,17 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     column: Expression.Any
   ): Expression.Any => {
     if (value !== null && typeof value === "object" && Expression.TypeId in value) {
-      return value as unknown as Expression.Any
+      return retargetLiteralExpression(value as unknown as Expression.Any, column)
     }
     return makeExpression({
       runtime: value as Value,
       dbType: column[Expression.TypeId].dbType,
+      runtimeSchema: column[Expression.TypeId].runtimeSchema,
+      driverValueMapping: column[Expression.TypeId].driverValueMapping,
       nullability: value === null ? "always" : "never",
       dialect: column[Expression.TypeId].dialect,
-      aggregation: "scalar",
-      source: undefined as never,
-      sourceNullability: "propagate" as const,
+      kind: "scalar",
+
       dependencies: {}
     }, {
       kind: "literal",
@@ -4050,15 +4046,10 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
         runtime: undefined as never,
         dbType: state.dbType,
         runtimeSchema: state.runtimeSchema,
+        driverValueMapping: state.driverValueMapping,
         nullability: state.nullability,
         dialect: state.dialect,
-        aggregation: "scalar",
-        source: {
-          tableName: alias,
-          columnName,
-          baseTableName: alias
-        },
-        sourceNullability: "propagate" as const,
+        kind: "scalar",
         dependencies: {
           [alias]: true
         } as Record<Alias, true>
@@ -4693,8 +4684,6 @@ type AstOf<Value extends Expression.Any> =
     ? Ast
     : never
 
-type AvailableNames<Available extends Record<string, Plan.AnySource>> = Extract<keyof Available, string>
-
 type RequiredFromInput<Value extends ExpressionInput> =
   Value extends Expression.Any
     ? RequiredFromDependencies<DependenciesOf<Value>>
@@ -4758,7 +4747,10 @@ type SelectFromResult<
   Exclude<OutstandingOfPlan<PlanValue>, SourceNameOf<CurrentSource>>,
   AssumptionsOfPlan<PlanValue>,
   MergeCapabilities<CapabilitiesOfPlan<PlanValue>, SourceCapabilitiesOf<CurrentSource>>,
-  StatementOfPlan<PlanValue>
+  StatementOfPlan<PlanValue>,
+  MutationTargetOfPlan<PlanValue>,
+  InsertSourceStateOfPlan<PlanValue>,
+  FactsOfPlan<PlanValue>
 >
 
 type UpdateFromResult<
@@ -4780,7 +4772,10 @@ type UpdateFromResult<
   Exclude<OutstandingOfPlan<PlanValue>, SourceNameOf<CurrentSource>>,
   AssumptionsOfPlan<PlanValue>,
   MergeCapabilities<CapabilitiesOfPlan<PlanValue>, SourceCapabilitiesOf<CurrentSource>>,
-  StatementOfPlan<PlanValue>
+  StatementOfPlan<PlanValue>,
+  MutationTargetOfPlan<PlanValue>,
+  InsertSourceStateOfPlan<PlanValue>,
+  FactsOfPlan<PlanValue>
 >
 
 type InsertFromResult<
@@ -4801,7 +4796,8 @@ type InsertFromResult<
     : CapabilitiesOfPlan<PlanValue>,
   StatementOfPlan<PlanValue>,
   MutationTargetOfPlan<PlanValue>,
-  "ready"
+  "ready",
+  FactsOfPlan<PlanValue>
 >
 
 type FromPlanConstraint<
@@ -4846,6 +4842,74 @@ type FromPlanResult<
         : never
       : never
 
+export type PublicStructuredFromConstraint<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
+  CurrentSource extends AnyValuesSource | AnyUnnestSource | AnyTableFunctionSource,
+  Dialect extends string
+> =
+  StatementOfPlan<PlanValue> extends "insert"
+    ? CurrentSource extends AnyValuesSource | AnyUnnestSource
+      ? RequirePendingInsertStatement<PlanValue>
+      : FromPlanConstraint<PlanValue, CurrentSource, Dialect>
+    : FromPlanConstraint<PlanValue, CurrentSource, Dialect>
+
+export type PublicStructuredFromResult<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
+  CurrentSource extends AnyValuesSource | AnyUnnestSource | AnyTableFunctionSource,
+  Dialect extends string
+> =
+  StatementOfPlan<PlanValue> extends "select"
+    ? QueryPlan<
+        SelectionOfPlan<PlanValue>,
+        Exclude<RequiredOfPlan<PlanValue>, SourceNameOf<CurrentSource>>,
+        AddAvailable<{}, SourceNameOf<CurrentSource>>,
+        PlanDialectOf<PlanValue> | SourceDialectOf<CurrentSource>,
+        GroupedOfPlan<PlanValue>,
+        SourceNameOf<CurrentSource>,
+        Exclude<OutstandingOfPlan<PlanValue>, SourceNameOf<CurrentSource>>,
+        AssumptionsOfPlan<PlanValue>,
+        MergeCapabilities<CapabilitiesOfPlan<PlanValue>, SourceCapabilitiesOf<CurrentSource>>,
+        StatementOfPlan<PlanValue>
+      >
+    : StatementOfPlan<PlanValue> extends "update"
+      ? QueryPlan<
+          SelectionOfPlan<PlanValue>,
+          Exclude<RequiredOfPlan<PlanValue>, SourceNameOf<CurrentSource>>,
+          AddAvailable<AvailableOfPlan<PlanValue>, SourceNameOf<CurrentSource>>,
+          PlanDialectOf<PlanValue> | SourceDialectOf<CurrentSource>,
+          GroupedOfPlan<PlanValue>,
+          ScopedNamesOfPlan<PlanValue> | SourceNameOf<CurrentSource>,
+          Exclude<OutstandingOfPlan<PlanValue>, SourceNameOf<CurrentSource>>,
+          AssumptionsOfPlan<PlanValue>,
+          MergeCapabilities<CapabilitiesOfPlan<PlanValue>, SourceCapabilitiesOf<CurrentSource>>,
+          StatementOfPlan<PlanValue>
+        >
+      : StatementOfPlan<PlanValue> extends "insert"
+      ? CurrentSource extends AnyValuesSource | AnyUnnestSource
+        ? QueryPlan<
+            SelectionOfPlan<PlanValue>,
+            never,
+            AvailableOfPlan<PlanValue>,
+            PlanDialectOf<PlanValue>,
+            GroupedOfPlan<PlanValue>,
+            ScopedNamesOfPlan<PlanValue>,
+            never,
+            AssumptionsOfPlan<PlanValue>,
+            CapabilitiesOfPlan<PlanValue>,
+            StatementOfPlan<PlanValue>,
+            MutationTargetOfPlan<PlanValue>,
+            "ready"
+          >
+        : FromPlanResult<PlanValue, CurrentSource, Dialect>
+      : FromPlanResult<PlanValue, CurrentSource, Dialect>
+
+export type PublicNonStructuredFromApi = <CurrentSource extends Exclude<FromInput, AnyValuesSource | AnyUnnestSource | AnyTableFunctionSource>>(
+  source: CurrentSource
+) =>
+  <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+    plan: PlanValue & FromPlanConstraint<PlanValue, CurrentSource, Dialect>
+  ) => FromPlanResult<PlanValue, CurrentSource, Dialect>
+
 type MergeRequiredFromPredicate<
   Predicate extends PredicateInput | undefined,
   Available extends Record<string, Plan.AnySource>
@@ -4923,7 +4987,7 @@ type AsCurriedResult<
     if (typeof value !== "object" || value === null || Expression.TypeId in value) {
       const expression = toDialectExpression(value as ExpressionInput)
       const projected = Object.create(Object.getPrototypeOf(expression)) as {
-        [Expression.TypeId]: Expression.State<any, any, any, any, any, any, any, Expression.SourceNullabilityMode>
+        [Expression.TypeId]: Expression.State<any, any, any, any, any, any>
         [ExpressionAst.TypeId]: ExpressionAst.Any
         [ProjectionAlias.TypeId]: ProjectionAlias.State<string>
         schema?: unknown
@@ -4959,14 +5023,14 @@ type AsCurriedResult<
     alias: Alias
   ): <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
     value: CompletePlan<PlanValue>
-  ) => import("./query.js").CteSource<PlanValue, Alias>
+  ) => import("../../internal/query.js").CteSource<PlanValue, Alias>
   function with_<
     PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
     Alias extends string
   >(
     value: CompletePlan<PlanValue>,
     alias: Alias
-  ): import("./query.js").CteSource<PlanValue, Alias>
+  ): import("../../internal/query.js").CteSource<PlanValue, Alias>
   function with_(valueOrAlias: unknown, alias?: string): unknown {
     if (alias === undefined) {
       return (value: unknown) => with_(value as any, valueOrAlias as string)
@@ -4983,14 +5047,14 @@ type AsCurriedResult<
     alias: Alias
   ): <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
     value: CompletePlan<PlanValue>
-  ) => import("./query.js").CteSource<PlanValue, Alias>
+  ) => import("../../internal/query.js").CteSource<PlanValue, Alias>
   function withRecursive_<
     PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
     Alias extends string
   >(
     value: CompletePlan<PlanValue>,
     alias: Alias
-  ): import("./query.js").CteSource<PlanValue, Alias>
+  ): import("../../internal/query.js").CteSource<PlanValue, Alias>
   function withRecursive_(valueOrAlias: unknown, alias?: string): unknown {
     if (alias === undefined) {
       return (value: unknown) => withRecursive_(value as any, valueOrAlias as string)
@@ -5008,14 +5072,14 @@ type AsCurriedResult<
     alias: Alias
   ): <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
     value: PlanValue
-  ) => import("./query.js").LateralSource<PlanValue, Alias>
+  ) => import("../../internal/query.js").LateralSource<PlanValue, Alias>
   function lateral<
     PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
     Alias extends string
   >(
     value: PlanValue,
     alias: Alias
-  ): import("./query.js").LateralSource<PlanValue, Alias>
+  ): import("../../internal/query.js").LateralSource<PlanValue, Alias>
   function lateral(valueOrAlias: unknown, alias?: string): unknown {
     if (alias === undefined) {
       return (value: unknown) => lateral(value as any, valueOrAlias as string)
@@ -5026,105 +5090,29 @@ type AsCurriedResult<
     )
   }
 
-  const values = <
+  export type ValuesApi = <
     Rows extends ValuesRowsInput
   >(
     rows: Rows
-  ): ValuesInput<
+  ) => ValuesInput<
     Rows,
     ValuesOutputShape<Rows[0], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
     Dialect
-  > => {
-    if (rows.length === 0) {
-      throw new Error("values(...) requires at least one row")
-    }
-    const normalizedRows: readonly [
-      Record<string, Expression.Any>,
-      ...Record<string, Expression.Any>[]
-    ] = rows.map((row) => normalizeValuesRow(row)) as any
-    const columnNames = Object.keys(normalizedRows[0]!)
-    for (const row of normalizedRows) {
-      const rowKeys = Object.keys(row)
-      if (rowKeys.length !== columnNames.length || !rowKeys.every((key, index) => key === columnNames[index])) {
-        throw new Error("values(...) rows must project the same columns in the same order")
-      }
-    }
-    return Object.assign(Object.create(ValuesInputProto), {
-      kind: "values",
-      dialect: profile.dialect,
-      rows: normalizedRows,
-      selection: normalizedRows[0]! as ValuesOutputShape<
-        Rows[0],
-        Dialect,
-        TextDb,
-        NumericDb,
-        BoolDb,
-        TimestampDb,
-        NullDb
-      >
-    }) as ValuesInput<
-      Rows,
-      ValuesOutputShape<Rows[0], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-      Dialect
-    >
-  }
+  >
 
-  const unnest = <
+  export type UnnestApi = <
     Columns extends UnnestColumnsInput,
     Alias extends string
   >(
     columns: Columns,
     alias: Alias
-  ): UnnestSource<
+  ) => UnnestSource<
     UnnestOutputShape<Columns, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
     Alias,
     Dialect
-  > => {
-    const normalizedColumns = normalizeUnnestColumns(columns)
-    const columnNames = Object.keys(normalizedColumns)
-    if (columnNames.length === 0) {
-      throw new Error("unnest(...) requires at least one column array")
-    }
-    const firstColumn = normalizedColumns[columnNames[0] as keyof typeof normalizedColumns]
-    const rowCount = firstColumn?.length ?? 0
-    if (rowCount === 0) {
-      throw new Error("unnest(...) requires at least one row")
-    }
-    for (const columnName of columnNames) {
-      const values = normalizedColumns[columnName]!
-      if (values.length !== rowCount) {
-        throw new Error("unnest(...) column arrays must have the same length")
-      }
-    }
-    const firstRow = Object.fromEntries(
-      columnNames.map((columnName) => [columnName, normalizedColumns[columnName]![0]!])
-    ) as Record<string, Expression.Any>
-    const columnsSelection = makeColumnReferenceSelection(alias, firstRow) as any as UnnestOutputShape<
-      Columns,
-      Dialect,
-      TextDb,
-      NumericDb,
-      BoolDb,
-      TimestampDb,
-      NullDb
-    >
-    const source = {
-      kind: "unnest",
-      name: alias,
-      baseName: alias,
-      dialect: profile.dialect,
-      values: columns,
-      arrays: normalizedColumns,
-      columns: columnsSelection
-    }
-    return Object.assign(source, columnsSelection) as unknown as UnnestSource<
-      UnnestOutputShape<Columns, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-      Alias,
-      Dialect
-    >
-  }
+  >
 
-  const generateSeries = <
+  export type GenerateSeriesApi = <
     Start extends NumericExpressionInput,
     Stop extends NumericExpressionInput,
     Step extends NumericExpressionInput | undefined = undefined,
@@ -5133,54 +5121,19 @@ type AsCurriedResult<
     start: Start,
     stop: Stop,
     step?: Step,
-    alias: Alias = "series" as Alias
-  ): Dialect extends "postgres"
+    alias?: Alias
+  ) => Dialect extends "postgres"
     ? TableFunctionSource<
         GenerateSeriesOutputShape<Start, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
         Alias,
         Dialect,
         "generate_series"
       >
-    : GenerateSeriesUnsupportedError<Dialect> => {
-    const startExpression = toDialectNumericExpression(start)
-    const stopExpression = toDialectNumericExpression(stop)
-    const stepExpression = step === undefined ? undefined : toDialectNumericExpression(step)
-    const valueSelection = {
-      value: startExpression
-    } as Record<string, Expression.Any>
-    const columns = makeColumnReferenceSelection(alias, valueSelection) as any as GenerateSeriesOutputShape<
-      Start,
-      Dialect,
-      TextDb,
-      NumericDb,
-      BoolDb,
-      TimestampDb,
-      NullDb
-    >
-    const source = {
-      kind: "tableFunction",
-      name: alias,
-      baseName: alias,
-      dialect: profile.dialect,
-      functionName: "generate_series",
-      args: stepExpression === undefined
-        ? [startExpression, stopExpression] as readonly Expression.Any[]
-        : [startExpression, stopExpression, stepExpression] as readonly Expression.Any[],
-      columns
-    }
-    return Object.assign(source, columns) as unknown as Dialect extends "postgres"
-      ? TableFunctionSource<
-          GenerateSeriesOutputShape<Start, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-          Alias,
-          Dialect,
-          "generate_series"
-        >
-      : GenerateSeriesUnsupportedError<Dialect>
-  }
+    : GenerateSeriesUnsupportedError<Dialect>
 
-  const select = <Selection extends SelectionShape>(
+  export type SelectApi = <Selection extends SelectionShape>(
     selection: Selection
-  ): QueryPlan<
+  ) => QueryPlan<
     Selection,
     ExtractRequired<Selection>,
     {},
@@ -5190,95 +5143,45 @@ type AsCurriedResult<
     ExtractRequired<Selection>,
     TrueFormula,
     "read",
-    "select"
-  > =>
-    makePlan({
-      selection,
-      required: extractRequiredRuntime(selection) as ExtractRequired<Selection>,
-      available: {},
-      dialect: profile.dialect as ExtractDialect<Selection> extends never ? Dialect : ExtractDialect<Selection>
-    }, {
-      kind: "select",
-      select: selection,
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: []
-    }, undefined as unknown as TrueFormula, "read", "select")
-
-  const buildSetOperation = <
-    Operator extends QueryAst.SetOperatorKind,
-    LeftPlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
-    RightPlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
-  >(
-    kind: Operator,
-    all: boolean,
-    left: SetCompatiblePlan<LeftPlanValue, Dialect>,
-    right: SetCompatibleRightPlan<LeftPlanValue, RightPlanValue, Dialect>
-  ): QueryPlan<
-    SelectionOfPlan<LeftPlanValue>,
-    never,
-    {},
-    PlanDialectOf<LeftPlanValue> | PlanDialectOf<RightPlanValue>,
-    GroupedOfPlan<LeftPlanValue>,
-    never,
-    never,
-    TrueFormula,
-    CapabilitiesOfPlan<LeftPlanValue> | CapabilitiesOfPlan<RightPlanValue>,
-    "set"
-  > => {
-    const leftState = left[Plan.TypeId]
-    const leftAst = getAst(left)
-    const basePlan = leftAst.kind === "set"
-      ? leftAst.setBase ?? left
-      : left
-    const leftOperations = leftAst.kind === "set"
-      ? [...(leftAst.setOperations ?? [])]
-      : []
-    return makePlan({
-      selection: leftState.selection as SelectionOfPlan<LeftPlanValue>,
-      required: undefined as never,
-      available: {},
-      dialect: (leftState.dialect ?? right[Plan.TypeId].dialect) as PlanDialectOf<LeftPlanValue> | PlanDialectOf<RightPlanValue>
-    }, {
-      kind: "set",
-      select: leftState.selection,
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: [],
-      setBase: basePlan,
-      setOperations: [
-        ...leftOperations,
-        {
-          kind,
-          all,
-          query: right
-        }
-      ]
-    }, undefined as unknown as TrueFormula, undefined as unknown as CapabilitiesOfPlan<LeftPlanValue> | CapabilitiesOfPlan<RightPlanValue>, "set")
+    "select",
+    any,
+    "ready",
+    EmptyFacts
+  >
+
+  const {
+    values,
+    unnest,
+    generateSeries,
+    select,
+    groupBy,
+    returning
+  } = makeDslQueryRuntime({
+    profile,
+    ValuesInputProto,
+    normalizeValuesRow,
+    normalizeUnnestColumns,
+    makeColumnReferenceSelection,
+    toDialectNumericExpression,
+    extractRequiredRuntime,
+    makePlan,
+    getAst,
+    getQueryState,
+    currentRequiredList,
+    dedupeGroupedExpressions
+  }) as {
+    readonly values: ValuesApi
+    readonly unnest: UnnestApi
+    readonly generateSeries: GenerateSeriesApi
+    readonly select: SelectApi
+    readonly groupBy: GroupByApi
+    readonly returning: ReturningApi
   }
 
-  const union = <
+  type SetOperationResult<
     LeftPlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
     RightPlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
-  >(
-    left: SetCompatiblePlan<LeftPlanValue, Dialect>,
-    right: SetCompatibleRightPlan<LeftPlanValue, RightPlanValue, Dialect>
-  ): QueryPlan<
-    SelectionOfPlan<LeftPlanValue>,
-    never,
-    {},
-    PlanDialectOf<LeftPlanValue> | PlanDialectOf<RightPlanValue>,
-    GroupedOfPlan<LeftPlanValue>,
-    never,
-    never,
-    TrueFormula,
-    CapabilitiesOfPlan<LeftPlanValue> | CapabilitiesOfPlan<RightPlanValue>,
-    "set"
-  > => buildSetOperation("union", false, left as never, right as never) as QueryPlan<
+  > = QueryPlan<
     SelectionOfPlan<LeftPlanValue>,
     never,
     {},
@@ -5291,297 +5194,48 @@ type AsCurriedResult<
     "set"
   >
 
-  const unionAll = <
+  type SetOperationApi = <
     LeftPlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
     RightPlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
   >(
     left: SetCompatiblePlan<LeftPlanValue, Dialect>,
     right: SetCompatibleRightPlan<LeftPlanValue, RightPlanValue, Dialect>
-  ): QueryPlan<
-    SelectionOfPlan<LeftPlanValue>,
-    never,
-    {},
-    PlanDialectOf<LeftPlanValue> | PlanDialectOf<RightPlanValue>,
-    GroupedOfPlan<LeftPlanValue>,
-    never,
-    never,
-    TrueFormula,
-    CapabilitiesOfPlan<LeftPlanValue> | CapabilitiesOfPlan<RightPlanValue>,
-    "set"
-  > => buildSetOperation("union", true, left as never, right as never) as QueryPlan<
-    SelectionOfPlan<LeftPlanValue>,
-    never,
-    {},
-    PlanDialectOf<LeftPlanValue> | PlanDialectOf<RightPlanValue>,
-    GroupedOfPlan<LeftPlanValue>,
-    never,
-    never,
-    TrueFormula,
-    CapabilitiesOfPlan<LeftPlanValue> | CapabilitiesOfPlan<RightPlanValue>,
-    "set"
-  >
+  ) => SetOperationResult<LeftPlanValue, RightPlanValue>
 
-  const intersect = <
-    LeftPlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
-    RightPlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
-  >(
-    left: SetCompatiblePlan<LeftPlanValue, Dialect>,
-    right: SetCompatibleRightPlan<LeftPlanValue, RightPlanValue, Dialect>
-  ): QueryPlan<
-    SelectionOfPlan<LeftPlanValue>,
-    never,
-    {},
-    PlanDialectOf<LeftPlanValue> | PlanDialectOf<RightPlanValue>,
-    GroupedOfPlan<LeftPlanValue>,
-    never,
-    never,
-    TrueFormula,
-    CapabilitiesOfPlan<LeftPlanValue> | CapabilitiesOfPlan<RightPlanValue>,
-    "set"
-  > => buildSetOperation("intersect", false, left as never, right as never) as QueryPlan<
-    SelectionOfPlan<LeftPlanValue>,
-    never,
-    {},
-    PlanDialectOf<LeftPlanValue> | PlanDialectOf<RightPlanValue>,
-    GroupedOfPlan<LeftPlanValue>,
-    never,
-    never,
-    TrueFormula,
-    CapabilitiesOfPlan<LeftPlanValue> | CapabilitiesOfPlan<RightPlanValue>,
-    "set"
-  >
+  type WhereApi = <Predicate extends PredicateInput>(
+    predicate: Predicate
+  ) =>
+    <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+      plan: PlanValue & RequireWhereStatement<PlanValue>
+    ) => QueryPlan<
+      SelectionOfPlan<PlanValue>,
+      AddExpressionRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, Predicate>,
+      AvailableOfPlan<PlanValue>,
+      PlanDialectOf<PlanValue> | DialectOfDialectInput<Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+      GroupedOfPlan<PlanValue>,
+      ScopedNamesOfPlan<PlanValue>,
+      AddExpressionRequired<OutstandingOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, Predicate>,
+      PlanAssumptionsAfterWhere<PlanValue, Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+      CapabilitiesOfPlan<PlanValue>,
+      StatementOfPlan<PlanValue>,
+      MutationTargetOfPlan<PlanValue>,
+      InsertSourceStateOfPlan<PlanValue>,
+      PlanFactsAfterWhere<PlanValue, Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+    >
 
-  const intersectAll = <
-    LeftPlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
-    RightPlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
-  >(
-    left: SetCompatiblePlan<LeftPlanValue, Dialect>,
-    right: SetCompatibleRightPlan<LeftPlanValue, RightPlanValue, Dialect>
-  ): QueryPlan<
-    SelectionOfPlan<LeftPlanValue>,
-    never,
-    {},
-    PlanDialectOf<LeftPlanValue> | PlanDialectOf<RightPlanValue>,
-    GroupedOfPlan<LeftPlanValue>,
-    never,
-    never,
-    TrueFormula,
-    CapabilitiesOfPlan<LeftPlanValue> | CapabilitiesOfPlan<RightPlanValue>,
-    "set"
-  > => buildSetOperation("intersect", true, left as never, right as never) as QueryPlan<
-    SelectionOfPlan<LeftPlanValue>,
-    never,
-    {},
-    PlanDialectOf<LeftPlanValue> | PlanDialectOf<RightPlanValue>,
-    GroupedOfPlan<LeftPlanValue>,
-    never,
-    never,
-    TrueFormula,
-    CapabilitiesOfPlan<LeftPlanValue> | CapabilitiesOfPlan<RightPlanValue>,
-    "set"
-  >
+  export type FromApi = <CurrentSource extends FromInput>(
+    source: CurrentSource
+  ) =>
+    <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+      plan: PlanValue & FromPlanConstraint<PlanValue, CurrentSource, Dialect>
+    ) => FromPlanResult<PlanValue, CurrentSource, Dialect>
 
-  const except = <
-    LeftPlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
-    RightPlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
-  >(
-    left: SetCompatiblePlan<LeftPlanValue, Dialect>,
-    right: SetCompatibleRightPlan<LeftPlanValue, RightPlanValue, Dialect>
-  ): QueryPlan<
-    SelectionOfPlan<LeftPlanValue>,
-    never,
-    {},
-    PlanDialectOf<LeftPlanValue> | PlanDialectOf<RightPlanValue>,
-    GroupedOfPlan<LeftPlanValue>,
-    never,
-    never,
-    TrueFormula,
-    CapabilitiesOfPlan<LeftPlanValue> | CapabilitiesOfPlan<RightPlanValue>,
-    "set"
-  > => buildSetOperation("except", false, left as never, right as never) as QueryPlan<
-    SelectionOfPlan<LeftPlanValue>,
-    never,
-    {},
-    PlanDialectOf<LeftPlanValue> | PlanDialectOf<RightPlanValue>,
-    GroupedOfPlan<LeftPlanValue>,
-    never,
-    never,
-    TrueFormula,
-    CapabilitiesOfPlan<LeftPlanValue> | CapabilitiesOfPlan<RightPlanValue>,
-    "set"
-  >
-
-  const exceptAll = <
-    LeftPlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
-    RightPlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
-  >(
-    left: SetCompatiblePlan<LeftPlanValue, Dialect>,
-    right: SetCompatibleRightPlan<LeftPlanValue, RightPlanValue, Dialect>
-  ): QueryPlan<
-    SelectionOfPlan<LeftPlanValue>,
-    never,
-    {},
-    PlanDialectOf<LeftPlanValue> | PlanDialectOf<RightPlanValue>,
-    GroupedOfPlan<LeftPlanValue>,
-    never,
-    never,
-    TrueFormula,
-    CapabilitiesOfPlan<LeftPlanValue> | CapabilitiesOfPlan<RightPlanValue>,
-    "set"
-  > => buildSetOperation("except", true, left as never, right as never) as QueryPlan<
-    SelectionOfPlan<LeftPlanValue>,
-    never,
-    {},
-    PlanDialectOf<LeftPlanValue> | PlanDialectOf<RightPlanValue>,
-    GroupedOfPlan<LeftPlanValue>,
-    never,
-    never,
-    TrueFormula,
-    CapabilitiesOfPlan<LeftPlanValue> | CapabilitiesOfPlan<RightPlanValue>,
-    "set"
-  >
-
-  const where = <Predicate extends PredicateInput>(
-    predicate: Predicate
-  ) =>
-    <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
-      plan: PlanValue & RequireWhereStatement<PlanValue>
-    ): QueryPlan<
-      SelectionOfPlan<PlanValue>,
-      AddExpressionRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, Predicate>,
-      AvailableOfPlan<PlanValue>,
-      PlanDialectOf<PlanValue> | DialectOfDialectInput<Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-      GroupedOfPlan<PlanValue>,
-      ScopedNamesOfPlan<PlanValue>,
-      AddExpressionRequired<OutstandingOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, Predicate>,
-      PlanAssumptionsAfterWhere<PlanValue, Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-      CapabilitiesOfPlan<PlanValue>,
-      StatementOfPlan<PlanValue>
-    > => {
-      const current = plan[Plan.TypeId]
-      const currentAst = getAst(plan)
-      const currentQuery = getQueryState(plan)
-      const predicateExpression = toDialectExpression(predicate)
-      const predicateRequired = extractRequiredFromDialectInputRuntime(predicate)
-      return makePlan({
-        selection: current.selection,
-        required: [...currentRequiredList(current.required), ...predicateRequired].filter((name, index, values) =>
-          !(name in current.available) && values.indexOf(name) === index) as AddExpressionRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, Predicate>,
-        available: current.available,
-        dialect: current.dialect as PlanDialectOf<PlanValue> | DialectOfDialectInput<Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
-      }, {
-        ...currentAst,
-        where: [...currentAst.where, {
-          kind: "where",
-          predicate: predicateExpression
-        }]
-      },
-      assumeFormulaTrue(
-        currentQuery.assumptions,
-        formulaOfExpressionRuntime(predicateExpression)
-      ) as PlanAssumptionsAfterWhere<PlanValue, Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-      currentQuery.capabilities,
-      currentQuery.statement as StatementOfPlan<PlanValue>)
-    }
-
-  const from = <CurrentSource extends FromInput>(
-    source: CurrentSource
-  ) =>
-    <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
-      plan: PlanValue & FromPlanConstraint<PlanValue, CurrentSource, Dialect>
-    ): FromPlanResult<PlanValue, CurrentSource, Dialect> => {
-      const current = plan[Plan.TypeId]
-      const currentAst = getAst(plan)
-      const currentQuery = getQueryState(plan)
-
-      if (currentQuery.statement === "insert") {
-        return attachInsertSource(
-          plan as QueryPlan<any, any, any, any, any, any, any, any, any, "insert", MutationTargetLike, "missing">,
-          source as AnyValuesInput | AnyValuesSource | AnyUnnestSource | CompletePlan<QueryPlan<any, any, any, any, any, any, any, any, any, any>>
-        ) as FromPlanResult<PlanValue, CurrentSource, Dialect>
-      }
-
-      if (
-        typeof source !== "object" ||
-        source === null ||
-        ("kind" in source && source.kind === "values" && !("name" in source)) ||
-        (!(Table.TypeId in source) && !("name" in source && "baseName" in source))
-      ) {
-        throw new Error("from(...) requires an aliased source in select/update statements")
-      }
-
-      const sourceLike = source as SourceLike
-      const { sourceName, sourceBaseName } = sourceDetails(sourceLike)
-      const presenceWitnesses = presenceWitnessesOfSourceLike(sourceLike)
-
-      if (currentQuery.statement === "select") {
-        const nextAst = {
-          ...currentAst,
-          from: {
-            kind: "from",
-            tableName: sourceName,
-            baseTableName: sourceBaseName,
-            source: sourceLike
-          }
-        } as QueryAst.Ast<Record<string, unknown>, any, "select">
-        return makePlan({
-          selection: current.selection,
-          required: currentRequiredList(current.required).filter((name) =>
-            name !== sourceName),
-          available: {
-            [sourceName]: {
-              name: sourceName,
-              mode: "required",
-              baseName: sourceBaseName,
-              _presentFormula: trueFormula(),
-              _presenceWitnesses: presenceWitnesses
-            }
-          } as AddAvailable<{}, string, "required", TrueFormula, PresenceWitnessKeysOfSource<Extract<CurrentSource, SourceLike>>>,
-          dialect: current.dialect
-        }, nextAst, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement) as FromPlanResult<PlanValue, CurrentSource, Dialect>
-      }
-
-      if (currentQuery.statement === "update") {
-        const nextAvailable = {
-          ...current.available,
-          [sourceName]: {
-            name: sourceName,
-            mode: "required" as const,
-            baseName: sourceBaseName,
-            _presentFormula: trueFormula(),
-            _presenceWitnesses: presenceWitnesses
-          }
-        }
-        const nextAst = {
-          ...currentAst,
-          fromSources: [
-            ...(currentAst.fromSources ?? []),
-            {
-              kind: "from" as const,
-              tableName: sourceName,
-              baseTableName: sourceBaseName,
-              source: sourceLike
-            }
-          ]
-        } as QueryAst.Ast<Record<string, unknown>, any, "update">
-        return makePlan({
-          selection: current.selection,
-          required: currentRequiredList(current.required).filter((name) =>
-            !(name in nextAvailable)),
-          available: nextAvailable,
-          dialect: current.dialect
-        }, nextAst, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement) as FromPlanResult<PlanValue, CurrentSource, Dialect>
-      }
-
-      throw new Error(`from(...) is not supported for ${currentQuery.statement} statements`)
-    }
-
-  const having = <Predicate extends HavingPredicateInput>(
+  type HavingApi = <Predicate extends HavingPredicateInput>(
     predicate: Predicate
   ) =>
     <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
       plan: PlanValue & RequireSelectStatement<PlanValue>
-    ): QueryPlan<
+    ) => QueryPlan<
       SelectionOfPlan<PlanValue>,
       AddExpressionRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, Predicate>,
       AvailableOfPlan<PlanValue>,
@@ -5591,58 +5245,13 @@ type AsCurriedResult<
       AddExpressionRequired<OutstandingOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, Predicate>,
       PlanAssumptionsAfterHaving<PlanValue, Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
       CapabilitiesOfPlan<PlanValue>,
-      StatementOfPlan<PlanValue>
-    > => {
-      const current = plan[Plan.TypeId]
-      const currentAst = getAst(plan)
-      const currentQuery = getQueryState(plan)
-      const predicateExpression = toDialectExpression(predicate)
-      const predicateRequired = extractRequiredFromDialectInputRuntime(predicate)
-      return makePlan({
-        selection: current.selection,
-        required: [...currentRequiredList(current.required), ...predicateRequired].filter((name, index, values) =>
-          !(name in current.available) && values.indexOf(name) === index) as AddExpressionRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, Predicate>,
-        available: current.available,
-        dialect: current.dialect as PlanDialectOf<PlanValue> | DialectOfDialectInput<Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
-      }, {
-        ...currentAst,
-        having: [...currentAst.having, {
-          kind: "having",
-          predicate: predicateExpression
-        }]
-      }, assumeFormulaTrue(
-        currentQuery.assumptions,
-        formulaOfExpressionRuntime(predicateExpression)
-      ) as PlanAssumptionsAfterHaving<PlanValue, Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-      currentQuery.capabilities,
-      currentQuery.statement as StatementOfPlan<PlanValue>)
-    }
-
-  const innerJoin = <CurrentTable extends SourceLike, Predicate extends PredicateInput>(
-    table: CurrentTable,
-    on: Predicate
-  ) =>
-    join("inner", table, on)
-
-  const leftJoin = <CurrentTable extends SourceLike, Predicate extends PredicateInput>(
-    table: CurrentTable,
-    on: Predicate
-  ) =>
-    join("left", table, on)
-
-  const rightJoin = <CurrentTable extends SourceLike, Predicate extends PredicateInput>(
-    table: CurrentTable,
-    on: Predicate
-  ) =>
-    join("right", table, on)
-
-  const fullJoin = <CurrentTable extends SourceLike, Predicate extends PredicateInput>(
-    table: CurrentTable,
-    on: Predicate
-  ) =>
-    join("full", table, on)
+      StatementOfPlan<PlanValue>,
+      MutationTargetOfPlan<PlanValue>,
+      InsertSourceStateOfPlan<PlanValue>,
+      PlanFactsAfterHaving<PlanValue, Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+    >
 
-  const crossJoin = <CurrentTable extends SourceLike>(
+  type CrossJoinApi = <CurrentTable extends SourceLike>(
     table: CurrentTable
   ) =>
     <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
@@ -5651,7 +5260,7 @@ type AsCurriedResult<
       ) & (
         SourceNameOf<CurrentTable> extends ScopedNamesOfPlan<PlanValue> ? never : unknown
       )
-    ): QueryPlan<
+    ) => QueryPlan<
       SelectionOfPlan<PlanValue>,
       AddJoinRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, never, "cross">,
       AddAvailable<
@@ -5668,49 +5277,9 @@ type AsCurriedResult<
       AssumptionsOfPlan<PlanValue>,
       MergeCapabilities<CapabilitiesOfPlan<PlanValue>, SourceCapabilitiesOf<CurrentTable>>,
       StatementOfPlan<PlanValue>
-    > => {
-      const current = plan[Plan.TypeId]
-      const currentAst = getAst(plan)
-      const currentQuery = getQueryState(plan)
-      const { sourceName, sourceBaseName } = sourceDetails(table)
-      const presenceWitnesses = presenceWitnessesOfSourceLike(table)
-      const nextAvailable = Object.assign(
-        {},
-        current.available as AvailableOfPlan<PlanValue>,
-        {
-          [sourceName]: {
-            name: sourceName,
-            mode: "required",
-            baseName: sourceBaseName,
-            _presentFormula: trueFormula(),
-            _presenceWitnesses: presenceWitnesses
-          }
-        }
-      ) as AddAvailable<
-        AvailableOfPlan<PlanValue>,
-        SourceNameOf<CurrentTable>,
-        "required",
-        TrueFormula,
-        PresenceWitnessKeysOfSource<CurrentTable>
-      >
-      return makePlan({
-        selection: current.selection,
-        required: currentRequiredList(current.required).filter((name) =>
-          !(name in nextAvailable)) as AddJoinRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, never, "cross">,
-        available: nextAvailable,
-        dialect: current.dialect as PlanDialectOf<PlanValue> | SourceDialectOf<CurrentTable>
-      }, {
-        ...currentAst,
-        joins: [...currentAst.joins, {
-          kind: "cross",
-          tableName: sourceName,
-          baseTableName: sourceBaseName,
-          source: table
-        }]
-      }, currentQuery.assumptions, currentQuery.capabilities as MergeCapabilities<CapabilitiesOfPlan<PlanValue>, SourceCapabilitiesOf<CurrentTable>>, currentQuery.statement as StatementOfPlan<PlanValue>)
-    }
+    >
 
-  const join = <
+  type JoinApi = <
     Kind extends QueryAst.JoinKind,
     CurrentTable extends SourceLike,
     Predicate extends PredicateInput
@@ -5725,7 +5294,7 @@ type AsCurriedResult<
       ) & (
         SourceNameOf<CurrentTable> extends ScopedNamesOfPlan<PlanValue> ? never : unknown
       )
-    ): QueryPlan<
+    ) => QueryPlan<
       SelectionOfPlan<PlanValue>,
       AddJoinRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, Predicate, Kind>,
       AvailableAfterJoin<
@@ -5741,73 +5310,54 @@ type AsCurriedResult<
       AddJoinRequired<OutstandingOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, Predicate, Kind>,
       PlanAssumptionsAfterJoin<PlanValue, Predicate, Kind, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
       MergeCapabilities<CapabilitiesOfPlan<PlanValue>, SourceCapabilitiesOf<CurrentTable>>,
-      StatementOfPlan<PlanValue>
-    > => {
-      const current = plan[Plan.TypeId]
-      const currentAst = getAst(plan)
-      const currentQuery = getQueryState(plan)
-      const onExpression = toDialectExpression(on)
-      const onFormula = formulaOfExpressionRuntime(onExpression)
-      const { sourceName, sourceBaseName } = sourceDetails(table)
-      const presenceWitnesses = presenceWitnessesOfSourceLike(table)
-      const baseAvailable = (kind === "right" || kind === "full"
-        ? Object.fromEntries(
-          Object.entries(current.available as Record<string, Plan.AnySource>).map(([name, source]) => [name, {
-            name: source.name,
-            mode: "optional" as const,
-            baseName: source.baseName,
-            _presentFormula: source._presentFormula,
-            _presenceWitnesses: source._presenceWitnesses
-          }])
-        )
-        : current.available) as AvailableOfPlan<PlanValue>
-      const nextAvailable = {
-        ...baseAvailable,
-        [sourceName]: {
-          name: sourceName,
-          mode: (kind === "left" || kind === "full" ? "optional" : "required") as JoinSourceMode<Kind>,
-          baseName: sourceBaseName,
-          _presentFormula: (kind === "inner" || kind === "left") ? onFormula : trueFormula(),
-          _presenceWitnesses: presenceWitnesses
-        }
-      } as AvailableAfterJoin<
+      StatementOfPlan<PlanValue>,
+      MutationTargetOfPlan<PlanValue>,
+      InsertSourceStateOfPlan<PlanValue>,
+      PlanFactsAfterJoin<PlanValue, Predicate, Kind, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+    >
+
+  type BinaryJoinApi<Kind extends QueryAst.JoinKind> = <
+    CurrentTable extends SourceLike,
+    Predicate extends PredicateInput
+  >(
+    table: CurrentTable,
+    on: Predicate
+  ) =>
+    <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+      plan: PlanValue & RequireJoinStatement<PlanValue> & (
+        keyof AvailableOfPlan<PlanValue> extends never ? never : unknown
+      ) & (
+        SourceNameOf<CurrentTable> extends ScopedNamesOfPlan<PlanValue> ? never : unknown
+      )
+    ) => QueryPlan<
+      SelectionOfPlan<PlanValue>,
+      AddJoinRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, Predicate, Kind>,
+      AvailableAfterJoin<
         AvailableOfPlan<PlanValue>,
         SourceNameOf<CurrentTable>,
         Kind,
         JoinPresenceFormula<Kind, Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
         PresenceWitnessKeysOfSource<CurrentTable>
-      >
-      return makePlan({
-        selection: current.selection,
-        required: [...currentRequiredList(current.required), ...extractRequiredFromDialectInputRuntime(on)].filter((name, index, values) =>
-          !(name in nextAvailable) && values.indexOf(name) === index) as AddJoinRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, Predicate, Kind>,
-        available: nextAvailable,
-        dialect: current.dialect as PlanDialectOf<PlanValue> | SourceDialectOf<CurrentTable> | DialectOfDialectInput<Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
-      }, {
-        ...currentAst,
-        joins: [...currentAst.joins, {
-          kind,
-          tableName: sourceName,
-          baseTableName: sourceBaseName,
-          source: table,
-          on: onExpression
-        }]
-      }, (
-        kind === "inner"
-          ? assumeFormulaTrue(currentQuery.assumptions, onFormula)
-          : currentQuery.assumptions
-      ) as PlanAssumptionsAfterJoin<PlanValue, Predicate, Kind, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-      currentQuery.capabilities as MergeCapabilities<CapabilitiesOfPlan<PlanValue>, SourceCapabilitiesOf<CurrentTable>>,
-      currentQuery.statement as StatementOfPlan<PlanValue>)
-    }
+      >,
+      PlanDialectOf<PlanValue> | SourceDialectOf<CurrentTable> | DialectOfDialectInput<Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+      GroupedOfPlan<PlanValue>,
+      ScopedNamesOfPlan<PlanValue> | SourceNameOf<CurrentTable>,
+      AddJoinRequired<OutstandingOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, Predicate, Kind>,
+      PlanAssumptionsAfterJoin<PlanValue, Predicate, Kind, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+      MergeCapabilities<CapabilitiesOfPlan<PlanValue>, SourceCapabilitiesOf<CurrentTable>>,
+      StatementOfPlan<PlanValue>,
+      MutationTargetOfPlan<PlanValue>,
+      InsertSourceStateOfPlan<PlanValue>,
+      PlanFactsAfterJoin<PlanValue, Predicate, Kind, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+    >
 
-  const orderBy = <Value extends ExpressionInput>(
+  type OrderByApi = <Value extends ExpressionInput>(
     value: Value,
-    direction: OrderDirection = "asc"
+    direction?: OrderDirection
   ) =>
     <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
       plan: PlanValue & MutationOrderLimitSupported<PlanValue, Dialect>
-    ): QueryPlan<
+    ) => QueryPlan<
       SelectionOfPlan<PlanValue>,
       AddExpressionRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, Value>,
       AvailableOfPlan<PlanValue>,
@@ -5817,80 +5367,16 @@ type AsCurriedResult<
       AddExpressionRequired<OutstandingOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, Value>,
       AssumptionsOfPlan<PlanValue>,
       CapabilitiesOfPlan<PlanValue>,
-      StatementOfPlan<PlanValue>
-    > => {
-      const current = plan[Plan.TypeId]
-      const currentAst = getAst(plan)
-      const currentQuery = getQueryState(plan)
-      const expression = toDialectExpression(value)
-      const required = extractRequiredFromDialectInputRuntime(value)
-      return makePlan({
-        selection: current.selection,
-        required: [...currentRequiredList(current.required), ...required].filter((name, index, values) =>
-          !(name in current.available) && values.indexOf(name) === index) as AddExpressionRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, Value>,
-        available: current.available,
-        dialect: current.dialect as PlanDialectOf<PlanValue> | DialectOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
-      }, {
-        ...currentAst,
-        orderBy: [...currentAst.orderBy, {
-          kind: "orderBy",
-          value: expression,
-          direction
-        }]
-      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement as StatementOfPlan<PlanValue>)
-    }
+      StatementOfPlan<PlanValue>,
+      MutationTargetOfPlan<PlanValue>,
+      InsertSourceStateOfPlan<PlanValue>,
+      FactsOfPlan<PlanValue>
+    >
 
-  function lock(
-    mode: "update" | "share",
-    options?: LockOptions
-  ): <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
-    plan: PlanValue & (StatementOfPlan<PlanValue> extends "select" ? unknown : never)
-  ) => QueryPlan<
-    SelectionOfPlan<PlanValue>,
-    RequiredOfPlan<PlanValue>,
-    AvailableOfPlan<PlanValue>,
-    PlanDialectOf<PlanValue>,
-    GroupedOfPlan<PlanValue>,
-    ScopedNamesOfPlan<PlanValue>,
-    OutstandingOfPlan<PlanValue>,
-    AssumptionsOfPlan<PlanValue>,
-    MergeCapabilities<CapabilitiesOfPlan<PlanValue>, "transaction">,
-    StatementOfPlan<PlanValue>
-  >
-  function lock<
-    Mode extends Dialect extends "mysql" ? "lowPriority" | "ignore" | "quick" : never
-  >(
-    mode: Mode,
-    options?: LockOptions
-  ): <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
-    plan: PlanValue & (
-      Dialect extends "mysql"
-        ? StatementOfPlan<PlanValue> extends "update"
-          ? Mode extends MutationLockModeForStatement<"update", Dialect> ? unknown : never
-          : StatementOfPlan<PlanValue> extends "delete"
-            ? Mode extends MutationLockModeForStatement<"delete", Dialect> ? unknown : never
-            : never
-        : never
-    )
-  ) => QueryPlan<
-    SelectionOfPlan<PlanValue>,
-    RequiredOfPlan<PlanValue>,
-    AvailableOfPlan<PlanValue>,
-    PlanDialectOf<PlanValue>,
-    GroupedOfPlan<PlanValue>,
-    ScopedNamesOfPlan<PlanValue>,
-    OutstandingOfPlan<PlanValue>,
-    AssumptionsOfPlan<PlanValue>,
-    MergeCapabilities<CapabilitiesOfPlan<PlanValue>, "transaction">,
-    StatementOfPlan<PlanValue>
-  >
-  function lock(
-    mode: QueryAst.LockClause["mode"],
-    options: LockOptions = {}
-  ) {
-    return <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
-      plan: PlanValue
-    ): QueryPlan<
+  interface LockApi {
+    (mode: "update" | "share", options?: LockOptions): <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+      plan: PlanValue & (StatementOfPlan<PlanValue> extends "select" ? unknown : never)
+    ) => QueryPlan<
       SelectionOfPlan<PlanValue>,
       RequiredOfPlan<PlanValue>,
       AvailableOfPlan<PlanValue>,
@@ -5900,32 +5386,45 @@ type AsCurriedResult<
       OutstandingOfPlan<PlanValue>,
       AssumptionsOfPlan<PlanValue>,
       MergeCapabilities<CapabilitiesOfPlan<PlanValue>, "transaction">,
-      StatementOfPlan<PlanValue>
-    > => {
-      const current = plan[Plan.TypeId]
-      const currentAst = getAst(plan)
-      const currentQuery = getQueryState(plan)
-      return makePlan({
-        selection: current.selection,
-        required: current.required as RequiredOfPlan<PlanValue>,
-        available: current.available,
-        dialect: current.dialect as PlanDialectOf<PlanValue>
-      }, {
-        ...currentAst,
-        lock: {
-          kind: "lock",
-          mode,
-          nowait: options.nowait ?? false,
-          skipLocked: options.skipLocked ?? false
-        }
-      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement as StatementOfPlan<PlanValue>)
-    }
+      StatementOfPlan<PlanValue>,
+      MutationTargetOfPlan<PlanValue>,
+      InsertSourceStateOfPlan<PlanValue>,
+      FactsOfPlan<PlanValue>
+    >
+    <Mode extends Dialect extends "mysql" ? "lowPriority" | "ignore" | "quick" : never>(
+      mode: Mode,
+      options?: LockOptions
+    ): <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+      plan: PlanValue & (
+        Dialect extends "mysql"
+          ? StatementOfPlan<PlanValue> extends "update"
+            ? Mode extends MutationLockModeForStatement<"update", Dialect> ? unknown : never
+            : StatementOfPlan<PlanValue> extends "delete"
+              ? Mode extends MutationLockModeForStatement<"delete", Dialect> ? unknown : never
+              : never
+          : never
+      )
+    ) => QueryPlan<
+      SelectionOfPlan<PlanValue>,
+      RequiredOfPlan<PlanValue>,
+      AvailableOfPlan<PlanValue>,
+      PlanDialectOf<PlanValue>,
+      GroupedOfPlan<PlanValue>,
+      ScopedNamesOfPlan<PlanValue>,
+      OutstandingOfPlan<PlanValue>,
+      AssumptionsOfPlan<PlanValue>,
+      MergeCapabilities<CapabilitiesOfPlan<PlanValue>, "transaction">,
+      StatementOfPlan<PlanValue>,
+      MutationTargetOfPlan<PlanValue>,
+      InsertSourceStateOfPlan<PlanValue>,
+      FactsOfPlan<PlanValue>
+    >
   }
 
-  const distinct = () =>
+  type DistinctApi = () =>
     <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
       plan: PlanValue & RequireSelectStatement<PlanValue>
-    ): QueryPlan<
+    ) => QueryPlan<
       SelectionOfPlan<PlanValue>,
       RequiredOfPlan<PlanValue>,
       AvailableOfPlan<PlanValue>,
@@ -5935,34 +5434,18 @@ type AsCurriedResult<
       OutstandingOfPlan<PlanValue>,
       AssumptionsOfPlan<PlanValue>,
       CapabilitiesOfPlan<PlanValue>,
-      StatementOfPlan<PlanValue>
-    > => {
-      const current = plan[Plan.TypeId]
-      const currentAst = getAst(plan)
-      const currentQuery = getQueryState(plan)
-      return makePlan({
-        selection: current.selection,
-        required: current.required as RequiredOfPlan<PlanValue>,
-        available: current.available,
-        dialect: current.dialect as PlanDialectOf<PlanValue>
-      }, {
-        ...currentAst,
-        distinct: true
-      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement as StatementOfPlan<PlanValue>)
-    }
-
-  const distinctOn = {
-    __effect_qb_error__: "effect-qb: distinctOn(...) is only supported by the postgres dialect",
-    __effect_qb_dialect__: profile.dialect,
-    __effect_qb_hint__: "Use postgres.Query.distinctOn(...) or regular distinct()/grouping logic"
-  } as DistinctOnApi<Dialect>
+      StatementOfPlan<PlanValue>,
+      MutationTargetOfPlan<PlanValue>,
+      InsertSourceStateOfPlan<PlanValue>,
+      FactsOfPlan<PlanValue>
+    >
 
-  const limit = <Value extends NumericExpressionInput>(
+  type LimitApi = <Value extends NumericExpressionInput>(
     value: Value
   ) =>
     <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
       plan: PlanValue & MutationOrderLimitSupported<PlanValue, Dialect>
-    ): QueryPlan<
+    ) => QueryPlan<
       SelectionOfPlan<PlanValue>,
       AddExpressionRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, DialectAsNumericExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
       AvailableOfPlan<PlanValue>,
@@ -5972,31 +5455,18 @@ type AsCurriedResult<
       AddExpressionRequired<OutstandingOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, DialectAsNumericExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
       AssumptionsOfPlan<PlanValue>,
       CapabilitiesOfPlan<PlanValue>,
-      StatementOfPlan<PlanValue>
-    > => {
-      const current = plan[Plan.TypeId]
-      const currentAst = getAst(plan)
-      const currentQuery = getQueryState(plan)
-      const expression = toDialectNumericExpression(value)
-      const required = extractRequiredFromDialectNumericInputRuntime(value)
-      return makePlan({
-        selection: current.selection,
-        required: [...currentRequiredList(current.required), ...required].filter((name, index, values) =>
-          !(name in current.available) && values.indexOf(name) === index) as AddExpressionRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, DialectAsNumericExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-        available: current.available,
-        dialect: current.dialect as PlanDialectOf<PlanValue> | DialectOfDialectNumericInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
-      }, {
-        ...currentAst,
-        limit: expression
-      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement as StatementOfPlan<PlanValue>)
-    }
+      StatementOfPlan<PlanValue>,
+      MutationTargetOfPlan<PlanValue>,
+      InsertSourceStateOfPlan<PlanValue>,
+      FactsOfPlan<PlanValue>
+    >
 
-  const offset = <Value extends NumericExpressionInput>(
+  type OffsetApi = <Value extends NumericExpressionInput>(
     value: Value
   ) =>
     <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
       plan: PlanValue & RequireSelectStatement<PlanValue>
-    ): QueryPlan<
+    ) => QueryPlan<
       SelectionOfPlan<PlanValue>,
       AddExpressionRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, DialectAsNumericExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
       AvailableOfPlan<PlanValue>,
@@ -6006,31 +5476,92 @@ type AsCurriedResult<
       AddExpressionRequired<OutstandingOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, DialectAsNumericExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
       AssumptionsOfPlan<PlanValue>,
       CapabilitiesOfPlan<PlanValue>,
-      StatementOfPlan<PlanValue>
-    > => {
-      const current = plan[Plan.TypeId]
-      const currentAst = getAst(plan)
-      const currentQuery = getQueryState(plan)
-      const expression = toDialectNumericExpression(value)
-      const required = extractRequiredFromDialectNumericInputRuntime(value)
-      return makePlan({
-        selection: current.selection,
-        required: [...currentRequiredList(current.required), ...required].filter((name, index, values) =>
-          !(name in current.available) && values.indexOf(name) === index) as AddExpressionRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, DialectAsNumericExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
-        available: current.available,
-        dialect: current.dialect as PlanDialectOf<PlanValue> | DialectOfDialectNumericInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
-      }, {
-        ...currentAst,
-        offset: expression
-      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement as StatementOfPlan<PlanValue>)
-    }
+      StatementOfPlan<PlanValue>,
+      MutationTargetOfPlan<PlanValue>,
+      InsertSourceStateOfPlan<PlanValue>,
+      FactsOfPlan<PlanValue>
+    >
+
+  const {
+    buildSetOperation,
+    where,
+    from,
+    having,
+    crossJoin,
+    join,
+    orderBy,
+    lock,
+    distinct,
+    limit,
+    offset
+  } = makeDslPlanRuntime({
+    profile,
+    makePlan,
+    getAst,
+    getQueryState,
+    currentRequiredList,
+    toDialectExpression,
+    toDialectNumericExpression,
+    extractRequiredFromDialectInputRuntime,
+    extractRequiredFromDialectNumericInputRuntime,
+    formulaOfExpressionRuntime,
+    assumeFormulaTrue,
+    trueFormula,
+    sourceDetails,
+    presenceWitnessesOfSourceLike,
+    attachInsertSource: (...args) => attachInsertSource(args[0], args[1])
+  }) as {
+    readonly buildSetOperation: (kind: QueryAst.SetOperatorKind, all: boolean, left: any, right: any) => any
+    readonly where: WhereApi
+    readonly from: FromApi
+    readonly having: HavingApi
+    readonly crossJoin: CrossJoinApi
+    readonly join: JoinApi
+    readonly orderBy: OrderByApi
+    readonly lock: LockApi
+    readonly distinct: DistinctApi
+    readonly limit: LimitApi
+    readonly offset: OffsetApi
+  }
+
+  const union = ((left, right) =>
+    buildSetOperation("union", false, left as never, right as never)) as SetOperationApi
+
+  const unionAll = ((left, right) =>
+    buildSetOperation("union", true, left as never, right as never)) as SetOperationApi
+
+  const intersect = ((left, right) =>
+    buildSetOperation("intersect", false, left as never, right as never)) as SetOperationApi
+
+  const intersectAll = ((left, right) =>
+    buildSetOperation("intersect", true, left as never, right as never)) as SetOperationApi
+
+  const except = ((left, right) =>
+    buildSetOperation("except", false, left as never, right as never)) as SetOperationApi
+
+  const exceptAll = ((left, right) =>
+    buildSetOperation("except", true, left as never, right as never)) as SetOperationApi
+
+  const innerJoin = ((table, on) => (join as any)("inner", table, on)) as BinaryJoinApi<"inner">
+
+  const leftJoin = ((table, on) => (join as any)("left", table, on)) as BinaryJoinApi<"left">
 
-  const groupBy = <Values extends readonly [GroupByInput, ...GroupByInput[]]>(
+  const rightJoin = ((table, on) => (join as any)("right", table, on)) as BinaryJoinApi<"right">
+
+  const fullJoin = ((table, on) => (join as any)("full", table, on)) as BinaryJoinApi<"full">
+
+  const distinctOn = {
+    __effect_qb_error__: "effect-qb: distinctOn(...) is only supported by the postgres dialect",
+    __effect_qb_dialect__: profile.dialect,
+    __effect_qb_hint__: "Use postgres.Query.distinctOn(...) or regular distinct()/grouping logic"
+  } as DistinctOnApi<Dialect>
+
+  type GroupByApi = <Values extends readonly [GroupByInput, ...GroupByInput[]]>(
     ...values: Values
   ) =>
     <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
       plan: PlanValue & RequireSelectStatement<PlanValue>
-    ): QueryPlan<
+    ) => QueryPlan<
       SelectionOfPlan<PlanValue>,
       Exclude<RequiredOfPlan<PlanValue> | RequiredFromDependencies<TupleDependencies<Values>>, AvailableNames<AvailableOfPlan<PlanValue>>>,
       AvailableOfPlan<PlanValue>,
@@ -6040,31 +5571,18 @@ type AsCurriedResult<
       Exclude<OutstandingOfPlan<PlanValue> | RequiredFromDependencies<TupleDependencies<Values>>, AvailableNames<AvailableOfPlan<PlanValue>>>,
       AssumptionsOfPlan<PlanValue>,
       CapabilitiesOfPlan<PlanValue>,
-      StatementOfPlan<PlanValue>
-    > => {
-      const current = plan[Plan.TypeId]
-      const currentAst = getAst(plan)
-      const currentQuery = getQueryState(plan)
-      const required = [...values.flatMap((value) => Object.keys(value[Expression.TypeId].dependencies))].filter((name, index, list) =>
-        !(name in current.available) && list.indexOf(name) === index)
-      return makePlan({
-        selection: current.selection,
-        required: [...currentRequiredList(current.required), ...required].filter((name, index, list) =>
-          !(name in current.available) && list.indexOf(name) === index) as Exclude<RequiredOfPlan<PlanValue> | RequiredFromDependencies<TupleDependencies<Values>>, AvailableNames<AvailableOfPlan<PlanValue>>>,
-        available: current.available,
-        dialect: current.dialect as PlanDialectOf<PlanValue> | TupleDialect<Values>
-      }, {
-        ...currentAst,
-        groupBy: dedupeGroupedExpressions([...currentAst.groupBy, ...values])
-      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement as StatementOfPlan<PlanValue>)
-    }
+      StatementOfPlan<PlanValue>,
+      MutationTargetOfPlan<PlanValue>,
+      InsertSourceStateOfPlan<PlanValue>,
+      FactsOfPlan<PlanValue>
+    >
 
-  const returning = <Selection extends SelectionShape>(
+  type ReturningApi = <Selection extends SelectionShape>(
     selection: Selection
   ) =>
     <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
       plan: PlanValue & RequireMutationStatement<PlanValue>
-    ): QueryPlan<
+    ) => QueryPlan<
       Selection,
       Exclude<RequiredOfPlan<PlanValue> | ExtractRequired<Selection>, AvailableNames<AvailableOfPlan<PlanValue>>>,
       AvailableOfPlan<PlanValue>,
@@ -6076,170 +5594,288 @@ type AsCurriedResult<
       CapabilitiesOfPlan<PlanValue>,
       StatementOfPlan<PlanValue>,
       MutationTargetOfPlan<PlanValue>,
-      InsertSourceStateOfPlan<PlanValue>
-    > => {
-      const current = plan[Plan.TypeId]
-      const currentAst = getAst(plan)
-      const currentQuery = getQueryState(plan)
-      return makePlan({
-        selection,
-        required: [...currentRequiredList(current.required), ...extractRequiredRuntime(selection)].filter((name, index, list) =>
-          !(name in current.available) && list.indexOf(name) === index) as Exclude<RequiredOfPlan<PlanValue> | ExtractRequired<Selection>, AvailableNames<AvailableOfPlan<PlanValue>>>,
-        available: current.available,
-        dialect: current.dialect as PlanDialectOf<PlanValue> | ExtractDialect<Selection>
-      }, {
-        ...currentAst,
-        select: selection
-      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement as StatementOfPlan<PlanValue>, currentQuery.target, currentQuery.insertSource)
-    }
+      InsertSourceStateOfPlan<PlanValue>,
+      FactsOfPlan<PlanValue>
+    >
 
-  function insert<
-    Target extends MutationTargetLike
+  export interface InsertApi {
+    <Target extends MutationTargetLike>(
+      target: Target
+    ): QueryPlan<
+      {},
+      never,
+      AddAvailable<{}, SourceNameOf<Target>>,
+      TableDialectOf<Target>,
+      never,
+      SourceNameOf<Target>,
+      never,
+      TrueFormula,
+      "write",
+      "insert",
+      Target,
+      "missing",
+      EmptyFacts
+    >
+    <Target extends MutationTargetLike, Values extends Record<string, unknown>>(
+      target: Target,
+      values: MutationValuesInput<"insert", Target, Values>
+    ): QueryPlan<
+      {},
+      Exclude<MutationRequiredFromValues<Values>, SourceNameOf<Target>>,
+      AddAvailable<{}, SourceNameOf<Target>>,
+      TableDialectOf<Target>,
+      never,
+      SourceNameOf<Target>,
+      Exclude<MutationRequiredFromValues<Values>, SourceNameOf<Target>>,
+      TrueFormula,
+      "write",
+      "insert",
+      Target,
+      "ready",
+      EmptyFacts
+    >
+  }
+
+  type AttachInsertSourceApi = (
+    plan: QueryPlan<any, any, any, any, any, any, any, any, any, "insert", MutationTargetLike, "missing">,
+    source: AnyValuesInput | AnyValuesSource | AnyUnnestSource | CompletePlan<QueryPlan<any, any, any, any, any, any, any, any, any, any>>
+  ) => QueryPlan<any, any, any, any, any, any, any, any, any, "insert", MutationTargetLike, "ready">
+
+  type OnConflictApi = <
+    Target extends MutationTargetLike,
+    const Columns extends DdlColumnInput,
+    UpdateValues extends MutationInputOf<Table.UpdateOf<Target>> | undefined = MutationInputOf<Table.UpdateOf<Target>> | undefined,
+    Options extends ConflictActionInput<Target, Dialect, UpdateValues> = ConflictActionInput<Target, Dialect, UpdateValues>
   >(
-    target: Target
-  ): QueryPlan<
+    target: ConflictTargetInput<Target, Dialect, Columns>,
+    options?: Options
+  ) =>
+    <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+      plan: PlanValue & RequireInsertStatement<PlanValue>
+    ) => QueryPlan<
+      SelectionOfPlan<PlanValue>,
+      Exclude<RequiredOfPlan<PlanValue> | MutationRequiredFromValues<Exclude<UpdateValues, undefined>> | RequiredFromInput<Extract<Options["where"], PredicateInput>>, AvailableNames<AvailableOfPlan<PlanValue>>>,
+      AvailableOfPlan<PlanValue>,
+      PlanDialectOf<PlanValue>,
+      GroupedOfPlan<PlanValue>,
+      ScopedNamesOfPlan<PlanValue>,
+      Exclude<OutstandingOfPlan<PlanValue> | MutationRequiredFromValues<Exclude<UpdateValues, undefined>> | RequiredFromInput<Extract<Options["where"], PredicateInput>>, AvailableNames<AvailableOfPlan<PlanValue>>>,
+      AssumptionsOfPlan<PlanValue>,
+      CapabilitiesOfPlan<PlanValue>,
+      StatementOfPlan<PlanValue>,
+      MutationTargetOfPlan<PlanValue>,
+      InsertSourceStateOfPlan<PlanValue>,
+      FactsOfPlan<PlanValue>
+    >
+
+  interface UpdateApi {
+    <Targets extends MutationTargetTuple, Values extends UpdateInputOfTarget<Targets>>(
+      target: Dialect extends "mysql" ? Targets : never,
+      values: Values
+    ): QueryPlan<
+      {},
+      Exclude<NestedMutationRequiredFromValues<Values>, MutationTargetNamesOf<Targets>>,
+      AddAvailableMany<{}, MutationTargetNamesOf<Targets>>,
+      TableDialectOf<Targets[0]>,
+      never,
+      MutationTargetNamesOf<Targets>,
+      Exclude<NestedMutationRequiredFromValues<Values>, MutationTargetNamesOf<Targets>>,
+      TrueFormula,
+      "write",
+      "update",
+      any,
+      "ready",
+      EmptyFacts
+    >
+    <Target extends MutationTargetLike, Values extends Record<string, unknown>>(
+      target: Target,
+      values: MutationValuesInput<"update", Target, Values>
+    ): QueryPlan<
+      {},
+      Exclude<MutationRequiredFromValues<Values>, SourceNameOf<Target>>,
+      AddAvailable<{}, SourceNameOf<Target>>,
+      TableDialectOf<Target>,
+      never,
+      SourceNameOf<Target>,
+      Exclude<MutationRequiredFromValues<Values>, SourceNameOf<Target>>,
+      TrueFormula,
+      "write",
+      "update",
+      any,
+      "ready",
+      EmptyFacts
+    >
+  }
+
+  type UpsertApi = <
+    Target extends MutationTargetLike,
+    Values extends MutationInputOf<Table.InsertOf<Target>>,
+    const Columns extends DdlColumnInput,
+    UpdateValues extends MutationInputOf<Table.UpdateOf<Target>>
+  >(
+    target: Target,
+    values: Values,
+    conflictColumns: ValidateTargetColumns<Target, NormalizeDdlColumns<Columns>>,
+    updateValues?: UpdateValues
+  ) => QueryPlan<
+    {},
+    Exclude<MutationRequiredFromValues<Values> | MutationRequiredFromValues<UpdateValues>, SourceNameOf<Target>>,
+    AddAvailable<{}, SourceNameOf<Target>>,
+    TableDialectOf<Target>,
+    never,
+    SourceNameOf<Target>,
+    Exclude<MutationRequiredFromValues<Values> | MutationRequiredFromValues<UpdateValues>, SourceNameOf<Target>>,
+    TrueFormula,
+    "write",
+    "insert",
+    Target,
+    "ready",
+    EmptyFacts
+  >
+
+  interface DeleteApi {
+    <Target extends MutationTargetLike>(
+      target: Target
+    ): QueryPlan<
+      {},
+      never,
+      AddAvailable<{}, SourceNameOf<Target>>,
+      TableDialectOf<Target>,
+      never,
+      SourceNameOf<Target>,
+      never,
+      TrueFormula,
+      "write",
+      "delete",
+      any,
+      "ready",
+      EmptyFacts
+    >
+    <Targets extends MutationTargetTuple>(
+      target: Dialect extends "mysql" ? Targets : never
+    ): QueryPlan<
+      {},
+      never,
+      AddAvailableMany<{}, MutationTargetNamesOf<Targets>>,
+      TableDialectOf<Targets[0]>,
+      never,
+      MutationTargetNamesOf<Targets>,
+      never,
+      TrueFormula,
+      "write",
+      "delete",
+      any,
+      "ready",
+      EmptyFacts
+    >
+  }
+
+  type TruncateApi = <Target extends MutationTargetLike>(
+    target: Target,
+    options?: TruncateOptions
+  ) => QueryPlan<
     {},
     never,
-    AddAvailable<{}, SourceNameOf<Target>>,
+    {},
     TableDialectOf<Target>,
     never,
-    SourceNameOf<Target>,
+    never,
     never,
     TrueFormula,
     "write",
-    "insert",
-    Target,
-    "missing"
+    "truncate",
+    any,
+    "ready",
+    EmptyFacts
   >
-  function insert<
+
+  type MergeApi = <
     Target extends MutationTargetLike,
-    Values extends Record<string, unknown>
+    Source extends SourceLike,
+    On extends PredicateInput,
+    MatchedValues extends MutationInputOf<Table.UpdateOf<Target>> = MutationInputOf<Table.UpdateOf<Target>>,
+    InsertValues extends MutationInputOf<Table.InsertOf<Target>> = MutationInputOf<Table.InsertOf<Target>>,
+    MatchedPredicate extends PredicateInput | undefined = undefined,
+    NotMatchedPredicate extends PredicateInput | undefined = undefined
   >(
     target: Target,
-    values: MutationValuesInput<"insert", Target, Values>
-  ): QueryPlan<
+    source: Source & (
+      SourceRequiredOf<Source> extends never ? unknown : SourceRequirementError<Source>
+    ),
+    on: On,
+    options?: MergeOptions<Target, MatchedValues, InsertValues, MatchedPredicate, NotMatchedPredicate>
+  ) => QueryPlan<
     {},
-    Exclude<MutationRequiredFromValues<Values>, SourceNameOf<Target>>,
-    AddAvailable<{}, SourceNameOf<Target>>,
-    TableDialectOf<Target>,
+    Exclude<
+      AddExpressionRequired<
+        MergeRequiredFromPredicate<
+          MatchedPredicate,
+          AddAvailable<AddAvailable<{}, SourceNameOf<Target>>, SourceNameOf<Source>>
+        > | MergeRequiredFromPredicate<
+          NotMatchedPredicate,
+          AddAvailable<AddAvailable<{}, SourceNameOf<Target>>, SourceNameOf<Source>>
+        > | MutationRequiredFromValues<MatchedValues> | MutationRequiredFromValues<InsertValues>,
+        AddAvailable<AddAvailable<{}, SourceNameOf<Target>>, SourceNameOf<Source>>,
+        On
+      >,
+      SourceNameOf<Target> | SourceNameOf<Source>
+    >,
+    AddAvailable<AddAvailable<{}, SourceNameOf<Target>>, SourceNameOf<Source>>,
+    TableDialectOf<Target> | SourceDialectOf<Source>,
     never,
-    SourceNameOf<Target>,
-    Exclude<MutationRequiredFromValues<Values>, SourceNameOf<Target>>,
+    SourceNameOf<Target> | SourceNameOf<Source>,
+    Exclude<
+      AddExpressionRequired<
+        MergeRequiredFromPredicate<
+          MatchedPredicate,
+          AddAvailable<AddAvailable<{}, SourceNameOf<Target>>, SourceNameOf<Source>>
+        > | MergeRequiredFromPredicate<
+          NotMatchedPredicate,
+          AddAvailable<AddAvailable<{}, SourceNameOf<Target>>, SourceNameOf<Source>>
+        > | MutationRequiredFromValues<MatchedValues> | MutationRequiredFromValues<InsertValues>,
+        AddAvailable<AddAvailable<{}, SourceNameOf<Target>>, SourceNameOf<Source>>,
+        On
+      >,
+      SourceNameOf<Target> | SourceNameOf<Source>
+    >,
     TrueFormula,
-    "write",
-    "insert",
-    Target,
-    "ready"
+    MergeCapabilities<"write", SourceCapabilitiesOf<Source>>,
+    "merge",
+    any,
+    "ready",
+    EmptyFacts
   >
-  function insert(
+
+  const mutationRuntime = makeDslMutationRuntime({
+    makePlan,
+    getAst,
+    getQueryState,
+    currentRequiredList,
+    toDialectExpression,
+    buildMutationAssignments,
+    buildInsertValuesRows,
+    normalizeInsertUnnestValues,
+    normalizeInsertSelectColumns,
+    buildConflictTarget,
+    mutationTargetClauses,
+    mutationAvailableSources,
+    normalizeColumnList,
+    targetSourceDetails,
+    sourceDetails
+  })
+
+  const insert: InsertApi = ((
     target: MutationTargetLike,
     values?: Record<string, unknown>
-  ): QueryPlan<any, any, any, any, any, any, any, any, any, "insert", MutationTargetLike, "missing" | "ready"> {
-    const { sourceName, sourceBaseName } = targetSourceDetails(target)
-    const assignments = values === undefined
-      ? []
-      : buildMutationAssignments(target, values)
-    const required = assignments.flatMap((entry) => Object.keys(entry.value[Expression.TypeId].dependencies))
-    const insertState = values === undefined ? "missing" : "ready"
-    return makePlan({
-      selection: {},
-      required: required.filter((name, index, list) => name !== sourceName && list.indexOf(name) === index),
-      available: {
-        [sourceName]: {
-          name: sourceName,
-          mode: "required",
-          baseName: sourceBaseName
-        }
-      } as AddAvailable<{}, string>,
-      dialect: target[Plan.TypeId].dialect
-    }, {
-      kind: "insert",
-      select: {},
-      into: {
-        kind: "from",
-        tableName: sourceName,
-        baseTableName: sourceBaseName,
-        source: target
-      },
-      values: assignments,
-      conflict: undefined,
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: []
-    }, undefined as unknown as TrueFormula, "write", "insert", target, insertState)
-  }
+  ) => mutationRuntime.insert(target, values)) as InsertApi
 
   const attachInsertSource = (
     plan: QueryPlan<any, any, any, any, any, any, any, any, any, "insert", MutationTargetLike, "missing">,
     source: AnyValuesInput | AnyValuesSource | AnyUnnestSource | CompletePlan<QueryPlan<any, any, any, any, any, any, any, any, any, any>>
-  ): QueryPlan<any, any, any, any, any, any, any, any, any, "insert", MutationTargetLike, "ready"> => {
-    const current = plan[Plan.TypeId]
-    const currentAst = getAst(plan)
-    const currentQuery = getQueryState(plan)
-    const target = currentQuery.target as MutationTargetLike
-    const targetSource = currentAst.into!
-    const sourceName = targetSource.tableName
-
-    if (typeof source === "object" && source !== null && "kind" in source && source.kind === "values") {
-      const valuesSource = source as AnyValuesInput | AnyValuesSource
-      const normalized = buildInsertValuesRows(target, valuesSource.rows as readonly [InsertRowInput<MutationTargetLike>, ...InsertRowInput<MutationTargetLike>[]])
-      return makePlan({
-        selection: current.selection,
-        required: normalized.required.filter((name) => name !== sourceName),
-        available: current.available,
-        dialect: current.dialect
-      }, {
-        ...currentAst,
-        values: [],
-        insertSource: {
-          kind: "values",
-          columns: normalized.columns,
-          rows: normalized.rows
-        }
-      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement, currentQuery.target, "ready")
-    }
-
-    if (typeof source === "object" && source !== null && "kind" in source && source.kind === "unnest") {
-      const unnestSource = source as AnyUnnestSource
-      const normalized = normalizeInsertUnnestValues(target, unnestSource.values as any)
-      return makePlan({
-        selection: current.selection,
-        required: [] as never,
-        available: current.available,
-        dialect: current.dialect
-      }, {
-        ...currentAst,
-        values: [],
-        insertSource: {
-          kind: "unnest",
-          columns: normalized.columns,
-          values: normalized.values
-        }
-      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement, currentQuery.target, "ready")
-    }
-
-    const sourcePlan = source as CompletePlan<QueryPlan<any, any, any, any, any, any, any, any, any, any>>
-    const selection = sourcePlan[Plan.TypeId].selection as Record<string, Expression.Any>
-    const columns = normalizeInsertSelectColumns(selection)
-    return makePlan({
-      selection: current.selection,
-      required: currentRequiredList(sourcePlan[Plan.TypeId].required).filter((name) => name !== sourceName),
-      available: current.available,
-      dialect: current.dialect
-      }, {
-        ...currentAst,
-        values: [],
-        insertSource: {
-          kind: "query",
-          columns,
-          query: sourcePlan
-        }
-      }, currentQuery.assumptions, currentQuery.capabilities as MergeCapabilities<typeof currentQuery.capabilities, CapabilitiesOfPlan<typeof sourcePlan>>, currentQuery.statement, currentQuery.target, "ready")
-  }
+  ): QueryPlan<any, any, any, any, any, any, any, any, any, "insert", MutationTargetLike, "ready"> =>
+    mutationRuntime.attachInsertSource(plan, source)
 
-  const onConflict = <
+  const onConflict: OnConflictApi = <
     Target extends MutationTargetLike,
     const Columns extends DdlColumnInput,
     UpdateValues extends MutationInputOf<Table.UpdateOf<Target>> | undefined = MutationInputOf<Table.UpdateOf<Target>> | undefined,
@@ -6262,109 +5898,16 @@ type AsCurriedResult<
       CapabilitiesOfPlan<PlanValue>,
       StatementOfPlan<PlanValue>,
       MutationTargetOfPlan<PlanValue>,
-      InsertSourceStateOfPlan<PlanValue>
-    > => {
-      const current = plan[Plan.TypeId]
-      const currentAst = getAst(plan)
-      const currentQuery = getQueryState(plan)
-      const insertTarget = currentAst.into!.source as Target
-      const conflictTarget = buildConflictTarget(insertTarget, target as readonly string[] | { readonly columns: readonly string[]; readonly where?: PredicateInput } | { readonly constraint: string })
-      const updateAssignments = options.update
-        ? buildMutationAssignments(insertTarget, options.update)
-        : []
-      const updateWhere = options.where === undefined
-        ? undefined
-        : toDialectExpression(options.where as PredicateInput)
-      const required = [
-        ...currentRequiredList(current.required),
-        ...updateAssignments.flatMap((entry) => Object.keys(entry.value[Expression.TypeId].dependencies)),
-        ...(updateWhere ? Object.keys(updateWhere[Expression.TypeId].dependencies) : [])
-      ].filter((name, index, list) =>
-        !(name in current.available) && list.indexOf(name) === index)
-      return makePlan({
-        selection: current.selection,
-        required: required as Exclude<RequiredOfPlan<PlanValue> | MutationRequiredFromValues<Exclude<UpdateValues, undefined>> | RequiredFromInput<Extract<Options["where"], PredicateInput>>, AvailableNames<AvailableOfPlan<PlanValue>>>,
-        available: current.available,
-        dialect: current.dialect as PlanDialectOf<PlanValue>
-      }, {
-        ...currentAst,
-        conflict: {
-          kind: "conflict",
-          target: conflictTarget,
-          action: updateAssignments.length === 0 ? "doNothing" : "doUpdate",
-          values: updateAssignments.length === 0 ? undefined : updateAssignments,
-          where: updateWhere
-        }
-      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement as StatementOfPlan<PlanValue>, currentQuery.target, currentQuery.insertSource)
-    }
+      InsertSourceStateOfPlan<PlanValue>,
+      FactsOfPlan<PlanValue>
+    > => mutationRuntime.onConflict(target, options)(plan)
 
-  function update<
-    Targets extends MutationTargetTuple,
-    Values extends UpdateInputOfTarget<Targets>
-  >(
-    target: Dialect extends "mysql" ? Targets : never,
-    values: Values
-  ): QueryPlan<
-    {},
-    Exclude<NestedMutationRequiredFromValues<Values>, MutationTargetNamesOf<Targets>>,
-    AddAvailableMany<{}, MutationTargetNamesOf<Targets>>,
-    TableDialectOf<Targets[0]>,
-    never,
-    MutationTargetNamesOf<Targets>,
-    Exclude<NestedMutationRequiredFromValues<Values>, MutationTargetNamesOf<Targets>>,
-    TrueFormula,
-    "write",
-    "update"
-  >
-  function update<
-    Target extends MutationTargetLike,
-    Values extends Record<string, unknown>
-  >(
-    target: Target,
-    values: MutationValuesInput<"update", Target, Values>
-  ): QueryPlan<
-    {},
-    Exclude<MutationRequiredFromValues<Values>, SourceNameOf<Target>>,
-    AddAvailable<{}, SourceNameOf<Target>>,
-    TableDialectOf<Target>,
-    never,
-    SourceNameOf<Target>,
-    Exclude<MutationRequiredFromValues<Values>, SourceNameOf<Target>>,
-    TrueFormula,
-    "write",
-    "update"
-  >
-  function update(
+  const update: UpdateApi = ((
     target: MutationTargetInput,
     values: Record<string, unknown>
-  ): QueryPlan<any, any, any, any, any, any, any, any, any, "update"> {
-    const targets = mutationTargetClauses(target)
-    const primaryTarget = targets[0]!
-    const assignments = buildMutationAssignments(target, values)
-    const targetNames = new Set(targets.map((entry) => entry.tableName))
-    const required = assignments
-      .flatMap((entry) => Object.keys(entry.value[Expression.TypeId].dependencies))
-      .filter((name, index, list) => !targetNames.has(name) && list.indexOf(name) === index)
-    return makePlan({
-      selection: {},
-      required,
-      available: mutationAvailableSources(target),
-      dialect: (primaryTarget.source as MutationTargetLike)[Plan.TypeId].dialect
-    }, {
-      kind: "update",
-      select: {},
-      target: primaryTarget,
-      targets,
-      set: assignments,
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: []
-    }, undefined as unknown as TrueFormula, "write", "update")
-  }
+  ) => mutationRuntime.update(target, values)) as UpdateApi
 
-  const upsert = <
+  const upsert: UpsertApi = <
     Target extends MutationTargetLike,
     Values extends MutationInputOf<Table.InsertOf<Target>>,
     const Columns extends DdlColumnInput,
@@ -6386,109 +5929,15 @@ type AsCurriedResult<
     "write",
     "insert",
     Target,
-    "ready"
-  > => {
-    const { sourceName, sourceBaseName } = targetSourceDetails(target)
-    const assignments = buildMutationAssignments(target, values)
-    const updateAssignments = updateValues ? buildMutationAssignments(target, updateValues) : []
-    const required = [
-      ...assignments.flatMap((entry) => Object.keys(entry.value[Expression.TypeId].dependencies)),
-      ...updateAssignments.flatMap((entry) => Object.keys(entry.value[Expression.TypeId].dependencies))
-    ]
-    return makePlan({
-      selection: {},
-      required: required.filter((name, index, list) => name !== sourceName && list.indexOf(name) === index) as unknown as Exclude<MutationRequiredFromValues<Values> | MutationRequiredFromValues<UpdateValues>, SourceNameOf<Target>>,
-      available: {
-        [sourceName]: {
-          name: sourceName,
-          mode: "required",
-          baseName: sourceBaseName
-        }
-      } as AddAvailable<{}, SourceNameOf<Target>>,
-      dialect: target[Plan.TypeId].dialect as TableDialectOf<Target>
-    }, {
-      kind: "insert",
-      select: {},
-      into: {
-        kind: "from",
-        tableName: sourceName,
-        baseTableName: sourceBaseName,
-        source: target
-      },
-      values: assignments,
-      conflict: {
-        kind: "conflict",
-        target: {
-          kind: "columns",
-          columns: normalizeColumnList(conflictColumns as string | readonly string[]) as readonly [string, ...string[]]
-        },
-        action: updateAssignments.length > 0 ? "doUpdate" : "doNothing",
-        values: updateAssignments.length > 0 ? updateAssignments : undefined
-      },
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: []
-    }, undefined as unknown as TrueFormula, "write", "insert", target, "ready")
-  }
+    "ready",
+    EmptyFacts
+  > => mutationRuntime.upsert(target, values, conflictColumns as string | readonly string[], updateValues)
 
-  function delete_<
-    Target extends MutationTargetLike
-  >(
-    target: Target
-  ): QueryPlan<
-    {},
-    never,
-    AddAvailable<{}, SourceNameOf<Target>>,
-    TableDialectOf<Target>,
-    never,
-    SourceNameOf<Target>,
-    never,
-    TrueFormula,
-    "write",
-    "delete"
-  >
-  function delete_<
-    Targets extends MutationTargetTuple
-  >(
-    target: Dialect extends "mysql" ? Targets : never
-  ): QueryPlan<
-    {},
-    never,
-    AddAvailableMany<{}, MutationTargetNamesOf<Targets>>,
-    TableDialectOf<Targets[0]>,
-    never,
-    MutationTargetNamesOf<Targets>,
-    never,
-    TrueFormula,
-    "write",
-    "delete"
-  >
-  function delete_(
+  const delete_: DeleteApi = ((
     target: MutationTargetInput
-  ): QueryPlan<any, any, any, any, any, any, any, any, any, "delete"> {
-    const targets = mutationTargetClauses(target)
-    const primaryTarget = targets[0]!
-    return makePlan({
-      selection: {},
-      required: [] as never,
-      available: mutationAvailableSources(target),
-      dialect: (primaryTarget.source as MutationTargetLike)[Plan.TypeId].dialect
-    }, {
-      kind: "delete",
-      select: {},
-      target: primaryTarget,
-      targets,
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: []
-    }, undefined as unknown as TrueFormula, "write", "delete")
-  }
+  ) => mutationRuntime.delete_(target)) as DeleteApi
 
-  const truncate = <
+  const truncate: TruncateApi = <
     Target extends MutationTargetLike
   >(
     target: Target,
@@ -6503,37 +5952,13 @@ type AsCurriedResult<
     never,
     TrueFormula,
     "write",
-    "truncate"
-  > => {
-    const { sourceName, sourceBaseName } = targetSourceDetails(target)
-    return makePlan({
-      selection: {},
-      required: [] as never,
-      available: {},
-      dialect: target[Plan.TypeId].dialect as TableDialectOf<Target>
-    }, {
-      kind: "truncate",
-      select: {},
-      target: {
-        kind: "from",
-        tableName: sourceName,
-        baseTableName: sourceBaseName,
-        source: target
-      },
-      truncate: {
-        kind: "truncate",
-        restartIdentity: options.restartIdentity ?? false,
-        cascade: options.cascade ?? false
-      },
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: []
-    }, undefined as unknown as TrueFormula, "write", "truncate")
-  }
+    "truncate",
+    any,
+    "ready",
+    EmptyFacts
+  > => mutationRuntime.truncate(target, options)
 
-  const merge = <
+  const merge: MergeApi = <
     Target extends MutationTargetLike,
     Source extends SourceLike,
     On extends PredicateInput,
@@ -6584,110 +6009,13 @@ type AsCurriedResult<
     >,
     TrueFormula,
     MergeCapabilities<"write", SourceCapabilitiesOf<Source>>,
-    "merge"
-  > => {
-    const { sourceName: targetName, sourceBaseName: targetBaseName } = targetSourceDetails(target)
-    const { sourceName: usingName, sourceBaseName: usingBaseName } = sourceDetails(source)
-    const onExpression = toDialectExpression(on)
-    const matched = options.whenMatched
-    const notMatched = options.whenNotMatched
-    if (matched && "delete" in matched && "update" in matched) {
-      throw new Error("merge whenMatched cannot specify both update and delete")
-    }
-    const matchedPredicate = matched?.predicate ? toDialectExpression(matched.predicate) : undefined
-    const matchedAssignments = matched && "update" in matched && matched.update
-      ? buildMutationAssignments(target, matched.update)
-      : []
-    const notMatchedPredicate = notMatched?.predicate ? toDialectExpression(notMatched.predicate) : undefined
-    const notMatchedAssignments = notMatched
-      ? buildMutationAssignments(target, notMatched.values)
-      : []
-    const required = [
-      ...Object.keys(onExpression[Expression.TypeId].dependencies),
-      ...matchedAssignments.flatMap((entry) => Object.keys(entry.value[Expression.TypeId].dependencies)),
-      ...notMatchedAssignments.flatMap((entry) => Object.keys(entry.value[Expression.TypeId].dependencies)),
-      ...(matchedPredicate ? Object.keys(matchedPredicate[Expression.TypeId].dependencies) : []),
-      ...(notMatchedPredicate ? Object.keys(notMatchedPredicate[Expression.TypeId].dependencies) : [])
-    ].filter((name, index, values) =>
-      name !== targetName && name !== usingName && values.indexOf(name) === index)
-    return makePlan({
-      selection: {},
-      required: required as unknown as Exclude<
-        AddExpressionRequired<
-          MergeRequiredFromPredicate<
-            MatchedPredicate,
-            AddAvailable<AddAvailable<{}, SourceNameOf<Target>>, SourceNameOf<Source>>
-          > | MergeRequiredFromPredicate<
-            NotMatchedPredicate,
-            AddAvailable<AddAvailable<{}, SourceNameOf<Target>>, SourceNameOf<Source>>
-          > | MutationRequiredFromValues<MatchedValues> | MutationRequiredFromValues<InsertValues>,
-          AddAvailable<AddAvailable<{}, SourceNameOf<Target>>, SourceNameOf<Source>>,
-          On
-        >,
-        SourceNameOf<Target> | SourceNameOf<Source>
-      >,
-      available: {
-        [targetName]: {
-          name: targetName,
-          mode: "required",
-          baseName: targetBaseName
-        },
-        [usingName]: {
-          name: usingName,
-          mode: "required",
-          baseName: usingBaseName
-        }
-      } as AddAvailable<AddAvailable<{}, SourceNameOf<Target>>, SourceNameOf<Source>>,
-      dialect: target[Plan.TypeId].dialect as TableDialectOf<Target> | SourceDialectOf<Source>
-    }, {
-      kind: "merge",
-      select: {},
-      target: {
-        kind: "from",
-        tableName: targetName,
-        baseTableName: targetBaseName,
-        source: target
-      },
-      using: {
-        kind: "from",
-        tableName: usingName,
-        baseTableName: usingBaseName,
-        source
-      },
-      merge: {
-        kind: "merge",
-        on: onExpression,
-        whenMatched: matched
-          ? ("delete" in matched && matched.delete
-            ? {
-                kind: "delete",
-                predicate: matchedPredicate
-              }
-            : {
-                kind: "update",
-                values: matchedAssignments,
-                predicate: matchedPredicate
-              })
-          : undefined,
-        whenNotMatched: notMatched
-          ? {
-              kind: "insert",
-              values: notMatchedAssignments,
-              predicate: notMatchedPredicate
-            }
-          : undefined
-      },
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: []
-    }, undefined as unknown as TrueFormula, "write" as MergeCapabilities<"write", SourceCapabilitiesOf<Source>>, "merge")
-  }
+    "merge",
+    any,
+    "ready",
+    EmptyFacts
+  > => mutationRuntime.merge(target, source, on, options)
 
-  const transaction = (
-    options: TransactionOptions = {}
-  ): QueryPlan<
+  type TransactionApi = (options?: TransactionOptions) => QueryPlan<
     {},
     never,
     {},
@@ -6698,28 +6026,9 @@ type AsCurriedResult<
     TrueFormula,
     "transaction",
     "transaction"
-  > =>
-    makePlan({
-      selection: {},
-      required: [] as never,
-      available: {},
-      dialect: profile.dialect as Dialect
-    }, {
-      kind: "transaction",
-      select: {},
-      transaction: {
-        kind: "transaction",
-        isolationLevel: options.isolationLevel,
-        readOnly: options.readOnly
-      },
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: []
-    }, undefined as unknown as TrueFormula, "transaction", "transaction")
-
-  const commit = (): QueryPlan<
+  >
+
+  type CommitApi = () => QueryPlan<
     {},
     never,
     {},
@@ -6730,26 +6039,9 @@ type AsCurriedResult<
     TrueFormula,
     "transaction",
     "commit"
-  > =>
-    makePlan({
-      selection: {},
-      required: [] as never,
-      available: {},
-      dialect: profile.dialect as Dialect
-    }, {
-      kind: "commit",
-      select: {},
-      transaction: {
-        kind: "commit"
-      },
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: []
-    }, undefined as unknown as TrueFormula, "transaction", "commit")
-
-  const rollback = (): QueryPlan<
+  >
+
+  type RollbackApi = () => QueryPlan<
     {},
     never,
     {},
@@ -6760,28 +6052,9 @@ type AsCurriedResult<
     TrueFormula,
     "transaction",
     "rollback"
-  > =>
-    makePlan({
-      selection: {},
-      required: [] as never,
-      available: {},
-      dialect: profile.dialect as Dialect
-    }, {
-      kind: "rollback",
-      select: {},
-      transaction: {
-        kind: "rollback"
-      },
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: []
-    }, undefined as unknown as TrueFormula, "transaction", "rollback")
-
-  const savepoint = <Name extends string>(
-    name: Name
-  ): QueryPlan<
+  >
+
+  type SavepointApi = <Name extends string>(name: Name) => QueryPlan<
     {},
     never,
     {},
@@ -6792,29 +6065,9 @@ type AsCurriedResult<
     TrueFormula,
     "transaction",
     "savepoint"
-  > =>
-    makePlan({
-      selection: {},
-      required: [] as never,
-      available: {},
-      dialect: profile.dialect as Dialect
-    }, {
-      kind: "savepoint",
-      select: {},
-      transaction: {
-        kind: "savepoint",
-        name
-      },
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: []
-    }, undefined as unknown as TrueFormula, "transaction", "savepoint")
-
-  const rollbackTo = <Name extends string>(
-    name: Name
-  ): QueryPlan<
+  >
+
+  type RollbackToApi = <Name extends string>(name: Name) => QueryPlan<
     {},
     never,
     {},
@@ -6825,29 +6078,9 @@ type AsCurriedResult<
     TrueFormula,
     "transaction",
     "rollbackTo"
-  > =>
-    makePlan({
-      selection: {},
-      required: [] as never,
-      available: {},
-      dialect: profile.dialect as Dialect
-    }, {
-      kind: "rollbackTo",
-      select: {},
-      transaction: {
-        kind: "rollbackTo",
-        name
-      },
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: []
-    }, undefined as unknown as TrueFormula, "transaction", "rollbackTo")
-
-  const releaseSavepoint = <Name extends string>(
-    name: Name
-  ): QueryPlan<
+  >
+
+  type ReleaseSavepointApi = <Name extends string>(name: Name) => QueryPlan<
     {},
     never,
     {},
@@ -6858,32 +6091,12 @@ type AsCurriedResult<
     TrueFormula,
     "transaction",
     "releaseSavepoint"
-  > =>
-    makePlan({
-      selection: {},
-      required: [] as never,
-      available: {},
-      dialect: profile.dialect as Dialect
-    }, {
-      kind: "releaseSavepoint",
-      select: {},
-      transaction: {
-        kind: "releaseSavepoint",
-        name
-      },
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: []
-    }, undefined as unknown as TrueFormula, "transaction", "releaseSavepoint")
-
-  const createTable = <
-    Target extends SchemaTableLike
-  >(
+  >
+
+  type CreateTableApi = <Target extends SchemaTableLike>(
     target: Target,
-    options: CreateTableOptions = {}
-  ): QueryPlan<
+    options?: CreateTableOptions
+  ) => QueryPlan<
     {},
     never,
     {},
@@ -6894,40 +6107,12 @@ type AsCurriedResult<
     TrueFormula,
     "ddl",
     "createTable"
-  > => {
-    const { sourceName, sourceBaseName } = targetSourceDetails(target)
-    return makePlan({
-      selection: {},
-      required: [] as never,
-      available: {},
-      dialect: target[Plan.TypeId].dialect as TableDialectOf<Target>
-    }, {
-      kind: "createTable",
-      select: {},
-      target: {
-        kind: "from",
-        tableName: sourceName,
-        baseTableName: sourceBaseName,
-        source: target
-      },
-      ddl: {
-        kind: "createTable",
-        ifNotExists: options.ifNotExists ?? false
-      },
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: []
-    }, undefined as unknown as TrueFormula, "ddl", "createTable")
-  }
+  >
 
-  const dropTable = <
-    Target extends SchemaTableLike
-  >(
+  type DropTableApi = <Target extends SchemaTableLike>(
     target: Target,
-    options: DropTableOptions = {}
-  ): QueryPlan<
+    options?: DropTableOptions
+  ) => QueryPlan<
     {},
     never,
     {},
@@ -6938,42 +6123,13 @@ type AsCurriedResult<
     TrueFormula,
     "ddl",
     "dropTable"
-  > => {
-    const { sourceName, sourceBaseName } = targetSourceDetails(target)
-    return makePlan({
-      selection: {},
-      required: [] as never,
-      available: {},
-      dialect: target[Plan.TypeId].dialect as TableDialectOf<Target>
-    }, {
-      kind: "dropTable",
-      select: {},
-      target: {
-        kind: "from",
-        tableName: sourceName,
-        baseTableName: sourceBaseName,
-        source: target
-      },
-      ddl: {
-        kind: "dropTable",
-        ifExists: options.ifExists ?? false
-      },
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: []
-    }, undefined as unknown as TrueFormula, "ddl", "dropTable")
-  }
+  >
 
-  const createIndex = <
-    Target extends SchemaTableLike,
-    const Columns extends DdlColumnInput
-  >(
+  type CreateIndexApi = <Target extends SchemaTableLike, const Columns extends DdlColumnInput>(
     target: Target,
     columns: Columns & ValidateDdlColumns<Target, NormalizeDdlColumns<Columns>>,
-    options: CreateIndexOptions = {}
-  ): QueryPlan<
+    options?: CreateIndexOptions
+  ) => QueryPlan<
     {},
     never,
     {},
@@ -6984,46 +6140,13 @@ type AsCurriedResult<
     TrueFormula,
     "ddl",
     "createIndex"
-  > => {
-    const normalizedColumns = normalizeColumnList(columns as string | readonly string[])
-    const { sourceName, sourceBaseName } = targetSourceDetails(target)
-    return makePlan({
-      selection: {},
-      required: [] as never,
-      available: {},
-      dialect: target[Plan.TypeId].dialect as TableDialectOf<Target>
-    }, {
-      kind: "createIndex",
-      select: {},
-      target: {
-        kind: "from",
-        tableName: sourceName,
-        baseTableName: sourceBaseName,
-        source: target
-      },
-      ddl: {
-        kind: "createIndex",
-        name: options.name ?? defaultIndexName(sourceBaseName, normalizedColumns, options.unique ?? false),
-        columns: normalizedColumns,
-        unique: options.unique ?? false,
-        ifNotExists: options.ifNotExists ?? false
-      },
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: []
-    }, undefined as unknown as TrueFormula, "ddl", "createIndex")
-  }
+  >
 
-  const dropIndex = <
-    Target extends SchemaTableLike,
-    const Columns extends DdlColumnInput
-  >(
+  type DropIndexApi = <Target extends SchemaTableLike, const Columns extends DdlColumnInput>(
     target: Target,
     columns: Columns & ValidateDdlColumns<Target, NormalizeDdlColumns<Columns>>,
-    options: DropIndexOptions = {}
-  ): QueryPlan<
+    options?: DropIndexOptions
+  ) => QueryPlan<
     {},
     never,
     {},
@@ -7034,107 +6157,9 @@ type AsCurriedResult<
     TrueFormula,
     "ddl",
     "dropIndex"
-  > => {
-    const normalizedColumns = normalizeColumnList(columns as string | readonly string[])
-    const { sourceName, sourceBaseName } = targetSourceDetails(target)
-    return makePlan({
-      selection: {},
-      required: [] as never,
-      available: {},
-      dialect: target[Plan.TypeId].dialect as TableDialectOf<Target>
-    }, {
-      kind: "dropIndex",
-      select: {},
-      target: {
-        kind: "from",
-        tableName: sourceName,
-        baseTableName: sourceBaseName,
-        source: target
-      },
-      ddl: {
-        kind: "dropIndex",
-        name: options.name ?? defaultIndexName(sourceBaseName, normalizedColumns, false),
-        ifExists: options.ifExists ?? false
-      },
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: []
-    }, undefined as unknown as TrueFormula, "ddl", "dropIndex")
-  }
+  >
 
-  const api = {
-    literal,
-    column,
-    cast,
-    type,
-    json,
-    jsonb,
-    eq,
-    neq,
-    lt,
-    lte,
-    gt,
-    gte,
-    isNull,
-    isNotNull,
-    upper,
-    lower,
-    like,
-    ilike,
-    regexMatch,
-    regexIMatch,
-    regexNotMatch,
-    regexNotIMatch,
-    and,
-    or,
-    not,
-    all: all_,
-    any: any_,
-    case: case_,
-    match,
-    coalesce,
-    call,
-    uuidGenerateV4,
-    nextVal,
-    in: in_,
-    notIn,
-    between,
-    contains,
-    containedBy,
-    overlaps,
-    concat,
-    exists,
-    over,
-    rowNumber,
-    rank,
-    denseRank,
-    count,
-    max,
-    min,
-    isDistinctFrom,
-    isNotDistinctFrom,
-    excluded,
-    as,
-    with: with_,
-    withRecursive: withRecursive_,
-    lateral,
-    scalar,
-    inSubquery,
-    compareAny,
-    compareAll,
-    values,
-    unnest,
-    generateSeries,
-    returning,
-    onConflict,
-    insert,
-    update,
-    upsert,
-    delete: delete_,
-    truncate,
-    merge,
+  const {
     transaction,
     commit,
     rollback,
@@ -7144,30 +6169,161 @@ type AsCurriedResult<
     createTable,
     dropTable,
     createIndex,
-    dropIndex,
-    union,
-    unionAll,
-    intersect,
-    intersectAll,
-    except,
-    exceptAll,
+    dropIndex
+  } = makeDslTransactionDdlRuntime({
+    profile,
+    makePlan,
+    targetSourceDetails,
+    normalizeColumnList,
+    defaultIndexName
+  }) as {
+    readonly transaction: TransactionApi
+    readonly commit: CommitApi
+    readonly rollback: RollbackApi
+    readonly savepoint: SavepointApi
+    readonly rollbackTo: RollbackToApi
+    readonly releaseSavepoint: ReleaseSavepointApi
+    readonly createTable: CreateTableApi
+    readonly dropTable: DropTableApi
+    readonly createIndex: CreateIndexApi
+    readonly dropIndex: DropIndexApi
+  }
+
+  const {
+    values: exportedValues,
+    unnest: exportedUnnest,
+    select: exportedSelect,
+    from: exportedFrom,
+    insert: exportedInsert
+  } = {
+    values,
+    unnest,
     select,
-    where,
-    having,
     from,
-    innerJoin,
-    leftJoin,
-    rightJoin,
-    fullJoin,
-    crossJoin,
-    distinct,
-    distinctOn,
-    limit,
-    offset,
-    lock,
-    orderBy,
-    groupBy
+    insert
+  } as {
+    readonly values: ValuesApi
+    readonly unnest: UnnestApi
+    readonly select: SelectApi
+    readonly from: FromApi
+    readonly insert: InsertApi
   }
 
-return api
-})()
+export const mysqlDsl = {
+  values: exportedValues,
+  unnest: exportedUnnest,
+  select: exportedSelect,
+  from: exportedFrom,
+  insert: exportedInsert
+} as {
+  readonly values: ValuesApi
+  readonly unnest: UnnestApi
+  readonly select: SelectApi
+  readonly from: FromApi
+  readonly insert: InsertApi
+}
+
+export {
+  literal,
+  column,
+  cast,
+  type,
+  json,
+  jsonb,
+  eq,
+  neq,
+  lt,
+  lte,
+  gt,
+  gte,
+  isNull,
+  isNotNull,
+  upper,
+  lower,
+  like,
+  ilike,
+  regexMatch,
+  regexIMatch,
+  regexNotMatch,
+  regexNotIMatch,
+  and,
+  or,
+  not,
+  all_ as all,
+  any_ as any,
+  case_,
+  match,
+  coalesce,
+  call,
+  uuidGenerateV4,
+  nextVal,
+  in_,
+  notIn,
+  between,
+  contains,
+  containedBy,
+  overlaps,
+  concat,
+  exists,
+  over,
+  rowNumber,
+  rank,
+  denseRank,
+  count,
+  max,
+  min,
+  isDistinctFrom,
+  isNotDistinctFrom,
+  excluded,
+  as,
+  with_,
+  withRecursive_ as withRecursive,
+  lateral,
+  scalar,
+  inSubquery,
+  compareAny,
+  compareAll,
+  exportedValues as values,
+  exportedUnnest as unnest,
+  generateSeries,
+  returning,
+  onConflict,
+  exportedInsert as insert,
+  update,
+  upsert,
+  delete_,
+  truncate,
+  merge,
+  transaction,
+  commit,
+  rollback,
+  savepoint,
+  rollbackTo,
+  releaseSavepoint,
+  createTable,
+  dropTable,
+  createIndex,
+  dropIndex,
+  union,
+  unionAll,
+  intersect,
+  intersectAll,
+  except,
+  exceptAll,
+  exportedSelect as select,
+  where,
+  having,
+  exportedFrom as from,
+  innerJoin,
+  leftJoin,
+  rightJoin,
+  fullJoin,
+  crossJoin,
+  distinct,
+  distinctOn,
+  limit,
+  offset,
+  lock,
+  orderBy,
+  groupBy
+}