effect-qb 0.19.0 → 0.20.0

package/src/sqlite/column.ts

@@ -18,7 +18,7 @@ import {
 import { sqliteDatatypes } from "./datatypes/index.js"
 
 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>>, {
@@ -43,11 +43,11 @@ const renderNumericDdlType = (
     : `${kind}(${options.precision},${options.scale})`
 }
 
-export const custom = <SchemaType extends Schema.Schema.Any, Db extends Expression.DbType.Any>(
+export const custom = <SchemaType extends Schema.Top, Db extends Expression.DbType.Any>(
   schema: SchemaType,
   dbType: Db
 ) =>
-  makeColumnDefinition(schema as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>>, {
     dbType: enrichDbType(sqliteDatatypes, dbType),
     nullable: false,
     hasDefault: false,
@@ -59,7 +59,7 @@ export const custom = <SchemaType extends Schema.Schema.Any, Db extends Expressi
     identity: undefined
   })
 
-export const uuid = () => primitive(Schema.UUID, sqliteDatatypes.uuid())
+export const uuid = () => primitive(Schema.String.check(Schema.isUUID()), sqliteDatatypes.uuid())
 export const text = () => primitive(Schema.String, sqliteDatatypes.text())
 export const int = () => primitive(Schema.Int, sqliteDatatypes.int())
 export const number = (options?: BaseColumn.NumericOptions) =>
@@ -79,8 +79,8 @@ export const date = () => primitive(LocalDateStringSchema, sqliteDatatypes.date(
 export const time = () => primitive(LocalTimeStringSchema, sqliteDatatypes.time())
 export const datetime = () => primitive(LocalDateTimeStringSchema, sqliteDatatypes.datetime())
 export const timestamp = () => primitive(LocalDateTimeStringSchema, sqliteDatatypes.timestamp())
-export const json = <SchemaType extends Schema.Schema.Any>(schema: SchemaType) =>
-  makeColumnDefinition(schema as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
+export const json = <SchemaType extends Schema.Top>(schema: SchemaType) =>
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>>, {
     dbType: { ...sqliteDatatypes.json(), variant: "json" } as Expression.DbType.Json<"sqlite", "json">,
     nullable: false,
     hasDefault: false,

package/src/sqlite/datatypes/index.ts

@@ -15,6 +15,7 @@ const withMetadata = <Kind extends keyof typeof sqliteDatatypeKinds & string>(
     runtime: kindSpec.runtime,
     compareGroup: familySpec?.compareGroup,
     castTargets: familySpec?.castTargets,
+    implicitTargets: (familySpec as { readonly implicitTargets?: readonly string[] }).implicitTargets,
     traits: familySpec?.traits
   }
 }

package/src/sqlite/datatypes/spec.ts

@@ -1,98 +1,10 @@
-import type { DatatypeFamilySpec, DatatypeKindSpec } from "../../internal/datatypes/shape.js"
+import {
+  sqliteDatatypeFamilies as matrixSqliteDatatypeFamilies,
+  sqliteDatatypeKinds as matrixSqliteDatatypeKinds
+} from "../../internal/datatypes/matrix.js"
 
-export const sqliteDatatypeFamilies = {
-  text: {
-    compareGroup: "text",
-    castTargets: ["text", "numeric", "integer", "real", "boolean", "date", "time", "datetime", "json", "blob", "null"],
-    traits: {
-      textual: true,
-      ordered: true
-    }
-  },
-  numeric: {
-    compareGroup: "numeric",
-    castTargets: ["numeric", "integer", "real", "text", "boolean", "date", "time", "datetime"],
-    traits: {
-      ordered: true
-    }
-  },
-  integer: {
-    compareGroup: "numeric",
-    castTargets: ["integer", "numeric", "real", "text", "boolean", "date", "time", "datetime"],
-    traits: {
-      ordered: true
-    }
-  },
-  real: {
-    compareGroup: "numeric",
-    castTargets: ["real", "numeric", "integer", "text", "boolean"],
-    traits: {
-      ordered: true
-    }
-  },
-  boolean: {
-    compareGroup: "boolean",
-    castTargets: ["boolean", "integer", "numeric", "text"],
-    traits: {}
-  },
-  date: {
-    compareGroup: "date",
-    castTargets: ["date", "time", "datetime", "text", "numeric", "integer"],
-    traits: {
-      ordered: true
-    }
-  },
-  time: {
-    compareGroup: "time",
-    castTargets: ["time", "date", "datetime", "text", "numeric", "integer"],
-    traits: {
-      ordered: true
-    }
-  },
-  datetime: {
-    compareGroup: "datetime",
-    castTargets: ["datetime", "date", "time", "text", "numeric", "integer"],
-    traits: {
-      ordered: true
-    }
-  },
-  json: {
-    compareGroup: "json",
-    castTargets: ["json", "text"],
-    traits: {}
-  },
-  blob: {
-    compareGroup: "blob",
-    castTargets: ["blob", "text"],
-    traits: {}
-  },
-  null: {
-    compareGroup: "null",
-    castTargets: ["text", "numeric", "integer", "real", "boolean", "date", "time", "datetime", "json", "blob", "null"],
-    traits: {}
-  }
-} as const satisfies Record<string, DatatypeFamilySpec>
-
-export const sqliteDatatypeKinds = {
-  text: { family: "text", runtime: "string" },
-  varchar: { family: "text", runtime: "string" },
-  char: { family: "text", runtime: "string" },
-  clob: { family: "text", runtime: "string" },
-  int: { family: "integer", runtime: "number" },
-  integer: { family: "integer", runtime: "number" },
-  bigint: { family: "integer", runtime: "bigintString" },
-  numeric: { family: "numeric", runtime: "decimalString" },
-  decimal: { family: "numeric", runtime: "decimalString" },
-  real: { family: "real", runtime: "number" },
-  double: { family: "real", runtime: "number" },
-  boolean: { family: "boolean", runtime: "boolean" },
-  date: { family: "date", runtime: "localDate" },
-  time: { family: "time", runtime: "localTime" },
-  datetime: { family: "datetime", runtime: "localDateTime" },
-  timestamp: { family: "datetime", runtime: "localDateTime" },
-  json: { family: "json", runtime: "json" },
-  blob: { family: "blob", runtime: "bytes" }
-} as const satisfies Record<string, DatatypeKindSpec>
+export const sqliteDatatypeFamilies = matrixSqliteDatatypeFamilies
+export const sqliteDatatypeKinds = matrixSqliteDatatypeKinds
 
 export type SqliteDatatypeFamily = keyof typeof sqliteDatatypeFamilies
 export type SqliteDatatypeKind = keyof typeof sqliteDatatypeKinds

package/src/sqlite/errors/normalize.ts

@@ -25,7 +25,6 @@ const unwrapSqliteDriverCause = (cause: unknown): unknown => {
   while (
     isRecord(current) &&
     "_tag" in current &&
-    current._tag === "SqlError" &&
     "cause" in current
   ) {
     current = current.cause

package/src/sqlite/executor.ts

@@ -1,5 +1,5 @@
 import * as Effect from "effect/Effect"
-import * as SqlClient from "@effect/sql/SqlClient"
+import * as SqlClient from "effect/unstable/sql/SqlClient"
 import * as Stream from "effect/Stream"
 
 import * as CoreExecutor from "../internal/executor.js"
@@ -41,8 +41,6 @@ export type SqliteQueryError<PlanValue extends CoreQuery.QueryPlan<any, any, any
 
 /** Runs an effect within the ambient SQLite SQL transaction service. */
 export const withTransaction = CoreExecutor.withTransaction
-/** Runs an effect in a nested SQLite SQL transaction scope. */
-export const withSavepoint = CoreExecutor.withSavepoint
 
 /** SQLite executor whose error channel narrows based on the query plan. */
 export interface QueryExecutor<Context = never> {
@@ -142,10 +140,10 @@ const fromDriver = <
   stream(plan) {
     const rendered = renderer.render(plan)
     return Stream.mapError(
-      Stream.mapChunksEffect(
+      Stream.mapArrayEffect(
         sqlDriver.stream(rendered),
         (rows) => Effect.try({
-          try: () => CoreExecutor.decodeChunk(rendered, plan, rows, { driverMode, valueMappings }),
+          try: () => CoreExecutor.decodeRows(rendered, plan, rows, { driverMode, valueMappings }) as never,
           catch: (error) => error as RowDecodeError
         })
       ),
@@ -181,7 +179,7 @@ const sqlClientDriver = (): Driver<any, SqlClient.SqlClient> =>
  * Creates the standard SQLite executor pipeline.
  *
  * By default this uses the built-in SQLite renderer plus the ambient
- * `@effect/sql` `SqlClient`. Advanced callers can override the renderer,
+ * `effect/unstable/sql` `SqlClient`. Advanced callers can override the renderer,
  * driver, or both.
  */
 export function make(): QueryExecutor<SqlClient.SqlClient>

package/src/sqlite/function/temporal.ts

@@ -35,7 +35,7 @@ const makeTemporal = <
 >(
   name: Name,
   dbType: Db,
-  runtimeSchema: Schema.Schema<Runtime, any, any>
+  runtimeSchema: Schema.Schema<Runtime>
 ): TemporalExpression<Runtime, Db, Name> =>
   makeExpression({
     runtime: undefined as unknown as Runtime,

package/src/sqlite/internal/dsl.ts

@@ -1590,11 +1590,14 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
 
   const literalSchemaOf = <Value extends LiteralValue>(
     value: Value
-  ): Schema.Schema.Any | undefined => {
+  ): Schema.Top | undefined => {
     if (value === null || value instanceof Date) {
       return undefined
     }
-    return Schema.Literal(value) as Schema.Schema.Any
+    if (typeof value === "number" && !Number.isFinite(value)) {
+      return undefined
+    }
+    return Schema.Literal(value) as unknown as Schema.Top
   }
 
   const literal = <const Value extends LiteralValue>(
@@ -4521,6 +4524,83 @@ type ValidateTargetColumnInput<
   Columns extends DdlColumnInput
 > = ValidateTargetColumns<Target, NormalizeDdlColumns<Columns>> extends never ? never : Columns
 
+type SameColumnSet<
+  Left extends readonly string[],
+  Right extends readonly string[]
+> = string extends Left[number] | Right[number]
+  ? false
+  : Exclude<Left[number], Right[number]> extends never
+    ? Exclude<Right[number], Left[number]> extends never
+      ? true
+      : false
+    : false
+
+type ConflictArbitersOf<Target extends MutationTargetLike> =
+  Target[typeof Table.TypeId]["conflictArbiters"][number]
+
+type MatchingConflictArbiter<
+  Target extends MutationTargetLike,
+  Columns extends readonly string[],
+  AllowPartial extends boolean
+> = ConflictArbitersOf<Target> extends infer Arbiter extends Table.ConflictArbiter
+  ? Arbiter extends Table.ConflictArbiter
+    ? SameColumnSet<Arbiter["columns"], Columns> extends true
+      ? Arbiter["scope"] extends "unconditional"
+        ? true
+        : AllowPartial extends true ? true : never
+      : never
+    : never
+  : never
+
+type HasInlineConflictArbiter<
+  Target extends MutationTargetLike,
+  Columns extends readonly string[]
+> = Columns extends readonly [infer Column extends Extract<keyof Target[typeof Table.TypeId]["fields"], string>]
+  ? Target[typeof Table.TypeId]["fields"][Column] extends { readonly metadata: { readonly primaryKey: true } | { readonly unique: true } }
+    ? true
+    : false
+  : false
+
+type HasConflictArbiter<
+  Target extends MutationTargetLike,
+  Columns extends readonly string[],
+  AllowPartial extends boolean
+> = string extends Extract<keyof Target[typeof Table.TypeId]["fields"], string>
+  ? true
+  : HasInlineConflictArbiter<Target, Columns> extends true
+    ? true
+  : true extends MatchingConflictArbiter<Target, Columns, AllowPartial> ? true : false
+
+type ConflictTargetArbiterError<
+  Columns,
+  AllowPartial extends boolean
+> = {
+  readonly __effect_qb_error__: "effect-qb: conflict target columns must match a primary key, unique constraint, or unique index"
+  readonly __effect_qb_conflict_columns__: Columns
+  readonly __effect_qb_partial_target__: AllowPartial
+  readonly __effect_qb_hint__: "Declare the target columns as primaryKey/unique, add a table-level Unique.make(...), or use a simple Pg.Index.uniqueIndex(...)"
+}
+
+type ValidateConflictColumnInput<
+  Target extends MutationTargetLike,
+  Columns extends DdlColumnInput,
+  AllowPartial extends boolean
+> = ValidateTargetColumnInput<Target, Columns> extends never
+  ? never
+  : HasConflictArbiter<Target, NormalizeDdlColumns<Columns>, AllowPartial> extends true
+    ? Columns
+    : ConflictTargetArbiterError<NormalizeDdlColumns<Columns>, AllowPartial>
+
+type ConflictColumnPlanConstraint<
+  Target extends MutationTargetLike,
+  Columns extends DdlColumnInput,
+  AllowPartial extends boolean
+> = ValidateTargetColumnInput<Target, Columns> extends never
+  ? never
+  : HasConflictArbiter<Target, NormalizeDdlColumns<Columns>, AllowPartial> extends true
+    ? unknown
+    : ConflictTargetArbiterError<NormalizeDdlColumns<Columns>, AllowPartial>
+
 type CreateIndexOptions<Name extends string = string> = {
   readonly name?: NonEmptyStringInput<Name>
   readonly unique?: boolean
@@ -5022,6 +5102,21 @@ type ConflictConstraintNameConstraint<Target> =
     ? { readonly constraint: NonEmptyStringInput<Constraint> }
     : unknown
 
+type ConflictTargetHasPredicate<Target> =
+  Target extends { readonly where: PredicateInput } ? true : false
+
+type ConflictTargetPlanConstraint<
+  Target extends MutationTargetLike,
+  ConflictTarget
+> =
+  ConflictTarget extends { readonly constraint: string }
+    ? unknown
+    : ConflictTarget extends { readonly columns: infer Columns extends DdlColumnInput }
+      ? ConflictColumnPlanConstraint<Target, Columns, ConflictTargetHasPredicate<ConflictTarget>>
+      : ConflictTarget extends DdlColumnInput
+        ? ConflictColumnPlanConstraint<Target, ConflictTarget, false>
+        : unknown
+
 type ConflictActionInput<
   Target extends MutationTargetLike,
   Dialect extends string,
@@ -6315,9 +6410,9 @@ type AsCurriedResult<
   >(
     target: ConflictTarget & ConflictConstraintNameConstraint<ConflictTarget>,
     options?: Options & ConflictActionUpdateNonEmptyConstraint<Options>
-  ) =>
+	  ) =>
     <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
-      plan: PlanValue & RequireInsertStatement<PlanValue>
+      plan: PlanValue & RequireInsertStatement<PlanValue> & ConflictTargetPlanConstraint<MutationTargetOfPlan<PlanValue>, ConflictTarget>
     ) => QueryPlan<
       SelectionOfPlan<PlanValue>,
       Exclude<RequiredOfPlan<PlanValue> | ConflictRequired<UpdateValues, Options, ConflictTarget>, AvailableNames<AvailableOfPlan<PlanValue>>>,
@@ -6381,7 +6476,7 @@ type AsCurriedResult<
   >(
     target: Target,
     values: Values & MutationValuesDialectConstraint<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-    conflictColumns: ValidateTargetColumnInput<Target, Columns>,
+    conflictColumns: ValidateConflictColumnInput<Target, Columns, false>,
     updateValues?: UpdateValues & UpdateValuesNonEmptyConstraint<Exclude<UpdateValues, undefined>> & MutationValuesDialectConstraint<Exclude<UpdateValues, undefined>, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
   ) => QueryPlan<
     {},

package/src/sqlite/json.ts

@@ -1,39 +1,8 @@
-/** SQLite JSON expression helpers. */
-export { json } from "./internal/dsl.js"
+/** SQLite-specific JSON expression helpers. Portable JSON helpers are exported from `effect-qb`. */
 import { json } from "./internal/dsl.js"
 
-export const key = json.key
-export const index = json.index
-export const wildcard = json.wildcard
-export const slice = json.slice
-export const descend = json.descend
-export const path = json.path
-export const get = json.get
-export const access = json.access
-export const traverse = json.traverse
-export const text = json.text
-export const accessText = json.accessText
-export const traverseText = json.traverseText
-export const contains = json.contains
-export const containedBy = json.containedBy
-export const hasKey = json.hasKey
-export const keyExists = json.keyExists
-export const hasAnyKeys = json.hasAnyKeys
-export const hasAllKeys = json.hasAllKeys
-export const delete_ = json.delete
-export { delete_ as delete }
-export const remove = json.remove
-export const set = json.set
 export const insert = json.insert
-export const concat = json.concat
-export const merge = json.merge
-export const buildObject = json.buildObject
-export const buildArray = json.buildArray
-export const toJson = json.toJson
-export const toJsonb = json.toJsonb
 export const typeOf = json.typeOf
 export const length = json.length
-export const keys = json.keys
 export const stripNulls = json.stripNulls
-export const pathExists = json.pathExists
 export const pathMatch = json.pathMatch

package/src/sqlite/renderer.ts

@@ -20,6 +20,9 @@ export type ValueMappings = Expression.DriverValueMappingsFor<SqliteDatatypeKind
 
 export interface MakeOptions {
   readonly valueMappings?: ValueMappings
+}
+
+interface RendererState extends MakeOptions {
   readonly casing?: Casing.Options
 }
 
@@ -33,19 +36,23 @@ const RendererProto = {
 }
 
 /** Creates the built-in SQLite renderer. */
-export const make = (options: MakeOptions = {}): Renderer => {
-  const renderer = CoreRenderer.makeTrusted("sqlite", (plan) => renderSqlitePlan(plan, options))
+const makeWithState = (state: RendererState = {}): Renderer => {
+  const renderer = CoreRenderer.makeTrusted("sqlite", (plan) => renderSqlitePlan(plan, state))
   return Object.assign(Object.create(RendererProto), renderer, {
     [Casing.TypeId]: {
-      casing: options.casing
+      casing: state.casing
     },
     withCasing: (override: Casing.Options) =>
-      make({
-        ...options,
-        casing: Casing.merge(options.casing, override)
+      makeWithState({
+        ...state,
+        casing: Casing.merge(state.casing, override)
       })
   }) as Renderer
 }
 
+/** Creates the built-in SQLite renderer. */
+export const make = (options: MakeOptions = {}): Renderer =>
+  makeWithState({ valueMappings: options.valueMappings })
+
 /** Shared built-in SQLite renderer instance. */
 export const sqlite = make()

package/src/sqlite/type.ts

@@ -0,0 +1,40 @@
+import type * as Expression from "../internal/scalar.js"
+import type { NonEmptyStringInput } from "../internal/table-options.js"
+import {
+  pickDatatypeConstructors,
+  sqliteSpecificDatatypeKeys,
+  type SqliteSpecificDatatypeKey
+} from "../internal/datatypes/matrix.js"
+import { sqliteDatatypes } from "./datatypes/index.js"
+
+type SqliteSpecificDatatypes = Pick<typeof sqliteDatatypes, SqliteSpecificDatatypeKey>
+
+type SqliteTypeNamespace = SqliteSpecificDatatypes & {
+  readonly custom: <Kind extends string>(kind: NonEmptyStringInput<Kind>) => Expression.DbType.Base<"sqlite", Kind>
+  readonly driverValueMapping: <Db extends Expression.DbType.Any>(
+    dbType: Db,
+    mapping: Expression.DriverValueMapping
+  ) => Db
+}
+
+const custom = <Kind extends string>(
+  kind: NonEmptyStringInput<Kind>
+): Expression.DbType.Base<"sqlite", Kind> => ({
+  dialect: "sqlite",
+  kind: kind as Kind
+})
+
+const driverValueMapping = <Db extends Expression.DbType.Any>(
+  dbType: Db,
+  mapping: Expression.DriverValueMapping
+): Db => ({
+  ...dbType,
+  driverValueMapping: mapping
+})
+
+/** SQLite-only database-type constructors for casts and typed column references. */
+export const type: SqliteTypeNamespace = {
+  ...pickDatatypeConstructors(sqliteDatatypes, sqliteSpecificDatatypeKeys),
+  custom,
+  driverValueMapping
+}

package/src/sqlite.ts

@@ -4,11 +4,13 @@ export * as Column from "./sqlite/column-extension.js"
 export * as Datatypes from "./sqlite/datatypes/index.js"
 /** SQLite error catalog and error normalization helpers. */
 export * as Errors from "./sqlite/errors/index.js"
-/** SQLite-specialized JSON expression helpers. */
+/** SQLite-specific JSON expression helpers. Portable JSON helpers are exported from the root package. */
 export * as Json from "./sqlite/json.js"
 /** SQLite-specialized typed query execution contracts. */
 export * as Executor from "./sqlite/executor.js"
 /** SQLite-specific query helpers. Portable queries are exported from the root package. */
 export * as Query from "./sqlite/query-extension.js"
+/** SQLite-only database-type constructors for casts and typed references. */
+export { type as Type } from "./sqlite/type.js"
 /** SQLite-specialized built-in renderer entrypoint. */
 export * as Renderer from "./sqlite/renderer.js"

package/src/standard/cast.ts

@@ -0,0 +1,113 @@
+import type * as ExpressionAst from "../internal/expression-ast.js"
+import type { CastTargetError } from "../internal/coercion/errors.js"
+import type { RuntimeOfDbType } from "../internal/coercion/analysis.js"
+import type { CanCastDbType } from "../internal/coercion/rules.js"
+import type { FamilyOfDbType } from "../internal/datatypes/lookup.js"
+import type { ExpressionInput } from "../internal/query.js"
+import type * as Expression from "../internal/scalar.js"
+import { cast as standardCast } from "../internal/standard-dsl.js"
+import type { standardDatatypes } from "./datatypes/index.js"
+import type { standardDatatypeFamilies } from "./datatypes/spec.js"
+
+type CastInput = ExpressionInput
+type CastTarget = Expression.DbType.Any
+type IsAny<Value> = 0 extends (1 & Value) ? true : false
+
+type StandardNullDb = Expression.DbType.Base<"standard", "null"> & {
+  readonly family: "null"
+  readonly runtime: "unknown"
+  readonly compareGroup: "null"
+  readonly castTargets: typeof standardDatatypeFamilies.null.castTargets
+  readonly traits: {}
+}
+
+type LiteralDbType<Value> =
+  Value extends string ? ReturnType<typeof standardDatatypes.text> :
+    Value extends number ? ReturnType<typeof standardDatatypes.real> :
+      Value extends boolean ? ReturnType<typeof standardDatatypes.boolean> :
+        Value extends Date ? ReturnType<typeof standardDatatypes.timestamp> :
+          StandardNullDb
+
+type CastSourceDbType<Value extends CastInput> = Value extends Expression.Any
+  ? Expression.DbTypeOf<Value>
+  : LiteralDbType<Value>
+
+type CastDialect<Value extends CastInput, Target extends CastTarget> =
+  CastSourceDbType<Value>["dialect"] | Target["dialect"]
+
+type CastNullability<Value extends CastInput> = Value extends Expression.Any
+  ? Expression.NullabilityOf<Value>
+  : Value extends null ? "always" : "never"
+
+type CastKind<Value extends CastInput> = Value extends Expression.Any
+  ? Expression.KindOf<Value>
+  : "scalar"
+
+type CastDependencies<Value extends CastInput> = Value extends Expression.Any
+  ? Expression.DependenciesOf<Value>
+  : never
+
+type JsonbScalarCastTarget<Value extends CastInput, Target extends CastTarget> =
+  Value extends Expression.Any
+    ? Expression.DbTypeOf<Value> extends Expression.DbType.Json<"postgres", "jsonb">
+      ? [Expression.RuntimeOf<Value>] extends [number]
+        ? FamilyOfDbType<Target> extends "numeric" ? Target : never
+        : [Expression.RuntimeOf<Value>] extends [boolean]
+          ? FamilyOfDbType<Target> extends "boolean" ? Target : never
+          : never
+      : never
+    : never
+
+type CanCastJsonbScalar<Value extends CastInput, Target extends CastTarget> =
+  [JsonbScalarCastTarget<Value, Target>] extends [never]
+    ? false
+    : JsonbScalarCastTarget<Value, Target> extends Target
+      ? true
+      : false
+
+type CastTargetInput<Value extends CastInput, Target extends CastTarget> =
+  IsAny<Value> extends true
+    ? Target
+    : IsAny<Target> extends true
+      ? Target
+      : CanCastDbType<CastSourceDbType<Value>, Target, CastDialect<Value, Target>> extends true
+        ? Target
+        : CanCastJsonbScalar<Value, Target> extends true
+          ? Target
+        : CastTargetError<CastSourceDbType<Value>, Target, CastDialect<Value, Target>>
+
+type CastValueInput<Value extends CastInput, Target extends CastTarget> =
+  CastTargetInput<Value, Target> extends Target
+    ? Value
+    : CastTargetInput<Value, Target>
+
+type CastExpression<
+  Value extends CastInput,
+  Target extends CastTarget
+> = Expression.Scalar<
+  RuntimeOfDbType<Target>,
+  Target,
+  CastNullability<Value>,
+  CastDialect<Value, Target>,
+  CastKind<Value>,
+  CastDependencies<Value>
+> & {
+  readonly [ExpressionAst.TypeId]: ExpressionAst.CastNode<Value extends Expression.Any ? Value : Expression.Any, Target>
+}
+
+export const to: {
+  <Value extends CastInput, Target extends CastTarget>(
+    value: Value,
+    target: Target & CastTargetInput<Value, Target>
+  ): CastExpression<Value, Target>
+  // `NoInfer` keeps `Value` out of its own inference constraint: it is inferred
+  // from the argument, then validated against the already-fixed `Target`.
+  // Without it, the validation forms an inference fixpoint that explodes under
+  // higher-order inference (e.g. `.pipe`).
+  <Target extends CastTarget>(
+    target: Target
+  ): <Value extends CastInput>(value: Value & CastValueInput<NoInfer<Value>, Target>) => CastExpression<Value, Target>
+} = ((...args: [CastInput, CastTarget] | [CastTarget]) =>
+  args.length === 1
+    ? ((value: CastInput) => standardCast(value as never, args[0] as never))
+    : standardCast(args[0] as never, args[1] as never)) as unknown as typeof to

package/src/standard/check.ts

@@ -0,0 +1,17 @@
+import * as BaseTable from "../internal/table.js"
+import type { TableOptionSpec } from "../internal/table-options.js"
+
+type CheckSpec = Extract<TableOptionSpec, { readonly kind: "check" }>
+
+export const make = BaseTable.check
+
+export const named = <const Name extends string>(
+  name: BaseTable.NonEmptyStringInput<Name>
+) =>
+  <Spec extends CheckSpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+    option: BaseTable.TableOption<Spec, TableContext>
+  ): BaseTable.TableOption<Spec & { readonly name: Name }, TableContext> =>
+    BaseTable.mapOption(option, (spec) => ({
+      ...spec,
+      name
+    } as Spec & { readonly name: Name }))