effect-qb 0.13.0 → 0.15.0

package/src/internal/predicate/context.d.ts

@@ -0,0 +1,67 @@
+import type { EqColumnAtom, EqLiteralAtom, NeqLiteralAtom, NonNullAtom, NullAtom, PredicateAtom, UnknownAtom } from "./atom.js";
+import type { AllFormula, AnyFormula, AtomFormula, FalseFormula, NotFormula, PredicateFormula, TrueFormula } from "./formula.js";
+type Polarity = "positive" | "negative";
+export interface Context<NonNullKeys extends string = never, NullKeys extends string = never, EqLiterals = {}, NeqLiterals = {}, SourceNames extends string = never, Contradiction extends boolean = false, Unknown extends boolean = false> {
+    readonly nonNullKeys: NonNullKeys;
+    readonly nullKeys: NullKeys;
+    readonly eqLiterals: EqLiterals;
+    readonly neqLiterals: NeqLiterals;
+    readonly sourceNames: SourceNames;
+    readonly contradiction: Contradiction;
+    readonly unknown: Unknown;
+}
+export type EmptyContext = Context;
+type AnyContext = Context<string, string, Record<string, string>, Record<string, string>, string, boolean, boolean>;
+type Frame<Formula extends PredicateFormula = PredicateFormula, Direction extends Polarity = Polarity> = {
+    readonly formula: Formula;
+    readonly polarity: Direction;
+};
+type SourceNameOfKey<Key extends string> = Key extends `${infer SourceName}.${string}` ? SourceName : never;
+type EqLiteralValueOf<EqLiterals, Key extends string> = EqLiterals extends Record<string, string> ? Key extends keyof EqLiterals ? EqLiterals[Key] : never : never;
+type NeqLiteralValuesOf<NeqLiterals, Key extends string> = NeqLiterals extends Record<string, string> ? Key extends keyof NeqLiterals ? NeqLiterals[Key] : never : never;
+type MergeEqLiteralMaps<Left, Right> = {
+    readonly [K in Extract<keyof Left | keyof Right, string>]: K extends keyof Left ? K extends keyof Right ? Left[K] extends Right[K] ? Left[K] : never : Left[K] : K extends keyof Right ? Right[K] : never;
+};
+type MergeNeqLiteralMaps<Left, Right> = {
+    readonly [K in Extract<keyof Left | keyof Right, string>]: K extends keyof Left ? K extends keyof Right ? 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 MarkContradiction<Ctx extends AnyContext> = Context<Ctx["nonNullKeys"], Ctx["nullKeys"], Ctx["eqLiterals"], Ctx["neqLiterals"], Ctx["sourceNames"], true, Ctx["unknown"]>;
+type MarkUnknown<Ctx extends AnyContext> = Context<Ctx["nonNullKeys"], Ctx["nullKeys"], Ctx["eqLiterals"], Ctx["neqLiterals"], Ctx["sourceNames"], Ctx["contradiction"], true>;
+type AddNonNull<Ctx extends AnyContext, Key extends string> = Context<Ctx["nonNullKeys"] | Key, Ctx["nullKeys"], Ctx["eqLiterals"], Ctx["neqLiterals"], Ctx["sourceNames"] | SourceNameOfKey<Key>, Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"], Ctx["unknown"]>;
+type AddNull<Ctx extends AnyContext, Key extends string> = Context<Ctx["nonNullKeys"], Ctx["nullKeys"] | Key, Ctx["eqLiterals"], Ctx["neqLiterals"], Ctx["sourceNames"] | SourceNameOfKey<Key>, Key extends Ctx["nonNullKeys"] ? true : Ctx["contradiction"], Ctx["unknown"]>;
+type AddEqLiteral<Ctx extends AnyContext, Key extends string, Value extends string> = Context<Ctx["nonNullKeys"] | Key, Ctx["nullKeys"], FilterNeverValues<MergeEqLiteralMaps<Ctx["eqLiterals"], {
+    readonly [K in Key]: Value;
+}>>, Ctx["neqLiterals"], Ctx["sourceNames"] | SourceNameOfKey<Key>, EqLiteralValueOf<Ctx["eqLiterals"], Key> extends never ? NeqLiteralValuesOf<Ctx["neqLiterals"], Key> extends infer NeqValues ? Value extends NeqValues ? true : Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"] : true : EqLiteralValueOf<Ctx["eqLiterals"], Key> extends Value ? NeqLiteralValuesOf<Ctx["neqLiterals"], Key> extends infer NeqValues ? Value extends NeqValues ? true : Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"] : true : true, Ctx["unknown"]>;
+type AddNeqLiteral<Ctx extends AnyContext, Key extends string, Value extends string> = Context<Ctx["nonNullKeys"] | Key, Ctx["nullKeys"], Ctx["eqLiterals"], FilterNeverValues<MergeNeqLiteralMaps<Ctx["neqLiterals"], {
+    readonly [K in Key]: Value;
+}>>, Ctx["sourceNames"] | SourceNameOfKey<Key>, EqLiteralValueOf<Ctx["eqLiterals"], Key> extends infer EqValue ? [EqValue] extends [never] ? Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"] : EqValue extends Value ? true : Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"] : true, Ctx["unknown"]>;
+type ApplyEqColumn<Ctx extends AnyContext, Left extends string, Right extends string> = EqLiteralValueOf<Ctx["eqLiterals"], Left> extends infer LeftValue ? EqLiteralValueOf<Ctx["eqLiterals"], Right> extends infer RightValue ? [LeftValue] extends [never] ? [RightValue] extends [never] ? AddNonNull<AddNonNull<Ctx, Left>, Right> : RightValue extends string ? AddEqLiteral<AddNonNull<AddNonNull<Ctx, Left>, Right>, Left, RightValue> : MarkContradiction<Ctx> : [RightValue] extends [never] ? LeftValue extends string ? AddEqLiteral<AddNonNull<AddNonNull<Ctx, Left>, Right>, Right, LeftValue> : MarkContradiction<Ctx> : LeftValue extends RightValue ? LeftValue extends string ? RightValue extends string ? AddEqLiteral<AddEqLiteral<AddNonNull<AddNonNull<Ctx, Left>, Right>, Left, LeftValue>, Right, RightValue> : MarkContradiction<Ctx> : MarkContradiction<Ctx> : MarkContradiction<Ctx> : never : never;
+type ApplyAtom<Ctx extends AnyContext, Atom extends PredicateAtom> = Atom extends NullAtom<infer Key extends string> ? AddNull<Ctx, Key> : Atom extends NonNullAtom<infer Key extends string> ? AddNonNull<Ctx, Key> : Atom extends EqLiteralAtom<infer Key extends string, infer Value extends string> ? 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;
+type ApplyNegativeAtom<Ctx extends AnyContext, Atom extends PredicateAtom> = Atom extends NullAtom<infer Key extends string> ? AddNonNull<Ctx, Key> : Atom extends NonNullAtom<infer Key extends string> ? AddNull<Ctx, Key> : Atom extends EqLiteralAtom<infer Key extends string, infer Value extends string> ? 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;
+type FramesFromItems<Items extends readonly PredicateFormula[], Direction extends Polarity> = Items extends readonly [
+    infer Head extends PredicateFormula,
+    ...infer Tail extends readonly PredicateFormula[]
+] ? readonly [Frame<Head, Direction>, ...FramesFromItems<Tail, Direction>] : readonly [];
+type IntersectEqLiteralMaps<Left, Right> = FilterNeverValues<{
+    readonly [K in Extract<keyof Left, keyof Right>]: Left[K] extends Right[K] ? Left[K] : never;
+}>;
+type IntersectNeqLiteralMaps<Left, Right> = FilterNeverValues<{
+    readonly [K in Extract<keyof Left, keyof Right>]: Extract<Left[K], Right[K]> extends never ? never : Extract<Left[K], Right[K]>;
+}>;
+type IntersectContexts<Left extends AnyContext, Right extends AnyContext> = Context<Extract<Left["nonNullKeys"], Right["nonNullKeys"]>, Extract<Left["nullKeys"], Right["nullKeys"]>, IntersectEqLiteralMaps<Left["eqLiterals"], Right["eqLiterals"]>, IntersectNeqLiteralMaps<Left["neqLiterals"], Right["neqLiterals"]>, Extract<Left["sourceNames"], Right["sourceNames"]>, Left["contradiction"] extends true ? Right["contradiction"] : Right["contradiction"] extends true ? Left["contradiction"] : false, Left["unknown"] extends true ? true : Right["unknown"] extends true ? true : false>;
+type AnalyzeAnyBranches<Ctx extends AnyContext, Items extends readonly PredicateFormula[], Direction extends Polarity, Current extends AnyContext | never = never> = 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> : [Current] extends [never] ? AnalyzeAnyBranches<Ctx, Tail, Direction, Branch> : AnalyzeAnyBranches<Ctx, Tail, Direction, IntersectContexts<Current, Branch>> : never : [Current] extends [never] ? MarkContradiction<Ctx> : Current;
+type Flip<Direction extends Polarity> = Direction extends "positive" ? "negative" : "positive";
+type AnalyzeBranch<Ctx extends AnyContext, Formula extends PredicateFormula, Direction extends Polarity> = AnalyzeStack<Ctx, readonly [Frame<Formula, Direction>]>;
+type AnalyzeFrame<Ctx extends AnyContext, Formula extends PredicateFormula, Direction extends Polarity, Tail extends readonly Frame[]> = [Formula] extends [TrueFormula] ? Direction extends "positive" ? AnalyzeStack<Ctx, Tail> : MarkContradiction<Ctx> : [Formula] extends [FalseFormula] ? Direction extends "positive" ? MarkContradiction<Ctx> : AnalyzeStack<Ctx, Tail> : [Formula] extends [AtomFormula<infer Atom extends PredicateAtom>] ? Direction extends "positive" ? AnalyzeStack<ApplyAtom<Ctx, Atom>, Tail> : AnalyzeStack<ApplyNegativeAtom<Ctx, Atom>, Tail> : [Formula] extends [NotFormula<infer Item extends PredicateFormula>] ? AnalyzeStack<Ctx, readonly [Frame<Item, Flip<Direction>>, ...Tail]> : [Formula] extends [AllFormula<infer Items extends readonly PredicateFormula[]>] ? Direction extends "positive" ? AnalyzeStack<Ctx, readonly [...FramesFromItems<Items, "positive">, ...Tail]> : AnalyzeStack<AnalyzeAnyBranches<Ctx, Items, "negative">, Tail> : [Formula] extends [AnyFormula<infer Items extends readonly PredicateFormula[]>] ? Direction extends "positive" ? AnalyzeStack<AnalyzeAnyBranches<Ctx, Items, "positive">, Tail> : AnalyzeStack<Ctx, readonly [...FramesFromItems<Items, "negative">, ...Tail]> : AnalyzeStack<MarkUnknown<Ctx>, Tail>;
+export type AnalyzeStack<Ctx extends AnyContext, Stack extends readonly Frame[]> = Ctx["contradiction"] extends true ? Ctx : Stack extends readonly [
+    infer Head extends Frame,
+    ...infer Tail extends readonly Frame[]
+] ? AnalyzeFrame<Ctx, Head["formula"], Head["polarity"], Tail> : Ctx;
+export type AnalyzeFormula<Formula extends PredicateFormula> = AnalyzeStack<EmptyContext, readonly [Frame<Formula, "positive">]>;
+export {};

