effect-qb 0.19.0 → 4.0.0-beta.92

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
   }
@@ -161,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

package/src/internal/schema-derivation.d.ts

@@ -34,11 +34,11 @@ export type InsertRow<TableName extends string, Fields extends TableFieldMap> =
 export type UpdateRow<TableName extends string, Fields extends TableFieldMap, PrimaryKey extends keyof Fields> = Simplify<Partial<{
     [K in UpdateKeys<Fields, PrimaryKey>]: BrandedUpdateType<Fields[K], TableName, Extract<K, string>>;
 }>>;
-type SchemaOfVariant<Variant extends TableSchemaVariant, TableName extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string> = Variant extends "select" ? Schema.Schema<SelectRow<TableName, Fields>> : Variant extends "insert" ? Schema.Schema<InsertRow<TableName, Fields>> : Schema.Schema<UpdateRow<TableName, Fields, PrimaryKeyColumns>>;
+type SchemaOfVariant<Variant extends TableSchemaVariant, TableName extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string> = Variant extends "select" ? Schema.ConstraintDecoder<SelectRow<TableName, Fields>, never> : Variant extends "insert" ? Schema.ConstraintDecoder<InsertRow<TableName, Fields>, never> : Schema.ConstraintDecoder<UpdateRow<TableName, Fields, PrimaryKeyColumns>, never>;
 export declare const deriveSchema: <Variant extends TableSchemaVariant, TableName extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(variant: Variant, tableName: TableName, fields: Fields, primaryKeyColumns: readonly PrimaryKeyColumns[]) => SchemaOfVariant<Variant, TableName, Fields, PrimaryKeyColumns>;
-export declare const deriveSelectSchema: <TableName extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(tableName: TableName, fields: Fields, primaryKeyColumns: readonly PrimaryKeyColumns[]) => Schema.Schema<SelectRow<TableName, Fields>>;
-export declare const deriveInsertSchema: <TableName extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(tableName: TableName, fields: Fields, primaryKeyColumns: readonly PrimaryKeyColumns[]) => Schema.Schema<InsertRow<TableName, Fields>>;
-export declare const deriveUpdateSchema: <TableName extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(tableName: TableName, fields: Fields, primaryKeyColumns: readonly PrimaryKeyColumns[]) => Schema.Schema<UpdateRow<TableName, Fields, PrimaryKeyColumns>>;
+export declare const deriveSelectSchema: <TableName extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(tableName: TableName, fields: Fields, primaryKeyColumns: readonly PrimaryKeyColumns[]) => Schema.ConstraintDecoder<SelectRow<TableName, Fields>, never>;
+export declare const deriveInsertSchema: <TableName extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(tableName: TableName, fields: Fields, primaryKeyColumns: readonly PrimaryKeyColumns[]) => Schema.ConstraintDecoder<InsertRow<TableName, Fields>, never>;
+export declare const deriveUpdateSchema: <TableName extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(tableName: TableName, fields: Fields, primaryKeyColumns: readonly PrimaryKeyColumns[]) => Schema.ConstraintDecoder<UpdateRow<TableName, Fields, PrimaryKeyColumns>, never>;
 /**
  * Derives the `select`, `insert`, and `update` schemas for a table.
  *
@@ -49,8 +49,8 @@ export declare const deriveUpdateSchema: <TableName extends string, Fields exten
  * `deriveUpdateSchema` so individual variants are derived lazily.
  */
 export declare const deriveSchemas: <TableName extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(tableName: TableName, fields: Fields, primaryKeyColumns: readonly PrimaryKeyColumns[]) => {
-    readonly select: Schema.Schema<SelectRow<TableName, Fields>>;
-    readonly insert: Schema.Schema<InsertRow<TableName, Fields>>;
-    readonly update: Schema.Schema<UpdateRow<TableName, Fields, PrimaryKeyColumns>>;
+    readonly select: Schema.ConstraintDecoder<SelectRow<TableName, Fields>, never>;
+    readonly insert: Schema.ConstraintDecoder<InsertRow<TableName, Fields>, never>;
+    readonly update: Schema.ConstraintDecoder<UpdateRow<TableName, Fields, PrimaryKeyColumns>, never>;
 };
 export {};

package/src/internal/schema-derivation.ts

