effect-qb 0.17.0 → 4.0.0-beta.66

package/src/internal/column-state.d.ts

@@ -70,7 +70,7 @@ export interface ColumnState<Select, Insert, Update, Db extends Expression.DbTyp
 export interface ColumnDefinition<Select, Insert, Update, Db extends Expression.DbType.Any, Nullable extends boolean, HasDefault extends boolean, Generated extends boolean, PrimaryKey extends boolean, Unique extends boolean, Ref, Dependencies extends Expression.BindingId = never> extends Pipeable, Expression.Scalar<Select, Db, Nullable extends true ? "maybe" : "never", Db["dialect"], "scalar", Dependencies> {
     readonly pipe: Pipeable["pipe"];
     readonly [ColumnTypeId]: ColumnState<Select, Insert, Update, Db, Nullable, HasDefault, Generated, PrimaryKey, Unique, Ref, Dependencies>;
-    readonly schema: Schema.Schema<NonNullable<Select>, any, any>;
+    readonly schema: Schema.Schema<NonNullable<Select>>;
     readonly metadata: {
         readonly dbType: Db;
         readonly nullable: Nullable;
@@ -111,7 +111,7 @@ export type AnyColumnDefinition = ColumnDefinition<any, any, any, Expression.DbT
 /** Convenience alias for any bound column. */
 export type AnyBoundColumn = BoundColumn<any, any, any, Expression.DbType.Any, boolean, boolean, boolean, boolean, boolean, any, string, string, string>;
 /** Constructs a runtime column-definition object from schema and metadata. */
-export declare const makeColumnDefinition: <Select, Insert, Update, Db extends Expression.DbType.Any, Nullable extends boolean, HasDefault extends boolean, Generated extends boolean, PrimaryKey extends boolean, Unique extends boolean, Ref, Dependencies extends string = never>(schema: Schema.Schema<NonNullable<Select>, any, any>, metadata: {
+export declare const makeColumnDefinition: <Select, Insert, Update, Db extends Expression.DbType.Any, Nullable extends boolean, HasDefault extends boolean, Generated extends boolean, PrimaryKey extends boolean, Unique extends boolean, Ref, Dependencies extends string = never>(schema: Schema.Schema<NonNullable<Select>>, metadata: {
     readonly dbType: Db;
     readonly nullable: Nullable;
     readonly hasDefault: HasDefault;
@@ -135,7 +135,7 @@ export declare const makeColumnDefinition: <Select, Insert, Update, Db extends E
     } | undefined;
 }) => ColumnDefinition<Select, Insert, Update, Db, Nullable, HasDefault, Generated, PrimaryKey, Unique, Ref, Dependencies>;
 export declare const remapColumnDefinition: <Select, Insert, Update, Db extends Expression.DbType.Any, Nullable extends boolean, HasDefault extends boolean, Generated extends boolean, PrimaryKey extends boolean, Unique extends boolean, Ref, Dependencies extends string = never>(column: ColumnDefinition<Select, Insert, Update, Db, Nullable, HasDefault, Generated, PrimaryKey, Unique, Ref, Dependencies>, options?: {
-    readonly schema?: Schema.Schema.Any | undefined;
+    readonly schema?: Schema.Top | undefined;
     readonly metadata?: {
         readonly dbType: Db;
         readonly nullable: Nullable;

package/src/internal/column-state.ts

@@ -123,7 +123,7 @@ export interface ColumnDefinition<
     Ref,
     Dependencies
   >
-  readonly schema: Schema.Schema<NonNullable<Select>, any, any>
+  readonly schema: Schema.Schema<NonNullable<Select>>
   readonly metadata: {
     readonly dbType: Db
     readonly nullable: Nullable
@@ -257,7 +257,7 @@ export const makeColumnDefinition = <
   Ref,
   Dependencies extends Expression.BindingId = never
 >(
-  schema: Schema.Schema<NonNullable<Select>, any, any>,
+  schema: Schema.Schema<NonNullable<Select>>,
   metadata: ColumnDefinition<
     Select,
     Insert,
@@ -345,7 +345,7 @@ export const remapColumnDefinition = <
     Dependencies
   >,
   options: {
-    readonly schema?: Schema.Schema.Any
+    readonly schema?: Schema.Top
     readonly metadata?: ColumnDefinition<
       Select,
       Insert,

package/src/internal/column.ts

@@ -225,21 +225,21 @@ type ForeignKeyOptions<Target extends AnyBoundColumn> = {
 
 type SchemaCompatibleColumn<
   Column extends AnyColumnDefinition,
-  SchemaType extends Schema.Schema.Any
-> = [BaseSelectType<Column>] extends [Schema.Schema.Encoded<SchemaType>]
+  SchemaType extends Schema.Top
+> = [BaseSelectType<Column>] extends [Schema.Codec.Encoded<SchemaType>]
   ? Column
   : never
 
 type ColumnSchemaOutput<
   Column extends AnyColumnDefinition,
-  SchemaType extends Schema.Schema.Any
+  SchemaType extends Schema.Top
 > = IsNullable<Column> extends true
   ? Schema.Schema.Type<SchemaType> | null
   : Schema.Schema.Type<SchemaType>
 
 type ColumnWithSchema<
   Column extends AnyColumnDefinition,
-  SchemaType extends Schema.Schema.Any
+  SchemaType extends Schema.Top
 > = ColumnDefinition<
   ColumnSchemaOutput<Column, SchemaType>,
   ColumnSchemaOutput<Column, SchemaType>,
@@ -376,7 +376,7 @@ const isColumnDefinitionValue = (value: unknown): value is AnyColumnDefinition =
   typeof value === "object" && value !== null && ColumnTypeId in value
 
 const primitive = <Type, Db extends Expression.DbType.Any>(
-  schema: Schema.Schema<Type, any, any>,
+  schema: Schema.Schema<Type>,
   dbType: Db
 ): ColumnDefinition<Type, Type, Type, Db, false, false, false, false, false, undefined> =>
   makeColumnDefinition(schema as Schema.Schema<NonNullable<Type>>, {
@@ -401,7 +401,7 @@ type ColumnModule<
   JsonKind extends string
 > = {
   readonly custom: <
-    SchemaType extends Schema.Schema.Any,
+    SchemaType extends Schema.Top,
     Db extends Expression.DbType.Any
   >(
     schema: SchemaType,
@@ -425,7 +425,7 @@ type ColumnModule<
   readonly boolean: () => ColumnDefinition<boolean, boolean, boolean, Expression.DbType.Base<Dialect, BooleanKind>, false, false, false, false, false, undefined>
   readonly date: () => ColumnDefinition<LocalDateString, LocalDateString, LocalDateString, Expression.DbType.Base<Dialect, DateKind>, false, false, false, false, false, undefined>
   readonly timestamp: () => ColumnDefinition<LocalDateTimeString, LocalDateTimeString, LocalDateTimeString, Expression.DbType.Base<Dialect, TimestampKind>, false, false, false, false, false, undefined>
-  readonly json: <SchemaType extends Schema.Schema.Any>(
+  readonly json: <SchemaType extends Schema.Top>(
     schema: SchemaType
   ) => ColumnDefinition<
     Schema.Schema.Type<SchemaType>,
@@ -442,7 +442,7 @@ type ColumnModule<
 }
 
 /** Replaces a column's runtime schema while preserving its SQL type metadata. */
-export const schema = <SchemaType extends Schema.Schema.Any>(nextSchema: SchemaType) =>
+export const schema = <SchemaType extends Schema.Top>(nextSchema: SchemaType) =>
   <Column extends AnyColumnDefinition>(
     column: SchemaCompatibleColumn<Column, SchemaType>
   ): ColumnWithSchema<Column, SchemaType> =>

package/src/internal/dialect.ts

@@ -23,7 +23,7 @@ export interface RenderState {
 
 export interface RenderValueContext {
   readonly dbType?: Expression.DbType.Any
-  readonly runtimeSchema?: Schema.Schema.Any
+  readonly runtimeSchema?: Schema.Top
   readonly driverValueMapping?: Expression.DriverValueMapping
 }
 

package/src/internal/executor.ts

@@ -1,9 +1,10 @@
 import * as Chunk from "effect/Chunk"
 import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
 import * as Option from "effect/Option"
 import * as Schema from "effect/Schema"
-import * as SqlClient from "@effect/sql/SqlClient"
-import * as SqlError from "@effect/sql/SqlError"
+import * as SqlClient from "effect/unstable/sql/SqlClient"
+import * as SqlError from "effect/unstable/sql/SqlError"
 import * as Stream from "effect/Stream"
 
 import * as Expression from "./scalar.js"
@@ -44,6 +45,10 @@ export interface RowDecodeError {
   readonly normalized?: unknown
   readonly stage: "normalize" | "schema"
   readonly cause: unknown
+  readonly schemaError?: {
+    readonly message: string
+    readonly issue: unknown
+  }
 }
 
 /**
@@ -183,26 +188,35 @@ const makeRowDecodeError = (
   stage: RowDecodeError["stage"],
   cause: unknown,
   normalized?: unknown
-): RowDecodeError => ({
-  _tag: "RowDecodeError",
-  message: stage === "normalize"
-    ? `Failed to normalize projection '${projection.alias}'`
-    : `Failed to decode projection '${projection.alias}' against its runtime schema`,
-  dialect: rendered.dialect,
-  query: {
-    sql: rendered.sql,
-    params: rendered.params
-  },
-  projection: {
-    alias: projection.alias,
-    path: projection.path
-  },
-  dbType: expression[Expression.TypeId].dbType,
-  raw,
-  normalized,
-  stage,
-  cause
-})
+): RowDecodeError => {
+  const schemaError = Schema.isSchemaError(cause)
+    ? {
+        message: cause.message,
+        issue: cause.issue
+      }
+    : undefined
+  return {
+    _tag: "RowDecodeError",
+    message: stage === "normalize"
+      ? `Failed to normalize projection '${projection.alias}'`
+      : `Failed to decode projection '${projection.alias}' against its runtime schema`,
+    dialect: rendered.dialect,
+    query: {
+      sql: rendered.sql,
+      params: rendered.params
+    },
+    projection: {
+      alias: projection.alias,
+      path: projection.path
+    },
+    dbType: expression[Expression.TypeId].dbType,
+    raw,
+    normalized,
+    stage,
+    cause,
+    ...(schemaError === undefined ? {} : { schemaError })
+  }
+}
 
 const hasOptionalSourceDependency = (
   expression: Expression.Any,
@@ -249,7 +263,7 @@ const dbTypeAllowsTopLevelJsonNull = (
 }
 
 const schemaAcceptsNull = (
-  schema: Schema.Schema.Any | undefined
+  schema: Schema.Top | undefined
 ): boolean =>
   schema !== undefined && (Schema.is(schema) as (value: unknown) => boolean)(null)
 
@@ -325,15 +339,20 @@ const decodeProjectionValue = (
     return normalized
   }
 
-  if ((Schema.is(schema as Schema.Schema.Any) as (value: unknown) => boolean)(normalized)) {
+  if ((Schema.is(schema as Schema.Top) as (value: unknown) => boolean)(normalized)) {
     return normalized
   }
 
-  try {
-    return (Schema.decodeUnknownSync as any)(schema)(normalized)
-  } catch (cause) {
-    throw makeRowDecodeError(rendered, projection, expression, raw, "schema", cause, normalized)
+  const decoded = (Schema.decodeUnknownExit as any)(schema)(normalized)
+  if (Exit.isSuccess(decoded)) {
+    return decoded.value
   }
+
+  const cause = Option.match(Exit.findErrorOption(decoded), {
+    onNone: () => decoded.cause,
+    onSome: (schemaError) => schemaError
+  })
+  throw makeRowDecodeError(rendered, projection, expression, raw, "schema", cause, normalized)
 }
 
 export const makeRowDecoder = (
@@ -390,7 +409,7 @@ export const decodeChunk = (
   } = {}
 ): Chunk.Chunk<any> => {
   const decodeRow = makeRowDecoder(rendered, plan, options)
-  return Chunk.unsafeFromArray(Chunk.toReadonlyArray(rows).map((row) => decodeRow(row)))
+  return Chunk.fromIterable(Chunk.toReadonlyArray(rows).map((row) => decodeRow(row)))
 }
 
 export const decodeRows = (
@@ -520,9 +539,9 @@ export const fromDriver = <
     },
     stream(plan: any) {
       const rendered = renderer.render(plan) as Renderer.RenderedQuery<any, Dialect>
-      return Stream.mapChunks(
+      return Stream.mapArray(
         sqlDriver.stream(rendered),
-        (rows) => Chunk.unsafeFromArray(remapRows<any>(rendered, Chunk.toReadonlyArray(rows)))
+        (rows) => remapRows<any>(rendered, rows) as never
       )
     }
   }
@@ -532,10 +551,10 @@ export const fromDriver = <
 export const streamFromSqlClient = <Dialect extends string>(
   query: Renderer.RenderedQuery<any, Dialect>
 ): Stream.Stream<FlatRow, SqlError.SqlError, SqlClient.SqlClient> =>
-  Stream.unwrapScoped(
+  Stream.unwrap(
     Effect.flatMap(SqlClient.SqlClient, (sql) =>
       Effect.flatMap(
-        Effect.serviceOption(SqlClient.TransactionConnection),
+        Effect.serviceOption(sql.transactionService),
         Option.match({
           onNone: () => sql.reserve,
           onSome: ([connection]) => Effect.succeed(connection)
@@ -556,7 +575,7 @@ export const fromSqlClient = <Dialect extends string>(
     stream: (query) => streamFromSqlClient(query)
   }))
 
-/** Runs an effect within the ambient `@effect/sql` transaction service. */
+/** Runs an effect within the ambient `effect/unstable/sql` transaction service. */
 export const withTransaction = <A, E, R>(
   effect: Effect.Effect<A, E, R>
 ): Effect.Effect<A, E | SqlError.SqlError, R | SqlClient.SqlClient> =>
@@ -565,7 +584,7 @@ export const withTransaction = <A, E, R>(
 /**
  * Runs an effect in a nested transaction scope.
  *
- * When the ambient `@effect/sql` client is already inside a transaction, the
+ * When the ambient `effect/unstable/sql` client is already inside a transaction, the
  * underlying client implementation uses a savepoint.
  */
 export const withSavepoint = <A, E, R>(

package/src/internal/query.d.ts

@@ -743,7 +743,7 @@ export declare const mergeManyDependencies: <Values extends readonly Expression.
 export declare const makeExpression: <Runtime, Db extends Expression.DbType.Any, Nullable extends Expression.Nullability, Dialect extends string, Kind extends Expression.ScalarKind, Deps extends string = never, Ast extends ExpressionAst.Any = ExpressionAst.Any, GroupKey extends string = GroupingKeyOfAst<Ast>>(state: {
     readonly runtime: Runtime;
     readonly dbType: Db;
-    readonly runtimeSchema?: Schema.Schema.Any | undefined;
+    readonly runtimeSchema?: Schema.Top | undefined;
     readonly nullability: Nullable;
     readonly dialect: Dialect;
     readonly kind?: Kind | undefined;

package/src/internal/query.ts

@@ -2412,7 +2412,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

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/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

@@ -156,7 +156,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