effect-qb 0.15.0 → 0.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-qb",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -49,7 +49,7 @@
   },
   "devDependencies": {
     "@types/bun": "latest",
-    "@typescript/native-preview": "latest"
+    "@typescript/native-preview": "beta"
   },
   "dependencies": {
     "@effect/experimental": "^0.57.0",

package/src/internal/column-state.ts

@@ -76,6 +76,7 @@ export interface ColumnState<
   readonly defaultValue?: DdlExpression
   readonly generatedValue?: DdlExpression
   readonly ddlType?: string
+  readonly driverValueMapping?: Expression.DriverValueMapping
   readonly identity?: {
     readonly generation: "always" | "byDefault"
   }
@@ -137,6 +138,7 @@ export interface ColumnDefinition<
     readonly defaultValue?: DdlExpression
     readonly generatedValue?: DdlExpression
     readonly ddlType?: string
+    readonly driverValueMapping?: Expression.DriverValueMapping
     readonly identity?: {
       readonly generation: "always" | "byDefault"
     }
@@ -289,6 +291,7 @@ export const makeColumnDefinition = <
     runtime: undefined as Select,
     dbType: metadata.dbType,
     runtimeSchema: schema,
+    driverValueMapping: metadata.driverValueMapping,
     nullability: (metadata.nullable ? "maybe" : "never") as Nullable extends true ? "maybe" : "never",
     dialect: metadata.dbType.dialect,
     kind: "scalar",
@@ -308,6 +311,7 @@ export const makeColumnDefinition = <
     defaultValue: metadata.defaultValue,
     generatedValue: metadata.generatedValue,
     ddlType: metadata.ddlType,
+    driverValueMapping: metadata.driverValueMapping,
     identity: metadata.identity,
     enum: metadata.enum
   }
@@ -379,6 +383,7 @@ export const remapColumnDefinition = <
     runtime: undefined as Select,
     dbType: metadata.dbType,
     runtimeSchema: schema,
+    driverValueMapping: metadata.driverValueMapping,
     nullability: (metadata.nullable ? "maybe" : "never") as Nullable extends true ? "maybe" : "never",
     dialect: metadata.dbType.dialect
   }
@@ -397,6 +402,7 @@ export const remapColumnDefinition = <
     defaultValue: metadata.defaultValue,
     generatedValue: metadata.generatedValue,
     ddlType: metadata.ddlType,
+    driverValueMapping: metadata.driverValueMapping,
     identity: metadata.identity,
     enum: metadata.enum
   }
@@ -443,6 +449,7 @@ export const bindColumn = <
     runtime: undefined as SelectType<Column>,
     dbType: column.metadata.dbType,
     runtimeSchema: schema,
+    driverValueMapping: column.metadata.driverValueMapping,
     nullability: (column.metadata.nullable ? "maybe" : "never") as IsNullable<Column> extends true ? "maybe" : "never",
     dialect: column.metadata.dbType.dialect,
     kind: "scalar",

package/src/internal/column.ts

@@ -123,6 +123,20 @@ type DdlTypedColumn<Column extends AnyColumnDefinition> = ColumnDefinition<
   ReferencesOf<Column>
 > & PreserveBrand<Column>
 
+type DriverValueMappedColumn<Column extends AnyColumnDefinition> = ColumnDefinition<
+  SelectType<Column>,
+  InsertType<Column>,
+  UpdateType<Column>,
+  Column[typeof ColumnTypeId]["dbType"],
+  IsNullable<Column>,
+  HasDefault<Column>,
+  IsGenerated<Column>,
+  IsPrimaryKey<Column>,
+  Column[typeof ColumnTypeId]["unique"],
+  ReferencesOf<Column>,
+  Column[typeof ColumnTypeId]["dependencies"]
+> & PreserveBrand<Column>
+
 type GeneratedColumn<Column extends AnyColumnDefinition> = ColumnDefinition<
   SelectType<Column>,
   InsertType<Column>,
@@ -543,6 +557,14 @@ export const ddlType = <SqlType extends string>(sqlType: SqlType) =>
       ddlType: sqlType
     }) as DdlTypedColumn<Column>
 
