effect-qb 0.16.0 → 0.19.0

package/src/internal/query.ts

@@ -6,6 +6,7 @@ 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"
+import type * as ProjectionAlias from "./projection-alias.js"
 import type { JsonNode } from "./json/ast.js"
 import type * as JsonPath from "./json/path.js"
 import type { QueryCapability } from "./query-requirements.js"
@@ -24,7 +25,7 @@ import type {
 } 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 { ColumnKey, ColumnKeyOfAst, ColumnKeyOfExpression, PredicateKeyOfAst } from "./predicate/key.js"
 import type { PredicateFormula, TrueFormula } from "./predicate/formula.js"
 import { trueFormula } from "./predicate/runtime.js"
 
@@ -95,7 +96,7 @@ export { union_query_capabilities } from "./query-requirements.js"
  * `Pipeable.pipe(...)` plus the metadata stored under `Expression.TypeId`.
  */
 const ExpressionProto = {
-  pipe(this: unknown) {
+  pipe(this: Pipeable) {
     return pipeArguments(this, arguments)
   }
 }
@@ -107,7 +108,7 @@ const ExpressionProto = {
  * chained through `.pipe(...)`.
  */
 const PlanProto = {
-  pipe(this: unknown) {
+  pipe(this: Pipeable) {
     return pipeArguments(this, arguments)
   }
 }
@@ -142,6 +143,34 @@ export interface QueryState<
 
 /** Effective SQL dialect carried by an expression. */
 export type DialectOf<Value extends Expression.Any> = Value[typeof Expression.TypeId]["dialect"]
+type ConcreteDialect<D> = D extends "standard" ? never : D
+type IsDialectUnion<Union, All = Union> = Union extends any
+  ? [All] extends [Union] ? false : true
+  : false
+export type DialectConflictError<A extends string, B extends string> = string & {
+  readonly _tag: "DialectConflict"
+  readonly left: A
+  readonly right: B
+}
+export type MergeDialect<A extends string, B extends string> =
+  [ConcreteDialect<A>, ConcreteDialect<B>] extends [never, never] ? "standard"
+    : [ConcreteDialect<A>, ConcreteDialect<B>] extends [never, infer C extends string] ? C
+      : [ConcreteDialect<A>, ConcreteDialect<B>] extends [infer C extends string, never] ? C
+        : ConcreteDialect<A> extends ConcreteDialect<B>
+          ? ConcreteDialect<B> extends ConcreteDialect<A>
+            ? A
+            : DialectConflictError<A, B>
+          : DialectConflictError<A, B>
+
+/** Collapses the portable standard tag out of a dialect union. */
+export type NormalizeDialect<Dialect extends string> =
+  [Dialect] extends [never]
+    ? never
+    : [Exclude<Dialect, "standard">] extends [never]
+      ? "standard"
+      : IsDialectUnion<Exclude<Dialect, "standard">> extends true
+        ? DialectConflictError<Exclude<Dialect, "standard">, Exclude<Dialect, "standard">>
+        : Exclude<Dialect, "standard">
 /** Source dependency union carried by an expression. */
 export type DependenciesOf<Value extends Expression.Any> = Expression.DependenciesOf<Value>
 /** Aggregation kind carried by an expression. */
@@ -281,8 +310,57 @@ type JoinGroupingKeys<Keys extends readonly string[]> = Keys extends readonly []
       ? `${Head},${JoinGroupingKeys<Tail>}`
       : string
 
+type EscapeGroupingBackslashes<Value extends string> = string extends Value
+  ? string
+  : Value extends `${infer Head}\\${infer Tail}`
+    ? `${Head}\\\\${EscapeGroupingBackslashes<Tail>}`
+    : Value
+
+type EscapeGroupingCommas<Value extends string> = string extends Value
+  ? string
+  : Value extends `${infer Head},${infer Tail}`
+    ? `${Head}\\,${EscapeGroupingCommas<Tail>}`
+    : Value
+
+type EscapeGroupingPipes<Value extends string> = string extends Value
+  ? string
+  : Value extends `${infer Head}|${infer Tail}`
+    ? `${Head}\\|${EscapeGroupingPipes<Tail>}`
+    : Value
+
+type EscapeGroupingEquals<Value extends string> = string extends Value
+  ? string
+  : Value extends `${infer Head}=${infer Tail}`
+    ? `${Head}\\=${EscapeGroupingEquals<Tail>}`
+    : Value
+
+type EscapeGroupingGreaterThan<Value extends string> = string extends Value
+  ? string
+  : Value extends `${infer Head}>${infer Tail}`
+    ? `${Head}\\>${EscapeGroupingGreaterThan<Tail>}`
+    : Value
+
+type EscapeGroupingText<Value extends string> =
+  EscapeGroupingGreaterThan<
+    EscapeGroupingEquals<
+      EscapeGroupingPipes<
+        EscapeGroupingCommas<
+          EscapeGroupingBackslashes<Value>
+        >
+      >
+    >
+  >
+
+type JsonStringKeysGroupingKey<Keys extends readonly string[]> = Keys extends readonly []
+  ? ""
+  : Keys extends readonly [infer Head extends string]
+    ? EscapeGroupingText<Head>
+    : Keys extends readonly [infer Head extends string, ...infer Tail extends readonly string[]]
+      ? `${EscapeGroupingText<Head>},${JsonStringKeysGroupingKey<Tail>}`
+      : string
+
 type JsonSegmentGroupingKey<Segment> =
-  Segment extends JsonPath.KeySegment<infer Key extends string> ? `key:${Key}` :
+  Segment extends JsonPath.KeySegment<infer Key extends string> ? `key:${EscapeGroupingText<Key>}` :
     Segment extends JsonPath.IndexSegment<infer Index extends number> ? `index:${Index}` :
       Segment extends JsonPath.WildcardSegment ? "wildcard" :
         Segment extends JsonPath.SliceSegment<infer Start extends number | undefined, infer End extends number | undefined>
@@ -290,7 +368,7 @@ type JsonSegmentGroupingKey<Segment> =
           : Segment extends JsonPath.DescendSegment
             ? "descend"
             : Segment extends string
-              ? `key:${Segment}`
+              ? `key:${EscapeGroupingText<Segment>}`
               : Segment extends number
                 ? `index:${Segment}`
                 : "unknown"
@@ -306,13 +384,13 @@ type JsonPathGroupingKey<Segments extends readonly any[]> = Segments extends rea
 type JsonOpaquePathGroupingKey<Value> =
   Value extends JsonPath.Path<infer Segments extends readonly JsonPath.CanonicalSegment[]>
     ? `jsonpath:${JsonPathGroupingKey<Segments>}` :
-  Value extends string ? `jsonpath:${Value}` :
+  Value extends string ? `jsonpath:${EscapeGroupingText<Value>}` :
     Value extends Expression.Any ? `jsonpath:${GroupingKeyOfExpression<Value>}` :
       "jsonpath:unknown"
 
 type JsonEntryGroupingKey<Entry> =
   Entry extends { readonly key: infer Key extends string; readonly value: infer Value extends Expression.Any }
-    ? `${Key}=>${GroupingKeyOfExpression<Value>}`
+    ? `${EscapeGroupingText<Key>}=>${GroupingKeyOfExpression<Value>}`
     : "entry:unknown"
 
 type JsonEntriesGroupingKey<Entries extends readonly { readonly key: string; readonly value: Expression.Any }[]> = Entries extends readonly []
@@ -338,13 +416,19 @@ type BranchGroupingKeys<
 
 type GroupingKeyOfAst<Ast extends ExpressionAst.Any> =
   Ast extends ExpressionAst.ColumnNode<infer TableName extends string, infer ColumnName extends string>
-    ? `column:${TableName}.${ColumnName}`
+    ? `column:${ColumnKey<TableName, ColumnName>}`
     : Ast extends ExpressionAst.LiteralNode<infer Value>
       ? `literal:${LiteralGroupingKey<Value>}`
     : Ast extends ExpressionAst.ExcludedNode<infer ColumnName extends string>
       ? `excluded:${ColumnName}`
     : Ast extends ExpressionAst.CastNode<infer Value extends Expression.Any, infer Target extends Expression.DbType.Any>
       ? `cast(${GroupingKeyOfExpression<Value>} as ${Target["dialect"]}:${Target["kind"]})`
+    : Ast extends ExpressionAst.CollateNode<infer Value extends Expression.Any, infer Collation extends readonly [string, ...string[]]>
+      ? `collate(${GroupingKeyOfExpression<Value>},${JsonStringKeysGroupingKey<Collation>})`
+    : Ast extends ExpressionAst.FunctionCallNode<infer Name extends string, infer Args extends readonly Expression.Any[]>
+      ? `function(${EscapeGroupingText<Name>},${JoinGroupingKeys<{
+          readonly [K in keyof Args]: Args[K] extends Expression.Any ? GroupingKeyOfExpression<Args[K]> : never
+        } & readonly string[]>})`
     : Ast extends ExpressionAst.UnaryNode<infer Kind extends ExpressionAst.UnaryKind, infer Value extends Expression.Any>
       ? `${Kind}(${GroupingKeyOfExpression<Value>})`
     : Ast extends ExpressionAst.BinaryNode<infer Kind extends ExpressionAst.BinaryKind, infer Left extends Expression.Any, infer Right extends Expression.Any>
@@ -357,7 +441,7 @@ type GroupingKeyOfAst<Ast extends ExpressionAst.Any> =
           ? Kind extends "jsonGet" | "jsonPath" | "jsonAccess" | "jsonTraverse" | "jsonGetText" | "jsonPathText" | "jsonAccessText" | "jsonTraverseText"
             ? `json(${Kind},${GroupingKeyOfExpression<Extract<Ast["value"] | Ast["base"] | Ast["left"], Expression.Any>>},${JsonPathGroupingKey<Extract<Ast["segments"] | Ast["path"], readonly any[]>>})`
             : Kind extends "jsonHasKey" | "jsonKeyExists" | "jsonHasAnyKeys" | "jsonHasAllKeys"
-              ? `json(${Kind},${GroupingKeyOfExpression<Extract<Ast["value"] | Ast["base"] | Ast["left"], Expression.Any>>},${JoinGroupingKeys<Extract<Ast["keys"], readonly string[]> & readonly string[]>})`
+              ? `json(${Kind},${GroupingKeyOfExpression<Extract<Ast["value"] | Ast["base"] | Ast["left"], Expression.Any>>},${JsonStringKeysGroupingKey<Extract<Ast["keys"], readonly string[]> & readonly string[]>})`
               : Kind extends "jsonConcat" | "jsonMerge" | "jsonDelete" | "jsonDeletePath" | "jsonRemove" | "jsonSet" | "jsonInsert"
                 ? `json(${Kind},${GroupingKeyOfExpression<Extract<Ast["left"] | Ast["base"] | Ast["value"], Expression.Any>>},${GroupingKeyOfExpression<Extract<Ast["right"] | Ast["newValue"] | Ast["insert"], Expression.Any>>},${JsonPathGroupingKey<Extract<Ast["segments"] | Ast["path"], readonly any[]>>})`
                 : Kind extends "jsonPathExists" | "jsonPathMatch"
@@ -408,15 +492,17 @@ export type ExtractRequired<Selection> = Selection extends Expression.Any
       }[keyof Selection]
     : never
 
-/** Walks a selection tree and unions the dialects referenced by its leaves. */
-export type ExtractDialect<Selection> = Selection extends Expression.Any
+type ExtractDialectRaw<Selection> = Selection extends Expression.Any
   ? DialectOf<Selection>
   : Selection extends Record<string, any>
     ? {
-        [K in keyof Selection]: ExtractDialect<Selection[K]>
+        [K in keyof Selection]: ExtractDialectRaw<Selection[K]>
       }[keyof Selection]
     : never
 
+/** Walks a selection tree and extracts the effective dialects referenced by its leaves. */
+export type ExtractDialect<Selection> = NormalizeDialect<Extract<ExtractDialectRaw<Selection>, string>>
+
 /**
  * Minimal table-like shape required by `from(...)` and joins.
  *
@@ -949,8 +1035,7 @@ export type UpdateInputOfTarget<Target extends MutationTargetInput> =
         }>
       : never
 
-/** Extracts the effective dialect from a source. */
-export type SourceDialectOf<Source extends SourceLike> =
+type SourceDialectOfRaw<Source extends SourceLike> =
   Source extends TableLike<any, infer Dialect> ? Dialect :
     Source extends { readonly kind: "derived"; readonly plan: infer PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any> } ? PlanDialectOf<PlanValue> :
       Source extends { readonly kind: "cte"; readonly plan: infer PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any> } ? PlanDialectOf<PlanValue> :
@@ -958,6 +1043,9 @@ export type SourceDialectOf<Source extends SourceLike> =
           Source extends { readonly dialect: infer Dialect extends string } ? Dialect :
       never
 
+/** Extracts the effective dialect from a source. */
+export type SourceDialectOf<Source extends SourceLike> = NormalizeDialect<SourceDialectOfRaw<Source>>
+
 /** Extracts the base table name from a source. */
 export type SourceBaseNameOf<Source extends SourceLike> =
   Source extends TableLike<any, any> ? Source[typeof Table.TypeId]["baseName"] :
@@ -1000,6 +1088,153 @@ type JoinPath<Segments extends readonly string[]> = Segments extends readonly []
       ? `${Head}__${JoinPath<Tail>}`
       : string
 
+type ProjectionAliasOf<
+  Value extends Expression.Any,
+  Path extends readonly string[]
+> = Value extends {
+  readonly [ProjectionAlias.TypeId]: ProjectionAlias.State<infer Alias extends string>
+} ? Alias : JoinPath<Path>
+
+type SelectionProjectionEntry<
+  Alias extends string,
+  Path extends readonly string[],
+  ExpectedAlias extends string
+> = {
+  readonly alias: Alias
+  readonly path: Path
+  readonly expectedAlias: ExpectedAlias
+}
+
+type SelectionProjectionEntries<
+  Selection,
+  Path extends readonly string[] = []
+> = Selection extends Expression.Any
+  ? SelectionProjectionEntry<ProjectionAliasOf<Selection, Path>, Path, JoinPath<Path>>
+  : Selection extends Record<string, any>
+    ? {
+        readonly [K in Extract<keyof Selection, string>]:
+          SelectionProjectionEntries<Selection[K], [...Path, K]>
+      }[Extract<keyof Selection, string>]
+    : never
+
+type SameProjectionPath<
+  Left extends readonly string[],
+  Right extends readonly string[]
+> = Left extends readonly []
+  ? Right extends readonly [] ? true : false
+  : Left extends readonly [infer LeftHead extends string, ...infer LeftTail extends readonly string[]]
+    ? Right extends readonly [infer RightHead extends string, ...infer RightTail extends readonly string[]]
+      ? [LeftHead] extends [RightHead]
+        ? [RightHead] extends [LeftHead]
+          ? SameProjectionPath<LeftTail, RightTail>
+          : false
+        : false
+      : false
+    : false
+
+type SameProjectionAlias<
+  Left extends string,
+  Right extends string
+> = [Left] extends [Right] ? [Right] extends [Left] ? true : false : false
+
+type HasDifferentPathForAlias<
+  Entries,
+  Alias extends string,
+  Path extends readonly string[]
+> = Entries extends SelectionProjectionEntry<infer EntryAlias, infer EntryPath, any>
+  ? SameProjectionAlias<EntryAlias, Alias> extends true
+    ? SameProjectionPath<EntryPath, Path> extends true ? never : true
+    : never
+  : never
+
+type DuplicateProjectionAliases<
+  Entries,
+  AllEntries = Entries
+> = Entries extends SelectionProjectionEntry<infer Alias, infer Path, any>
+  ? string extends Alias ? never
+    : true extends HasDifferentPathForAlias<AllEntries, Alias, Path> ? Alias : never
+  : never
+
+type ProjectionAliasMismatches<Entries> =
+  Entries extends SelectionProjectionEntry<infer Alias, any, infer ExpectedAlias>
+    ? string extends Alias ? never
+      : string extends ExpectedAlias ? never
+        : SameProjectionAlias<Alias, ExpectedAlias> extends true ? never : Alias
+    : never
+
+type DerivedProjectionDuplicateAliases<Selection> =
+  DuplicateProjectionAliases<SelectionProjectionEntries<Selection>>
+
+type DerivedProjectionAliasMismatches<Selection> =
+  ProjectionAliasMismatches<SelectionProjectionEntries<Selection>>
+
+type IsAny<Value> = 0 extends (1 & Value) ? true : false
+
+type IsBroadSelection<Selection> =
+  IsAny<Selection> extends true ? true :
+    unknown extends Selection ? true : false
+
+type DerivedProjectionIssues<Selection> =
+  IsBroadSelection<Selection> extends true
+    ? never
+    : | DerivedProjectionDuplicateAliases<Selection>
+      | DerivedProjectionAliasMismatches<Selection>
+
+export type SelectionProjectionDuplicateAliases<Selection> =
+  IsBroadSelection<Selection> extends true
+    ? never
+    : DuplicateProjectionAliases<SelectionProjectionEntries<Selection>>
+
+export type SelectionProjectionAliasCollisionError<Selection> = Selection & {
+  readonly __effect_qb_error__: "effect-qb: projection aliases must be unique"
+  readonly __effect_qb_duplicate_projection_aliases__: SelectionProjectionDuplicateAliases<Selection>
+}
+
+export type SelectionProjectionAliasCollisionConstraint<Selection> =
+  [SelectionProjectionDuplicateAliases<Selection>] extends [never]
+    ? unknown
+    : SelectionProjectionAliasCollisionError<Selection>
+
+export type DerivedSourceProjectionCompatibilityError<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
+> = PlanValue & {
+  readonly __effect_qb_error__: "effect-qb: derived subqueries require unique path-based projection aliases"
+  readonly __effect_qb_duplicate_projection_aliases__: DerivedProjectionDuplicateAliases<SelectionOfPlan<PlanValue>>
+  readonly __effect_qb_alias_mismatches__: DerivedProjectionAliasMismatches<SelectionOfPlan<PlanValue>>
+  readonly __effect_qb_hint__: "Use unique nested selection paths and do not override projection aliases inside derived subqueries"
+}
+
+export type DerivedProjectionCompatiblePlan<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
+  ValidPlan = PlanValue
+> = [DerivedProjectionIssues<SelectionOfPlan<PlanValue>>] extends [never]
+  ? ValidPlan
+  : ValidPlan & DerivedSourceProjectionCompatibilityError<PlanValue>
+
+export type DerivedSourceCompatiblePlan<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
+> = DerivedProjectionCompatiblePlan<PlanValue, CompletePlan<PlanValue>>
+
+type InlineSourceStatementError<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
+> = PlanValue & {
+  readonly __effect_qb_error__: "effect-qb: inline derived sources only accept select-like query plans"
+  readonly __effect_qb_statement__: StatementOfPlan<PlanValue>
+  readonly __effect_qb_hint__: "Use select(...) or a set operator for as(...) and lateral(...); use with(...) for data-modifying CTEs where supported"
+}
+
+export type DerivedTableCompatiblePlan<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
+> = StatementOfPlan<PlanValue> extends SelectLikeStatement
+  ? DerivedSourceCompatiblePlan<PlanValue>
+  : InlineSourceStatementError<PlanValue>
+
+export type LateralSourceCompatiblePlan<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
+> = StatementOfPlan<PlanValue> extends SelectLikeStatement
+  ? DerivedProjectionCompatiblePlan<PlanValue>
+  : InlineSourceStatementError<PlanValue>
+
 type DerivedLeafExpression<
   Value extends Expression.Any,
   Alias extends string,
@@ -1066,7 +1301,7 @@ export type AvailableOfPlan<
 /** 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, any, any>
-> = QueryPlanParts<PlanValue>["dialect"]
+> = NormalizeDialect<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, any, any>
@@ -1085,6 +1320,12 @@ export type AssumptionsOfPlan<
 export type FactsOfPlan<
   PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>
 > = QueryPlanState<PlanValue>["facts"]
+export type CommonSetFacts<
+  Left extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
+  Right extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
+> = [FactsOfPlan<Left>] extends [FactsOfPlan<Right>]
+  ? [FactsOfPlan<Right>] extends [FactsOfPlan<Left>] ? FactsOfPlan<Left> : EmptyFacts
+  : EmptyFacts
 export type PredicateStateOfPlan<
   PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>
 > = PredicateState<AssumptionsOfPlan<PlanValue>, FactsOfPlan<PlanValue>>
@@ -1217,9 +1458,10 @@ export type AddJoinRequired<
   Available extends Record<string, RowSet.AnySource>,
   JoinedName extends string,
   Predicate extends PredicateInput | never,
-  Kind extends QueryAst.JoinKind = "inner"
+  Kind extends QueryAst.JoinKind = "inner",
+  SourceRequired extends string = never
 > = Exclude<
-  Required | (Predicate extends never ? never : RequiredFromInput<Predicate>),
+  Required | SourceRequired | (Predicate extends never ? never : RequiredFromInput<Predicate>),
   AvailableNames<AvailableAfterJoin<Available, JoinedName, Kind>>
 >
 
@@ -1270,7 +1512,7 @@ export type MergeNullabilityTuple<
 /** Dialect union across a tuple of expressions. */
 export type TupleDialect<
   Values extends readonly Expression.Any[]
-> = Values[number] extends never ? never : DialectOf<Values[number]>
+> = Values[number] extends never ? never : NormalizeDialect<DialectOf<Values[number]>>
 
 /** Converts a union into an intersection. */
 type UnionToIntersection<Union> = (
@@ -1744,30 +1986,45 @@ type JsonLiteralSetsForColumn<
   ? Paths
   : {}
 
+type JsonPathHead<
+  Path extends string,
+  Current extends string = ""
+> = Path extends `\\.${infer Rest}`
+  ? JsonPathHead<Rest, `${Current}.`>
+  : Path extends `\\\\${infer Rest}`
+    ? JsonPathHead<Rest, `${Current}\\`>
+    : Path extends `.${infer Tail}`
+      ? readonly [Current, Tail]
+      : Path extends `${infer Character}${infer Rest}`
+        ? JsonPathHead<Rest, `${Current}${Character}`>
+        : readonly [Current, ""]
+
 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 }
+  ? JsonPathHead<Path> extends readonly [infer Head extends string, infer Tail extends string]
+    ? Tail extends ""
+      ? Runtime extends object
+        ? Head extends keyof Runtime
+          ? RefineRuntimeByAllowedLiterals<NonNullable<Runtime[Head]>, Values> extends infer Refined
+            ? [Refined] extends [never]
+              ? never
+              : Omit<Runtime, Head> & { readonly [K in Head]: Refined }
+            : never
           : 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 }
+        : RefineRuntimeByAllowedLiterals<NonNullable<Runtime>, Values>
+      : 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
-      : RefineRuntimeByAllowedLiterals<NonNullable<Runtime>, Values>
+    : never
   : never
 
 type RefineJsonRuntimeWithConstraints<
@@ -1914,7 +2171,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 RowSet.TypeId]["dialect"]
+  readonly __effect_qb_plan_dialect__: PlanDialectOf<PlanValue>
   readonly __effect_qb_target_dialect__: EngineDialect
   readonly __effect_qb_hint__: "Use the matching dialect module or renderer/executor"
 }
