effect-qb 4.0.0-beta.66 → 4.0.0-beta.92

package/src/internal/json/path-access.ts

@@ -0,0 +1,351 @@
+import { pipeArguments, type Pipeable } from "effect/Pipeable"
+
+import * as ExpressionAst from "../expression-ast.js"
+import * as Expression from "../scalar.js"
+import * as JsonPath from "./path.js"
+import type { JsonValueAtPath } from "./types.js"
+
+const WrappedTypeId: unique symbol = Symbol.for("effect-qb/JsonPathAccess")
+
+type JsonDb = Expression.DbType.Json<any, any>
+
+type AnyJsonExpression = Expression.Scalar<
+  any,
+  JsonDb,
+  Expression.Nullability,
+  string,
+  Expression.ScalarKind,
+  Expression.BindingId
+>
+
+type JsonNullabilityOf<Output> =
+  null extends Output
+    ? Exclude<Output, null> extends never ? "always" : "maybe"
+    : "never"
+
+type IsAny<Value> = 0 extends (1 & Value) ? true : false
+
+type SegmentTuple<Segments> = Segments extends readonly JsonPath.CanonicalSegment[]
+  ? Segments
+  : readonly JsonPath.CanonicalSegment[]
+
+type JsonAccessAst<Value> = Value extends {
+  readonly [ExpressionAst.TypeId]: infer Ast
+} ? Ast : never
+
+type JsonAccessParts<
+  Value,
+  Acc extends readonly JsonPath.CanonicalSegment[] = readonly [],
+  Depth extends readonly unknown[] = []
+> =
+  Depth["length"] extends 8 ? readonly [Value, Acc] :
+    [JsonAccessAst<Value>] extends [never]
+      ? readonly [Value, Acc]
+      : JsonAccessAst<Value> extends ExpressionAst.JsonAccessNode<any, infer Base extends Expression.Any, infer Segments>
+      ? JsonAccessParts<Base, readonly [...SegmentTuple<Segments>, ...Acc], readonly [...Depth, unknown]>
+      : readonly [Value, Acc]
+
+type JsonAccessRoot<Value> =
+  JsonAccessParts<Value> extends readonly [infer Base, readonly JsonPath.CanonicalSegment[]]
+    ? Base
+    : Value
+
+type JsonAccessSegments<Value> =
+  JsonAccessParts<Value> extends readonly [any, infer Segments extends readonly JsonPath.CanonicalSegment[]]
+    ? Segments
+    : readonly []
+
+type JsonAccessBase<Value> =
+  JsonAccessRoot<Value> extends Expression.Any ? JsonAccessRoot<Value> : Value
+
+type JsonPathOutput<
+  Root,
+  Segments extends readonly JsonPath.CanonicalSegment[],
+  Operation extends string
+> =
+  JsonValueAtPath<Exclude<Root, null>, JsonPath.Path<Segments>, Operation> |
+  (null extends Root ? null : never)
+
+type JsonAccessExpression<
+  Base extends AnyJsonExpression,
+  Segments extends readonly JsonPath.CanonicalSegment[]
+> = WithJsonPathAccess<
+  Expression.Scalar<
+    JsonPathOutput<Expression.RuntimeOf<JsonAccessBase<Base>>, Segments, "json.get">,
+    Expression.DbTypeOf<JsonAccessBase<Base>>,
+    JsonNullabilityOf<JsonPathOutput<Expression.RuntimeOf<JsonAccessBase<Base>>, Segments, "json.get">>,
+    Expression.DbTypeOf<JsonAccessBase<Base>>["dialect"],
+    Expression.KindOf<JsonAccessBase<Base>>,
+    Expression.DependenciesOf<JsonAccessBase<Base>>
+  > & {
+    readonly [ExpressionAst.TypeId]: ExpressionAst.JsonAccessNode<
+      JsonPath.IsExactPath<JsonPath.Path<Segments>> extends true ? "jsonPath" : "jsonTraverse",
+      JsonAccessBase<Base>,
+      Segments
+    >
+  }
+>
+
+type JsonKeyAccess<
+  Base extends AnyJsonExpression,
+  Key extends string
+> = JsonAccessExpression<Base, readonly [...JsonAccessSegments<Base>, JsonPath.KeySegment<Key>]>
+
+type JsonIndexAccess<
+  Base extends AnyJsonExpression,
+  Index extends number
+> = JsonAccessExpression<Base, readonly [...JsonAccessSegments<Base>, JsonPath.IndexSegment<Index>]>
+
+type ReservedPathKey =
+  | "pipe"
+  | "then"
+  | "toString"
+  | "toJSON"
+  | "valueOf"
+  | "constructor"
+  | "__proto__"
+  | "prototype"
+  | "inspect"
+  | "schema"
+  | "metadata"
+  | "columns"
+  | "name"
+
+type KeysOfUnion<Value> = Value extends unknown ? keyof Value : never
+
+type JsonObjectKey<Key> = Key extends string
+  ? Key extends ReservedPathKey ? never :
+    Key extends `${number}` ? never :
+      Key
+  : never
+
+type TupleNumberKey<Key> = Key extends `${infer Index extends number}` ? Index : never
+
+type JsonTupleAccessors<
+  Base extends AnyJsonExpression,
+  Runtime extends readonly unknown[]
+> = {
+  readonly [Key in Extract<keyof Runtime, `${number}`> as TupleNumberKey<Key>]: JsonIndexAccess<Base, TupleNumberKey<Key>>
+} & {
+  readonly [index: number]: JsonIndexAccess<Base, number>
+}
+
+type JsonArrayAccessors<
+  Base extends AnyJsonExpression,
+  Runtime extends readonly unknown[]
+> = number extends Runtime["length"]
+  ? {
+      readonly [index: number]: JsonIndexAccess<Base, number>
+    }
+  : JsonTupleAccessors<Base, Runtime>
+
+type JsonObjectAccessors<
+  Base extends AnyJsonExpression,
+  Runtime extends object
+> = {
+  readonly [Key in KeysOfUnion<Runtime> as JsonObjectKey<Key>]: JsonKeyAccess<Base, JsonObjectKey<Key>>
+}
+
+type JsonObjectPredicateKeys<Runtime> =
+  Runtime extends readonly unknown[]
+    ? never
+    : Runtime extends object
+      ? Extract<KeysOfUnion<Runtime>, string>
+      : never
+
+export type JsonObjectKeyOf<Value extends Expression.Any> =
+  IsAny<Expression.RuntimeOf<Value>> extends true
+    ? string
+    : Exclude<Expression.RuntimeOf<Value>, null> extends infer Runtime
+      ? string extends JsonObjectPredicateKeys<Runtime>
+        ? string
+        : JsonObjectPredicateKeys<Runtime>
+      : never
+
+type JsonPathAccessors<Base extends AnyJsonExpression> =
+  IsAny<Expression.RuntimeOf<Base>> extends true
+    ? {}
+    : Exclude<Expression.RuntimeOf<Base>, null> extends infer Runtime
+      ? Runtime extends readonly unknown[]
+        ? JsonArrayAccessors<Base, Runtime>
+        : Runtime extends object
+          ? JsonObjectAccessors<Base, Runtime>
+          : {}
+      : {}
+
+export type WithJsonPathAccess<Value> = Value extends AnyJsonExpression
+  ? Value & JsonPathAccessors<Value>
+  : Value
+
+const accessKinds = new Set<string>([
+  "jsonGet",
+  "jsonPath",
+  "jsonAccess",
+  "jsonTraverse",
+  "jsonGetText",
+  "jsonPathText",
+  "jsonAccessText",
+  "jsonTraverseText"
+])
+
+const reservedKeys = new Set<string>([
+  "pipe",
+  "then",
+  "toString",
+  "toJSON",
+  "valueOf",
+  "constructor",
+  "__proto__",
+  "prototype",
+  "inspect",
+  "schema",
+  "metadata",
+  "columns",
+  "name"
+])
+
+const isObjectLike = (value: unknown): value is object =>
+  (typeof value === "object" || typeof value === "function") && value !== null
+
+const isExpression = (value: unknown): value is Expression.Any =>
+  isObjectLike(value) && Expression.TypeId in value
+
+const isJsonExpression = (value: unknown): value is AnyJsonExpression => {
+  if (!isExpression(value)) {
+    return false
+  }
+  const dbType = value[Expression.TypeId].dbType as { readonly kind?: string; readonly variant?: string }
+  return dbType.kind === "json" || dbType.kind === "jsonb" || dbType.variant === "json" || dbType.variant === "jsonb"
+}
+
+const isWrapped = (value: object): boolean =>
+  (value as { readonly [WrappedTypeId]?: true })[WrappedTypeId] === true
+
+const normalizeSegment = (segment: JsonPath.CanonicalSegment): JsonPath.CanonicalSegment => {
+  switch (segment.kind) {
+    case "key":
+      return JsonPath.key(segment.key)
+    case "index":
+      return JsonPath.index(segment.index)
+    case "wildcard":
+      return JsonPath.wildcard()
+    case "slice":
+      return JsonPath.slice(segment.start, segment.end)
+    case "descend":
+      return JsonPath.descend()
+  }
+}
+
+const accessPathOf = (value: Expression.Any): {
+  readonly base: Expression.Any
+  readonly segments: readonly JsonPath.CanonicalSegment[]
+} => {
+  const segments: JsonPath.CanonicalSegment[] = []
+  let base: Expression.Any = value
+  while (isExpression(base)) {
+    const ast = (base as Expression.Any & {
+      readonly [ExpressionAst.TypeId]?: ExpressionAst.Any
+    })[ExpressionAst.TypeId] as { readonly kind?: unknown; readonly base?: unknown; readonly segments?: unknown } | undefined
+    if (ast === undefined || typeof ast.kind !== "string" || !accessKinds.has(ast.kind) || !isExpression(ast.base) || !Array.isArray(ast.segments)) {
+      break
+    }
+    segments.unshift(...ast.segments.map(normalizeSegment))
+    base = ast.base
+  }
+  return { base, segments }
+}
+
+const isIntegerProperty = (property: string): boolean =>
+  /^(?:-?(?:0|[1-9][0-9]*))$/.test(property)
+
+const jsonAccessKind = (
+  segments: readonly JsonPath.CanonicalSegment[]
+): ExpressionAst.JsonAccessKind =>
+  segments.every((segment) => segment.kind === "key" || segment.kind === "index")
+    ? segments.length === 1 ? "jsonGet" : "jsonPath"
+    : "jsonTraverse"
+
+const makeExpression = <
+  Runtime,
+  Db extends Expression.DbType.Any,
+  Nullable extends Expression.Nullability,
+  Dialect extends string,
+  Kind extends Expression.ScalarKind,
+  Deps extends Expression.BindingId,
+  Ast extends ExpressionAst.Any
+>(
+  state: Expression.State<Runtime, Db, Nullable, Dialect, Kind, Deps>,
+  ast: Ast
+): Expression.Scalar<Runtime, Db, Nullable, Dialect, Kind, Deps> & {
+  readonly [ExpressionAst.TypeId]: Ast
+} => {
+  const expression = Object.create(null) as Expression.Scalar<Runtime, Db, Nullable, Dialect, Kind, Deps> & {
+    [ExpressionAst.TypeId]: Ast
+    [Expression.TypeId]: Expression.State<Runtime, Db, Nullable, Dialect, Kind, Deps>
+    pipe: Pipeable["pipe"]
+  }
+  Object.defineProperty(expression, "pipe", {
+    configurable: true,
+    writable: true,
+    value: function(this: Pipeable) {
+      return pipeArguments(expression, arguments)
+    }
+  })
+  expression[Expression.TypeId] = state
+  expression[ExpressionAst.TypeId] = ast
+  return expression
+}
+
+const makePathExpression = (
+  value: AnyJsonExpression,
+  segment: JsonPath.CanonicalSegment
+): AnyJsonExpression => {
+  const access = accessPathOf(value)
+  const segments = [...access.segments, normalizeSegment(segment)]
+  const base = access.base as AnyJsonExpression
+  const baseState = base[Expression.TypeId]
+  return withJsonPathAccess(makeExpression(
+    {
+      ...baseState,
+      runtime: undefined,
+      nullability: undefined as unknown as Expression.Nullability
+    },
+    {
+      kind: jsonAccessKind(segments),
+      base,
+      segments
+    } satisfies ExpressionAst.JsonAccessNode<any, any, any>
+  ) as AnyJsonExpression)
+}
+
+const pathProxyHandler: ProxyHandler<AnyJsonExpression> = {
+  get(target, property, receiver) {
+    if (typeof property === "symbol") {
+      return Reflect.get(target, property, receiver)
+    }
+    if (Reflect.has(target, property) || reservedKeys.has(property)) {
+      return Reflect.get(target, property, receiver)
+    }
+    const segment = isIntegerProperty(property)
+      ? JsonPath.index(Number(property))
+      : JsonPath.key(property)
+    return makePathExpression(target, segment)
+  },
+  has(target, property) {
+    return Reflect.has(target, property)
+  }
+}
+
+export const withJsonPathAccess = <Value>(value: Value): WithJsonPathAccess<Value> => {
+  if (!isObjectLike(value) || !isJsonExpression(value) || isWrapped(value)) {
+    return value as WithJsonPathAccess<Value>
+  }
+  const proxy = new Proxy(value, pathProxyHandler) as unknown as WithJsonPathAccess<Value> & {
+    [WrappedTypeId]: true
+  }
+  Object.defineProperty(proxy, WrappedTypeId, {
+    configurable: false,
+    value: true
+  })
+  return proxy
+}

