effect-qb 0.17.0 → 0.20.0

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>
@@ -2412,7 +2459,7 @@ export const makeExpression = <
   state: {
     readonly runtime: Runtime
     readonly dbType: Db
-    readonly runtimeSchema?: Schema.Schema.Any
+    readonly runtimeSchema?: Schema.Top
     readonly driverValueMapping?: Expression.DriverValueMapping
     readonly nullability: Nullable
     readonly dialect: Dialect
@@ -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. */

package/src/internal/renderer.ts

@@ -1,7 +1,6 @@
 import * as Query from "./query.js"
-import type * as Expression from "./scalar.js"
+import * as Expression from "./scalar.js"
 import { flattenSelection, type Projection, validateProjections } from "./projections.js"
-import * as Plan from "./row-set.js"
 
 /** Symbol used to attach rendered-query phantom row metadata. */
 export const TypeId: unique symbol = Symbol.for("effect-qb/Renderer")
@@ -38,8 +37,7 @@ 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
@@ -91,24 +89,38 @@ 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}`)
   }
   return {
     dialect,
     render(plan) {
-      const required = Query.currentRequiredList(plan[Plan.TypeId].required)
-      if (required.length > 0) {
-        throw new Error(`query references sources that are not yet in scope: ${required.join(", ")}`)
-      }
-      const planDialect = plan[Plan.TypeId].dialect
-      if (planDialect !== dialect) {
-        throw new Error("effect-qb: plan dialect is not compatible with the target renderer or executor")
-      }
       const rendered = render(plan)
       const projections = rendered.projections ?? []
-      validateProjections(projections)
-      validateProjectionPathsMatchSelection(plan as Query.Plan.Any, projections)
+      if (validate) {
+        validateProjections(projections)
+        validateProjectionPathsMatchSelection(plan as Query.Plan.Any, projections)
+      }
       return {
         sql: rendered.sql,
         params: rendered.params ?? [],

package/src/internal/runtime/driver-value-mapping.ts

@@ -9,7 +9,7 @@ export type DriverValueMappings = Expression.DriverValueMappings
 export interface DriverValueContext {
   readonly dialect?: string
   readonly dbType?: Expression.DbType.Any
-  readonly runtimeSchema?: Schema.Schema.Any
+  readonly runtimeSchema?: Schema.Top
   readonly driverValueMapping?: DriverValueMapping
   readonly valueMappings?: DriverValueMappings
 }
@@ -99,13 +99,13 @@ const isJsonDbType = (dbType: Expression.DbType.Any | undefined): boolean => {
 }
 
 const schemaAccepts = (
-  schema: Schema.Schema.Any | undefined,
+  schema: Schema.Top | undefined,
   value: unknown
 ): boolean =>
   schema !== undefined && (Schema.is(schema) as (candidate: unknown) => boolean)(value)
 
 const encodeWithSchema = (
-  schema: Schema.Schema.Any | undefined,
+  schema: Schema.Top | undefined,
   value: unknown
 ): { readonly value: unknown; readonly encoded: boolean } => {
   if (schema === undefined) {

package/src/internal/runtime/normalize.ts

@@ -23,6 +23,13 @@ const isPlainRecord = (value: unknown): value is Record<string, unknown> => {
 
 const pad = (value: number, width = 2): string => value.toString().padStart(width, "0")
 
+const validDate = (value: Date): Date => {
+  if (Number.isNaN(value.getTime())) {
+    throw new Error("Expected a valid Date value")
+  }
+  return value
+}
+
 const formatLocalDate = (value: Date): string =>
   `${pad(value.getUTCFullYear(), 4)}-${pad(value.getUTCMonth() + 1)}-${pad(value.getUTCDate())}`
 
@@ -125,7 +132,7 @@ const normalizeDecimalString = (value: unknown): string => {
 
 const normalizeLocalDate = (value: unknown): string => {
   if (value instanceof Date) {
-    return formatLocalDate(value)
+    return formatLocalDate(validDate(value))
   }
   const raw = expectString(value, "local date").trim()
   if (isValidLocalDateString(raw)) {
@@ -143,7 +150,7 @@ const normalizeLocalDate = (value: unknown): string => {
 
 const normalizeLocalTime = (value: unknown): string => {
   if (value instanceof Date) {
-    return formatLocalTime(value)
+    return formatLocalTime(validDate(value))
   }
   const raw = expectString(value, "local time").trim()
   if (isValidLocalTimeString(raw)) {
@@ -154,7 +161,7 @@ const normalizeLocalTime = (value: unknown): string => {
 
 const normalizeOffsetTime = (value: unknown): string => {
   if (value instanceof Date) {
-    return `${formatLocalTime(value)}Z`
+    return `${formatLocalTime(validDate(value))}Z`
   }
   const raw = expectString(value, "offset time").trim()
   if (isValidOffsetTimeString(raw)) {
@@ -165,7 +172,7 @@ const normalizeOffsetTime = (value: unknown): string => {
 
 const normalizeLocalDateTime = (value: unknown): string => {
   if (value instanceof Date) {
-    return formatLocalDateTime(value)
+    return formatLocalDateTime(validDate(value))
   }
   const raw = expectString(value, "local datetime").trim()
   const canonicalLocalDateTime = raw.replace(" ", "T")
@@ -184,7 +191,7 @@ const normalizeLocalDateTime = (value: unknown): string => {
 
 const normalizeInstant = (value: unknown): string => {
   if (value instanceof Date) {
-    return value.toISOString()
+    return validDate(value).toISOString()
   }
   const raw = expectString(value, "instant").trim()
   if (!/[zZ]|[+-]\d{2}:\d{2}$/.test(raw)) {

package/src/internal/runtime/schema.ts

@@ -27,7 +27,7 @@ import {
 } from "./value.js"
 import type { RuntimeTag } from "../datatypes/shape.js"
 
-export type RuntimeSchema = Schema.Schema<any, any, any>
+export type RuntimeSchema = Schema.Top
 
 type SchemaContext = {
   readonly assumptions: PredicateFormula
@@ -38,7 +38,7 @@ const schemaCache = new WeakMap<Expression.Any, RuntimeSchema | undefined>()
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === "object" && value !== null && !Array.isArray(value)
 
-const FiniteNumberSchema = Schema.Number.pipe(Schema.finite())
+const FiniteNumberSchema = Schema.Number.check(Schema.isFinite())
 
 const runtimeSchemaForTag = (tag: RuntimeTag): RuntimeSchema | undefined => {
   switch (tag) {
@@ -67,14 +67,11 @@ const runtimeSchemaForTag = (tag: RuntimeTag): RuntimeSchema | undefined => {
     case "decimalString":
       return DecimalStringSchema
     case "bytes":
-      return Schema.Uint8ArrayFromSelf
+      return Schema.Uint8Array
     case "array":
       return Schema.Array(Schema.Unknown)
     case "record":
-      return Schema.Record({
-        key: Schema.String,
-        value: Schema.Unknown
-      })
+      return Schema.Record(Schema.String, Schema.Unknown)
     case "null":
       return Schema.Null
     case "unknown":
@@ -114,7 +111,7 @@ export const runtimeSchemaForDbType = (
 }
 
 const makeSchemaFromAst = (ast: SchemaAST.AST): RuntimeSchema =>
-  Schema.make(ast)
+  Schema.make<RuntimeSchema>(ast)
 
 const unionAst = (asts: ReadonlyArray<SchemaAST.AST>): SchemaAST.AST | undefined => {
   if (asts.length === 0) {
@@ -123,7 +120,7 @@ const unionAst = (asts: ReadonlyArray<SchemaAST.AST>): SchemaAST.AST | undefined
   if (asts.length === 1) {
     return asts[0]
   }
-  return SchemaAST.Union.make(asts)
+  return new SchemaAST.Union(asts, "anyOf")
 }
 
 const propertyAstOf = (
@@ -131,18 +128,14 @@ const propertyAstOf = (
   key: string
 ): SchemaAST.AST | undefined => {
   switch (ast._tag) {
-    case "Transformation":
-      return propertyAstOf(SchemaAST.typeAST(ast), key)
-    case "Refinement":
-      return propertyAstOf(ast.from, key)
     case "Suspend":
-      return propertyAstOf(ast.f(), key)
-    case "TypeLiteral": {
+      return propertyAstOf(ast.thunk(), key)
+    case "Objects": {
       const property = ast.propertySignatures.find((entry) => entry.name === key)
       if (property !== undefined) {
         return property.type
       }
-      const index = ast.indexSignatures.find((entry) => entry.parameter._tag === "StringKeyword")
+      const index = ast.indexSignatures.find((entry) => entry.parameter._tag === "String")
       return index?.type
     }
     case "Union": {
@@ -162,21 +155,17 @@ const numberAstOf = (
   index: number
 ): SchemaAST.AST | undefined => {
   switch (ast._tag) {
-    case "Transformation":
-      return numberAstOf(SchemaAST.typeAST(ast), index)
-    case "Refinement":
-      return numberAstOf(ast.from, index)
     case "Suspend":
-      return numberAstOf(ast.f(), index)
-    case "TupleType": {
+      return numberAstOf(ast.thunk(), index)
+    case "Arrays": {
       const element = ast.elements[index]
       if (element !== undefined) {
-        return element.type
+        return element
       }
       if (ast.rest.length === 0) {
         return undefined
       }
-      return unionAst(ast.rest.map((entry) => entry.type))
+      return unionAst(ast.rest)
     }
     case "Union": {
       const values = ast.types.flatMap((member) => {
@@ -199,7 +188,9 @@ const schemaAstAtExactJsonPath = (
   schema: RuntimeSchema,
   segments: readonly JsonPath.CanonicalSegment[]
 ): SchemaAST.AST | undefined => {
-  let current: SchemaAST.AST = SchemaAST.typeAST(schema.ast)
+  // JSON path operators return encoded JSON subvalues, so preserve field-level
+  // encoding links instead of walking the type-side AST.
+  let current: SchemaAST.AST = schema.ast
   for (const segment of segments) {
     if (segment.kind === "key") {
       const property = propertyAstOf(current, segment.key)
@@ -230,7 +221,7 @@ const unionSchemas = (schemas: ReadonlyArray<RuntimeSchema | undefined>): Runtim
   if (resolved.length === 1) {
     return resolved[0]
   }
-  return Schema.Union(...resolved)
+  return Schema.Union(resolved)
 }
 
 const firstSelectedExpression = (
@@ -241,24 +232,23 @@ const firstSelectedExpression = (
 }
 
 const isJsonCompatibleAst = (ast: SchemaAST.AST): boolean => {
+  ast = SchemaAST.toType(ast)
   switch (ast._tag) {
-    case "StringKeyword":
-    case "NumberKeyword":
-    case "BooleanKeyword":
-    case "TupleType":
-    case "TypeLiteral":
+    case "String":
+    case "Number":
+    case "Boolean":
+    case "Null":
+    case "Arrays":
+    case "Objects":
       return true
     case "Literal":
-      return ast.literal === null ||
-        typeof ast.literal === "string" ||
+      return typeof ast.literal === "string" ||
         typeof ast.literal === "number" ||
         typeof ast.literal === "boolean"
     case "Union":
       return ast.types.every(isJsonCompatibleAst)
-    case "Transformation":
-      return isJsonCompatibleAst(SchemaAST.typeAST(ast))
     case "Suspend":
-      return isJsonCompatibleAst(ast.f())
+      return isJsonCompatibleAst(ast.thunk())
     default:
       return false
   }
@@ -268,7 +258,7 @@ const jsonCompatibleSchema = (schema: RuntimeSchema | undefined): RuntimeSchema
   if (schema === undefined) {
     return undefined
   }
-  const ast = SchemaAST.typeAST(schema.ast)
+  const ast = SchemaAST.toType(schema.ast)
   return isJsonCompatibleAst(ast) ? schema : JsonValueSchema
 }
 
@@ -283,7 +273,7 @@ const buildStructSchema = (
 }
 
 const buildTupleSchema = (values: readonly Expression.Any[], context?: SchemaContext): RuntimeSchema =>
-  Schema.Tuple(...values.map((value) => expressionRuntimeSchema(value, context) ?? JsonValueSchema))
+  Schema.Tuple(values.map((value) => expressionRuntimeSchema(value, context) ?? JsonValueSchema))
 
 const deriveCaseSchema = (
   ast: ExpressionAst.CaseNode,

package/src/internal/runtime/value.ts

@@ -19,7 +19,7 @@ const brandString = <BrandName extends string>(
   brand: BrandName
 ): Schema.Schema<string & Brand.Brand<BrandName>> =>
   Schema.String.pipe(
-    Schema.pattern(pattern),
+    Schema.check(Schema.isPattern(pattern)),
     Schema.brand(brand)
   ) as unknown as Schema.Schema<string & Brand.Brand<BrandName>>
 
@@ -100,32 +100,32 @@ export const isValidInstantString = (value: string): boolean => {
 }
 
 export const LocalDateStringSchema = Schema.String.pipe(
-  Schema.pattern(localDatePattern),
-  Schema.filter(isValidLocalDateString),
+  Schema.check(Schema.isPattern(localDatePattern)),
+  Schema.check(Schema.makeFilter((value) => isValidLocalDateString(value))),
   Schema.brand("LocalDateString")
 ) as unknown as Schema.Schema<LocalDateString>
 
 export const LocalTimeStringSchema = Schema.String.pipe(
-  Schema.pattern(localTimePattern),
-  Schema.filter(isValidLocalTimeString),
+  Schema.check(Schema.isPattern(localTimePattern)),
+  Schema.check(Schema.makeFilter((value) => isValidLocalTimeString(value))),
   Schema.brand("LocalTimeString")
 ) as unknown as Schema.Schema<LocalTimeString>
 
 export const OffsetTimeStringSchema = Schema.String.pipe(
-  Schema.pattern(offsetTimePattern),
-  Schema.filter(isValidOffsetTimeString),
+  Schema.check(Schema.isPattern(offsetTimePattern)),
+  Schema.check(Schema.makeFilter((value) => isValidOffsetTimeString(value))),
   Schema.brand("OffsetTimeString")
 ) as unknown as Schema.Schema<OffsetTimeString>
 
 export const LocalDateTimeStringSchema = Schema.String.pipe(
-  Schema.pattern(localDateTimePattern),
-  Schema.filter(isValidLocalDateTimeString),
+  Schema.check(Schema.isPattern(localDateTimePattern)),
+  Schema.check(Schema.makeFilter((value) => isValidLocalDateTimeString(value))),
   Schema.brand("LocalDateTimeString")
 ) as unknown as Schema.Schema<LocalDateTimeString>
 
 export const InstantStringSchema = Schema.String.pipe(
-  Schema.pattern(instantPattern),
-  Schema.filter(isValidInstantString),
+  Schema.check(Schema.isPattern(instantPattern)),
+  Schema.check(Schema.makeFilter((value) => isValidInstantString(value))),
   Schema.brand("InstantString")
 ) as unknown as Schema.Schema<InstantString>
 
@@ -177,32 +177,29 @@ export const isCanonicalDecimalString = (value: string): boolean => {
 }
 
 export const BigIntStringSchema = Schema.String.pipe(
-  Schema.filter(isCanonicalBigIntString),
+  Schema.check(Schema.makeFilter((value) => isCanonicalBigIntString(value))),
   Schema.brand("BigIntString")
 ) as unknown as Schema.Schema<BigIntString>
 
 export const DecimalStringSchema = Schema.String.pipe(
-  Schema.filter(isCanonicalDecimalString),
+  Schema.check(Schema.makeFilter((value) => isCanonicalDecimalString(value))),
   Schema.brand("DecimalString")
 ) as unknown as Schema.Schema<DecimalString>
 
 export const JsonValueSchema: Schema.Schema<JsonValue> = Schema.suspend(() =>
-  Schema.Union(
+  Schema.Union([
     Schema.String,
-    Schema.Number.pipe(Schema.finite()),
+    Schema.Number.check(Schema.isFinite()),
     Schema.Boolean,
     Schema.Null,
     Schema.Array(JsonValueSchema),
-    Schema.Record({
-      key: Schema.String,
-      value: JsonValueSchema
-    })
-  )
+    Schema.Record(Schema.String, JsonValueSchema)
+  ])
 )
 
-export const JsonPrimitiveSchema: Schema.Schema<JsonPrimitive> = Schema.Union(
+export const JsonPrimitiveSchema: Schema.Schema<JsonPrimitive> = Schema.Union([
   Schema.String,
-  Schema.Number.pipe(Schema.finite()),
+  Schema.Number.check(Schema.isFinite()),
   Schema.Boolean,
   Schema.Null
-)
+])

package/src/internal/scalar.d.ts

@@ -73,7 +73,7 @@ export declare namespace DbType {
 export interface State<Runtime, Db extends DbType.Any, Nullable extends Nullability, Dialect extends string, Kind extends ScalarKind, Deps extends BindingId = never> {
     readonly runtime: Runtime;
     readonly dbType: Db;
-    readonly runtimeSchema?: Schema.Schema.Any;
+    readonly runtimeSchema?: Schema.Top;
     readonly nullability: Nullable;
     readonly dialect: Dialect;
     readonly kind: Kind;

package/src/internal/scalar.ts

@@ -50,6 +50,7 @@ export declare namespace DbType {
     readonly runtime?: RuntimeTag
     readonly compareGroup?: string
     readonly castTargets?: readonly string[]
+    readonly implicitTargets?: readonly string[]
     readonly traits?: DatatypeTraits
     readonly driverValueMapping?: DriverValueMapping
   }
@@ -143,7 +144,12 @@ export interface DriverValueMapping {
   readonly jsonSelectSql?: (sql: string, dbType: DbType.Any) => string
 }
 
-export type DriverValueMappings = Readonly<Record<string, DriverValueMapping | undefined>>
+export type DriverValueMappings = Readonly<Partial<Record<string, DriverValueMapping>>>
+
+export type DriverValueMappingsFor<
+  Kind extends string,
+  Family extends string
+> = Readonly<Partial<Record<Kind | Family | RuntimeTag, DriverValueMapping>>>
 
 /** Canonical static metadata stored on an expression. */
 export interface State<
@@ -156,7 +162,7 @@ export interface State<
 > {
   readonly runtime: Runtime
   readonly dbType: Db
-  readonly runtimeSchema?: Schema.Schema.Any
+  readonly runtimeSchema?: Schema.Top
   readonly driverValueMapping?: DriverValueMapping
   readonly nullability: Nullable
   readonly dialect: Dialect