package/src/internal/{predicate-context.ts → predicate/context.ts}

@@ -1,5 +1,5 @@
-import type { EqColumnAtom, EqLiteralAtom, NeqLiteralAtom, NonNullAtom, NullAtom, PredicateAtom, UnknownAtom } from "./predicate-atom.js"
-import type { AllFormula, AnyFormula, AtomFormula, FalseFormula, NotFormula, PredicateFormula, TrueFormula } from "./predicate-formula.js"
+import type { EqColumnAtom, EqLiteralAtom, NeqLiteralAtom, NonNullAtom, NullAtom, PredicateAtom, UnknownAtom } from "./atom.js"
+import type { AllFormula, AnyFormula, AtomFormula, FalseFormula, NotFormula, PredicateFormula, TrueFormula } from "./formula.js"
 
 type Polarity = "positive" | "negative"
 
@@ -7,6 +7,7 @@ export interface Context<
   NonNullKeys extends string = never,
   NullKeys extends string = never,
   EqLiterals = {},
+  NeqLiterals = {},
   SourceNames extends string = never,
   Contradiction extends boolean = false,
   Unknown extends boolean = false
@@ -14,13 +15,22 @@ export interface Context<
   readonly nonNullKeys: NonNullKeys
   readonly nullKeys: NullKeys
   readonly eqLiterals: EqLiterals
