effect-qb 0.16.0 → 4.0.0-beta.66

package/src/internal/runtime/normalize.ts

@@ -1,13 +1,30 @@
 import type * as Expression from "../scalar.js"
 import type { RuntimeTag } from "../datatypes/shape.js"
+import {
+  canonicalizeBigIntString,
+  canonicalizeDecimalString,
+  isValidInstantString,
+  isValidLocalDateString,
+  isValidLocalDateTimeString,
+  isValidLocalTimeString,
+  isValidOffsetTimeString
+} from "./value.js"
 
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === "object" && value !== null && !Array.isArray(value)
 
+const isPlainRecord = (value: unknown): value is Record<string, unknown> => {
+  if (!isRecord(value)) {
+    return false
+  }
+  const prototype = Object.getPrototypeOf(value)
+  return prototype === Object.prototype || prototype === null
+}
+
 const pad = (value: number, width = 2): string => value.toString().padStart(width, "0")
 
 const formatLocalDate = (value: Date): string =>
-  `${value.getUTCFullYear()}-${pad(value.getUTCMonth() + 1)}-${pad(value.getUTCDate())}`
+  `${pad(value.getUTCFullYear(), 4)}-${pad(value.getUTCMonth() + 1)}-${pad(value.getUTCDate())}`
 
 const formatLocalTime = (value: Date): string => {
   const milliseconds = value.getUTCMilliseconds()
@@ -34,12 +51,17 @@ const expectString = (value: unknown, label: string): string => {
   throw new Error(`Expected ${label} as string`)
 }
 
+const finiteNumberStringPattern = /^[+-]?(?:(?:\d+\.?\d*)|(?:\.\d+))(?:[eE][+-]?\d+)?$/
+
 const normalizeNumber = (value: unknown): number => {
   if (typeof value === "number" && Number.isFinite(value)) {
     return value
   }
-  if (typeof value === "string" && value.trim() !== "") {
-    const parsed = Number(value)
+  if (typeof value === "string") {
+    const trimmed = value.trim()
+    const parsed = finiteNumberStringPattern.test(trimmed)
+      ? Number(trimmed)
+      : Number.NaN
     if (Number.isFinite(parsed)) {
       return parsed
     }
@@ -81,27 +103,12 @@ const normalizeBigIntString = (value: unknown): string => {
   if (typeof value === "number" && Number.isSafeInteger(value)) {
     return BigInt(value).toString()
   }
-  if (typeof value === "string" && /^-?\d+$/.test(value.trim())) {
-    return BigInt(value.trim()).toString()
+  if (typeof value === "string") {
+    return canonicalizeBigIntString(value)
   }
   throw new Error("Expected an integer-like bigint value")
 }
 
-const canonicalizeDecimalString = (input: string): string => {
-  const trimmed = input.trim()
-  const match = /^([+-]?)(\d+)(?:\.(\d+))?$/.exec(trimmed)
-  if (match === null) {
-    throw new Error("Expected a decimal string")
-  }
-  const sign = match[1] === "-" ? "-" : ""
-  const integer = match[2]!.replace(/^0+(?=\d)/, "") || "0"
-  const fraction = (match[3] ?? "").replace(/0+$/, "")
-  if (fraction.length === 0) {
-    return `${sign}${integer}`
-  }
-  return `${sign}${integer}.${fraction}`
-}
-
 const normalizeDecimalString = (value: unknown): string => {
   if (typeof value === "string") {
     return canonicalizeDecimalString(value)
@@ -121,12 +128,15 @@ const normalizeLocalDate = (value: unknown): string => {
     return formatLocalDate(value)
   }
   const raw = expectString(value, "local date").trim()
-  if (/^\d{4}-\d{2}-\d{2}$/.test(raw)) {
+  if (isValidLocalDateString(raw)) {
     return raw
   }
-  const parsed = new Date(raw)
-  if (!Number.isNaN(parsed.getTime())) {
-    return formatLocalDate(parsed)
+  const canonicalInstant = raw.replace(" ", "T").replace(/z$/, "Z")
+  if (isValidInstantString(canonicalInstant)) {
+    const parsed = new Date(canonicalInstant)
+    if (!Number.isNaN(parsed.getTime())) {
+      return formatLocalDate(parsed)
+    }
   }
   throw new Error("Expected a local-date value")
 }
@@ -136,7 +146,7 @@ const normalizeLocalTime = (value: unknown): string => {
     return formatLocalTime(value)
   }
   const raw = expectString(value, "local time").trim()
-  if (/^\d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(raw)) {
+  if (isValidLocalTimeString(raw)) {
     return raw
   }
   throw new Error("Expected a local-time value")
@@ -147,7 +157,7 @@ const normalizeOffsetTime = (value: unknown): string => {
     return `${formatLocalTime(value)}Z`
   }
   const raw = expectString(value, "offset time").trim()
-  if (/^\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(raw)) {
+  if (isValidOffsetTimeString(raw)) {
     return raw
   }
   throw new Error("Expected an offset-time value")
@@ -158,11 +168,13 @@ const normalizeLocalDateTime = (value: unknown): string => {
     return formatLocalDateTime(value)
   }
   const raw = expectString(value, "local datetime").trim()
-  if (/^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(raw)) {
-    return raw.replace(" ", "T")
+  const canonicalLocalDateTime = raw.replace(" ", "T")
+  if (isValidLocalDateTimeString(canonicalLocalDateTime)) {
+    return canonicalLocalDateTime
   }
-  if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(raw)) {
-    const parsed = new Date(raw)
+  const canonicalInstant = raw.replace(" ", "T").replace(/z$/, "Z")
+  if (isValidInstantString(canonicalInstant)) {
+    const parsed = new Date(canonicalInstant)
     if (!Number.isNaN(parsed.getTime())) {
       return formatLocalDateTime(parsed)
     }
@@ -178,7 +190,11 @@ const normalizeInstant = (value: unknown): string => {
   if (!/[zZ]|[+-]\d{2}:\d{2}$/.test(raw)) {
     throw new Error("Instant values require a timezone offset")
   }
-  const parsed = new Date(raw)
+  const canonicalInstant = raw.replace(" ", "T").replace(/z$/, "Z")
+  if (!isValidInstantString(canonicalInstant)) {
+    throw new Error("Expected an ISO instant value")
+  }
+  const parsed = new Date(canonicalInstant)
   if (Number.isNaN(parsed.getTime())) {
     throw new Error("Expected an ISO instant value")
   }
@@ -209,20 +225,21 @@ const normalizeBytes = (value: unknown): Uint8Array => {
   throw new Error("Expected a byte array value")
 }
 
-const isJsonValue = (value: unknown): boolean => {
+export const isJsonValue = (value: unknown): boolean => {
   if (value === null) {
     return true
   }
   switch (typeof value) {
     case "string":
-    case "number":
     case "boolean":
       return true
+    case "number":
+      return Number.isFinite(value)
     case "object":
       if (Array.isArray(value)) {
         return value.every(isJsonValue)
       }
-      return isRecord(value) && Object.values(value).every(isJsonValue)
+      return isPlainRecord(value) && Object.values(value).every(isJsonValue)
     default:
       return false
   }
@@ -230,11 +247,18 @@ const isJsonValue = (value: unknown): boolean => {
 
 const normalizeJson = (value: unknown): unknown => {
   if (typeof value === "string") {
-    const parsed = JSON.parse(value)
-    if (isJsonValue(parsed)) {
-      return parsed
+    try {
+      const parsed = JSON.parse(value)
+      if (isJsonValue(parsed)) {
+        return parsed
+      }
+      throw new Error("Parsed JSON value is not a valid JSON runtime")
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        return value
+      }
+      throw error
     }
-    throw new Error("Parsed JSON value is not a valid JSON runtime")
   }
   if (isJsonValue(value)) {
     return value

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,12 +38,14 @@ 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.check(Schema.isFinite())
+
 const runtimeSchemaForTag = (tag: RuntimeTag): RuntimeSchema | undefined => {
   switch (tag) {
     case "string":
       return Schema.String
     case "number":
-      return Schema.Number
+      return FiniteNumberSchema
     case "bigintString":
       return BigIntStringSchema
     case "boolean":
@@ -65,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":
@@ -112,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) {
@@ -121,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 = (
@@ -129,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": {
@@ -160,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) => {
@@ -197,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)
@@ -228,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 = (
@@ -239,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
   }
@@ -266,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
 }
 
@@ -281,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,
@@ -388,7 +380,7 @@ const deriveRuntimeSchema = (
       return Schema.String
     case "count":
     case "jsonLength":
-      return Schema.Number
+      return FiniteNumberSchema
     case "max":
     case "min":
       return expressionRuntimeSchema(ast.value, context)
@@ -404,7 +396,7 @@ const deriveRuntimeSchema = (
     case "window":
       return ast.function === "over" && ast.value !== undefined
         ? expressionRuntimeSchema(ast.value, context)
-        : Schema.Number
+        : FiniteNumberSchema
     case "jsonGet":
     case "jsonPath":
     case "jsonAccess":

package/src/internal/runtime/value.ts

@@ -19,67 +19,187 @@ 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>>
 
-export const LocalDateStringSchema = brandString(
-  /^\d{4}-\d{2}-\d{2}$/,
-  "LocalDateString"
-)
+export const localDatePattern = /^(\d{4})-(\d{2})-(\d{2})$/
 
-export const LocalTimeStringSchema = brandString(
-  /^\d{2}:\d{2}:\d{2}(?:\.\d+)?$/,
-  "LocalTimeString"
-)
+export const isValidLocalDateString = (value: string): boolean => {
+  const match = localDatePattern.exec(value)
+  if (match === null) {
+    return false
+  }
+  const year = Number(match[1])
+  const month = Number(match[2])
+  const day = Number(match[3])
+  const parsed = new Date(Date.UTC(year, month - 1, day))
+  parsed.setUTCFullYear(year)
+  return parsed.getUTCFullYear() === year &&
+    parsed.getUTCMonth() === month - 1 &&
+    parsed.getUTCDate() === day
+}
 
-export const OffsetTimeStringSchema = brandString(
-  /^\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/,
-  "OffsetTimeString"
-)
+export const localTimePattern = /^(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?$/
 
-export const LocalDateTimeStringSchema = brandString(
-  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?$/,
-  "LocalDateTimeString"
-)
+export const isValidLocalTimeString = (value: string): boolean => {
+  const match = localTimePattern.exec(value)
+  if (match === null) {
+    return false
+  }
+  const hour = Number(match[1])
+  const minute = Number(match[2])
+  const second = Number(match[3])
+  return hour >= 0 && hour <= 23 &&
+    minute >= 0 && minute <= 59 &&
+    second >= 0 && second <= 59
+}
 
-export const InstantStringSchema = brandString(
-  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/,
-  "InstantString"
-)
+const offsetPattern = /^(?:Z|[+-](\d{2}):(\d{2}))$/
+
+const isValidOffset = (value: string): boolean => {
+  const match = offsetPattern.exec(value)
+  if (match === null) {
+    return false
+  }
+  if (value === "Z") {
+    return true
+  }
+  const hour = Number(match[1])
+  const minute = Number(match[2])
+  return hour >= 0 && hour <= 23 &&
+    minute >= 0 && minute <= 59
+}
+
+export const offsetTimePattern = /^(\d{2}:\d{2}:\d{2}(?:\.\d+)?)(Z|[+-]\d{2}:\d{2})$/
+
+export const isValidOffsetTimeString = (value: string): boolean => {
+  const match = offsetTimePattern.exec(value)
+  return match !== null &&
+    isValidLocalTimeString(match[1]!) &&
+    isValidOffset(match[2]!)
+}
+
+export const localDateTimePattern = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}(?:\.\d+)?)$/
+
+export const isValidLocalDateTimeString = (value: string): boolean => {
+  const match = localDateTimePattern.exec(value)
+  return match !== null &&
+    isValidLocalDateString(match[1]!) &&
+    isValidLocalTimeString(match[2]!)
+}
+
+export const instantPattern = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}(?:\.\d+)?)(Z|[+-]\d{2}:\d{2})$/
+
+export const isValidInstantString = (value: string): boolean => {
+  const match = instantPattern.exec(value)
+  return match !== null &&
+    isValidLocalDateString(match[1]!) &&
+    isValidLocalTimeString(match[2]!) &&
+    isValidOffset(match[3]!)
+}
+
+export const LocalDateStringSchema = Schema.String.pipe(
+  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.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.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.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.check(Schema.isPattern(instantPattern)),
+  Schema.check(Schema.makeFilter((value) => isValidInstantString(value))),
+  Schema.brand("InstantString")
+) as unknown as Schema.Schema<InstantString>
 
 export const YearStringSchema = brandString(
   /^\d{4}$/,
   "YearString"
 )
 
-export const BigIntStringSchema = brandString(
-  /^-?\d+$/,
-  "BigIntString"
-)
+export const canonicalizeBigIntString = (input: string): string => {
+  const trimmed = input.trim()
+  if (!/^-?\d+$/.test(trimmed)) {
+    throw new Error("Expected an integer-like bigint value")
+  }
+  return BigInt(trimmed).toString()
+}
 
-export const DecimalStringSchema = brandString(
-  /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/,
-  "DecimalString"
-)
+export const isCanonicalBigIntString = (value: string): boolean => {
+  try {
+    return canonicalizeBigIntString(value) === value
+  } catch {
+    return false
+  }
+}
+
+export const canonicalizeDecimalString = (input: string): string => {
+  const trimmed = input.trim()
+  const match = /^([+-]?)(\d+)(?:\.(\d+))?$/.exec(trimmed)
+  if (match === null) {
+    throw new Error("Expected a decimal string")
+  }
+  const sign = match[1] === "-" ? "-" : ""
+  const integer = match[2]!.replace(/^0+(?=\d)/, "") || "0"
+  const fraction = (match[3] ?? "").replace(/0+$/, "")
+  if (fraction.length === 0) {
+    if (integer === "0") {
+      return "0"
+    }
+    return `${sign}${integer}`
+  }
+  return `${sign}${integer}.${fraction}`
+}
+
+export const isCanonicalDecimalString = (value: string): boolean => {
+  try {
+    return canonicalizeDecimalString(value) === value
+  } catch {
+    return false
+  }
+}
+
+export const BigIntStringSchema = Schema.String.pipe(
+  Schema.check(Schema.makeFilter((value) => isCanonicalBigIntString(value))),
+  Schema.brand("BigIntString")
+) as unknown as Schema.Schema<BigIntString>
+
+export const DecimalStringSchema = Schema.String.pipe(
+  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,
+    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,
+  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