+/** Overrides how a column crosses the SQL driver boundary. */
+export const driverValueMapping = (mapping: Expression.DriverValueMapping) =>
+  <Column extends AnyColumnDefinition>(column: Column): DriverValueMappedColumn<Column> =>
+    mapColumn(column, {
+      ...column.metadata,
+      driverValueMapping: mapping
+    }) as DriverValueMappedColumn<Column>
+
 /** Marks a column as a Postgres array type. */
 export const array = <Options extends ArrayOptions | undefined = undefined>(
   options?: Options

package/src/internal/dialect.ts

@@ -1,3 +1,7 @@
+import type * as Schema from "effect/Schema"
+
+import type * as Expression from "./scalar.js"
+
 /**
  * Mutable rendering state shared while serializing SQL for a concrete dialect.
  *
@@ -6,6 +10,7 @@
  */
 export interface RenderState {
   readonly params: unknown[]
+  readonly valueMappings?: Expression.DriverValueMappings
   readonly ctes: {
     readonly name: string
     readonly sql: string
@@ -14,6 +19,12 @@ export interface RenderState {
   readonly cteNames: Set<string>
 }
 
+export interface RenderValueContext {
+  readonly dbType?: Expression.DbType.Any
+  readonly runtimeSchema?: Schema.Schema.Any
+  readonly driverValueMapping?: Expression.DriverValueMapping
+}
+
 /**
  * Minimal runtime contract for a SQL dialect.
  *
@@ -24,7 +35,7 @@ export interface RenderState {
 export interface SqlDialect<Name extends string = string> {
   readonly name: Name
   quoteIdentifier(value: string): string
-  renderLiteral(value: unknown, state: RenderState): string
+  renderLiteral(value: unknown, state: RenderState, context?: RenderValueContext): string
   renderTableReference(tableName: string, baseTableName: string, schemaName?: string): string
   renderConcat(values: readonly string[]): string
 }

package/src/internal/executor.ts

@@ -9,7 +9,7 @@ import * as Stream from "effect/Stream"
 import * as Expression from "./scalar.js"
 import * as ExpressionAst from "./expression-ast.js"
 import { resolveImplicationScope, type ImplicationScope } from "./implication-runtime.js"
-import { normalizeDbValue } from "./runtime/normalize.js"
+import { fromDriverValue } from "./runtime/driver-value-mapping.js"
 import { expressionRuntimeSchema } from "./runtime/schema.js"
 import { flattenSelection } from "./projections.js"
 import * as Query from "./query.js"
@@ -243,12 +243,19 @@ const decodeProjectionValue = (
   expression: Expression.Any,
   raw: unknown,
   scope: ImplicationScope,
-  driverMode: DriverMode
+  driverMode: DriverMode,
+  valueMappings?: Expression.DriverValueMappings
 ): unknown => {
   let normalized = raw
   if (driverMode === "raw") {
     try {
-      normalized = normalizeDbValue(expression[Expression.TypeId].dbType, raw)
+      normalized = fromDriverValue(raw, {
+        dialect: rendered.dialect,
+        dbType: expression[Expression.TypeId].dbType,
+        runtimeSchema: expression[Expression.TypeId].runtimeSchema,
+        driverValueMapping: expression[Expression.TypeId].driverValueMapping,
+        valueMappings
+      })
     } catch (cause) {
       throw makeRowDecodeError(rendered, projection, expression, raw, "normalize", cause)
     }
@@ -303,6 +310,7 @@ export const makeRowDecoder = (
   plan: Query.Plan.Any,
   options: {
     readonly driverMode?: DriverMode
+    readonly valueMappings?: Expression.DriverValueMappings
   } = {}
 ): ((row: FlatRow) => any) => {
   const projections = flattenSelection(
@@ -312,6 +320,7 @@ export const makeRowDecoder = (
     projections.map((projection) => [projection.alias, projection.expression] as const)
   )
   const driverMode = options.driverMode ?? "raw"
+  const valueMappings = options.valueMappings ?? rendered.valueMappings
   const scope = resolveImplicationScope(plan[Plan.TypeId].available, Query.getQueryState(plan).assumptions)
   return (row) => {
     const decoded: Record<string, unknown> = {}
@@ -326,7 +335,7 @@ export const makeRowDecoder = (
       setPath(
         decoded,
         projection.path,
-        decodeProjectionValue(rendered, projection, expression, row[projection.alias], scope, driverMode)
+        decodeProjectionValue(rendered, projection, expression, row[projection.alias], scope, driverMode, valueMappings)
       )
     }
     return decoded
@@ -339,6 +348,7 @@ export const decodeChunk = (
   rows: Chunk.Chunk<FlatRow>,
   options: {
     readonly driverMode?: DriverMode
+    readonly valueMappings?: Expression.DriverValueMappings
   } = {}
 ): Chunk.Chunk<any> => {
   const decodeRow = makeRowDecoder(rendered, plan, options)
@@ -351,6 +361,7 @@ export const decodeRows = (
   rows: ReadonlyArray<FlatRow>,
   options: {
     readonly driverMode?: DriverMode
+    readonly valueMappings?: Expression.DriverValueMappings
   } = {}
 ): ReadonlyArray<any> => {
   const decodeRow = makeRowDecoder(rendered, plan, options)

package/src/internal/predicate/analysis.ts

@@ -1,9 +1,74 @@
-import type { AnalyzeFormula } from "./context.js"
+import type { AnalyzeFormula, AssumeFactsFalse, AssumeFactsTrue, PredicateContext } from "./context.js"
 import type { FormulaOfPredicate } from "./normalize.js"
 import type { And, Not, PredicateFormula, TrueFormula } from "./formula.js"
 
 type ContextOf<Formula extends PredicateFormula> = AnalyzeFormula<Formula>
 
+export type EmptyFacts = AnalyzeFormula<TrueFormula>
+
+export type FactsOfFormula<
+  Formula extends PredicateFormula
+> = AnalyzeFormula<Formula>
+
+export interface PredicateState<
+  Formula extends PredicateFormula = PredicateFormula,
+  Facts extends PredicateContext = PredicateContext
+> {
+  readonly formula: Formula
+  readonly facts: Facts
+}
+
+export type EmptyPredicateState = PredicateState<TrueFormula, EmptyFacts>
+
+export type PredicateStateFormula<
+  State extends PredicateState
+> = State["formula"]
+
+export type PredicateStateFacts<
+  State extends PredicateState
+> = State["facts"]
+
+export type GuaranteedNonNullKeysInFacts<
+  Facts extends PredicateContext
+> = Facts["nonNullKeys"]
+
+export type GuaranteedNullKeysInFacts<
+  Facts extends PredicateContext
+> = Facts["nullKeys"]
+
+export type GuaranteedSourceNamesInFacts<
+  Facts extends PredicateContext
+> = Facts["sourceNames"]
+
+export type GuaranteedLiteralSetInFacts<
+  Facts extends PredicateContext,
+  Key extends string
+> = [Facts["literalSets"]] extends [{ readonly [K in Key]: infer Values }]
+  ? Values
+  : never
+
+export type GuaranteedEqLiteralInFacts<
+  Facts extends PredicateContext,
+  Key extends string
+> = [Facts["eqLiterals"]] extends [{ readonly [K in Key]: infer Values }]
+  ? Values
+  : never
+
+export type GuaranteedNeqLiteralInFacts<
+  Facts extends PredicateContext,
+  Key extends string
+> = [Facts["neqLiterals"]] extends [{ readonly [K in Key]: infer Values }]
+  ? Values
+  : never
+
+export type GuaranteedJsonLiteralSetInFacts<
+  Facts extends PredicateContext,
+  ColumnKey extends string,
+  Path extends string
+> = [Facts["jsonLiteralSets"]] extends [{ readonly [C in ColumnKey]: { readonly [P in Path]: infer Values } }]
+  ? Values
+  : never
+
 export type GuaranteedNonNullKeys<
   Assumptions extends PredicateFormula
 > = ContextOf<Assumptions>["nonNullKeys"]
@@ -23,6 +88,17 @@ export type GuaranteedEqLiteral<
   ? ContextOf<Assumptions>["eqLiterals"][Key]
   : never
 
+export type GuaranteedLiteralSets<
+  Assumptions extends PredicateFormula
+> = ContextOf<Assumptions>["literalSets"]
+
+export type GuaranteedLiteralSet<
+  Assumptions extends PredicateFormula,
+  Key extends string
+> = Key extends keyof ContextOf<Assumptions>["literalSets"]
+  ? ContextOf<Assumptions>["literalSets"][Key]
+  : never
+
 type IsContradiction<Formula extends PredicateFormula> =
   ContextOf<Formula>["contradiction"] extends true ? true : false
 
@@ -70,6 +146,32 @@ export type AssumeFalse<
   Predicate
 > = AssumeFormulaFalse<Assumptions, FormulaOfPredicate<Predicate>>
 
+export type AssumePredicateStateFormulaTrue<
+  State extends PredicateState,
+  Formula extends PredicateFormula
+> = PredicateState<
+  AssumeFormulaTrue<PredicateStateFormula<State>, Formula>,
+  AssumeFactsTrue<PredicateStateFacts<State>, Formula>
+>
+
+export type AssumePredicateStateFormulaFalse<
+  State extends PredicateState,
+  Formula extends PredicateFormula
+> = PredicateState<
+  AssumeFormulaFalse<PredicateStateFormula<State>, Formula>,
+  AssumeFactsFalse<PredicateStateFacts<State>, Formula>
+>
+
+export type AssumePredicateStateTrue<
+  State extends PredicateState,
+  Predicate
+> = AssumePredicateStateFormulaTrue<State, FormulaOfPredicate<Predicate>>
+
+export type AssumePredicateStateFalse<
+  State extends PredicateState,
+  Predicate
+> = AssumePredicateStateFormulaFalse<State, FormulaOfPredicate<Predicate>>
+
 export type Contradicts<
   Assumptions extends PredicateFormula,
   Predicate

package/src/internal/predicate/atom.ts

@@ -20,6 +20,12 @@ export interface NeqLiteralAtom<Key extends string, Value extends string> {
   readonly value: Value
 }
 
+export interface LiteralSetAtom<Key extends string, Values extends string> {
+  readonly kind: "literal-set"
+  readonly key: Key
+  readonly values: readonly Values[]
+}
+
 export interface EqColumnAtom<
   LeftKey extends string,
   RightKey extends string
@@ -39,5 +45,6 @@ export type PredicateAtom =
   | NonNullAtom<string>
   | EqLiteralAtom<string, string>
   | NeqLiteralAtom<string, string>
+  | LiteralSetAtom<string, string>
   | EqColumnAtom<string, string>
   | UnknownAtom<string>

package/src/internal/predicate/context.ts

@@ -1,4 +1,4 @@
-import type { EqColumnAtom, EqLiteralAtom, NeqLiteralAtom, NonNullAtom, NullAtom, PredicateAtom, UnknownAtom } from "./atom.js"
+import type { EqColumnAtom, EqLiteralAtom, LiteralSetAtom, NeqLiteralAtom, NonNullAtom, NullAtom, PredicateAtom, UnknownAtom } from "./atom.js"
 import type { AllFormula, AnyFormula, AtomFormula, FalseFormula, NotFormula, PredicateFormula, TrueFormula } from "./formula.js"
 
 type Polarity = "positive" | "negative"
@@ -8,6 +8,8 @@ export interface Context<
   NullKeys extends string = never,
   EqLiterals = {},
   NeqLiterals = {},
+  LiteralSets = {},
+  JsonLiteralSets = {},
   SourceNames extends string = never,
   Contradiction extends boolean = false,
   Unknown extends boolean = false
@@ -16,6 +18,8 @@ export interface Context<
   readonly nullKeys: NullKeys
   readonly eqLiterals: EqLiterals
   readonly neqLiterals: NeqLiterals
+  readonly literalSets: LiteralSets
+  readonly jsonLiteralSets: JsonLiteralSets
   readonly sourceNames: SourceNames
   readonly contradiction: Contradiction
   readonly unknown: Unknown
@@ -27,6 +31,8 @@ type AnyContext = Context<
   string,
   Record<string, string>,
   Record<string, string>,
+  Record<string, string>,
+  Record<string, Record<string, string>>,
   string,
   boolean,
   boolean
@@ -84,15 +90,75 @@ type MergeNeqLiteralMaps<Left, Right> = {
         : never
 }
 
+type MergeLiteralSetMaps<Left, Right> = {
+  readonly [K in Extract<keyof Left | keyof Right, string>]:
+    K extends keyof Left
+      ? K extends keyof Right
+        ? Extract<Left[K], Right[K]>
+        : Left[K]
+      : K extends keyof Right
+        ? Right[K]
+        : never
+}
+
+type MergeJsonLiteralSetPathMaps<Left, Right> = {
+  readonly [K in Extract<keyof Left | keyof Right, string>]:
+    K extends keyof Left
+      ? K extends keyof Right
+        ? Extract<Left[K], Right[K]>
+        : Left[K]
+      : K extends keyof Right
+        ? Right[K]
+        : never
+}
+
+type MergeJsonLiteralSetMaps<Left, Right> = {
+  readonly [K in Extract<keyof Left | keyof Right, string>]:
+    K extends keyof Left
+      ? K extends keyof Right
+        ? MergeJsonLiteralSetPathMaps<Left[K], Right[K]>
+        : Left[K]
+      : K extends keyof Right
+        ? Right[K]
+        : never
+}
+
 type FilterNeverValues<Map> = {
   readonly [K in keyof Map as Map[K] extends never ? never : K]: Map[K]
 }
 
+type JsonKeyParts<Key extends string> = string extends Key
+  ? never
+  : Key extends `${infer ColumnKey}#json:${infer Path}`
+    ? readonly [ColumnKey, Path]
+    : never
+
+type LiteralSetMapAfterAdd<
+  LiteralSets,
+  Key extends string,
+  Values extends string
+> = [JsonKeyParts<Key>] extends [never]
+  ? FilterNeverValues<MergeLiteralSetMaps<LiteralSets, { readonly [K in Key]: Values }>>
+  : LiteralSets
+
+type JsonLiteralSetMapAfterAdd<
+  JsonLiteralSets,
+  Key extends string,
+  Values extends string
+> = JsonKeyParts<Key> extends readonly [infer ColumnKey extends string, infer Path extends string]
+  ? MergeJsonLiteralSetMaps<
+      JsonLiteralSets,
+      { readonly [C in ColumnKey]: { readonly [P in Path]: Values } }
+    >
+  : JsonLiteralSets
+
 type MarkContradiction<Ctx extends AnyContext> = Context<
   Ctx["nonNullKeys"],
   Ctx["nullKeys"],
   Ctx["eqLiterals"],
   Ctx["neqLiterals"],
+  Ctx["literalSets"],
+  Ctx["jsonLiteralSets"],
   Ctx["sourceNames"],
   true,
   Ctx["unknown"]
@@ -103,6 +169,8 @@ type MarkUnknown<Ctx extends AnyContext> = Context<
   Ctx["nullKeys"],
   Ctx["eqLiterals"],
   Ctx["neqLiterals"],
+  Ctx["literalSets"],
+  Ctx["jsonLiteralSets"],
   Ctx["sourceNames"],
   Ctx["contradiction"],
   true
@@ -116,6 +184,8 @@ type AddNonNull<
   Ctx["nullKeys"],
   Ctx["eqLiterals"],
   Ctx["neqLiterals"],
+  Ctx["literalSets"],
+  Ctx["jsonLiteralSets"],
   Ctx["sourceNames"] | SourceNameOfKey<Key>,
   Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"],
   Ctx["unknown"]
@@ -129,11 +199,35 @@ type AddNull<
   Ctx["nullKeys"] | Key,
   Ctx["eqLiterals"],
   Ctx["neqLiterals"],
+  Ctx["literalSets"],
+  Ctx["jsonLiteralSets"],
   Ctx["sourceNames"] | SourceNameOfKey<Key>,
   Key extends Ctx["nonNullKeys"] ? true : Ctx["contradiction"],
   Ctx["unknown"]
 >
 
+type AddLiteralSet<
+  Ctx extends AnyContext,
+  Key extends string,
+  Values extends string
+> = Context<
+  Ctx["nonNullKeys"] | Key,
+  Ctx["nullKeys"],
+  Ctx["eqLiterals"],
+  Ctx["neqLiterals"],
+  LiteralSetMapAfterAdd<Ctx["literalSets"], Key, Values>,
+  JsonLiteralSetMapAfterAdd<Ctx["jsonLiteralSets"], Key, Values>,
+  Ctx["sourceNames"] | SourceNameOfKey<Key>,
+  EqLiteralValueOf<Ctx["eqLiterals"], Key> extends infer EqValue
+    ? [EqValue] extends [never]
+      ? Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"]
+      : EqValue extends Values
+        ? Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"]
+        : true
+    : true,
+  Ctx["unknown"]
+>
+
 type AddEqLiteral<
   Ctx extends AnyContext,
   Key extends string,
@@ -143,6 +237,8 @@ type AddEqLiteral<
   Ctx["nullKeys"],
   FilterNeverValues<MergeEqLiteralMaps<Ctx["eqLiterals"], { readonly [K in Key]: Value }>>,
   Ctx["neqLiterals"],
+  LiteralSetMapAfterAdd<Ctx["literalSets"], Key, Value>,
+  JsonLiteralSetMapAfterAdd<Ctx["jsonLiteralSets"], Key, Value>,
   Ctx["sourceNames"] | SourceNameOfKey<Key>,
   EqLiteralValueOf<Ctx["eqLiterals"], Key> extends never
     ? NeqLiteralValuesOf<Ctx["neqLiterals"], Key> extends infer NeqValues
@@ -169,6 +265,8 @@ type AddNeqLiteral<
   Ctx["nullKeys"],
   Ctx["eqLiterals"],
   FilterNeverValues<MergeNeqLiteralMaps<Ctx["neqLiterals"], { readonly [K in Key]: Value }>>,
+  Ctx["literalSets"],
+  Ctx["jsonLiteralSets"],
   Ctx["sourceNames"] | SourceNameOfKey<Key>,
   EqLiteralValueOf<Ctx["eqLiterals"], Key> extends infer EqValue
     ? [EqValue] extends [never]
@@ -219,11 +317,13 @@ type ApplyAtom<
         ? AddEqLiteral<Ctx, Key, Value>
         : Atom extends NeqLiteralAtom<infer Key extends string, infer Value extends string>
           ? AddNeqLiteral<Ctx, Key, Value>
-          : Atom extends EqColumnAtom<infer Left extends string, infer Right extends string>
-            ? ApplyEqColumn<Ctx, Left, Right>
-            : Atom extends UnknownAtom<any>
-              ? MarkUnknown<Ctx>
-              : Ctx
+          : Atom extends LiteralSetAtom<infer Key extends string, infer Values extends string>
+            ? AddLiteralSet<Ctx, Key, Values>
+            : Atom extends EqColumnAtom<infer Left extends string, infer Right extends string>
+              ? ApplyEqColumn<Ctx, Left, Right>
+              : Atom extends UnknownAtom<any>
+                ? MarkUnknown<Ctx>
+                : Ctx
 
 type ApplyNegativeAtom<
   Ctx extends AnyContext,
@@ -237,11 +337,13 @@ type ApplyNegativeAtom<
         ? AddNeqLiteral<Ctx, Key, Value>
         : Atom extends NeqLiteralAtom<infer Key extends string, infer Value extends string>
           ? AddEqLiteral<Ctx, Key, Value>
-          : Atom extends EqColumnAtom<infer Left extends string, infer Right extends string>
-            ? AddNonNull<AddNonNull<Ctx, Left>, Right>
-            : Atom extends UnknownAtom<any>
-              ? MarkUnknown<Ctx>
-              : Ctx
+          : Atom extends LiteralSetAtom<infer Key extends string, any>
+            ? AddNonNull<Ctx, Key>
+            : Atom extends EqColumnAtom<infer Left extends string, infer Right extends string>
+              ? AddNonNull<AddNonNull<Ctx, Left>, Right>
+              : Atom extends UnknownAtom<any>
+                ? MarkUnknown<Ctx>
+                : Ctx
 
 type FramesFromItems<
   Items extends readonly PredicateFormula[],
@@ -268,6 +370,27 @@ type IntersectNeqLiteralMaps<
     Extract<Left[K], Right[K]> extends never ? never : Extract<Left[K], Right[K]>
 }>
 
+type UnionLiteralSetMaps<
+  Left,
+  Right
+> = FilterNeverValues<{
+  readonly [K in Extract<keyof Left, keyof Right>]: Left[K] | Right[K]
+}>
+
+type UnionJsonLiteralSetPathMaps<
+  Left,
+  Right
+> = FilterNeverValues<{
+  readonly [K in Extract<keyof Left, keyof Right>]: Left[K] | Right[K]
+}>
+
+type UnionJsonLiteralSetMaps<
+  Left,
+  Right
+> = {
+  readonly [K in Extract<keyof Left, keyof Right>]: UnionJsonLiteralSetPathMaps<Left[K], Right[K]>
+}
+
 type IntersectContexts<
   Left extends AnyContext,
   Right extends AnyContext
@@ -276,6 +399,8 @@ type IntersectContexts<
   Extract<Left["nullKeys"], Right["nullKeys"]>,
   IntersectEqLiteralMaps<Left["eqLiterals"], Right["eqLiterals"]>,
   IntersectNeqLiteralMaps<Left["neqLiterals"], Right["neqLiterals"]>,
+  UnionLiteralSetMaps<Left["literalSets"], Right["literalSets"]>,
+  UnionJsonLiteralSetMaps<Left["jsonLiteralSets"], Right["jsonLiteralSets"]>,
   Extract<Left["sourceNames"], Right["sourceNames"]>,
   Left["contradiction"] extends true
     ? Right["contradiction"]
@@ -289,17 +414,20 @@ type AnalyzeAnyBranches<
   Ctx extends AnyContext,
   Items extends readonly PredicateFormula[],
   Direction extends Polarity,
-  Current extends AnyContext | never = never
-> = Items extends readonly [
+  Current extends AnyContext | never = never,
+  Seen extends readonly unknown[] = []
+> = Seen["length"] extends 20
+  ? MarkUnknown<Ctx>
+  : Items extends readonly [
   infer Head extends PredicateFormula,
   ...infer Tail extends readonly PredicateFormula[]
 ]
   ? AnalyzeBranch<Ctx, Head, Direction> extends infer Branch extends AnyContext
     ? Branch["contradiction"] extends true
-      ? AnalyzeAnyBranches<Ctx, Tail, Direction, Current>
+      ? AnalyzeAnyBranches<Ctx, Tail, Direction, Current, readonly [...Seen, unknown]>
       : [Current] extends [never]
-        ? AnalyzeAnyBranches<Ctx, Tail, Direction, Branch>
-        : AnalyzeAnyBranches<Ctx, Tail, Direction, IntersectContexts<Current, Branch>>
+        ? AnalyzeAnyBranches<Ctx, Tail, Direction, Branch, readonly [...Seen, unknown]>
+        : AnalyzeAnyBranches<Ctx, Tail, Direction, IntersectContexts<Current, Branch>, readonly [...Seen, unknown]>
     : never
   : [Current] extends [never]
     ? MarkContradiction<Ctx>
@@ -356,3 +484,15 @@ export type AnalyzeStack<
 
 export type AnalyzeFormula<Formula extends PredicateFormula> =
   AnalyzeStack<EmptyContext, readonly [Frame<Formula, "positive">]>
+
+export type PredicateContext = AnyContext
+
+export type AssumeFactsTrue<
+  Ctx extends PredicateContext,
+  Formula extends PredicateFormula
+> = AnalyzeStack<Ctx, readonly [Frame<Formula, "positive">]>
+
+export type AssumeFactsFalse<
+  Ctx extends PredicateContext,
+  Formula extends PredicateFormula
+> = AnalyzeStack<Ctx, readonly [Frame<Formula, "negative">]>