+  readonly neqLiterals: NeqLiterals
   readonly sourceNames: SourceNames
   readonly contradiction: Contradiction
   readonly unknown: Unknown
 }
 
 export type EmptyContext = Context
-type AnyContext = Context<string, string, Record<string, string>, string, boolean, boolean>
+type AnyContext = Context<
+  string,
+  string,
+  Record<string, string>,
+  Record<string, string>,
+  string,
+  boolean,
+  boolean
+>
 
 type Frame<
   Formula extends PredicateFormula = PredicateFormula,
@@ -41,6 +51,15 @@ type EqLiteralValueOf<
     : never
   : never
 
+type NeqLiteralValuesOf<
+  NeqLiterals,
+  Key extends string
+> = NeqLiterals extends Record<string, string>
+  ? Key extends keyof NeqLiterals
+    ? NeqLiterals[Key]
+    : never
+  : never
+
 type MergeEqLiteralMaps<Left, Right> = {
   readonly [K in Extract<keyof Left | keyof Right, string>]:
     K extends keyof Left
@@ -54,6 +73,17 @@ type MergeEqLiteralMaps<Left, Right> = {
         : never
 }
 
+type MergeNeqLiteralMaps<Left, Right> = {
+  readonly [K in Extract<keyof Left | keyof Right, string>]:
+    K extends keyof Left
+      ? K extends keyof Right
+        ? 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]
 }
@@ -62,6 +92,7 @@ type MarkContradiction<Ctx extends AnyContext> = Context<
   Ctx["nonNullKeys"],
   Ctx["nullKeys"],
   Ctx["eqLiterals"],
+  Ctx["neqLiterals"],
   Ctx["sourceNames"],
   true,
   Ctx["unknown"]
@@ -71,6 +102,7 @@ type MarkUnknown<Ctx extends AnyContext> = Context<
   Ctx["nonNullKeys"],
   Ctx["nullKeys"],
   Ctx["eqLiterals"],
+  Ctx["neqLiterals"],
   Ctx["sourceNames"],
   Ctx["contradiction"],
   true
@@ -83,6 +115,7 @@ type AddNonNull<
   Ctx["nonNullKeys"] | Key,
   Ctx["nullKeys"],
   Ctx["eqLiterals"],
+  Ctx["neqLiterals"],
   Ctx["sourceNames"] | SourceNameOfKey<Key>,
   Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"],
   Ctx["unknown"]
@@ -95,6 +128,7 @@ type AddNull<
   Ctx["nonNullKeys"],
   Ctx["nullKeys"] | Key,
   Ctx["eqLiterals"],
+  Ctx["neqLiterals"],
   Ctx["sourceNames"] | SourceNameOfKey<Key>,
   Key extends Ctx["nonNullKeys"] ? true : Ctx["contradiction"],
   Ctx["unknown"]
@@ -108,11 +142,20 @@ type AddEqLiteral<
   Ctx["nonNullKeys"] | Key,
   Ctx["nullKeys"],
   FilterNeverValues<MergeEqLiteralMaps<Ctx["eqLiterals"], { readonly [K in Key]: Value }>>,
+  Ctx["neqLiterals"],
   Ctx["sourceNames"] | SourceNameOfKey<Key>,
   EqLiteralValueOf<Ctx["eqLiterals"], Key> extends never
-    ? Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"]
+    ? NeqLiteralValuesOf<Ctx["neqLiterals"], Key> extends infer NeqValues
+      ? Value extends NeqValues
+        ? true
+        : Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"]
+      : true
     : EqLiteralValueOf<Ctx["eqLiterals"], Key> extends Value
-      ? Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"]
+      ? NeqLiteralValuesOf<Ctx["neqLiterals"], Key> extends infer NeqValues
+        ? Value extends NeqValues
+          ? true
+          : Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"]
+        : true
       : true,
   Ctx["unknown"]
 >
@@ -120,8 +163,22 @@ type AddEqLiteral<
 type AddNeqLiteral<
   Ctx extends AnyContext,
   Key extends string,
-  _Value extends string
-> = AddNonNull<Ctx, Key>
+  Value extends string
+> = Context<
+  Ctx["nonNullKeys"] | Key,
+  Ctx["nullKeys"],
+  Ctx["eqLiterals"],
+  FilterNeverValues<MergeNeqLiteralMaps<Ctx["neqLiterals"], { readonly [K in Key]: Value }>>,
+  Ctx["sourceNames"] | SourceNameOfKey<Key>,
+  EqLiteralValueOf<Ctx["eqLiterals"], Key> extends infer EqValue
+    ? [EqValue] extends [never]
+      ? Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"]
+      : EqValue extends Value
+        ? true
+        : Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"]
+    : true,
+  Ctx["unknown"]
+>
 
 type ApplyEqColumn<
   Ctx extends AnyContext,