@@ -105,7 +105,7 @@ const maybeBrandSchema = (
   column: AnyColumnDefinition,
   tableName: string,
   columnName: string
-): Schema.Schema.Any =>
+): Schema.Top =>
   column.metadata.brand === true
     ? Schema.brand(`${tableName}.${columnName}`)(column.schema)
     : column.schema
@@ -114,7 +114,7 @@ const selectSchema = (
   column: AnyColumnDefinition,
   tableName: string,
   columnName: string
-): Schema.Schema.Any =>
+): Schema.Top =>
   column.metadata.nullable ? Schema.NullOr(maybeBrandSchema(column, tableName, columnName)) : maybeBrandSchema(column, tableName, columnName)
 
 const insertSchema = (
@@ -151,9 +151,9 @@ type SchemaOfVariant<
   TableName extends string,
   Fields extends TableFieldMap,
   PrimaryKeyColumns extends keyof Fields & string
-> = Variant extends "select" ? Schema.Schema<SelectRow<TableName, Fields>>
-  : Variant extends "insert" ? Schema.Schema<InsertRow<TableName, Fields>>
-  : Schema.Schema<UpdateRow<TableName, Fields, PrimaryKeyColumns>>
+> = Variant extends "select" ? Schema.ConstraintDecoder<SelectRow<TableName, Fields>, never>
+  : Variant extends "insert" ? Schema.ConstraintDecoder<InsertRow<TableName, Fields>, never>
+  : Schema.ConstraintDecoder<UpdateRow<TableName, Fields, PrimaryKeyColumns>, never>
 
 const fieldSchemaForVariant = (
   variant: TableSchemaVariant,
@@ -202,7 +202,7 @@ export const deriveSelectSchema = <
   tableName: TableName,
   fields: Fields,
   primaryKeyColumns: readonly PrimaryKeyColumns[]
-): Schema.Schema<SelectRow<TableName, Fields>> =>
+): Schema.ConstraintDecoder<SelectRow<TableName, Fields>, never> =>
   deriveSchema("select", tableName, fields, primaryKeyColumns)
 
 export const deriveInsertSchema = <
@@ -213,7 +213,7 @@ export const deriveInsertSchema = <
   tableName: TableName,
   fields: Fields,
   primaryKeyColumns: readonly PrimaryKeyColumns[]
-): Schema.Schema<InsertRow<TableName, Fields>> =>
+): Schema.ConstraintDecoder<InsertRow<TableName, Fields>, never> =>
   deriveSchema("insert", tableName, fields, primaryKeyColumns)
 
 export const deriveUpdateSchema = <
@@ -224,7 +224,7 @@ export const deriveUpdateSchema = <
   tableName: TableName,
   fields: Fields,
   primaryKeyColumns: readonly PrimaryKeyColumns[]
-): Schema.Schema<UpdateRow<TableName, Fields, PrimaryKeyColumns>> =>
+): Schema.ConstraintDecoder<UpdateRow<TableName, Fields, PrimaryKeyColumns>, never> =>
   deriveSchema("update", tableName, fields, primaryKeyColumns)
 
 /**
@@ -245,9 +245,9 @@ export const deriveSchemas = <
   fields: Fields,
   primaryKeyColumns: readonly PrimaryKeyColumns[]
 ): {
-  readonly select: Schema.Schema<SelectRow<TableName, Fields>>
-  readonly insert: Schema.Schema<InsertRow<TableName, Fields>>
-  readonly update: Schema.Schema<UpdateRow<TableName, Fields, PrimaryKeyColumns>>
+  readonly select: Schema.ConstraintDecoder<SelectRow<TableName, Fields>, never>
+  readonly insert: Schema.ConstraintDecoder<InsertRow<TableName, Fields>, never>
+  readonly update: Schema.ConstraintDecoder<UpdateRow<TableName, Fields, PrimaryKeyColumns>, never>
 } => ({
   select: deriveSelectSchema(tableName, fields, primaryKeyColumns),
   insert: deriveInsertSchema(tableName, fields, primaryKeyColumns),

package/src/internal/standard-dsl.ts

@@ -114,6 +114,7 @@ import * as ExpressionAst from "./expression-ast.js"
 import { presenceWitnessesOfSourceLike } from "./implication-runtime.js"
 import type { JsonNode } from "./json/ast.js"
 import type { JsonPathUsageError } from "./json/errors.js"
+import { withJsonPathAccess } from "./json/path-access.js"
 import * as JsonPath from "./json/path.js"
 import type {
   JsonConcatResult,
@@ -300,17 +301,21 @@ type ComparableInput<
   TimestampDb extends Expression.DbType.Any,
   NullDb extends Expression.DbType.Any,
   Operator extends string
-> = CanCompareDbTypes<
-  DialectDbTypeOfInput<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-  DialectDbTypeOfInput<Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-  Dialect
-> extends true ? Right : OperandCompatibilityError<
-    Operator,
-    DialectDbTypeOfInput<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-    DialectDbTypeOfInput<Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-    Dialect,
-    "the same db type family"
-  >
+> = 0 extends (1 & Left)
+  ? Right
+  : 0 extends (1 & Right)
+    ? Right
+    : CanCompareDbTypes<
+      DialectDbTypeOfInput<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+      DialectDbTypeOfInput<Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+      Dialect
+    > extends true ? Right : OperandCompatibilityError<
+      Operator,
+      DialectDbTypeOfInput<Left, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+      DialectDbTypeOfInput<Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+      Dialect,
+      "the same db type family"
+    >
 
 type TextInput<
   Value extends ExpressionInput,
@@ -1519,7 +1524,7 @@ type NumberWindowExpression<
  */
 type Dialect = "standard"
 type TextDb = ReturnType<typeof standardDatatypes.text>