package/src/internal/predicate/runtime.ts

@@ -474,6 +474,9 @@ const valueKeyOfLiteral = (value: unknown): string => {
     return "null"
   }
   if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) {
+      throw new Error("Expected a valid Date value")
+    }
     return `date:${value.toISOString()}`
   }
   return "unknown"

package/src/internal/query.d.ts

@@ -37,6 +37,31 @@ export interface QueryState<Outstanding extends string, AvailableNames extends s
 }
 /** 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. */
@@ -135,10 +160,11 @@ export type SelectionShape = Expression.Any | {
 export type ExtractRequired<Selection> = Selection extends Expression.Any ? RequiredFromDependencies<DependenciesOf<Selection>> : Selection extends Record<string, any> ? {
     [K in keyof Selection]: ExtractRequired<Selection[K]>;
 }[keyof Selection] : never;
-/** Walks a selection tree and unions the dialects referenced by its leaves. */
-export type ExtractDialect<Selection> = Selection extends Expression.Any ? DialectOf<Selection> : Selection extends Record<string, any> ? {
-    [K in keyof Selection]: ExtractDialect<Selection[K]>;
+type ExtractDialectRaw<Selection> = Selection extends Expression.Any ? DialectOf<Selection> : Selection extends Record<string, any> ? {
+    [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.
  *
@@ -419,8 +445,7 @@ export type MutationTargetNamesOf<Target extends MutationTargetInput> = Target e
 export type UpdateInputOfTarget<Target extends MutationTargetInput> = Target extends MutationTargetLike ? MutationInputOf<Table.UpdateOf<Target>> : Target extends MutationTargetTuple ? Simplify<{
     readonly [K in MutationTargetNamesOf<Target>]?: MutationInputOf<Table.UpdateOf<MutationTargetByName<Target, K>>>;
 }> : never;
-/** Extracts the effective dialect from a source. */
-export type SourceDialectOf<Source extends SourceLike> = Source extends TableLike<any, infer Dialect> ? Dialect : Source extends {
+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 {
@@ -432,6 +457,8 @@ export type SourceDialectOf<Source extends SourceLike> = Source extends TableLik
 } ? PlanDialectOf<PlanValue> : 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"] : Source extends {
     readonly kind: "derived";
@@ -493,7 +520,7 @@ export type RequiredOfPlan<PlanValue extends QueryPlan<any, any, any, any, any,
 /** 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, 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, any, any>> = QueryPlanParts<PlanValue>["dialect"];
+export type PlanDialectOf<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>> = 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>> = QueryPlanState<PlanValue>["grouped"];
 /** Extracts the available-name phantom carried by a query plan. */
@@ -562,7 +589,7 @@ type MergeNullability<Left extends Expression.Nullability, Right extends Express
 /** Folds nullability across a tuple for null-propagating scalar operators. */
 export type MergeNullabilityTuple<Values extends readonly Expression.Any[], Current extends Expression.Nullability = "never"> = Values extends readonly [infer Head extends Expression.Any, ...infer Tail extends readonly Expression.Any[]] ? MergeNullabilityTuple<Tail, MergeNullability<Current, Expression.NullabilityOf<Head>>> : Current;
 /** Dialect union across a tuple of expressions. */
-export type TupleDialect<Values extends readonly Expression.Any[]> = Values[number] extends never ? never : DialectOf<Values[number]>;
+export type TupleDialect<Values extends readonly Expression.Any[]> = Values[number] extends never ? never : NormalizeDialect<DialectOf<Values[number]>>;
 /** Dependency union across a tuple of scalar expressions. */
 export type TupleDependencies<Values extends readonly Expression.Any[]> = Values[number] extends never ? never : DependenciesOf<Values[number]>;
 /** Builds the canonical dependency union from a string union of table names. */
@@ -661,7 +688,7 @@ type AggregationCompatibilityError<PlanValue extends QueryPlan<any, any, any, an
 };
 type DialectCompatibilityError<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>, 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";
 };
@@ -678,11 +705,11 @@ export type AggregationCompatiblePlan<PlanValue extends QueryPlan<any, any, any,
 /** 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>> = 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<PlanDialect extends string, EngineDialect extends string> = [PlanDialect] extends [never] ? true : Extract<PlanDialect, EngineDialect> extends never ? false : true;
+type IsDialectCompatible<PlanDialect extends string, EngineDialect extends string> = [PlanDialect] extends [never] ? 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 ? CompletePlan<PlanValue> : DialectCompatibilityError<PlanValue, EngineDialect>;
+export type DialectCompatiblePlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>, EngineDialect extends string> = IsDialectCompatible<PlanDialectOf<PlanValue>, EngineDialect> extends true ? CompletePlan<PlanValue> : DialectCompatibilityError<PlanValue, EngineDialect>;
 /** 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> : DialectCompatibilityError<PlanValue, EngineDialect>;
+export type DialectCompatibleNestedPlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>, EngineDialect extends string> = IsDialectCompatible<PlanDialectOf<PlanValue>, EngineDialect> extends true ? AggregationCompatiblePlan<PlanValue> : DialectCompatibilityError<PlanValue, EngineDialect>;
 type SetOperandStatement = "select" | "set";
 type IsUnion<Value, All = Value> = Value extends any ? ([All] extends [Value] ? false : true) : never;
 type SingleSelectedExpressionError<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> = PlanValue & {

package/src/internal/query.ts

@@ -96,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)
   }
 }
@@ -108,7 +108,7 @@ const ExpressionProto = {
  * chained through `.pipe(...)`.
  */
 const PlanProto = {
-  pipe(this: unknown) {
+  pipe(this: Pipeable) {
     return pipeArguments(this, arguments)
   }
 }
@@ -143,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. */
@@ -464,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.
  *
@@ -1005,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> :
@@ -1014,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"] :
@@ -1148,6 +1180,21 @@ type DerivedProjectionIssues<Selection> =
     : | 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 & {
@@ -1254,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>
@@ -1465,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> = (
@@ -2124,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"
 }
@@ -2175,7 +2222,7 @@ type IsDialectCompatible<
   EngineDialect extends string
 > = [PlanDialect] extends [never]
   ? true
-  : Exclude<PlanDialect, EngineDialect> extends never
+  : Exclude<PlanDialect, EngineDialect | "standard"> extends never
     ? true
     : false
 
@@ -2183,7 +2230,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 RowSet.TypeId]["dialect"], EngineDialect> extends true
+> = IsDialectCompatible<PlanDialectOf<PlanValue>, EngineDialect> extends true
   ? CompletePlan<PlanValue>
   : DialectCompatibilityError<PlanValue, EngineDialect>
 
@@ -2201,7 +2248,7 @@ type NestedPlanStatementError<
 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
+> = IsDialectCompatible<PlanDialectOf<PlanValue>, EngineDialect> extends true
   ? StatementOfPlan<PlanValue> extends SelectLikeStatement
     ? AggregationCompatiblePlan<PlanValue>
     : NestedPlanStatementError<PlanValue>
@@ -2427,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)
     }
   })
@@ -2477,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)
     }
   })
@@ -2536,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. */