@@ -177,7 +234,7 @@ type ApplyNegativeAtom<
     : Atom extends NonNullAtom<infer Key extends string>
       ? AddNull<Ctx, Key>
       : Atom extends EqLiteralAtom<infer Key extends string, infer Value extends string>
-        ? AddNonNull<Ctx, Key>
+        ? 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>
@@ -203,6 +260,14 @@ type IntersectEqLiteralMaps<
   readonly [K in Extract<keyof Left, keyof Right>]: Left[K] extends Right[K] ? Left[K] : never
 }>
 
+type IntersectNeqLiteralMaps<
+  Left,
+  Right
+> = FilterNeverValues<{
+  readonly [K in Extract<keyof Left, keyof Right>]:
+    Extract<Left[K], Right[K]> extends never ? never : Extract<Left[K], Right[K]>
+}>
+
 type IntersectContexts<
   Left extends AnyContext,
   Right extends AnyContext
@@ -210,6 +275,7 @@ type IntersectContexts<
   Extract<Left["nonNullKeys"], Right["nonNullKeys"]>,
   Extract<Left["nullKeys"], Right["nullKeys"]>,
   IntersectEqLiteralMaps<Left["eqLiterals"], Right["eqLiterals"]>,
+  IntersectNeqLiteralMaps<Left["neqLiterals"], Right["neqLiterals"]>,
   Extract<Left["sourceNames"], Right["sourceNames"]>,
   Left["contradiction"] extends true
     ? Right["contradiction"]
@@ -228,7 +294,7 @@ type AnalyzeAnyBranches<
   infer Head extends PredicateFormula,
   ...infer Tail extends readonly PredicateFormula[]
 ]
-  ? AnalyzeStack<Ctx, readonly [Frame<Head, Direction>]> extends infer Branch extends AnyContext
+  ? AnalyzeBranch<Ctx, Head, Direction> extends infer Branch extends AnyContext
     ? Branch["contradiction"] extends true
       ? AnalyzeAnyBranches<Ctx, Tail, Direction, Current>
       : [Current] extends [never]
@@ -241,6 +307,41 @@ type AnalyzeAnyBranches<
 
 type Flip<Direction extends Polarity> = Direction extends "positive" ? "negative" : "positive"
 
+type AnalyzeBranch<
+  Ctx extends AnyContext,
+  Formula extends PredicateFormula,
+  Direction extends Polarity
+> = AnalyzeStack<Ctx, readonly [Frame<Formula, Direction>]>
+
+type AnalyzeFrame<
+  Ctx extends AnyContext,
+  Formula extends PredicateFormula,
+  Direction extends Polarity,
+  Tail extends readonly Frame[]
+> = [Formula] extends [TrueFormula]
+  ? Direction extends "positive"
+    ? AnalyzeStack<Ctx, Tail>
+    : MarkContradiction<Ctx>
+  : [Formula] extends [FalseFormula]
+    ? Direction extends "positive"
+      ? MarkContradiction<Ctx>
+      : AnalyzeStack<Ctx, Tail>
+    : [Formula] extends [AtomFormula<infer Atom extends PredicateAtom>]
+      ? Direction extends "positive"
+        ? AnalyzeStack<ApplyAtom<Ctx, Atom>, Tail>
+        : AnalyzeStack<ApplyNegativeAtom<Ctx, Atom>, Tail>
+      : [Formula] extends [NotFormula<infer Item extends PredicateFormula>]
+        ? AnalyzeStack<Ctx, readonly [Frame<Item, Flip<Direction>>, ...Tail]>
+        : [Formula] extends [AllFormula<infer Items extends readonly PredicateFormula[]>]
+          ? Direction extends "positive"
+            ? AnalyzeStack<Ctx, readonly [...FramesFromItems<Items, "positive">, ...Tail]>
+            : AnalyzeStack<AnalyzeAnyBranches<Ctx, Items, "negative">, Tail>
+          : [Formula] extends [AnyFormula<infer Items extends readonly PredicateFormula[]>]
+            ? Direction extends "positive"
+              ? AnalyzeStack<AnalyzeAnyBranches<Ctx, Items, "positive">, Tail>
+              : AnalyzeStack<Ctx, readonly [...FramesFromItems<Items, "negative">, ...Tail]>
+            : AnalyzeStack<MarkUnknown<Ctx>, Tail>
+
 export type AnalyzeStack<
   Ctx extends AnyContext,
   Stack extends readonly Frame[]
@@ -250,29 +351,7 @@ export type AnalyzeStack<
       infer Head extends Frame,
       ...infer Tail extends readonly Frame[]
     ]
-    ? Head["formula"] extends TrueFormula
-      ? Head["polarity"] extends "positive"
-        ? AnalyzeStack<Ctx, Tail>
-        : MarkContradiction<Ctx>
-      : Head["formula"] extends FalseFormula
-        ? Head["polarity"] extends "positive"
-          ? MarkContradiction<Ctx>
-          : AnalyzeStack<Ctx, Tail>
-        : Head["formula"] extends AtomFormula<infer Atom extends PredicateAtom>
-          ? Head["polarity"] extends "positive"
-            ? AnalyzeStack<ApplyAtom<Ctx, Atom>, Tail>
-            : AnalyzeStack<ApplyNegativeAtom<Ctx, Atom>, Tail>
-          : Head["formula"] extends NotFormula<infer Item extends PredicateFormula>
-            ? AnalyzeStack<Ctx, readonly [Frame<Item, Flip<Head["polarity"]>>, ...Tail]>
-            : Head["formula"] extends AllFormula<infer Items extends readonly PredicateFormula[]>
-              ? Head["polarity"] extends "positive"
-                ? AnalyzeStack<Ctx, readonly [...FramesFromItems<Items, "positive">, ...Tail]>
-                : AnalyzeStack<AnalyzeAnyBranches<Ctx, Items, "negative">, Tail>
-              : Head["formula"] extends AnyFormula<infer Items extends readonly PredicateFormula[]>
-                ? Head["polarity"] extends "positive"
-                  ? AnalyzeStack<AnalyzeAnyBranches<Ctx, Items, "positive">, Tail>
-                  : AnalyzeStack<Ctx, readonly [...FramesFromItems<Items, "negative">, ...Tail]>
-                : AnalyzeStack<MarkUnknown<Ctx>, Tail>
+    ? AnalyzeFrame<Ctx, Head["formula"], Head["polarity"], Tail>
     : Ctx
 
 export type AnalyzeFormula<Formula extends PredicateFormula> =