-type NumericDb = ReturnType<typeof standardDatatypes.float8>
+type NumericDb = ReturnType<typeof standardDatatypes.real>
 type BoolDb = ReturnType<typeof standardDatatypes.boolean>
 type TimestampDb = ReturnType<typeof standardDatatypes.timestamp>
 type NullDb = Expression.DbType.Base<"standard", "null"> & {
@@ -1533,7 +1538,7 @@ type TypeWitnesses = typeof standardDatatypes
 const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, TypeWitnesses> = {
   dialect: "standard",
   textDb: standardDatatypes.text() as TextDb,
-  numericDb: standardDatatypes.float8() as NumericDb,
+  numericDb: standardDatatypes.real() as NumericDb,
   boolDb: standardDatatypes.boolean() as BoolDb,
   timestampDb: standardDatatypes.timestamp() as TimestampDb,
   nullDb: {
@@ -1554,11 +1559,11 @@ 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
+    return Schema.Literal(value) as unknown as Schema.Top
   }
 
   const literal = <const Value extends LiteralValue>(
@@ -2339,13 +2344,6 @@ type BinaryPredicateExpression<
 
   const type = {
     ...profile.type,
-    array,
-    range,
-    multirange,
-    record,
-    domain,
-    enum: enum_,
-    set,
     custom,
     driverValueMapping
   }
@@ -2403,7 +2401,7 @@ type BinaryPredicateExpression<
     MergeAggregationTuple<typeof expressions>,
     TupleDependencies<typeof expressions>,
     Ast
-  > => makeExpression({
+  > => withJsonPathAccess(makeExpression({
     runtime: state.runtime,
     dbType: state.dbType,
     nullability: state.nullability,
@@ -2411,7 +2409,7 @@ type BinaryPredicateExpression<
     kind: mergeAggregationManyRuntime(expressions) as MergeAggregationTuple<typeof expressions>,
 
     dependencies: mergeManyDependencies(expressions)
-  }, ast) as AstBackedExpression<
+  }, ast)) as AstBackedExpression<
     Runtime,
     Db,
     Nullability,
@@ -2432,7 +2430,7 @@ type BinaryPredicateExpression<
   const makeJsonLiteralExpression = <Value extends JsonLiteralInput>(
     value: Value,
     dbType: Expression.DbType.Json<any, any> = jsonDb
-  ) => makeExpression({
+  ) => withJsonPathAccess(makeExpression({
     runtime: value as JsonRuntime<Value>,
     dbType,
     nullability: (value === null ? "always" : "never") as JsonNullabilityOf<Value>,
@@ -2443,7 +2441,7 @@ type BinaryPredicateExpression<
   }, {
     kind: "literal",
     value
-  })
+  }))
 
   const wrapJsonExpression = (
     value: Expression.Any,
@@ -4524,6 +4522,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
@@ -4964,6 +5039,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,
@@ -6295,7 +6385,7 @@ type AsCurriedResult<
     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>>>,
@@ -6359,7 +6449,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<
     {},