effect-qb 0.14.0 → 0.16.0

package/src/internal/query.ts

@@ -1,7 +1,8 @@
 import { pipeArguments, type Pipeable } from "effect/Pipeable"
+import type * as Schema from "effect/Schema"
 
-import * as Expression from "./expression.js"
-import * as Plan from "./plan.js"
+import * as Expression from "./scalar.js"
+import * as RowSet from "./row-set.js"
 import * as Table from "./table.js"
 import * as ExpressionAst from "./expression-ast.js"
 import * as QueryAst from "./query-ast.js"
@@ -9,10 +10,23 @@ import type { JsonNode } from "./json/ast.js"
 import type * as JsonPath from "./json/path.js"
 import type { QueryCapability } from "./query-requirements.js"
 import type { CaseBranchAssumeFalse, CaseBranchAssumeTrue, CaseBranchDecision } from "./case-analysis.js"
-import type { ContradictsFormula, GuaranteedNonNullKeys, GuaranteedNullKeys, GuaranteedSourceNames } from "./predicate-analysis.js"
-import type { ColumnKeyOfExpression } from "./predicate-key.js"
-import type { PredicateFormula, TrueFormula } from "./predicate-formula.js"
-import { trueFormula } from "./predicate-runtime.js"
+import type {
+  ContradictsFormula,
+  EmptyFacts,
+  FactsOfFormula,
+  GuaranteedLiteralSetInFacts,
+  GuaranteedNeqLiteralInFacts,
+  GuaranteedJsonLiteralSetInFacts,
+  GuaranteedNonNullKeysInFacts,
+  GuaranteedNullKeysInFacts,
+  GuaranteedSourceNamesInFacts,
+  PredicateState
+} from "./predicate/analysis.js"
+import type { AssumeFactsFalse, AssumeFactsTrue, PredicateContext } from "./predicate/context.js"
+import type { FormulaOfPredicate } from "./predicate/normalize.js"
+import type { ColumnKeyOfAst, ColumnKeyOfExpression, PredicateKeyOfAst } from "./predicate/key.js"
+import type { PredicateFormula, TrueFormula } from "./predicate/formula.js"
+import { trueFormula } from "./predicate/runtime.js"
 
 export type {
   MergeCapabilities,
@@ -25,7 +39,7 @@ export type {
   RuntimeOfDbType,
   TextCompatibleDbType,
   CastableDbType
-} from "./coercion-analysis.js"
+} from "./coercion/analysis.js"
 export type {
   CanonicalSegment as JsonPathSegment,
   DescendSegment as JsonPathDescendSegment,
@@ -60,12 +74,12 @@ export type {
 export type {
   CoercionKind,
   CoercionKindOf
-} from "./coercion-kind.js"
+} from "./coercion/kind.js"
 export type {
   CanCastDbType,
   CanCompareDbTypes,
   CanContainDbTypes
-} from "./coercion-rules.js"
+} from "./coercion/rules.js"
 export type {
   ConflictClause,
   LockClause,
@@ -99,12 +113,12 @@ const PlanProto = {
 }
 
 /** Internal symbol used to preserve query-only phantom metadata through inference. */
-const QueryTypeId: unique symbol = Symbol.for("effect-qb/Query/internal")
+export const QueryTypeId: unique symbol = Symbol.for("effect-qb/Query/internal")
 
 type InsertSourceState = "ready" | "missing"
 
 /** Internal phantom state tracked on query plans. */
-interface QueryState<
+export interface QueryState<
   Outstanding extends string,
   AvailableNames extends string,
   Grouped extends string,
@@ -112,26 +126,26 @@ interface QueryState<
   Capabilities extends QueryCapability,
   Statement extends QueryAst.QueryStatement,
   Target,
-  InsertState extends InsertSourceState
+  InsertState extends InsertSourceState,
+  Facts extends PredicateContext
 > {
   readonly required: Outstanding
   readonly availableNames: AvailableNames
   readonly grouped: Grouped
   readonly assumptions: Assumptions
+  readonly facts: Facts
   readonly capabilities: Capabilities
   readonly statement: Statement
   readonly target: Target
   readonly insertSource: InsertState
 }
 
-/** Source provenance attached to an expression. */
-export type SourceOf<Value extends Expression.Any> = Value[typeof Expression.TypeId]["source"]
 /** Effective SQL dialect carried by an expression. */
 export type DialectOf<Value extends Expression.Any> = Value[typeof Expression.TypeId]["dialect"]
-/** Source dependency map carried by an expression. */
+/** Source dependency union carried by an expression. */
 export type DependenciesOf<Value extends Expression.Any> = Expression.DependenciesOf<Value>
 /** Aggregation kind carried by an expression. */
-export type AggregationOf<Value extends Expression.Any> = Value[typeof Expression.TypeId]["aggregation"]
+export type KindOf<Value extends Expression.Any> = Value[typeof Expression.TypeId]["kind"]
 type AstOf<Value extends Expression.Any> = Value extends { readonly [ExpressionAst.TypeId]: infer Ast extends ExpressionAst.Any } ? Ast : never
 
 /**
@@ -143,11 +157,11 @@ type AstOf<Value extends Expression.Any> = Value extends { readonly [ExpressionA
 export type LiteralValue = string | number | boolean | null | Date
 
 /** Runtime expression type produced by `literal(...)` for a primitive value. */
-type LiteralExpression<Value extends LiteralValue> = Expression.Expression<
+type LiteralExpression<Value extends LiteralValue> = Expression.Scalar<
   Value,
   LiteralDbType<Value>,
   LiteralNullability<Value>,
-  "postgres",
+  string,
   "scalar",
   never
 >
@@ -161,21 +175,19 @@ type LiteralExpression<Value extends LiteralValue> = Expression.Expression<
 export type ExpressionInput = Expression.Any | LiteralValue
 
 /** Input accepted by numeric clauses such as `limit(...)` and `offset(...)`. */
-export type NumericExpressionInput = Expression.Expression<
+export type NumericExpressionInput = Expression.Scalar<
   number,
   Expression.DbType.Any,
   Expression.Nullability,
   string,
   "scalar",
-  any,
-  Expression.SourceDependencies,
-  Expression.SourceNullabilityMode
+  Expression.BindingId
 > | number
 
 /** Values accepted by mutation payload fields. */
 export type MutationValueInput<Value> =
   | Value
-  | Expression.Expression<Value, Expression.DbType.Any, Expression.Nullability, string, Expression.AggregationKind, any, any, any>
+  | Expression.Scalar<Value, Expression.DbType.Any, Expression.Nullability, string, Expression.ScalarKind, Expression.BindingId>
 
 /** Maps a payload shape to values or expressions of the same runtime type. */
 export type MutationInputOf<Shape> = {
@@ -185,74 +197,64 @@ export type MutationInputOf<Shape> = {
 type Simplify<T> = { readonly [K in keyof T]: T[K] } & {}
 
 /** Input accepted by boolean plan clauses such as `where(...)` and joins. */
-export type PredicateInput = Expression.Expression<
+export type PredicateInput = Expression.Scalar<
   boolean,
   Expression.DbType.Any,
   Expression.Nullability,
   string,
   "scalar",
-  any,
-  Expression.SourceDependencies,
-  Expression.SourceNullabilityMode
+  Expression.BindingId
 > | boolean
 
 /** Input accepted by `having(...)`. */
-export type HavingPredicateInput = Expression.Expression<
+export type HavingPredicateInput = Expression.Scalar<
   boolean,
   Expression.DbType.Any,
   Expression.Nullability,
   string,
   "scalar" | "aggregate",
-  any,
-  Expression.SourceDependencies,
-  Expression.SourceNullabilityMode
+  Expression.BindingId
 > | boolean
 
 /** Input accepted by `GROUP BY`. */
-export type GroupByInput = Expression.Expression<
+export type GroupByInput = Expression.Scalar<
   any,
   Expression.DbType.Any,
   Expression.Nullability,
   string,
   "scalar",
-  any
+  Expression.BindingId
 >
 
 /** Maps a literal runtime value to its SQL-level DB type descriptor. */
 type LiteralDbType<Value extends LiteralValue> =
-  Value extends string ? Expression.DbType.PgText :
-    Value extends number ? Expression.DbType.PgNumeric :
-      Value extends boolean ? Expression.DbType.PgBool :
-        Value extends Date ? Expression.DbType.PgTimestamp :
-          Expression.DbType.Base<"postgres", "null">
+  Value extends string ? Expression.DbType.Base<string, "text"> :
+    Value extends number ? Expression.DbType.Base<string, "numeric"> :
+      Value extends boolean ? Expression.DbType.Base<string, "boolean"> :
+        Value extends Date ? Expression.DbType.Base<string, "timestamp"> :
+          Expression.DbType.Base<string, "null">
 
 /** Maps a literal runtime value to its static nullability state. */
 type LiteralNullability<Value extends LiteralValue> = Value extends null ? "always" : "never"
 /** Converts a supported input into its canonical expression type. */
 type AsExpression<Value extends ExpressionInput> = Value extends Expression.Any ? Value : LiteralExpression<Extract<Value, LiteralValue>>
-/** Extracts provenance from an operator input after coercion. */
-type SourceOfInput<Value extends ExpressionInput> = SourceOf<AsExpression<Value>>
 /** Extracts dialect from an operator input after coercion. */
 type DialectOfInput<Value extends ExpressionInput> = DialectOf<AsExpression<Value>>
 /** Extracts dependencies from an operator input after coercion. */
 type DependenciesOfInput<Value extends ExpressionInput> = DependenciesOf<AsExpression<Value>>
-/** Extracts required sources from an operator input after coercion. */
-type RequiredFromInput<Value extends ExpressionInput> = RequiredFromDependencies<DependenciesOfInput<Value>>
+/** Extracts required bindings from an operator input after coercion. */
+type RequiredFromInput<Value extends ExpressionInput> = DependenciesOfInput<Value>
 /** String-valued expressions accepted by text operators. */
-export type StringExpressionInput = Expression.Expression<
+export type StringExpressionInput = Expression.Scalar<
   string | null,
   Expression.DbType.Any,
   Expression.Nullability,
   string,
-  Expression.AggregationKind,
-  any,
-  Expression.SourceDependencies,
-  Expression.SourceNullabilityMode
+  Expression.ScalarKind,
+  Expression.BindingId
 > | string
 /** Converts a string operator input into its canonical expression type. */
 type AsStringExpression<Value extends StringExpressionInput> = Value extends Expression.Any ? Value : LiteralExpression<Extract<Value, string>>
-/** Extracts provenance from a string operator input after coercion. */
-type SourceOfStringInput<Value extends StringExpressionInput> = SourceOf<AsStringExpression<Value>>
 /** Extracts dialect from a string operator input after coercion. */
 type DialectOfStringInput<Value extends StringExpressionInput> = DialectOf<AsStringExpression<Value>>
 /** Extracts dependencies from a string operator input after coercion. */
@@ -260,10 +262,8 @@ type DependenciesOfStringInput<Value extends StringExpressionInput> = Dependenci
 /** Extracts intrinsic nullability from a string operator input after coercion. */
 type NullabilityOfStringInput<Value extends StringExpressionInput> = Expression.NullabilityOf<AsStringExpression<Value>>
 
-/** Extracts a required table name from expression provenance. */
-type RequiredFromSource<Source> = Source extends { readonly tableName: infer Name extends string } ? Name : never
-/** Extracts required table names from an expression dependency map. */
-export type RequiredFromDependencies<Dependencies extends Expression.SourceDependencies> = Extract<keyof Dependencies, string>
+/** Extracts required bindings from an expression dependency union. */
+export type RequiredFromDependencies<Dependencies extends Expression.BindingId> = Dependencies
 
 type LiteralGroupingKey<Value> =
   Value extends string ? `string:${Value}` :
@@ -378,8 +378,13 @@ type GroupingKeyOfAst<Ast extends ExpressionAst.Any> =
             ? "exists(subquery)"
           : never
 
-/** Canonical grouping identity for an expression AST. */
-export type GroupingKeyOfExpression<Value extends Expression.Any> = GroupingKeyOfAst<AstOf<Value>>
+/** Canonical grouping identity for an expression. */
+export type GroupingKeyOfExpression<Value extends Expression.Any> =
+  Expression.GroupKeyOf<Value> extends infer GroupKey extends string
+    ? string extends GroupKey
+      ? GroupingKeyOfAst<AstOf<Value>>
+      : GroupKey
+    : GroupingKeyOfAst<AstOf<Value>>
 
 /**
  * Recursive selection tree accepted by `select(...)`.
@@ -418,7 +423,7 @@ export type ExtractDialect<Selection> = Selection extends Expression.Any
  * The query layer only needs the plan metadata and the static table name. It
  * deliberately avoids depending on the full table-definition surface.
  */
-export type TableLike<Name extends string = string, Dialect extends string = string> = Plan.Plan<any, any, Record<string, Plan.AnySource>, Dialect> & {
+export type TableLike<Name extends string = string, Dialect extends string = string> = RowSet.RowSet<any, any, Record<string, RowSet.AnySource>, Dialect> & {
   readonly [Table.TypeId]: {
     readonly name: Name
     readonly baseName: string
@@ -556,6 +561,9 @@ export type TableFunctionSource<
   readonly columns: DerivedSelectionOf<Selection, Alias>
 }
 
+/** Broad structural shape for table-function sources when used as composable inputs. */
+export type AnyTableFunctionSource = TableFunctionSource<Record<string, Expression.Any>, string, string, string>
+
 /** Accepts either a physical table or a derived table source. */
 type DerivedSourceShape = {
   readonly kind: "derived"
@@ -649,12 +657,12 @@ type JsonMutationDbKindError<
   ExpectedKind extends string,
   ReceivedKind extends string
 > = {
-  readonly __effect_qb_error__: "effect-qb: incompatible postgres json mutation value"
+  readonly __effect_qb_error__: "effect-qb: incompatible json mutation value"
   readonly __effect_qb_column__: ColumnName
-  readonly __effect_qb_reason__: "postgres json/jsonb kinds do not match"
+  readonly __effect_qb_reason__: "json kinds do not match"
   readonly __effect_qb_expected_json_kind__: ExpectedKind
   readonly __effect_qb_received_json_kind__: ReceivedKind
-  readonly __effect_qb_hint__: "Use postgres.Function.json for json columns and postgres.Function.jsonb for jsonb columns"
+  readonly __effect_qb_hint__: "Use the dialect Json helpers that match the target json kind"
 }
 
 type JsonMutationShapeError<
@@ -662,7 +670,7 @@ type JsonMutationShapeError<
   Expected,
   Received
 > = {
-  readonly __effect_qb_error__: "effect-qb: incompatible postgres json mutation value"
+  readonly __effect_qb_error__: "effect-qb: incompatible json mutation value"
   readonly __effect_qb_column__: ColumnName
   readonly __effect_qb_reason__: "json value is not assignable to the target column schema"
   readonly __effect_qb_json_issues__: JsonShapeIssues<Expected, Received>
@@ -705,6 +713,13 @@ type JsonArrayPath<Path extends string> = Path extends ""
   ? "[number]"
   : `${Path}[number]`
 
+type JsonTupleIndexPath<
+  Path extends string,
+  Index extends string
+> = Path extends ""
+  ? `[${Index}]`
+  : `${Path}[${Index}]`
+
 type JsonIssueKeyPath<Path extends string> = Path extends ""
   ? "root"
   : Path
@@ -751,6 +766,22 @@ type JsonObjectShapeIssues<
         JsonShapeIssues<Expected[K], Received[K], JsonObjectKeyPath<Path, K>>
     }[JsonSharedKeys<Expected, Received>]
 
+type JsonTupleIndices<Value extends readonly unknown[]> = Extract<keyof Value, `${number}`>
+
+type JsonTupleShapeIssues<
+  Expected extends readonly unknown[],
+  Received extends readonly unknown[],
+  Path extends string
+> =
+  | {
+      readonly [K in Exclude<JsonTupleIndices<Expected>, JsonTupleIndices<Received>>]:
+        JsonShapeIssue<JsonTupleIndexPath<Path, K>, "missing_required_property", Expected[K], undefined>
+    }[Exclude<JsonTupleIndices<Expected>, JsonTupleIndices<Received>>]
+  | {
+      readonly [K in Extract<JsonTupleIndices<Expected>, JsonTupleIndices<Received>>]:
+        JsonShapeIssues<Expected[K], Received[K], JsonTupleIndexPath<Path, K>>
+    }[Extract<JsonTupleIndices<Expected>, JsonTupleIndices<Received>>]
+
 type JsonShapeIssues<
   Expected,
   Received,
@@ -759,7 +790,15 @@ type JsonShapeIssues<
   ? never
   : [Expected] extends [readonly (infer ExpectedElement)[]]
     ? [Received] extends [readonly (infer ReceivedElement)[]]
-      ? JsonShapeIssues<ExpectedElement, ReceivedElement, JsonArrayPath<Path>>
+      ? number extends Expected["length"]
+        ? JsonShapeIssues<ExpectedElement, ReceivedElement, JsonArrayPath<Path>>
+        : number extends Received["length"]
+          ? JsonShapeIssues<ExpectedElement, ReceivedElement, JsonArrayPath<Path>>
+          : JsonTupleShapeIssues<Expected, Received, Path> extends infer Issues
+            ? [Issues] extends [never]
+              ? JsonShapeIssue<Path, "type_mismatch", Expected, Received>
+              : Issues
+            : never
       : JsonShapeIssue<Path, "type_mismatch", Expected, Received>
     : [Expected] extends [object]
       ? [Expected] extends [Function]
@@ -776,7 +815,7 @@ type JsonShapeIssues<
       : JsonShapeIssue<Path, "type_mismatch", Expected, Received>
 
 type MutationAcceptedInput<Column> =
-  Column extends Expression.Expression<infer Runtime, any, any, any, any, any, any, any>
+  Column extends Expression.Scalar<infer Runtime, any, any, any, any, any>
     ? MutationValueInput<Runtime>
     : never
 
@@ -784,14 +823,14 @@ type MutationValueCompatibilityIssue<
   Column,
   Value,
   ColumnName extends string
-> = Column extends Expression.Expression<any, infer ColumnDb extends Expression.DbType.Any, any, any, any, any, any, any>
-  ? ColumnDb extends Expression.DbType.Json<"postgres", infer ExpectedKind>
-    ? Value extends Expression.Expression<any, infer ValueDb extends Expression.DbType.Any, any, any, any, any, any, any>
-      ? ValueDb extends Expression.DbType.Json<"postgres", infer ReceivedKind>
+> = Column extends Expression.Scalar<any, infer ColumnDb extends Expression.DbType.Any, any, any, any, any>
+  ? ColumnDb extends Expression.DbType.Json<infer ColumnDialect extends string, infer ExpectedKind>
+    ? Value extends Expression.Scalar<any, infer ValueDb extends Expression.DbType.Any, any, any, any, any>
+      ? ValueDb extends Expression.DbType.Json<ColumnDialect, infer ReceivedKind>
         ? [ExpectedKind] extends [ReceivedKind]
           ? [ReceivedKind] extends [ExpectedKind]
-            ? Value extends Expression.Expression<infer ReceivedRuntime, any, any, any, any, any, any, any>
-              ? Column extends Expression.Expression<infer ExpectedRuntime, any, any, any, any, any, any, any>
+            ? Value extends Expression.Scalar<infer ReceivedRuntime, any, any, any, any, any>
+              ? Column extends Expression.Scalar<infer ExpectedRuntime, any, any, any, any, any>
                 ? [ReceivedRuntime] extends [ExpectedRuntime]
                   ? never
                   : JsonMutationShapeError<ColumnName, ExpectedRuntime, ReceivedRuntime>
@@ -799,29 +838,29 @@ type MutationValueCompatibilityIssue<
               : never
             : JsonMutationDbKindError<ColumnName, ExpectedKind, ReceivedKind>
           : JsonMutationDbKindError<ColumnName, ExpectedKind, ReceivedKind>
-        : Value extends Expression.Expression<infer ReceivedRuntime, any, any, any, any, any, any, any>
-          ? Column extends Expression.Expression<infer ExpectedRuntime, any, any, any, any, any, any, any>
+        : Value extends Expression.Scalar<infer ReceivedRuntime, any, any, any, any, any>
+          ? Column extends Expression.Scalar<infer ExpectedRuntime, any, any, any, any, any>
             ? [ReceivedRuntime] extends [ExpectedRuntime]
               ? never
               : JsonMutationShapeError<ColumnName, ExpectedRuntime, ReceivedRuntime>
             : never
-          : Column extends Expression.Expression<infer ExpectedRuntime, any, any, any, any, any, any, any>
+          : Column extends Expression.Scalar<infer ExpectedRuntime, any, any, any, any, any>
             ? [Value] extends [ExpectedRuntime]
               ? never
               : JsonMutationShapeError<ColumnName, ExpectedRuntime, Value>
             : never
-      : Column extends Expression.Expression<infer ExpectedRuntime, any, any, any, any, any, any, any>
+      : Column extends Expression.Scalar<infer ExpectedRuntime, any, any, any, any, any>
         ? [Value] extends [ExpectedRuntime]
           ? never
           : JsonMutationShapeError<ColumnName, ExpectedRuntime, Value>
         : never
-    : Value extends Expression.Expression<infer ReceivedRuntime, any, any, any, any, any, any, any>
-      ? Column extends Expression.Expression<infer ExpectedRuntime, any, any, any, any, any, any, any>
+    : Value extends Expression.Scalar<infer ReceivedRuntime, any, any, any, any, any>
+      ? Column extends Expression.Scalar<infer ExpectedRuntime, any, any, any, any, any>
         ? [ReceivedRuntime] extends [ExpectedRuntime]
           ? never
           : MutationValueShapeError<ColumnName, ExpectedRuntime, ReceivedRuntime>
         : never
-      : Column extends Expression.Expression<infer ExpectedRuntime, any, any, any, any, any, any, any>
+      : Column extends Expression.Scalar<infer ExpectedRuntime, any, any, any, any, any>
         ? [Value] extends [ExpectedRuntime]
           ? never
           : MutationValueShapeError<ColumnName, ExpectedRuntime, Value>
@@ -965,15 +1004,13 @@ type DerivedLeafExpression<
   Value extends Expression.Any,
   Alias extends string,
   ColumnName extends string
-> = Expression.Expression<
+> = Expression.Scalar<
   Expression.RuntimeOf<Value>,
   Expression.DbTypeOf<Value>,
   Expression.NullabilityOf<Value>,
   DialectOf<Value>,
   "scalar",
-  Expression.ColumnSource<Alias, ColumnName, Alias>,
-  Record<Alias, true>,
-  "propagate"
+  Alias
 > & {
   readonly [ExpressionAst.TypeId]: ExpressionAst.ColumnNode<Alias, ColumnName>
 }
@@ -994,41 +1031,66 @@ export type DerivedSelectionOf<
 /** Extracts the static SQL table name from a table-like value. */
 export type TableNameOf<T extends TableLike> = T[typeof Table.TypeId]["name"]
 /** Extracts the effective dialect from a table-like value. */
-export type TableDialectOf<T extends TableLike> = T[typeof Plan.TypeId]["dialect"]
+export type TableDialectOf<T extends TableLike> = T[typeof RowSet.TypeId]["dialect"]
 /** Names of sources already available to a plan. */
-type AvailableNames<Available extends Record<string, Plan.AnySource>> = Extract<keyof Available, string>
+type AvailableNames<Available extends Record<string, RowSet.AnySource>> = Extract<keyof Available, string>
 /** Availability mode of a named source within the current plan scope. */
 type SourceModeOf<
-  Available extends Record<string, Plan.AnySource>,
+  Available extends Record<string, RowSet.AnySource>,
   Name extends string
 > = Name extends keyof Available ? Available[Name]["mode"] : never
 type TrueAssumptions = TrueFormula
 
+/** Extracts the public plan state carried under `RowSet.TypeId`. */
+type QueryPlanParts<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>
+> = PlanValue[typeof RowSet.TypeId]
+
+/** Extracts the internal phantom query state carried under `QueryTypeId`. */
+type QueryPlanState<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>
+> = PlanValue[typeof QueryTypeId]
+
 /** Extracts the selection carried by a query plan. */
-export type SelectionOfPlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
-  PlanValue[typeof Plan.TypeId]["selection"]
+export type SelectionOfPlan<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>
+> = QueryPlanParts<PlanValue>["selection"]
 /** Extracts the public required-source state carried by a query plan. */
-export type RequiredOfPlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
-  PlanValue[typeof Plan.TypeId]["required"]
+export type RequiredOfPlan<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>
+> = QueryPlanParts<PlanValue>["required"]
 /** Extracts the available-source scope carried by a query plan. */
-export type AvailableOfPlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
-  PlanValue[typeof Plan.TypeId]["available"]
+export type AvailableOfPlan<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>
+> = QueryPlanParts<PlanValue>["available"]
 /** Extracts the effective dialect carried by a query plan. */
-export type PlanDialectOf<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
-  PlanValue[typeof Plan.TypeId]["dialect"]
+export type PlanDialectOf<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>
+> = QueryPlanParts<PlanValue>["dialect"]
 /** Extracts the grouped-source phantom carried by a query plan. */
-export type GroupedOfPlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
-  PlanValue extends QueryPlan<any, any, any, any, infer Grouped, any, any, any, any, any> ? Grouped : never
+export type GroupedOfPlan<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>
+> = QueryPlanState<PlanValue>["grouped"]
 /** Extracts the available-name phantom carried by a query plan. */
-export type ScopedNamesOfPlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
-  PlanValue extends QueryPlan<any, any, any, any, any, infer ScopedNames, any, any, any, any> ? ScopedNames : never
+export type ScopedNamesOfPlan<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>
+> = QueryPlanState<PlanValue>["availableNames"]
 /** Extracts the outstanding-required-source phantom carried by a query plan. */
-export type OutstandingOfPlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
-  PlanValue extends QueryPlan<any, any, any, any, any, any, infer Outstanding, any, any, any> ? Outstanding : never
-export type AssumptionsOfPlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
-  PlanValue extends QueryPlan<any, any, any, any, any, any, any, infer Assumptions, any, any> ? Assumptions : TrueAssumptions
-export type CapabilitiesOfPlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
-  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, infer Capabilities, any> ? Capabilities : never
+export type OutstandingOfPlan<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>
+> = QueryPlanState<PlanValue>["required"]
+export type AssumptionsOfPlan<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>
+> = QueryPlanState<PlanValue>["assumptions"]
+export type FactsOfPlan<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>
+> = QueryPlanState<PlanValue>["facts"]
+export type PredicateStateOfPlan<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>
+> = PredicateState<AssumptionsOfPlan<PlanValue>, FactsOfPlan<PlanValue>>
+export type CapabilitiesOfPlan<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>
+> = QueryPlanState<PlanValue>["capabilities"]
 /** Extracts capabilities contributed by a source wrapper. */
 export type SourceCapabilitiesOf<Source extends SourceLike> =
   Source extends TableLike<any, any> ? never :
@@ -1037,14 +1099,20 @@ export type SourceCapabilitiesOf<Source extends SourceLike> =
         Source extends { readonly kind: "lateral"; readonly plan: infer PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any> } ? CapabilitiesOfPlan<PlanValue> :
           never
 /** Extracts the statement kind carried by a query plan. */
-export type StatementOfPlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
-  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, infer Statement> ? Statement : never
+export type StatementOfPlan<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>
+> = QueryPlanState<PlanValue>["statement"]
 /** Extracts the mutation target phantom carried by a query plan. */
-export type MutationTargetOfPlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
-  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, infer Target> ? Target : never
+export type MutationTargetOfPlan<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>
+> = QueryPlanState<PlanValue>["target"]
 /** Extracts whether an insert plan still needs a source attached. */
-export type InsertSourceStateOfPlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
-  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, infer InsertState> ? InsertState : "ready"
+export type InsertSourceStateOfPlan<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>
+> = QueryPlanState<PlanValue>["insertSource"]
+export type StateOfPlan<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>
+> = QueryPlanParts<PlanValue>
 
 type PresenceWitnessKeysOfSelection<Selection> = Selection extends Expression.Any
   ? AstOf<Selection> extends ExpressionAst.ColumnNode<any, any>
@@ -1060,7 +1128,7 @@ type PresenceWitnessKeysOfSelection<Selection> = Selection extends Expression.An
 
 export type PresenceWitnessKeysOfSource<Source extends SourceLike> =
   Source extends TableLike<any, any>
-    ? PresenceWitnessKeysOfSelection<Source[typeof Plan.TypeId]["selection"]>
+    ? PresenceWitnessKeysOfSelection<Source[typeof RowSet.TypeId]["selection"]>
     : Source extends { readonly columns: infer Columns }
       ? PresenceWitnessKeysOfSelection<Columns>
       : never
@@ -1071,21 +1139,21 @@ export type PresenceWitnessKeysOfSource<Source extends SourceLike> =
  * This is used by `from(...)` and the join builders.
  */
 export type AddAvailable<
-  Available extends Record<string, Plan.AnySource>,
+  Available extends Record<string, RowSet.AnySource>,
   Name extends string,
-  Mode extends Plan.SourceMode = "required",
+  Mode extends RowSet.SourceMode = "required",
   PresentFormula extends PredicateFormula = TrueFormula,
   PresenceWitness extends string = never
-> = Available & Record<Name, Plan.Source<Name, Mode, PresentFormula, PresenceWitness>>
+> = Available & Record<Name, RowSet.Source<Name, Mode, PresentFormula, PresenceWitness>>
 
 export type AddAvailableMany<
-  Available extends Record<string, Plan.AnySource>,
+  Available extends Record<string, RowSet.AnySource>,
   Names extends string,
-  Mode extends Plan.SourceMode = "required",
+  Mode extends RowSet.SourceMode = "required",
   PresentFormula extends PredicateFormula = TrueFormula,
   PresenceWitness extends string = never
 > = Available & {
-  readonly [K in Names]: Plan.Source<K, Mode, PresentFormula, PresenceWitness>
+  readonly [K in Names]: RowSet.Source<K, Mode, PresentFormula, PresenceWitness>
 }
 
 /** Join mode projected into the plan's source-scope mode lattice. */
@@ -1094,27 +1162,27 @@ export type JoinSourceMode<Kind extends QueryAst.JoinKind> = Kind extends "left"
   : "required"
 
 type DemoteAllAvailable<
-  Available extends Record<string, Plan.AnySource>
+  Available extends Record<string, RowSet.AnySource>
 > = {
-  readonly [K in keyof Available]: Available[K] extends Plan.Source<
+  readonly [K in keyof Available]: Available[K] extends RowSet.Source<
     infer Name extends string,
     any,
     infer PresentFormula extends PredicateFormula,
     infer PresenceWitness extends string
   >
-    ? Plan.Source<Name, "optional", PresentFormula, PresenceWitness>
+    ? RowSet.Source<Name, "optional", PresentFormula, PresenceWitness>
     : never
 }
 
 export type ExistingAvailableAfterJoin<
-  Available extends Record<string, Plan.AnySource>,
+  Available extends Record<string, RowSet.AnySource>,
   Kind extends QueryAst.JoinKind
 > = Kind extends "right" | "full"
   ? DemoteAllAvailable<Available>
   : Available
 
 export type AvailableAfterJoin<
-  Available extends Record<string, Plan.AnySource>,
+  Available extends Record<string, RowSet.AnySource>,
   JoinedName extends string,
   Kind extends QueryAst.JoinKind,
   PresentFormula extends PredicateFormula = TrueFormula,
@@ -1134,7 +1202,7 @@ export type AvailableAfterJoin<
  */
 export type AddExpressionRequired<
   Required,
-  Available extends Record<string, Plan.AnySource>,
+  Available extends Record<string, RowSet.AnySource>,
   Value extends ExpressionInput
 > = Exclude<Required | RequiredFromInput<Value>, AvailableNames<Available>>
 
@@ -1146,7 +1214,7 @@ export type AddExpressionRequired<
  */
 export type AddJoinRequired<
   Required,
-  Available extends Record<string, Plan.AnySource>,
+  Available extends Record<string, RowSet.AnySource>,
   JoinedName extends string,
   Predicate extends PredicateInput | never,
   Kind extends QueryAst.JoinKind = "inner"
@@ -1157,8 +1225,8 @@ export type AddJoinRequired<
 
 /** Merges two aggregation kinds through a derived expression. */
 export type MergeAggregation<
-  Left extends Expression.AggregationKind,
-  Right extends Expression.AggregationKind
+  Left extends Expression.ScalarKind,
+  Right extends Expression.ScalarKind
 > = Left extends "window"
   ? "window"
   : Right extends "window"
@@ -1172,9 +1240,9 @@ export type MergeAggregation<
 /** 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
 
 /** Merges two nullability states for null-propagating scalar operators. */
@@ -1204,23 +1272,18 @@ export type TupleDialect<
   Values extends readonly Expression.Any[]
 > = Values[number] extends never ? never : DialectOf<Values[number]>
 
-/** Source union across a tuple of expressions. */
-export type TupleSource<
-  Values extends readonly Expression.Any[]
-> = Values[number] extends never ? never : SourceOf<Values[number]>
-
 /** Converts a union into an intersection. */
 type UnionToIntersection<Union> = (
   Union extends any ? (value: Union) => void : never
 ) extends (value: infer Intersection) => void ? Intersection : never
 
-/** Dependency-map intersection suitable for provenance unions across a tuple. */
+/** Dependency union across a tuple of scalar expressions. */
 export type TupleDependencies<
   Values extends readonly Expression.Any[]
-> = DependencyRecord<Values[number] extends never ? never : Extract<keyof DependenciesOf<Values[number]>, string>>
+> = Values[number] extends never ? never : DependenciesOf<Values[number]>
 
-/** Builds a canonical dependency map from a string union of table names. */
-export type DependencyRecord<Keys extends string> = [Keys] extends [never] ? {} : Record<Keys, true>
+/** Builds the canonical dependency union from a string union of table names. */
+export type DependencyRecord<Keys extends string> = Keys
 
 /** Grouped expression identities carried by a tuple of scalar expressions. */
 export type GroupedKeysFromValues<
@@ -1231,7 +1294,7 @@ export type GroupedKeysFromValues<
 
 /** Whether a selection contains any aggregate expressions. */
 type SelectionHasAggregate<Selection> = Selection extends Expression.Any
-  ? AggregationOf<Selection> extends "aggregate" ? true : false
+  ? KindOf<Selection> extends "aggregate" ? true : false
   : Selection extends Record<string, any>
     ? Extract<{
         [K in keyof Selection]: SelectionHasAggregate<Selection[K]>
@@ -1243,9 +1306,9 @@ type IsGroupedSelectionValid<
   Selection,
   Grouped extends string
 > = Selection extends Expression.Any
-  ? AggregationOf<Selection> extends "aggregate"
+  ? KindOf<Selection> extends "aggregate"
     ? true
-    : AggregationOf<Selection> extends "window"
+    : KindOf<Selection> extends "window"
       ? false
       : RequiredFromDependencies<DependenciesOf<Selection>> extends never
         ? true
@@ -1281,13 +1344,14 @@ type MergeNullabilityStates<
 
 type FoldEffectiveNullability<
   Values extends readonly Expression.Any[],
-  Available extends Record<string, Plan.AnySource>,
-  Assumptions extends PredicateFormula
+  Available extends Record<string, RowSet.AnySource>,
+  Assumptions extends PredicateFormula,
+  Facts extends PredicateContext
 > = Extract<{
-  [K in keyof Values]: Values[K] extends Expression.Any ? EffectiveNullability<Values[K], Available, Assumptions> : never
+  [K in keyof Values]: Values[K] extends Expression.Any ? EffectiveNullability<Values[K], Available, Assumptions, Facts> : never
 }[number], "always"> extends never
   ? Extract<{
-      [K in keyof Values]: Values[K] extends Expression.Any ? EffectiveNullability<Values[K], Available, Assumptions> : never
+      [K in keyof Values]: Values[K] extends Expression.Any ? EffectiveNullability<Values[K], Available, Assumptions, Facts> : never
     }[number], "maybe"> extends never
     ? "never"
     : "maybe"
@@ -1295,13 +1359,14 @@ type FoldEffectiveNullability<
 
 type CoalesceEffectiveNullability<
   Values extends readonly Expression.Any[],
-  Available extends Record<string, Plan.AnySource>,
-  Assumptions extends PredicateFormula
+  Available extends Record<string, RowSet.AnySource>,
+  Assumptions extends PredicateFormula,
+  Facts extends PredicateContext
 > = Extract<{
-  [K in keyof Values]: Values[K] extends Expression.Any ? EffectiveNullability<Values[K], Available, Assumptions> : never
+  [K in keyof Values]: Values[K] extends Expression.Any ? EffectiveNullability<Values[K], Available, Assumptions, Facts> : never
 }[number], "never"> extends never
   ? Extract<{
-      [K in keyof Values]: Values[K] extends Expression.Any ? EffectiveNullability<Values[K], Available, Assumptions> : never
+      [K in keyof Values]: Values[K] extends Expression.Any ? EffectiveNullability<Values[K], Available, Assumptions, Facts> : never
     }[number], "maybe"> extends never
     ? "always"
     : "maybe"
@@ -1315,48 +1380,48 @@ type NullabilityOfOutput<Output> =
 type PreciseFactSet<Value extends string> = string extends Value ? never : Value
 
 type KnownGuaranteedNullKeys<
-  Assumptions extends PredicateFormula
-> = PreciseFactSet<GuaranteedNullKeys<Assumptions>>
+  Facts extends PredicateContext
+> = PreciseFactSet<GuaranteedNullKeysInFacts<Facts>>
 
 type KnownGuaranteedNonNullKeys<
-  Assumptions extends PredicateFormula
-> = PreciseFactSet<GuaranteedNonNullKeys<Assumptions>>
+  Facts extends PredicateContext
+> = PreciseFactSet<GuaranteedNonNullKeysInFacts<Facts>>
 
 type KnownGuaranteedSourceNames<
-  Assumptions extends PredicateFormula
-> = PreciseFactSet<GuaranteedSourceNames<Assumptions>>
+  Facts extends PredicateContext
+> = PreciseFactSet<GuaranteedSourceNamesInFacts<Facts>>
 
 type ExplicitlyRequiredSourceNames<
-  Available extends Record<string, Plan.AnySource>
+  Available extends Record<string, RowSet.AnySource>
 > = Extract<{
   readonly [K in keyof Available]:
-    Available[K] extends Plan.Source<any, infer Mode extends Plan.SourceMode>
+    Available[K] extends RowSet.Source<any, infer Mode extends RowSet.SourceMode>
       ? Mode extends "required" ? K : never
       : never
 }[keyof Available], string>
 
-type PresentFormulaOfSource<Source extends Plan.AnySource> =
-  Source extends Plan.Source<any, any, infer PresentFormula extends PredicateFormula, any>
+type PresentFormulaOfSource<Source extends RowSet.AnySource> =
+  Source extends RowSet.Source<any, any, infer PresentFormula extends PredicateFormula, any>
     ? PresentFormula
     : TrueFormula
 
-type PresenceWitnessesOfSource<Source extends Plan.AnySource> =
-  Source extends Plan.Source<any, any, any, infer PresenceWitness extends string>
+type PresenceWitnessesOfSource<Source extends RowSet.AnySource> =
+  Source extends RowSet.Source<any, any, any, infer PresenceWitness extends string>
     ? PresenceWitness
     : never
 
 type ImpliedSourceNamesFromRequired<
-  Available extends Record<string, Plan.AnySource>,
+  Available extends Record<string, RowSet.AnySource>,
   Required extends string
 > = Extract<{
   readonly [K in Extract<keyof Available, string>]:
     K extends Required
-      ? PreciseFactSet<GuaranteedSourceNames<PresentFormulaOfSource<Available[K]>>>
+      ? PreciseFactSet<GuaranteedSourceNamesInFacts<FactsOfFormula<PresentFormulaOfSource<Available[K]>>>>
       : never
 }[Extract<keyof Available, string>], string>
 
 type ExpandRequiredSourceNames<
-  Available extends Record<string, Plan.AnySource>,
+  Available extends Record<string, RowSet.AnySource>,
   Required extends string
 > = ExpandRequiredSourceNamesStep<
   Available,
@@ -1365,7 +1430,7 @@ type ExpandRequiredSourceNames<
 >
 
 type ExpandRequiredSourceNamesStep<
-  Available extends Record<string, Plan.AnySource>,
+  Available extends Record<string, RowSet.AnySource>,
   Current extends string,
   Next extends string
 > = [Exclude<Next, Current>] extends [never]
@@ -1373,33 +1438,36 @@ type ExpandRequiredSourceNamesStep<
   : ExpandRequiredSourceNames<Available, Next>
 
 type DirectlyAbsentSourceNames<
-  Available extends Record<string, Plan.AnySource>,
-  Assumptions extends PredicateFormula
+  Available extends Record<string, RowSet.AnySource>,
+  Assumptions extends PredicateFormula,
+  Facts extends PredicateContext
 > = Extract<{
   readonly [K in Extract<keyof Available, string>]:
-    K extends string
-      ? PresenceWitnessesOfSource<Available[K]> extends infer Witnesses extends string
-        ? Extract<Witnesses, KnownGuaranteedNullKeys<Assumptions>> extends never
-          ? ContradictsFormula<Assumptions, PresentFormulaOfSource<Available[K]>> extends true
-            ? K
-            : never
-          : K
-        : never
+    Available[K] extends RowSet.Source<any, infer Mode extends RowSet.SourceMode, any, any>
+      ? Mode extends "required"
+        ? never
+        : PresenceWitnessesOfSource<Available[K]> extends infer Witnesses extends string
+          ? Extract<Witnesses, KnownGuaranteedNullKeys<Facts>> extends never
+            ? ContradictsFormula<Assumptions, PresentFormulaOfSource<Available[K]>> extends true
+              ? K
+              : never
+            : K
+          : never
       : never
 }[Extract<keyof Available, string>], string>
 
 type ImpliedAbsentSourceNames<
-  Available extends Record<string, Plan.AnySource>,
+  Available extends Record<string, RowSet.AnySource>,
   Absent extends string
 > = Extract<{
   readonly [K in Extract<keyof Available, string>]:
-    Extract<PreciseFactSet<GuaranteedSourceNames<PresentFormulaOfSource<Available[K]>>>, Absent> extends never
+    Extract<PreciseFactSet<GuaranteedSourceNamesInFacts<FactsOfFormula<PresentFormulaOfSource<Available[K]>>>>, Absent> extends never
       ? never
       : K
 }[Extract<keyof Available, string>], string>
 
 type ExpandAbsentSourceNames<
-  Available extends Record<string, Plan.AnySource>,
+  Available extends Record<string, RowSet.AnySource>,
   Current extends string
 > = ExpandAbsentSourceNamesStep<
   Available,
@@ -1408,7 +1476,7 @@ type ExpandAbsentSourceNames<
 >
 
 type ExpandAbsentSourceNamesStep<
-  Available extends Record<string, Plan.AnySource>,
+  Available extends Record<string, RowSet.AnySource>,
   Current extends string,
   Next extends string
 > = [Exclude<Next, Current>] extends [never]
@@ -1416,35 +1484,38 @@ type ExpandAbsentSourceNamesStep<
   : ExpandAbsentSourceNames<Available, Next>
 
 type AbsentSourceNamesInScope<
-  Available extends Record<string, Plan.AnySource>,
-  Assumptions extends PredicateFormula
-> = ExpandAbsentSourceNames<Available, DirectlyAbsentSourceNames<Available, Assumptions>>
+  Available extends Record<string, RowSet.AnySource>,
+  Assumptions extends PredicateFormula,
+  Facts extends PredicateContext
+> = ExpandAbsentSourceNames<Available, DirectlyAbsentSourceNames<Available, Assumptions, Facts>>
 
 type RequiredSourceNamesInScope<
-  Available extends Record<string, Plan.AnySource>,
-  Assumptions extends PredicateFormula
+  Available extends Record<string, RowSet.AnySource>,
+  Assumptions extends PredicateFormula,
+  Facts extends PredicateContext
 > = Exclude<
   ExpandRequiredSourceNames<
     Available,
-    ExplicitlyRequiredSourceNames<Available> | KnownGuaranteedSourceNames<Assumptions>
+    ExplicitlyRequiredSourceNames<Available> | KnownGuaranteedSourceNames<Facts>
   >,
-  AbsentSourceNamesInScope<Available, Assumptions>
+  AbsentSourceNamesInScope<Available, Assumptions, Facts>
 >
 
 type EffectiveAvailable<
-  Available extends Record<string, Plan.AnySource>,
-  Assumptions extends PredicateFormula
+  Available extends Record<string, RowSet.AnySource>,
+  Assumptions extends PredicateFormula,
+  Facts extends PredicateContext
 > = {
   readonly [K in keyof Available]:
-    Available[K] extends Plan.Source<
+    Available[K] extends RowSet.Source<
       infer Name extends string,
-      infer Mode extends Plan.SourceMode,
+      infer Mode extends RowSet.SourceMode,
       infer PresentFormula extends PredicateFormula,
       infer PresenceWitness extends string
     >
-      ? Plan.Source<
+      ? RowSet.Source<
           Name,
-          K extends RequiredSourceNamesInScope<Available, Assumptions> ? "required" : Mode,
+          K extends RequiredSourceNamesInScope<Available, Assumptions, Facts> ? "required" : Mode,
           PresentFormula,
           PresenceWitness
         > & {
@@ -1454,133 +1525,363 @@ type EffectiveAvailable<
 }
 
 type HasAbsentSource<
-  Dependencies extends Expression.SourceDependencies,
-  Available extends Record<string, Plan.AnySource>,
-  Assumptions extends PredicateFormula
+  Dependencies extends Expression.BindingId,
+  Available extends Record<string, RowSet.AnySource>,
+  Assumptions extends PredicateFormula,
+  Facts extends PredicateContext
+> = Extract<Dependencies, AbsentSourceNamesInScope<Available, Assumptions, Facts>> extends never ? false : true
+
+type OptionalSourceNamesInScope<
+  Available extends Record<string, RowSet.AnySource>
 > = Extract<{
-  [K in keyof Dependencies & string]:
-    K extends AbsentSourceNamesInScope<Available, Assumptions> ? true : never
-}[keyof Dependencies & string], true> extends never ? false : true
+  [K in keyof Available & string]: SourceModeOf<Available, K> extends "optional" ? K : never
+}[keyof Available & string], string>
+
+type EffectiveNullabilityFromBase<
+  Value extends Expression.Any,
+  Available extends Record<string, RowSet.AnySource>,
+  Assumptions extends PredicateFormula,
+  Facts extends PredicateContext
+> = Expression.NullabilityOf<Value> extends "always" ? "always"
+  : PredicateKeyOfAst<AstOf<Value>> extends infer Key extends string
+    ? IsUnion<Key> extends true
+      ? EffectiveNullabilityFromSources<Value, Available, Assumptions, Facts>
+      : string extends Key
+        ? EffectiveNullabilityFromSources<Value, Available, Assumptions, Facts>
+        : Key extends KnownGuaranteedNullKeys<Facts>
+          ? "always"
+          : Key extends KnownGuaranteedNonNullKeys<Facts>
+            ? "never"
+            : EffectiveNullabilityFromSources<Value, Available, Assumptions, Facts>
+    : EffectiveNullabilityFromSources<Value, Available, Assumptions, Facts>
+
+type EffectiveNullabilityFromSources<
+  Value extends Expression.Any,
+  Available extends Record<string, RowSet.AnySource>,
+  Assumptions extends PredicateFormula,
+  Facts extends PredicateContext
+> = HasAbsentSource<DependenciesOf<Value>, Available, Assumptions, Facts> extends true ? "always"
+  : HasOptionalSource<DependenciesOf<Value>, Available> extends true ? "maybe"
+    : Expression.NullabilityOf<Value>
 
 type BaseEffectiveNullability<
   Value extends Expression.Any,
-  Available extends Record<string, Plan.AnySource>,
-  Assumptions extends PredicateFormula
+  Available extends Record<string, RowSet.AnySource>,
+  Assumptions extends PredicateFormula,
+  Facts extends PredicateContext
 > = AstOf<Value> extends ExpressionAst.ColumnNode<infer TableName extends string, infer ColumnName extends string>
-  ? TableName extends AbsentSourceNamesInScope<Available, Assumptions>
+  ? TableName extends AbsentSourceNamesInScope<Available, Assumptions, Facts>
     ? "always"
-    : `${TableName}.${ColumnName}` extends KnownGuaranteedNullKeys<Assumptions>
+    : `${TableName}.${ColumnName}` extends KnownGuaranteedNullKeys<Facts>
     ? "always"
-    : `${TableName}.${ColumnName}` extends KnownGuaranteedNonNullKeys<Assumptions>
+    : `${TableName}.${ColumnName}` extends KnownGuaranteedNonNullKeys<Facts>
       ? "never"
-      : Expression.NullabilityOf<Value> extends "always" ? "always"
-        : Expression.SourceNullabilityOf<Value> extends "resolved"
-          ? Expression.NullabilityOf<Value>
-        : HasAbsentSource<DependenciesOf<Value>, Available, Assumptions> extends true ? "always"
-        : HasOptionalSource<DependenciesOf<Value>, Available> extends true ? "maybe"
-        : Expression.NullabilityOf<Value>
-  : Expression.NullabilityOf<Value> extends "always" ? "always"
-    : Expression.SourceNullabilityOf<Value> extends "resolved"
-      ? Expression.NullabilityOf<Value>
-      : HasAbsentSource<DependenciesOf<Value>, Available, Assumptions> extends true ? "always"
-      : HasOptionalSource<DependenciesOf<Value>, Available> extends true ? "maybe"
-      : Expression.NullabilityOf<Value>
+      : EffectiveNullabilityFromBase<Value, Available, Assumptions, Facts>
+  : EffectiveNullabilityFromBase<Value, Available, Assumptions, Facts>
 
 type CaseOutputOf<
   Branches extends readonly ExpressionAst.CaseBranchNode[],
   Else extends Expression.Any,
-  Available extends Record<string, Plan.AnySource>,
-  Assumptions extends PredicateFormula
+  Available extends Record<string, RowSet.AnySource>,
+  Assumptions extends PredicateFormula,
+  Facts extends PredicateContext
 > = Branches extends readonly [
   infer Head extends ExpressionAst.CaseBranchNode,
   ...infer Tail extends readonly ExpressionAst.CaseBranchNode[]
 ]
   ? Head extends ExpressionAst.CaseBranchNode<infer Predicate extends Expression.Any, infer Then extends Expression.Any>
     ? CaseBranchDecision<Assumptions, Predicate> extends "skip"
-      ? CaseOutputOf<Tail, Else, Available, Assumptions>
+      ? CaseOutputOf<Tail, Else, Available, Assumptions, Facts>
       : CaseBranchDecision<Assumptions, Predicate> extends "take"
-        ? ExpressionOutput<Then, EffectiveAvailable<Available, CaseBranchAssumeTrue<Assumptions, Predicate>>, CaseBranchAssumeTrue<Assumptions, Predicate>>
-        : ExpressionOutput<Then, EffectiveAvailable<Available, CaseBranchAssumeTrue<Assumptions, Predicate>>, CaseBranchAssumeTrue<Assumptions, Predicate>> |
-          CaseOutputOf<Tail, Else, Available, CaseBranchAssumeFalse<Assumptions, Predicate>>
+        ? FormulaOfPredicate<Predicate> extends infer BranchFormula extends PredicateFormula
+          ? ExpressionOutput<
+              Then,
+              EffectiveAvailable<
+                Available,
+                CaseBranchAssumeTrue<Assumptions, Predicate>,
+                AssumeFactsTrue<Facts, BranchFormula>
+              >,
+              CaseBranchAssumeTrue<Assumptions, Predicate>,
+              AssumeFactsTrue<Facts, BranchFormula>
+            >
+          : never
+        : FormulaOfPredicate<Predicate> extends infer BranchFormula extends PredicateFormula
+          ? ExpressionOutput<
+              Then,
+              EffectiveAvailable<
+                Available,
+                CaseBranchAssumeTrue<Assumptions, Predicate>,
+                AssumeFactsTrue<Facts, BranchFormula>
+              >,
+              CaseBranchAssumeTrue<Assumptions, Predicate>,
+              AssumeFactsTrue<Facts, BranchFormula>
+            > |
+            CaseOutputOf<
+              Tail,
+              Else,
+              Available,
+              CaseBranchAssumeFalse<Assumptions, Predicate>,
+              AssumeFactsFalse<Facts, BranchFormula>
+            >
+          : never
     : never
-  : ExpressionOutput<Else, EffectiveAvailable<Available, Assumptions>, Assumptions>
+  : ExpressionOutput<Else, EffectiveAvailable<Available, Assumptions, Facts>, Assumptions, Facts>
 
 /** Effective nullability of an expression after source-scope nullability is applied. */
+type EffectiveNullabilityOfAst<
+  Value extends Expression.Any,
+  Ast extends ExpressionAst.Any,
+  Available extends Record<string, RowSet.AnySource>,
+  Assumptions extends PredicateFormula = TrueAssumptions,
+  Facts extends PredicateContext = EmptyFacts
+> = Ast extends ExpressionAst.ColumnNode<any, any>
+  ? BaseEffectiveNullability<Value, Available, Assumptions, Facts>
+  : Ast extends ExpressionAst.LiteralNode<any>
+    ? Expression.NullabilityOf<Value>
+    : Ast extends ExpressionAst.UnaryNode<infer Kind, infer UnaryValue extends Expression.Any>
+      ? Kind extends "upper" | "lower" | "not"
+        ? EffectiveNullability<UnaryValue, Available, Assumptions, Facts>
+        : Kind extends "isNull" | "isNotNull" | "count"
+          ? "never"
+          : Expression.NullabilityOf<Value>
+      : Ast extends ExpressionAst.BinaryNode<"eq", infer Left extends Expression.Any, infer Right extends Expression.Any>
+        ? EffectiveNullability<Left, Available, Assumptions, Facts> extends "never"
+          ? EffectiveNullability<Right, Available, Assumptions, Facts> extends "never" ? "never" : "maybe"
+          : "maybe"
+        : Ast extends ExpressionAst.VariadicNode<infer Kind, infer Values extends readonly Expression.Any[]>
+          ? Kind extends "coalesce"
+            ? CoalesceEffectiveNullability<Values, Available, Assumptions, Facts>
+            : Kind extends "and" | "or" | "concat"
+              ? FoldEffectiveNullability<Values, Available, Assumptions, Facts>
+              : BaseEffectiveNullability<Value, Available, Assumptions, Facts>
+          : Ast extends ExpressionAst.CaseNode<infer Branches extends readonly ExpressionAst.CaseBranchNode[], infer Else extends Expression.Any>
+            ? NullabilityOfOutput<CaseOutputOf<Branches, Else, Available, Assumptions, Facts>>
+          : BaseEffectiveNullability<Value, Available, Assumptions, Facts>
+
 export type EffectiveNullability<
   Value extends Expression.Any,
-  Available extends Record<string, Plan.AnySource>,
-  Assumptions extends PredicateFormula = TrueAssumptions
+  Available extends Record<string, RowSet.AnySource>,
+  Assumptions extends PredicateFormula = TrueAssumptions,
+  Facts extends PredicateContext = EmptyFacts
 > =
   AstOf<Value> extends infer Ast extends ExpressionAst.Any
-    ? Ast extends ExpressionAst.ColumnNode<any, any>
-      ? BaseEffectiveNullability<Value, Available, Assumptions>
-      : Ast extends ExpressionAst.LiteralNode<any>
-        ? Expression.NullabilityOf<Value>
-        : Ast extends ExpressionAst.UnaryNode<infer Kind, infer UnaryValue extends Expression.Any>
-          ? Kind extends "upper" | "lower" | "not"
-            ? EffectiveNullability<UnaryValue, Available, Assumptions>
-            : Kind extends "isNull" | "isNotNull" | "count"
-              ? "never"
-              : Expression.NullabilityOf<Value>
-          : Ast extends ExpressionAst.BinaryNode<"eq", infer Left extends Expression.Any, infer Right extends Expression.Any>
-            ? EffectiveNullability<Left, Available, Assumptions> extends "never"
-              ? EffectiveNullability<Right, Available, Assumptions> extends "never" ? "never" : "maybe"
-              : "maybe"
-            : Ast extends ExpressionAst.VariadicNode<infer Kind, infer Values extends readonly Expression.Any[]>
-              ? Kind extends "coalesce"
-                ? CoalesceEffectiveNullability<Values, Available, Assumptions>
-                : Kind extends "and" | "or" | "concat"
-                  ? FoldEffectiveNullability<Values, Available, Assumptions>
-                  : BaseEffectiveNullability<Value, Available, Assumptions>
-              : Ast extends ExpressionAst.CaseNode<infer Branches extends readonly ExpressionAst.CaseBranchNode[], infer Else extends Expression.Any>
-                ? NullabilityOfOutput<CaseOutputOf<Branches, Else, Available, Assumptions>>
-              : BaseEffectiveNullability<Value, Available, Assumptions>
-    : BaseEffectiveNullability<Value, Available, Assumptions>
+    ? EffectiveNullabilityOfAst<Value, Ast, Available, Assumptions, Facts>
+    : BaseEffectiveNullability<Value, Available, Assumptions, Facts>
+
+type LiteralKeyValue<Value extends string> =
+  Value extends `string:${infer Literal}` ? Literal :
+    Value extends `number:${infer Literal extends number}` ? Literal :
+      Value extends "boolean:true" ? true :
+        Value extends "boolean:false" ? false :
+          never
+
+type LiteralSetRuntime<Values> =
+  Values extends readonly (infer Value)[] ? LiteralSetRuntime<Value> :
+    Values extends string ? LiteralKeyValue<Values> :
+      never
+
+type NarrowRuntimeToAllowed<
+  Runtime,
+  Allowed
+> = Runtime extends unknown
+  ? Extract<Runtime, Allowed> extends infer Extracted
+    ? [Extracted] extends [never]
+      ? Allowed extends Runtime ? Allowed : never
+      : Extracted
+    : never
+  : never
+
+type RefineRuntimeByAllowedLiterals<
+  Runtime,
+  Values
+> = [Values] extends [never]
+  ? Runtime
+  : string extends Values
+    ? Runtime
+    : NarrowRuntimeToAllowed<Runtime, LiteralSetRuntime<Values>>
+
+type RefineRuntimeByExcludedLiterals<
+  Runtime,
+  Values
+> = [Values] extends [never]
+  ? Runtime
+  : string extends Values
+    ? Runtime
+    : Exclude<Runtime, LiteralSetRuntime<Values>>
+
+type JsonKeyParts<Key extends string> = string extends Key
+  ? never
+  : Key extends `${infer ColumnKey}#json:${infer Path}`
+    ? readonly [ColumnKey, Path]
+    : never
+
+type LiteralSetForPredicateKey<
+  Facts extends PredicateContext,
+  Key extends string
+> = [JsonKeyParts<Key>] extends [never]
+  ? GuaranteedLiteralSetInFacts<Facts, Key>
+  : JsonKeyParts<Key> extends readonly [infer ColumnKey extends string, infer Path extends string]
+    ? GuaranteedJsonLiteralSetInFacts<Facts, ColumnKey, Path>
+    : never
+
+type RefineRuntimeForPredicateKey<
+  Runtime,
+  Facts extends PredicateContext,
+  Key extends string
+> = IsUnion<Key> extends true
+  ? Runtime
+  : string extends Key
+    ? Runtime
+    : RefineRuntimeByExcludedLiterals<
+        RefineRuntimeByAllowedLiterals<Runtime, LiteralSetForPredicateKey<Facts, Key>>,
+        GuaranteedNeqLiteralInFacts<Facts, Key>
+      >
+
+type JsonLiteralSetsForColumn<
+  Facts extends PredicateContext,
+  ColumnKey extends string
+> = [Facts["jsonLiteralSets"]] extends [{ readonly [C in ColumnKey]: infer Paths }]
+  ? Paths
+  : {}
+
+type RefineJsonRuntimeAtPath<
+  Runtime,
+  Path extends string,
+  Values
+> = Runtime extends unknown
+  ? Path extends `${infer Head}.${infer Tail}`
+    ? Runtime extends object
+      ? Head extends keyof Runtime
+        ? RefineJsonRuntimeAtPath<NonNullable<Runtime[Head]>, Tail, Values> extends infer Refined
+          ? [Refined] extends [never]
+            ? never
+            : Omit<Runtime, Head> & { readonly [K in Head]: Refined }
+          : never
+        : never
+      : never
+    : Runtime extends object
+      ? Path extends keyof Runtime
+        ? RefineRuntimeByAllowedLiterals<NonNullable<Runtime[Path]>, Values> extends infer Refined
+          ? [Refined] extends [never]
+            ? never
+            : Omit<Runtime, Path> & { readonly [K in Path]: Refined }
+          : never
+        : never
+      : RefineRuntimeByAllowedLiterals<NonNullable<Runtime>, Values>
+  : never
+
+type RefineJsonRuntimeWithConstraints<
+  Runtime,
+  Constraints
+> = [keyof Constraints & string] extends [never]
+  ? Runtime
+  : {
+      readonly [Path in keyof Constraints & string]:
+        [RefineJsonRuntimeAtPath<Runtime, Path, Constraints[Path]>] extends [never] ? Path : never
+    }[keyof Constraints & string] extends never
+    ? UnionToIntersection<{
+        readonly [Path in keyof Constraints & string]: RefineJsonRuntimeAtPath<Runtime, Path, Constraints[Path]>
+      }[keyof Constraints & string]>
+    : never
+
+type RefineJsonRuntimeForColumn<
+  Runtime,
+  ColumnKey extends string,
+  Facts extends PredicateContext
+> = Runtime extends object
+  ? Runtime extends unknown
+    ? RefineJsonRuntimeWithConstraints<Runtime, JsonLiteralSetsForColumn<Facts, ColumnKey>>
+    : never
+  : Runtime
+
+type AssumptionRefinedRuntime<
+  Ast extends ExpressionAst.Any,
+  Runtime,
+  Facts extends PredicateContext
+> = [PredicateKeyOfAst<Ast>] extends [never]
+  ? Runtime
+  : PredicateKeyOfAst<Ast> extends infer PredicateKey extends string
+    ? [ColumnKeyOfAst<Ast>] extends [never]
+      ? RefineRuntimeForPredicateKey<Runtime, Facts, PredicateKey>
+      : ColumnKeyOfAst<Ast> extends infer ColumnKey extends string
+        ? RefineRuntimeForPredicateKey<RefineJsonRuntimeForColumn<Runtime, ColumnKey, Facts>, Facts, PredicateKey>
+        : Runtime
+    : Runtime
 
 /** Result runtime type of an expression after effective nullability is resolved. */
 export type ExpressionOutput<
   Value extends Expression.Any,
-  Available extends Record<string, Plan.AnySource>,
-  Assumptions extends PredicateFormula = TrueAssumptions
-> = AstOf<Value> extends ExpressionAst.CaseNode<infer Branches extends readonly ExpressionAst.CaseBranchNode[], infer Else extends Expression.Any>
-  ? CaseOutputOf<Branches, Else, Available, Assumptions>
-  : EffectiveNullability<Value, Available, Assumptions> extends "never"
-    ? Expression.NullabilityOf<Value> extends "never"
-      ? Expression.RuntimeOf<Value>
-      : NonNullable<Expression.RuntimeOf<Value>>
-    : EffectiveNullability<Value, Available, Assumptions> extends "always"
-      ? null
-      : Expression.RuntimeOf<Value> | null
+  Available extends Record<string, RowSet.AnySource>,
+  Assumptions extends PredicateFormula = TrueAssumptions,
+  Facts extends PredicateContext = EmptyFacts
+> = AstOf<Value> extends infer Ast extends ExpressionAst.Any
+  ? Ast extends ExpressionAst.CaseNode<infer Branches extends readonly ExpressionAst.CaseBranchNode[], infer Else extends Expression.Any>
+    ? CaseOutputOf<Branches, Else, Available, Assumptions, Facts>
+    : EffectiveNullabilityOfAst<Value, Ast, Available, Assumptions, Facts> extends infer Nullability
+      ? Expression.NullabilityOf<Value> extends infer BaseNullability
+        ? Expression.RuntimeOf<Value> extends infer Runtime
+          ? AssumptionRefinedRuntime<Ast, Runtime, Facts> extends infer RefinedRuntime
+            ? Nullability extends "never"
+              ? BaseNullability extends "never"
+                ? RefinedRuntime
+                : NonNullable<RefinedRuntime>
+              : Nullability extends "always"
+                ? null
+                : RefinedRuntime | null
+            : never
+          : never
+        : never
+      : never
+    : never
 
 /** Result runtime type of a nested selection after source-scope nullability is resolved. */
 export type OutputOfSelection<
   Selection,
-  Available extends Record<string, Plan.AnySource>,
-  Assumptions extends PredicateFormula = TrueAssumptions
+  Available extends Record<string, RowSet.AnySource>,
+  Assumptions extends PredicateFormula = TrueAssumptions,
+  Facts extends PredicateContext = EmptyFacts
 > = Selection extends Expression.Any
-  ? ExpressionOutput<Selection, Available, Assumptions>
+  ? ExpressionOutput<Selection, Available, Assumptions, Facts>
   : Selection extends Record<string, any>
     ? {
-        readonly [K in keyof Selection]: OutputOfSelection<Selection[K], Available, Assumptions>
+        readonly [K in keyof Selection]: OutputOfSelection<Selection[K], Available, Assumptions, Facts>
       }
     : never
 
-/** Resolved row type produced by a concrete query plan. */
-export type ResultRow<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> = OutputOfSelection<
-  PlanValue[typeof Plan.TypeId]["selection"],
-  EffectiveAvailable<PlanValue[typeof Plan.TypeId]["available"], AssumptionsOfPlan<PlanValue>>,
-  AssumptionsOfPlan<PlanValue>
+type ResolvedSelectionOutput<
+  Selection,
+  Available extends Record<string, RowSet.AnySource>,
+  Assumptions extends PredicateFormula,
+  Facts extends PredicateContext
+> = OutputOfSelection<
+  Selection,
+  EffectiveAvailable<Available, Assumptions, Facts>,
+  Assumptions,
+  Facts
 >
 
+/** Resolved row type produced by a concrete query plan. */
+export type ResultRow<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
+  SelectionOfPlan<PlanValue> extends infer Selection
+    ? AvailableOfPlan<PlanValue> extends infer Available extends Record<string, RowSet.AnySource>
+      ? AssumptionsOfPlan<PlanValue> extends infer Assumptions extends PredicateFormula
+        ? FactsOfPlan<PlanValue> extends infer Facts extends PredicateContext
+          ? ResolvedSelectionOutput<Selection, Available, Assumptions, Facts>
+          : never
+        : never
+      : never
+    : never
+
 /** Resolved row collection type produced by a concrete query plan. */
 export type ResultRows<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> = ReadonlyArray<ResultRow<PlanValue>>
 
 /** Conservative runtime row shape produced by remapping projection aliases. */
-export type RuntimeResultRow<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> = OutputOfSelection<
-  PlanValue[typeof Plan.TypeId]["selection"],
-  PlanValue[typeof Plan.TypeId]["available"],
-  TrueAssumptions
->
+export type RuntimeResultRow<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
+  SelectionOfPlan<PlanValue> extends infer Selection
+    ? AvailableOfPlan<PlanValue> extends infer Available extends Record<string, RowSet.AnySource>
+      ? OutputOfSelection<Selection, Available, TrueAssumptions, EmptyFacts>
+      : never
+    : never
 
 /** Conservative runtime row collection type. */
 export type RuntimeResultRows<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> = ReadonlyArray<RuntimeResultRow<PlanValue>>
@@ -1613,7 +1914,7 @@ type DialectCompatibilityError<
   EngineDialect extends string
 > = PlanValue & {
   readonly __effect_qb_error__: "effect-qb: plan dialect is not compatible with the target renderer or executor"
-  readonly __effect_qb_plan_dialect__: PlanValue[typeof Plan.TypeId]["dialect"]
+  readonly __effect_qb_plan_dialect__: PlanValue[typeof RowSet.TypeId]["dialect"]
   readonly __effect_qb_target_dialect__: EngineDialect
   readonly __effect_qb_hint__: "Use the matching dialect module or renderer/executor"
 }
@@ -1640,25 +1941,23 @@ type InsertHasOptionalDefaults<
 /** Narrows a query plan to aggregate-compatible selections. */
 export type AggregationCompatiblePlan<
   PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
-> = PlanValue extends QueryPlan<infer Selection, any, any, any, infer Grouped, any, any, any, any, any>
-  ? IsAggregationCompatibleSelection<Selection, Grouped> extends true ? PlanValue : AggregationCompatibilityError<PlanValue>
-  : never
+> = IsAggregationCompatibleSelection<SelectionOfPlan<PlanValue>, GroupedOfPlan<PlanValue>> extends true
+  ? PlanValue
+  : AggregationCompatibilityError<PlanValue>
 
 /** Narrows a query plan to aggregate-compatible, source-complete plans. */
 export type CompletePlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
-  PlanValue extends QueryPlan<infer Selection, infer Required, any, any, infer Grouped, any, any, any, any, infer Statement, any, infer InsertState>
-    ? Statement extends "insert"
-      ? InsertState extends "missing"
-        ? InsertHasOptionalDefaults<PlanValue> extends true
-          ? PlanValue
-          : InsertSourceCompletenessError<PlanValue>
-        : HasKnownOutstanding<Required> extends true
-          ? SourceCompletenessError<PlanValue, Extract<Required, string>>
-          : IsAggregationCompatibleSelection<Selection, Grouped> extends true ? PlanValue : AggregationCompatibilityError<PlanValue>
-      : HasKnownOutstanding<Required> extends true
-        ? SourceCompletenessError<PlanValue, Extract<Required, string>>
-        : IsAggregationCompatibleSelection<Selection, Grouped> extends true ? PlanValue : AggregationCompatibilityError<PlanValue>
-    : never
+  StatementOfPlan<PlanValue> extends "insert"
+    ? InsertSourceStateOfPlan<PlanValue> extends "missing"
+      ? InsertHasOptionalDefaults<PlanValue> extends true
+        ? PlanValue
+        : InsertSourceCompletenessError<PlanValue>
+      : HasKnownOutstanding<RequiredOfPlan<PlanValue>> extends true
+        ? SourceCompletenessError<PlanValue, Extract<RequiredOfPlan<PlanValue>, string>>
+        : IsAggregationCompatibleSelection<SelectionOfPlan<PlanValue>, GroupedOfPlan<PlanValue>> extends true ? PlanValue : AggregationCompatibilityError<PlanValue>
+    : HasKnownOutstanding<RequiredOfPlan<PlanValue>> extends true
+      ? SourceCompletenessError<PlanValue, Extract<RequiredOfPlan<PlanValue>, string>>
+      : IsAggregationCompatibleSelection<SelectionOfPlan<PlanValue>, GroupedOfPlan<PlanValue>> extends true ? PlanValue : AggregationCompatibilityError<PlanValue>
 
 /** Whether a plan dialect is compatible with a target engine dialect. */
 type IsDialectCompatible<
@@ -1674,7 +1973,7 @@ type IsDialectCompatible<
 export type DialectCompatiblePlan<
   PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
   EngineDialect extends string
-> = IsDialectCompatible<PlanValue[typeof Plan.TypeId]["dialect"], EngineDialect> extends true
+> = IsDialectCompatible<PlanValue[typeof RowSet.TypeId]["dialect"], EngineDialect> extends true
   ? CompletePlan<PlanValue>
   : DialectCompatibilityError<PlanValue, EngineDialect>
 
@@ -1682,7 +1981,7 @@ export type DialectCompatiblePlan<
 export type DialectCompatibleNestedPlan<
   PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
   EngineDialect extends string
-> = IsDialectCompatible<PlanValue[typeof Plan.TypeId]["dialect"], EngineDialect> extends true
+> = IsDialectCompatible<PlanValue[typeof RowSet.TypeId]["dialect"], EngineDialect> extends true
   ? AggregationCompatiblePlan<PlanValue>
   : DialectCompatibilityError<PlanValue, EngineDialect>
 
@@ -1767,11 +2066,9 @@ export type SetCompatibleRightPlan<
 
 /** True when any of an expression's dependencies are optional in the current scope. */
 type HasOptionalSource<
-  Dependencies extends Expression.SourceDependencies,
-  Available extends Record<string, Plan.AnySource>
-> = Extract<{
-  [K in keyof Dependencies & string]: SourceModeOf<Available, K> extends "optional" ? true : never
-}[keyof Dependencies & string], true> extends never ? false : true
+  Dependencies extends Expression.BindingId,
+  Available extends Record<string, RowSet.AnySource>
+> = Extract<Dependencies, OptionalSourceNamesInScope<Available>> extends never ? false : true
 
 /**
  * Concrete query-plan value produced by the query DSL.
@@ -1783,65 +2080,53 @@ type HasOptionalSource<
 export type QueryPlan<
   Selection,
   Required = never,
-  Available extends Record<string, Plan.AnySource> = {},
+  Available extends Record<string, RowSet.AnySource> = {},
   Dialect extends string = never,
   Grouped extends string = never,
-  ScopedNames extends string = Extract<keyof Available, string>,
-  Outstanding extends string = Extract<Required, string>,
+  ScopedNames extends string = never,
+  Outstanding extends string = never,
   Assumptions extends PredicateFormula = TrueAssumptions,
   Capabilities extends QueryCapability = "read",
   Statement extends QueryAst.QueryStatement = "select",
-  Target = unknown,
-  InsertState extends InsertSourceState = InsertSourceState
-> = Plan.Plan<Selection, Required, Available, Dialect> & {
-  readonly [Plan.TypeId]: Plan.State<Selection, Required, Available, Dialect>
+  Target = any,
+  InsertState extends InsertSourceState = InsertSourceState,
+  Facts extends PredicateContext = PredicateContext
+> = RowSet.RowSet<Selection, Required, Available, Dialect> & {
+  readonly [QueryTypeId]: QueryState<
+    Outstanding,
+    ScopedNames,
+    Grouped,
+    Assumptions,
+    Capabilities,
+    Statement,
+    Target,
+    InsertState,
+    Facts
+  >
   readonly [QueryAst.TypeId]: QueryAst.Ast<Selection, Grouped, Statement>
-  readonly [QueryTypeId]: QueryState<Outstanding, ScopedNames, Grouped, Assumptions, Capabilities, Statement, Target, InsertState>
 }
 
-/**
- * Normalizes expression provenance into a flat list.
- *
- * Single-source expressions store one provenance object, while derived
- * operators may carry multiple sources. This helper hides that shape
- * difference.
- */
-const normalizeSources = (source: unknown): readonly unknown[] =>
-  source === undefined ? [] : Array.isArray(source) ? source : [source]
-
-/**
- * Merges the provenance of two expressions into one normalized runtime value.
- *
- * The result is:
- * - `undefined` when neither side is sourced
- * - a single provenance object when exactly one source exists
- * - an array when multiple sources are involved
- */
-export const mergeSources = (left: unknown, right?: unknown): unknown => {
-  const values = [...normalizeSources(left), ...normalizeSources(right)]
-  if (values.length === 0) {
-    return undefined
-  }
-  if (values.length === 1) {
-    return values[0]
-  }
-  return values
+export namespace Plan {
+  export type Any = QueryPlan<any, any, any, any, any, any, any, any, any, any>
 }
 
-/** Merges two expression dependency maps into a single normalized record. */
-export const mergeDependencies = (
-  left: Expression.SourceDependencies,
-  right: Expression.SourceDependencies = {}
-): Expression.SourceDependencies => ({
-  ...left,
-  ...right
-})
+/** Merges two expression dependency records into a single normalized record. */
+export const mergeDependencies = <
+  Left extends Expression.BindingId = never,
+  Right extends Expression.BindingId = never
+>(
+  left: Record<Left, true> | undefined,
+  right: Record<Right, true> | undefined = undefined
+): Record<Left | Right, true> => ({
+  ...(left ?? {}),
+  ...(right ?? {})
+}) as Record<Left | Right, true>
 
 /** Merges expression aggregation kinds at runtime. */
 export const mergeAggregationRuntime = (
-  left: Expression.AggregationKind,
-  right: Expression.AggregationKind = "scalar"
-): Expression.AggregationKind =>
+  left: Expression.ScalarKind,
+  right: Expression.ScalarKind = "scalar"
+): Expression.ScalarKind =>
   left === "window" || right === "window"
     ? "window"
     : left === "aggregate" || right === "aggregate"
@@ -1851,10 +2136,10 @@ export const mergeAggregationRuntime = (
 /** Folds runtime aggregation across a list of expressions. */
 export const mergeAggregationManyRuntime = (
   values: readonly Expression.Any[]
-): Expression.AggregationKind =>
+): Expression.ScalarKind =>
   values.reduce(
-    (current, value) => mergeAggregationRuntime(current, value[Expression.TypeId].aggregation),
-    "scalar" as Expression.AggregationKind
+    (current, value) => mergeAggregationRuntime(current, value[Expression.TypeId].kind),
+    "scalar" as Expression.ScalarKind
   )
 
 /** Merges expression nullability for null-propagating scalar operators. */
@@ -1877,19 +2162,14 @@ export const mergeNullabilityManyRuntime = (
     "never" as Expression.Nullability
   )
 
-/** Merges provenance across a variadic expression input list. */
-export const mergeManySources = (values: readonly Expression.Any[]): unknown =>
-  values.reduce<unknown>(
-    (current, value) => mergeSources(current, value[Expression.TypeId].source),
-    undefined
-  )
-
 /** Merges dependency maps across a variadic expression input list. */
-export const mergeManyDependencies = (values: readonly Expression.Any[]): Expression.SourceDependencies =>
-  values.reduce(
-    (current, value) => mergeDependencies(current, value[Expression.TypeId].dependencies),
-    {} as Expression.SourceDependencies
-  )
+export const mergeManyDependencies = <Values extends readonly Expression.Any[]>(
+  values: Values
+): Record<TupleDependencies<Values>, true> =>
+  values.reduce<Record<string, true>>(
+    (current, value) => mergeDependencies(current, value[Expression.TypeId].dependencies) as Record<string, true>,
+    {}
+  ) as Record<TupleDependencies<Values>, true>
 
 /**
  * Creates a runtime expression object from fully computed static metadata.
@@ -1902,19 +2182,43 @@ export const makeExpression = <
   Db extends Expression.DbType.Any,
   Nullable extends Expression.Nullability,
   Dialect extends string,
-  Aggregation extends Expression.AggregationKind,
-  Source,
-  Dependencies extends Expression.SourceDependencies = {},
-  SourceNullability extends Expression.SourceNullabilityMode = "propagate",
-  Ast extends ExpressionAst.Any = ExpressionAst.Any
+  Kind extends Expression.ScalarKind,
+  Deps extends Expression.BindingId = never,
+  Ast extends ExpressionAst.Any = ExpressionAst.Any,
+  GroupKey extends string = GroupingKeyOfAst<Ast>
 >(
-  state: Expression.State<Runtime, Db, Nullable, Dialect, Aggregation, Source, Dependencies, SourceNullability>,
+  state: {
+    readonly runtime: Runtime
+    readonly dbType: Db
+    readonly runtimeSchema?: Schema.Schema.Any
+    readonly driverValueMapping?: Expression.DriverValueMapping
+    readonly nullability: Nullable
+    readonly dialect: Dialect
+    readonly kind?: Kind
+    readonly dependencies?: Record<string, true>
+  },
   ast: Ast
-): Expression.Expression<Runtime, Db, Nullable, Dialect, Aggregation, Source, Dependencies, SourceNullability> & {
+): Expression.Scalar<Runtime, Db, Nullable, Dialect, Kind, Deps, GroupKey> & {
   readonly [ExpressionAst.TypeId]: Ast
 } => {
   const expression = Object.create(ExpressionProto)
-  expression[Expression.TypeId] = state
+  Object.defineProperty(expression, "pipe", {
+    configurable: true,
+    writable: true,
+    value: function(this: unknown) {
+      return pipeArguments(expression, arguments)
+    }
+  })
+  expression[Expression.TypeId] = {
+    runtime: state.runtime,
+    dbType: state.dbType,
+    runtimeSchema: state.runtimeSchema,
+    driverValueMapping: state.driverValueMapping,
+    nullability: state.nullability,
+    dialect: state.dialect,
+    kind: state.kind ?? ("scalar" as Kind),
+    dependencies: state.dependencies ?? {}
+  } as Expression.State<Runtime, Db, Nullable, Dialect, Kind, Deps>
   expression[ExpressionAst.TypeId] = ast
   return expression
 }
@@ -1926,7 +2230,7 @@ export const makeExpression = <
 export const makePlan = <
   Selection,
   Required,
-  Available extends Record<string, Plan.AnySource>,
+  Available extends Record<string, RowSet.AnySource>,
   Dialect extends string,
   Grouped extends string = never,
   ScopedNames extends string = Extract<keyof Available, string>,
@@ -1934,25 +2238,35 @@ export const makePlan = <
   Assumptions extends PredicateFormula = TrueAssumptions,
   Capabilities extends QueryCapability = "read",
   Statement extends QueryAst.QueryStatement = "select",
-  Target = never,
-  InsertState extends InsertSourceState = "ready"
+  Target = any,
+  InsertState extends InsertSourceState = InsertSourceState,
+  Facts extends PredicateContext = PredicateContext
 >(
-  state: Plan.State<Selection, Required, Available, Dialect>,
+  state: RowSet.State<Selection, Required, Available, Dialect>,
   ast: QueryAst.Ast<Selection, Grouped, Statement>,
   _assumptions?: Assumptions,
   _capabilities?: Capabilities,
   _statement?: Statement,
   _target?: Target,
-  _insertState?: InsertState
-): QueryPlan<Selection, Required, Available, Dialect, Grouped, ScopedNames, Outstanding, Assumptions, Capabilities, Statement, Target, InsertState> => {
+  _insertState?: InsertState,
+  _facts?: Facts
+): QueryPlan<Selection, Required, Available, Dialect, Grouped, ScopedNames, Outstanding, Assumptions, Capabilities, Statement, Target, InsertState, Facts> => {
   const plan = Object.create(PlanProto)
-  plan[Plan.TypeId] = state
+  Object.defineProperty(plan, "pipe", {
+    configurable: true,
+    writable: true,
+    value: function(this: unknown) {
+      return pipeArguments(plan, arguments)
+    }
+  })
+  plan[RowSet.TypeId] = state
   plan[QueryAst.TypeId] = ast
   plan[QueryTypeId] = {
     required: undefined as unknown as Outstanding,
     availableNames: undefined as unknown as ScopedNames,
     grouped: undefined as unknown as Grouped,
     assumptions: ((_assumptions ?? trueFormula()) as Assumptions),
+    facts: ((_facts ?? undefined) as unknown as Facts),
     capabilities: undefined as unknown as Capabilities,
     statement: (_statement ?? ("select" as Statement)) as Statement,
     target: (_target ?? (undefined as unknown as Target)) as Target,
@@ -1973,7 +2287,7 @@ export const getAst = <
 /** Returns the internal phantom query state carried by a query plan. */
 export const getQueryState = (
   plan: QueryPlan<any, any, any, any, any, any, any, any, any, any>
-): QueryState<any, any, any, any, any, any, any, any> => plan[QueryTypeId]
+): QueryState<any, any, any, any, any, any, any, any, any> => plan[QueryTypeId]
 
 /**
  * Collects the required table names referenced by a runtime selection object.