package/src/internal/predicate/formula.d.ts

@@ -0,0 +1,35 @@
+import type { PredicateAtom } from "./atom.js";
+export interface TrueFormula {
+    readonly kind: "true";
+}
+export interface FalseFormula {
+    readonly kind: "false";
+}
+export interface AtomFormula<Atom extends PredicateAtom> {
+    readonly kind: "atom";
+    readonly atom: Atom;
+}
+export interface AllFormula<Items extends readonly PredicateFormula[]> {
+    readonly kind: "all";
+    readonly items: Items;
+}
+export interface AnyFormula<Items extends readonly PredicateFormula[]> {
+    readonly kind: "any";
+    readonly items: Items;
+}
+export interface NotFormula<Item extends PredicateFormula> {
+    readonly kind: "not";
+    readonly item: Item;
+}
+export type PredicateFormula = TrueFormula | FalseFormula | AtomFormula<PredicateAtom> | AllFormula<readonly PredicateFormula[]> | AnyFormula<readonly PredicateFormula[]> | NotFormula<PredicateFormula>;
+type NormalizeAllItems<Items extends readonly PredicateFormula[], Current extends readonly PredicateFormula[] = []> = Items extends readonly [infer Head extends PredicateFormula, ...infer Tail extends readonly PredicateFormula[]] ? Head extends TrueFormula ? NormalizeAllItems<Tail, Current> : Head extends FalseFormula ? [FalseFormula] : Head extends AllFormula<infer Nested extends readonly PredicateFormula[]> ? NormalizeAllItems<[...Nested, ...Tail], Current> : NormalizeAllItems<Tail, [...Current, Head]> : Current;
+type NormalizeAnyItems<Items extends readonly PredicateFormula[], Current extends readonly PredicateFormula[] = []> = Items extends readonly [infer Head extends PredicateFormula, ...infer Tail extends readonly PredicateFormula[]] ? Head extends FalseFormula ? NormalizeAnyItems<Tail, Current> : Head extends TrueFormula ? [TrueFormula] : Head extends AnyFormula<infer Nested extends readonly PredicateFormula[]> ? NormalizeAnyItems<[...Nested, ...Tail], Current> : NormalizeAnyItems<Tail, [...Current, Head]> : Current;
+type CollapseNormalizedAll<Items extends readonly PredicateFormula[]> = NormalizeAllItems<Items> extends infer Normalized extends readonly PredicateFormula[] ? [Normalized] extends [readonly [FalseFormula]] ? FalseFormula : [Normalized] extends [readonly []] ? TrueFormula : [Normalized] extends [readonly [infer Only extends PredicateFormula]] ? Only : AllFormula<Normalized> : never;
+type CollapseNormalizedAny<Items extends readonly PredicateFormula[]> = NormalizeAnyItems<Items> extends infer Normalized extends readonly PredicateFormula[] ? [Normalized] extends [readonly [TrueFormula]] ? TrueFormula : [Normalized] extends [readonly []] ? FalseFormula : [Normalized] extends [readonly [infer Only extends PredicateFormula]] ? Only : AnyFormula<Normalized> : never;
+export type NormalizeBooleanConstants<Formula extends PredicateFormula> = [
+    Formula
+] extends [AllFormula<infer Items extends readonly PredicateFormula[]>] ? CollapseNormalizedAll<Items> : [Formula] extends [AnyFormula<infer Items extends readonly PredicateFormula[]>] ? CollapseNormalizedAny<Items> : [Formula] extends [NotFormula<infer Item extends PredicateFormula>] ? [Item] extends [TrueFormula] ? FalseFormula : [Item] extends [FalseFormula] ? TrueFormula : Formula : Formula;
+export type And<Left extends PredicateFormula, Right extends PredicateFormula> = NormalizeBooleanConstants<AllFormula<[Left, Right]>>;
+export type Or<Left extends PredicateFormula, Right extends PredicateFormula> = NormalizeBooleanConstants<AnyFormula<[Left, Right]>>;
+export type Not<Value extends PredicateFormula> = NormalizeBooleanConstants<NotFormula<Value>>;
+export {};

package/src/internal/{predicate-formula.ts → predicate/formula.ts}