@@ -1965,27 +2222,39 @@ type IsDialectCompatible<
   EngineDialect extends string
 > = [PlanDialect] extends [never]
   ? true
-  : Extract<PlanDialect, EngineDialect> extends never
-    ? false
-    : true
+  : Exclude<PlanDialect, EngineDialect | "standard"> extends never
+    ? true
+    : false
 
 /** Narrows a complete plan to those compatible with a target engine dialect. */
 export type DialectCompatiblePlan<
   PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
   EngineDialect extends string
-> = IsDialectCompatible<PlanValue[typeof RowSet.TypeId]["dialect"], EngineDialect> extends true
+> = IsDialectCompatible<PlanDialectOf<PlanValue>, EngineDialect> extends true
   ? CompletePlan<PlanValue>
   : DialectCompatibilityError<PlanValue, EngineDialect>
 
+type SelectLikeStatement = "select" | "set"
+
+type NestedPlanStatementError<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
+> = PlanValue & {
+  readonly __effect_qb_error__: "effect-qb: subquery expressions only accept select-like query plans"
+  readonly __effect_qb_statement__: StatementOfPlan<PlanValue>
+  readonly __effect_qb_hint__: "Use select(...) or a set operator as the nested subquery expression"
+}
+
 /** Nested-plan compatibility used by subquery expressions such as `exists(...)`. */
 export type DialectCompatibleNestedPlan<
   PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
   EngineDialect extends string