@@ -1,4 +1,4 @@
-import type { PredicateAtom } from "./predicate-atom.js"
+import type { PredicateAtom } from "./atom.js"
 
 export interface TrueFormula {
   readonly kind: "true"
@@ -62,27 +62,39 @@ type NormalizeAnyItems<
         : NormalizeAnyItems<Tail, [...Current, Head]>
   : Current
 
-export type NormalizeBooleanConstants<Formula extends PredicateFormula> =
-  Formula extends AllFormula<infer Items extends readonly PredicateFormula[]>
-    ? NormalizeAllItems<Items> extends [FalseFormula]
+type CollapseNormalizedAll<
+  Items extends readonly PredicateFormula[]
+> = NormalizeAllItems<Items> extends infer Normalized extends readonly PredicateFormula[]
+  ? [Normalized] extends [readonly [FalseFormula]]
+    ? FalseFormula
+    : [Normalized] extends [readonly []]
+      ? TrueFormula
+      : [Normalized] extends [readonly [infer Only extends PredicateFormula]]
+        ? Only
+        : AllFormula<Normalized>
+  : never
+
+type CollapseNormalizedAny<
+  Items extends readonly PredicateFormula[]
+> = NormalizeAnyItems<Items> extends infer Normalized extends readonly PredicateFormula[]
+  ? [Normalized] extends [readonly [TrueFormula]]
+    ? TrueFormula
+    : [Normalized] extends [readonly []]
       ? FalseFormula
-      : NormalizeAllItems<Items> extends readonly []
-        ? TrueFormula
-        : NormalizeAllItems<Items> extends readonly [infer Only extends PredicateFormula]
-          ? Only
-          : AllFormula<NormalizeAllItems<Items>>
-    : Formula extends AnyFormula<infer Items extends readonly PredicateFormula[]>
-      ? NormalizeAnyItems<Items> extends [TrueFormula]
-        ? TrueFormula
-        : NormalizeAnyItems<Items> extends readonly []
-          ? FalseFormula
-          : NormalizeAnyItems<Items> extends readonly [infer Only extends PredicateFormula]
-            ? Only
-            : AnyFormula<NormalizeAnyItems<Items>>
-      : Formula extends NotFormula<infer Item extends PredicateFormula>
-        ? Item extends TrueFormula
+      : [Normalized] extends [readonly [infer Only extends PredicateFormula]]
+        ? Only
+        : AnyFormula<Normalized>
+  : never
+
+export type NormalizeBooleanConstants<Formula extends PredicateFormula> =
+  [Formula] extends [AllFormula<infer Items extends readonly PredicateFormula[]>]
+    ? CollapseNormalizedAll<Items>
+    : [Formula] extends [AnyFormula<infer Items extends readonly PredicateFormula[]>]
+      ? CollapseNormalizedAny<Items>
+      : [Formula] extends [NotFormula<infer Item extends PredicateFormula>]
+        ? [Item] extends [TrueFormula]
           ? FalseFormula
-          : Item extends FalseFormula
+          : [Item] extends [FalseFormula]
             ? TrueFormula
             : Formula
         : Formula

package/src/internal/predicate/key.d.ts

@@ -0,0 +1,11 @@
+import type * as Expression from "../scalar.js";
+import type * as ExpressionAst from "../expression-ast.js";
+export type ColumnKey<TableName extends string, ColumnName extends string> = `${TableName}.${ColumnName}`;
+export type ColumnKeyOfAst<Ast extends ExpressionAst.Any> = Ast extends ExpressionAst.ColumnNode<infer TableName extends string, infer ColumnName extends string> ? ColumnKey<TableName, ColumnName> : never;
+type AstOf<Value extends Expression.Any> = Value extends {
+    readonly [ExpressionAst.TypeId]: infer Ast extends ExpressionAst.Any;
+} ? Ast : never;
+export type ColumnKeyOfExpression<Value extends Expression.Any> = ColumnKeyOfAst<AstOf<Value>>;
+export type LiteralKey<Value> = Value extends string ? `string:${Value}` : Value extends number ? `number:${Value}` : Value extends boolean ? `boolean:${Value}` : Value extends null ? "null" : Value extends Date ? `date:${string}` : "unknown";
+export type ValueKey<Value> = LiteralKey<Value>;
+export {};

package/src/internal/{predicate-key.ts → predicate/key.ts}

@@ -1,5 +1,5 @@
-import type * as Expression from "./expression.js"
-import type * as ExpressionAst from "./expression-ast.js"
+import type * as Expression from "../scalar.js"
+import type * as ExpressionAst from "../expression-ast.js"
 
 export type ColumnKey<
   TableName extends string,

package/src/internal/{predicate-nnf.ts → predicate/nnf.ts}

@@ -1,5 +1,5 @@
-import type { EqColumnAtom, EqLiteralAtom, NeqLiteralAtom, NonNullAtom, NullAtom, PredicateAtom, UnknownAtom } from "./predicate-atom.js"
-import type { PredicateFormula } from "./predicate-formula.js"
+import type { EqColumnAtom, EqLiteralAtom, NeqLiteralAtom, NonNullAtom, NullAtom, PredicateAtom, UnknownAtom } from "./atom.js"
+import type { PredicateFormula } from "./formula.js"
 
 export type NegateAtom<Atom extends PredicateAtom> =
   Atom extends NullAtom<infer Key extends string> ? NonNullAtom<Key> :

package/src/internal/predicate/normalize.d.ts

@@ -0,0 +1,53 @@
+import type * as Expression from "../scalar.js";
+import type * as ExpressionAst from "../expression-ast.js";
+import type { ColumnKeyOfExpression, ValueKey } from "./key.js";
+import type { AllFormula, AnyFormula, AtomFormula, FalseFormula, PredicateFormula, TrueFormula } from "./formula.js";
+import type { EqLiteralAtom, NeqLiteralAtom, NonNullAtom, NullAtom, UnknownAtom } from "./atom.js";
+type AstOf<Value extends Expression.Any> = Value extends {
+    readonly [ExpressionAst.TypeId]: infer Ast extends ExpressionAst.Any;
+} ? Ast : never;
+type LiteralValueOfExpression<Value extends Expression.Any> = AstOf<Value> extends ExpressionAst.LiteralNode<infer Literal> ? Literal : never;
+type True = TrueFormula;
+type False = FalseFormula;
+type UnknownTag<Tag extends string> = AtomFormula<UnknownAtom<Tag>>;
+type AtomOf<Atom extends import("./atom.js").PredicateAtom> = AtomFormula<Atom>;
+type FactOf<Atom extends import("./atom.js").PredicateAtom> = AtomFormula<Atom>;
+type NonNullFactsOfExpression<Value extends Expression.Any> = [
+    ColumnKeyOfExpression<Value>
+] extends [never] ? never : FactOf<NonNullAtom<ColumnKeyOfExpression<Value>>>;
+type CombineFacts<Left extends PredicateFormula, Right extends PredicateFormula> = [Left] extends [never] ? Right : [Right] extends [never] ? Left : import("./formula.js").NormalizeBooleanConstants<AllFormula<[Left, Right]>>;
+type FactsOfExpressions<Values extends readonly Expression.Any[]> = Values extends readonly [
+    infer Head extends Expression.Any,
+    ...infer Tail extends readonly Expression.Any[]
+] ? CombineFacts<FormulaOfExpression<Head>, FactsOfExpressions<Tail>> : never;
+type FormulaOfEq<Left extends Expression.Any, Right extends Expression.Any> = [
+    ColumnKeyOfExpression<Left>
+] extends [never] ? [ColumnKeyOfExpression<Right>] extends [never] ? LiteralValueOfExpression<Left> extends infer LeftLiteral ? LiteralValueOfExpression<Right> extends infer RightLiteral ? [LeftLiteral] extends [never] ? UnknownTag<"eq:unsupported"> : [RightLiteral] extends [never] ? UnknownTag<"eq:unsupported"> : LeftLiteral extends null ? False : RightLiteral extends null ? False : [LeftLiteral] extends [RightLiteral] ? True : False : UnknownTag<"eq:unsupported"> : UnknownTag<"eq:unsupported"> : LiteralValueOfExpression<Left> extends infer LeftLiteral ? [LeftLiteral] extends [never] ? UnknownTag<"eq:unsupported"> : LeftLiteral extends null ? False : AtomOf<EqLiteralAtom<ColumnKeyOfExpression<Right>, ValueKey<LeftLiteral>>> : UnknownTag<"eq:unsupported"> : [ColumnKeyOfExpression<Right>] extends [never] ? LiteralValueOfExpression<Right> extends infer RightLiteral ? [RightLiteral] extends [never] ? UnknownTag<"eq:unsupported"> : RightLiteral extends null ? False : AtomOf<EqLiteralAtom<ColumnKeyOfExpression<Left>, ValueKey<RightLiteral>>> : UnknownTag<"eq:unsupported"> : AtomOf<import("./atom.js").EqColumnAtom<ColumnKeyOfExpression<Left>, ColumnKeyOfExpression<Right>>>;
+type FormulaOfNeq<Left extends Expression.Any, Right extends Expression.Any> = [
+    ColumnKeyOfExpression<Left>
+] extends [never] ? [ColumnKeyOfExpression<Right>] extends [never] ? LiteralValueOfExpression<Left> extends infer LeftLiteral ? LiteralValueOfExpression<Right> extends infer RightLiteral ? [LeftLiteral] extends [never] ? UnknownTag<"neq:unsupported"> : [RightLiteral] extends [never] ? UnknownTag<"neq:unsupported"> : LeftLiteral extends null ? False : RightLiteral extends null ? False : [LeftLiteral] extends [RightLiteral] ? False : True : UnknownTag<"neq:unsupported"> : UnknownTag<"neq:unsupported"> : LiteralValueOfExpression<Left> extends infer LeftLiteral ? [LeftLiteral] extends [never] ? UnknownTag<"neq:unsupported"> : LeftLiteral extends null ? False : AtomOf<NeqLiteralAtom<ColumnKeyOfExpression<Right>, ValueKey<LeftLiteral>>> : UnknownTag<"neq:unsupported"> : [ColumnKeyOfExpression<Right>] extends [never] ? LiteralValueOfExpression<Right> extends infer RightLiteral ? [RightLiteral] extends [never] ? UnknownTag<"neq:unsupported"> : RightLiteral extends null ? False : AtomOf<NeqLiteralAtom<ColumnKeyOfExpression<Left>, ValueKey<RightLiteral>>> : UnknownTag<"neq:unsupported"> : CombineFacts<NonNullFactsOfExpression<Left>, NonNullFactsOfExpression<Right>>;
+type FormulaOfIsNotDistinctFrom<Left extends Expression.Any, Right extends Expression.Any> = LiteralValueOfExpression<Left> extends infer LeftLiteral ? LiteralValueOfExpression<Right> extends infer RightLiteral ? [LeftLiteral] extends [never] ? [RightLiteral] extends [never] ? UnknownTag<"isNotDistinctFrom:unsupported"> : RightLiteral extends null ? [ColumnKeyOfExpression<Left>] extends [never] ? UnknownTag<"isNotDistinctFrom:unsupported"> : AtomOf<NullAtom<ColumnKeyOfExpression<Left>>> : UnknownTag<"isNotDistinctFrom:unsupported"> : LeftLiteral extends null ? [ColumnKeyOfExpression<Right>] extends [never] ? UnknownTag<"isNotDistinctFrom:unsupported"> : AtomOf<NullAtom<ColumnKeyOfExpression<Right>>> : RightLiteral extends null ? [ColumnKeyOfExpression<Left>] extends [never] ? UnknownTag<"isNotDistinctFrom:unsupported"> : AtomOf<NullAtom<ColumnKeyOfExpression<Left>>> : [ColumnKeyOfExpression<Left>] extends [never] ? [ColumnKeyOfExpression<Right>] extends [never] ? CombineFacts<NonNullFactsOfExpression<Left>, NonNullFactsOfExpression<Right>> : AtomOf<EqLiteralAtom<ColumnKeyOfExpression<Right>, ValueKey<LeftLiteral>>> : AtomOf<EqLiteralAtom<ColumnKeyOfExpression<Left>, ValueKey<RightLiteral>>> : UnknownTag<"isNotDistinctFrom:unsupported"> : UnknownTag<"isNotDistinctFrom:unsupported">;
+type OrFormulas<Items extends readonly PredicateFormula[]> = import("./formula.js").NormalizeBooleanConstants<AnyFormula<Items>>;
+type AndFormulas<Items extends readonly PredicateFormula[]> = import("./formula.js").NormalizeBooleanConstants<AllFormula<Items>>;
+type FormulaTupleOf<Values extends readonly Expression.Any[]> = {
+    readonly [K in keyof Values]: Values[K] extends Expression.Any ? FormulaOfExpression<Values[K]> : never;
+} & readonly PredicateFormula[];
+type AllFormulaOfValues<Values extends readonly Expression.Any[]> = import("./formula.js").NormalizeBooleanConstants<AllFormula<FormulaTupleOf<Values>>>;
+type AnyFormulaOfValues<Values extends readonly Expression.Any[]> = import("./formula.js").NormalizeBooleanConstants<AnyFormula<FormulaTupleOf<Values>>>;
+type FormulaOfInValues<Left extends Expression.Any, Values extends readonly Expression.Any[], Current extends readonly PredicateFormula[] = []> = Values extends readonly [
+    infer Head extends Expression.Any,
+    ...infer Tail extends readonly Expression.Any[]
+] ? FormulaOfInValues<Left, Tail, [...Current, FormulaOfEq<Left, Head>]> : Current;
+type FormulaOfNotInValues<Left extends Expression.Any, Values extends readonly Expression.Any[], Current extends readonly PredicateFormula[] = []> = Values extends readonly [
+    infer Head extends Expression.Any,
+    ...infer Tail extends readonly Expression.Any[]
+] ? FormulaOfNotInValues<Left, Tail, [...Current, FormulaOfNeq<Left, Head>]> : Current;
+type FormulaOfVariadic<Kind extends ExpressionAst.VariadicKind, Values extends readonly Expression.Any[]> = Kind extends "and" ? AllFormulaOfValues<Values> : Kind extends "or" ? AnyFormulaOfValues<Values> : Kind extends "in" ? Values extends readonly [infer Left extends Expression.Any, ...infer Tail extends readonly Expression.Any[]] ? OrFormulas<FormulaOfInValues<Left, Tail>> : False : Kind extends "notIn" ? Values extends readonly [infer Left extends Expression.Any, ...infer Tail extends readonly Expression.Any[]] ? CombineFacts<NonNullFactsOfExpression<Left>, AndFormulas<FormulaOfNotInValues<Left, Tail>>> : True : Kind extends "between" ? FactsOfExpressions<Values> extends infer Facts extends PredicateFormula ? [Facts] extends [never] ? UnknownTag<"variadic:between"> : CombineFacts<Facts, UnknownTag<"variadic:between">> : UnknownTag<"variadic:between"> : UnknownTag<`variadic:${Kind}`>;
+type FormulaOfUnary<Kind extends ExpressionAst.UnaryKind, Inner extends Expression.Any> = Kind extends "isNull" ? [ColumnKeyOfExpression<Inner>] extends [never] ? UnknownTag<"isNull:unsupported"> : AtomOf<NullAtom<ColumnKeyOfExpression<Inner>>> : Kind extends "isNotNull" ? [ColumnKeyOfExpression<Inner>] extends [never] ? UnknownTag<"isNotNull:unsupported"> : AtomOf<NonNullAtom<ColumnKeyOfExpression<Inner>>> : Kind extends "not" ? import("./formula.js").Not<FormulaOfExpression<Inner>> : UnknownTag<`unary:${Kind}`>;
+type FormulaOfBinary<Kind extends ExpressionAst.BinaryKind, Left extends Expression.Any, Right extends Expression.Any> = Kind extends "eq" ? FormulaOfEq<Left, Right> : Kind extends "neq" ? FormulaOfNeq<Left, Right> : Kind extends "lt" | "lte" | "gt" | "gte" | "like" | "ilike" | "contains" | "containedBy" | "overlaps" ? CombineFacts<NonNullFactsOfExpression<Left>, NonNullFactsOfExpression<Right>> : Kind extends "isNotDistinctFrom" ? FormulaOfIsNotDistinctFrom<Left, Right> : Kind extends "isDistinctFrom" ? import("./formula.js").Not<FormulaOfIsNotDistinctFrom<Left, Right>> : CombineFacts<NonNullFactsOfExpression<Left>, NonNullFactsOfExpression<Right>>;
+type FormulaOfAst<Ast extends ExpressionAst.Any> = [Ast] extends [ExpressionAst.LiteralNode<infer Literal>] ? Literal extends true ? True : Literal extends false ? False : UnknownTag<"literal:non-boolean"> : [Ast] extends [ExpressionAst.UnaryNode<infer Kind extends ExpressionAst.UnaryKind, infer Inner extends Expression.Any>] ? FormulaOfUnary<Kind, Inner> : [Ast] extends [ExpressionAst.VariadicNode<infer Kind extends ExpressionAst.VariadicKind, infer Values extends readonly Expression.Any[]>] ? FormulaOfVariadic<Kind, Values> : [Ast] extends [ExpressionAst.BinaryNode<infer Kind extends ExpressionAst.BinaryKind, infer Left extends Expression.Any, infer Right extends Expression.Any>] ? FormulaOfBinary<Kind, Left, Right> : UnknownTag<`expr:${Ast["kind"]}`>;
+export type FormulaOfExpression<Value extends Expression.Any> = [
+    AstOf<Value>
+] extends [infer Ast extends ExpressionAst.Any] ? FormulaOfAst<Ast> : UnknownTag<"missing-ast">;
+export type FormulaOfPredicate<Value> = Value extends true ? True : Value extends false ? False : Value extends Expression.Any ? FormulaOfExpression<Value> : UnknownTag<"predicate:unsupported">;
+export {};