-> = IsDialectCompatible<PlanValue[typeof RowSet.TypeId]["dialect"], EngineDialect> extends true
-  ? AggregationCompatiblePlan<PlanValue>
+> = IsDialectCompatible<PlanDialectOf<PlanValue>, EngineDialect> extends true
+  ? StatementOfPlan<PlanValue> extends SelectLikeStatement
+    ? AggregationCompatiblePlan<PlanValue>
+    : NestedPlanStatementError<PlanValue>
   : DialectCompatibilityError<PlanValue, EngineDialect>
 
-type SetOperandStatement = "select" | "set"
+type SetOperandStatement = SelectLikeStatement
 type IsUnion<Value, All = Value> = Value extends any ? ([All] extends [Value] ? false : true) : never
 
 type SingleSelectedExpressionError<
@@ -2205,7 +2474,7 @@ export const makeExpression = <
   Object.defineProperty(expression, "pipe", {
     configurable: true,
     writable: true,
-    value: function(this: unknown) {
+    value: function(this: Pipeable) {
       return pipeArguments(expression, arguments)
     }
   })
@@ -2255,7 +2524,7 @@ export const makePlan = <
   Object.defineProperty(plan, "pipe", {
     configurable: true,
     writable: true,
-    value: function(this: unknown) {
+    value: function(this: Pipeable) {
       return pipeArguments(plan, arguments)
     }
   })
@@ -2314,16 +2583,8 @@ export const extractRequiredRuntime = (selection: SelectionShape): readonly stri
 
 /** Extracts the single top-level expression from a scalar subquery selection. */
 export const extractSingleSelectedExpressionRuntime = (selection: SelectionShape): Expression.Any => {
-  const keys = Object.keys(selection)
-  if (keys.length !== 1) {
-    throw new Error("scalar subqueries must select exactly one top-level expression")
-  }
-  const record = selection as Record<string, unknown>
-  const value = record[keys[0]!]
-  if (value === null || typeof value !== "object" || !(Expression.TypeId in (value as object))) {
-    throw new Error("scalar subqueries must select a scalar expression")
-  }
-  return value as unknown as Expression.Any
+  const record = selection as Record<string, Expression.Any>
+  return record[Object.keys(record)[0]!]!
 }
 
 /** Converts the plan's runtime `required` metadata into a mutable string list. */

package/src/internal/renderer.ts

@@ -1,6 +1,6 @@
 import * as Query from "./query.js"
-import type * as Expression from "./scalar.js"
-import { type Projection, validateProjections } from "./projections.js"
+import * as Expression from "./scalar.js"
+import { flattenSelection, type Projection, validateProjections } from "./projections.js"
 
 /** Symbol used to attach rendered-query phantom row metadata. */
 export const TypeId: unique symbol = Symbol.for("effect-qb/Renderer")
@@ -37,14 +37,13 @@ export type RowOf<Value extends RenderedQuery<any, any>> = Value[typeof TypeId][
  *
  * Renderers only accept complete, dialect-compatible plans. The returned
  * `RenderedQuery` keeps the canonical `Query.ResultRow<...>` type attached for
- * downstream executor layers, and the built-in renderer also performs a
- * matching runtime aggregate-shape validation.
+ * downstream executor layers.
  */
 export interface Renderer<Dialect extends string = string> {
   readonly dialect: Dialect
   render<PlanValue extends Query.Plan.Any>(
     plan: Query.DialectCompatiblePlan<PlanValue, Dialect>
-  ): RenderedQuery<any, Dialect>
+  ): RenderedQuery<Query.ResultRow<PlanValue>, Dialect>
 }
 
 type CustomRender<Dialect extends string> = <PlanValue extends Query.Plan.Any>(
@@ -56,6 +55,29 @@ type CustomRender<Dialect extends string> = <PlanValue extends Query.Plan.Any>(
   readonly valueMappings?: Expression.DriverValueMappings
 }
 
+const projectionPathKey = (path: readonly string[]): string => JSON.stringify(path)
+
+const formatProjectionPath = (path: readonly string[]): string => path.join(".")
+
+const validateProjectionPathsMatchSelection = (
+  plan: Query.Plan.Any,
+  projections: readonly Projection[]
+): void => {
+  const expected = flattenSelection(Query.getAst(plan).select as Record<string, unknown>)
+  const expectedPaths = new Set(expected.map((projection) => projectionPathKey(projection.path)))
+  const actualPaths = new Set(projections.map((projection) => projectionPathKey(projection.path)))
+  for (const projection of projections) {
+    if (!expectedPaths.has(projectionPathKey(projection.path))) {
+      throw new Error(`Projection path ${formatProjectionPath(projection.path)} does not exist in the query selection`)
+    }
+  }
+  for (const projection of expected) {
+    if (!actualPaths.has(projectionPathKey(projection.path))) {
+      throw new Error(`Projection path ${formatProjectionPath(projection.path)} is missing from rendered projections`)
+    }
+  }
+}
+
 /**
  * Constructs a renderer from a dialect and implementation callback.
  */
@@ -67,6 +89,26 @@ export function make<Dialect extends string>(
   dialect: Dialect,
   render: CustomRender<Dialect>
 ): Renderer<Dialect> {
+  return makeRenderer(dialect, render, true)
+}
+
+/** Internal renderer factory for built-in renderers that derive projections from typed plans. */
+export function makeTrusted<Dialect extends string>(
+  dialect: Dialect,
+  render: CustomRender<Dialect>
+): Renderer<Dialect>
+export function makeTrusted<Dialect extends string>(
+  dialect: Dialect,
+  render: CustomRender<Dialect>
+): Renderer<Dialect> {
+  return makeRenderer(dialect, render, false)
+}
+
+const makeRenderer = <Dialect extends string>(
+  dialect: Dialect,
+  render: CustomRender<Dialect>,
+  validate: boolean
+): Renderer<Dialect> => {
   if (typeof render !== "function") {
     throw new Error(`Renderer.make requires an explicit render implementation for dialect: ${dialect}`)
   }
@@ -75,7 +117,10 @@ export function make<Dialect extends string>(
     render(plan) {
       const rendered = render(plan)
       const projections = rendered.projections ?? []
-      validateProjections(projections)
+      if (validate) {
+        validateProjections(projections)
+        validateProjectionPathsMatchSelection(plan as Query.Plan.Any, projections)
+      }
       return {
         sql: rendered.sql,
         params: rendered.params ?? [],