effect-qb 0.14.0 → 0.15.0

package/src/internal/json/ast.d.ts

@@ -0,0 +1,30 @@
+import type * as Expression from "../scalar.js";
+import type * as JsonPath from "./path.js";
+export type JsonKind = "jsonGet" | "jsonPath" | "jsonAccess" | "jsonTraverse" | "jsonGetText" | "jsonPathText" | "jsonAccessText" | "jsonTraverseText" | "jsonHasKey" | "jsonKeyExists" | "jsonHasAnyKeys" | "jsonHasAllKeys" | "jsonConcat" | "jsonMerge" | "jsonDelete" | "jsonDeletePath" | "jsonRemove" | "jsonSet" | "jsonInsert" | "jsonPathExists" | "jsonPathMatch" | "jsonBuildObject" | "jsonBuildArray" | "jsonToJson" | "jsonToJsonb" | "jsonTypeOf" | "jsonLength" | "jsonKeys" | "jsonStripNulls";
+/**
+ * Broad JSON AST node accepted by the renderer.
+ *
+ * The JSON subsystem is intentionally shaped as a small grammar rather than a
+ * collection of bespoke node interfaces. The renderer uses the `kind` plus the
+ * common field names below to lower the nodes into dialect SQL.
+ */
+export interface JsonNode<Kind extends JsonKind = JsonKind> {
+    readonly kind: Kind;
+    readonly value?: Expression.Any;
+    readonly base?: Expression.Any;
+    readonly left?: Expression.Any;
+    readonly right?: Expression.Any;
+    readonly path?: JsonPath.Path<any> | readonly any[];
+    readonly segments?: readonly any[];
+    readonly keys?: readonly string[];
+    readonly query?: string | Expression.Any;
+    readonly newValue?: Expression.Any;
+    readonly insert?: Expression.Any;
+    readonly createMissing?: boolean;
+    readonly insertAfter?: boolean;
+    readonly entries?: readonly {
+        readonly key: string;
+        readonly value: Expression.Any;
+    }[];
+    readonly values?: readonly Expression.Any[];
+}

package/src/internal/json/ast.ts

@@ -1,4 +1,4 @@
-import type * as Expression from ".././expression.js"
+import type * as Expression from "../scalar.js"
 import type * as JsonPath from "./path.js"
 
 export type JsonKind =

package/src/internal/json/errors.d.ts

@@ -0,0 +1,8 @@
+export type JsonPathUsageError<Operation extends string, Root, Path, Reason extends string> = {
+    readonly __effect_qb_error__: "effect-qb: invalid json path usage";
+    readonly __effect_qb_json_operation__: Operation;
+    readonly __effect_qb_json_reason__: Reason;
+    readonly __effect_qb_json_root__: Root;
+    readonly __effect_qb_json_path__: Path;
+    readonly __effect_qb_hint__: "Use key(...) on objects, index(...) on arrays, and prefer exact key/index paths when you want precise output typing";
+};

package/src/internal/json/path.d.ts

@@ -0,0 +1,75 @@
+import type * as Expression from "../scalar.js";
+import type { JsonPathUsageError } from "./errors.js";
+import type { JsonBuildArray as JsonBuildArrayResult, JsonBuildObject as JsonBuildObjectResult, JsonConcatResult, JsonDeleteAtPath, JsonLiteralInput, JsonStripNullsResult as JsonStripNullsResultValue, JsonValueAtPath, JsonSetAtPath } from "./types.js";
+import type { JsonKeysResult as JsonKeysResultValue, JsonLengthResult as JsonLengthResultValue, JsonTextResult as JsonTextResultValue, JsonTypeName as JsonTypeNameValue } from "./types.js";
+export declare const SegmentTypeId: unique symbol;
+export type SegmentTypeId = typeof SegmentTypeId;
+export declare const TypeId: unique symbol;
+export type TypeId = typeof TypeId;
+type SegmentState<Kind extends string> = {
+    readonly kind: Kind;
+};
+export interface KeySegment<Key extends string = string> {
+    readonly [SegmentTypeId]: SegmentState<"key">;
+    readonly kind: "key";
+    readonly key: Key;
+}
+export interface IndexSegment<Index extends number = number> {
+    readonly [SegmentTypeId]: SegmentState<"index">;
+    readonly kind: "index";
+    readonly index: Index;
+}
+export interface WildcardSegment {
+    readonly [SegmentTypeId]: SegmentState<"wildcard">;
+    readonly kind: "wildcard";
+}
+export interface SliceSegment<Start extends number | undefined = number | undefined, End extends number | undefined = number | undefined> {
+    readonly [SegmentTypeId]: SegmentState<"slice">;
+    readonly kind: "slice";
+    readonly start: Start;
+    readonly end: End;
+}
+export interface DescendSegment {
+    readonly [SegmentTypeId]: SegmentState<"descend">;
+    readonly kind: "descend";
+}
+export type CanonicalSegment = KeySegment | IndexSegment | WildcardSegment | SliceSegment | DescendSegment;
+export type AnySegment = any;
+export type ExactSegment = KeySegment | IndexSegment;
+type PathState<Segments extends readonly CanonicalSegment[]> = {
+    readonly segments: Segments;
+};
+export interface Path<Segments extends readonly CanonicalSegment[] = readonly CanonicalSegment[]> {
+    readonly [TypeId]: PathState<Segments>;
+    readonly segments: Segments;
+}
+export type JsonPath<Segments extends readonly CanonicalSegment[] = readonly CanonicalSegment[]> = Path<Segments>;
+export type JsonPathSegments = readonly CanonicalSegment[];
+export type JsonPrimitive = JsonLiteralInput;
+export type JsonLiteral = JsonLiteralInput;
+export type JsonInput = Expression.Any | JsonLiteral;
+export declare const key: <Key extends string>(value: Key) => KeySegment<Key>;
+export declare const index: <Index extends number>(value: Index) => IndexSegment<Index>;
+export declare const wildcard: () => WildcardSegment;
+export declare const slice: <Start extends number | undefined = undefined, End extends number | undefined = undefined>(start?: Start | undefined, end?: End | undefined) => SliceSegment<Start, End>;
+export declare const descend: () => DescendSegment;
+export declare const path: <Segments extends readonly CanonicalSegment[]>(...segments: Segments) => Path<Segments>;
+export declare const makeJsonPath: <Segments extends readonly CanonicalSegment[]>(...segments: Segments) => Path<Segments>;
+export type SegmentsOf<Value extends Path<any>> = Value[typeof TypeId]["segments"];
+export type IsExactSegment<Segment extends CanonicalSegment> = Segment extends ExactSegment ? true : false;
+export type IsExactPath<PathValue extends Path<any>> = SegmentsOf<PathValue> extends readonly [infer Head extends CanonicalSegment, ...infer Tail extends readonly CanonicalSegment[]] ? IsExactSegment<Head> extends true ? Tail extends readonly [] ? true : IsExactPath<Path<Tail>> : false : true;
+export type JsonPathValue<Root, PathValue extends Path<any>, Operation extends string = "json.get"> = JsonValueAtPath<Root, PathValue, Operation>;
+export type JsonPathOutput<Root, PathValue extends Path<any>, Operation extends string = "json.get"> = JsonValueAtPath<Root, PathValue, Operation>;
+export type JsonPathCompatible<Root, PathValue extends Path<any>, Operation extends string = "json.get"> = JsonValueAtPath<Root, PathValue, Operation> extends JsonPathUsageError<any, any, any, any> ? JsonValueAtPath<Root, PathValue, Operation> : PathValue;
+export type JsonPathUpdate<Root, PathValue extends Path<any>, Next, Operation extends string = "json.set"> = JsonSetAtPath<Root, PathValue, Next, Operation>;
+export type JsonPathDelete<Root, PathValue extends Path<any>, Operation extends string = "json.delete"> = JsonDeleteAtPath<Root, PathValue, Operation>;
+export type JsonConcat<Left, Right> = JsonConcatResult<Left, Right>;
+export type JsonBuildObject<Shape extends Record<string, JsonInput>> = JsonBuildObjectResult<Shape>;
+export type JsonBuildArray<Values extends readonly JsonInput[]> = JsonBuildArrayResult<Values>;
+export type JsonTextResult<Value> = JsonTextResultValue<Value>;
+export type JsonTypeName<Value> = JsonTypeNameValue<Value>;
+export type JsonLengthResult<Value> = JsonLengthResultValue<Value>;
+export type JsonKeysResult<Value> = JsonKeysResultValue<Value>;
+export type JsonStripNullsResult<Value> = JsonStripNullsResultValue<Value>;
+export type JsonValueOfInput<Input> = Input extends Expression.Any ? Expression.RuntimeOf<Input> : Input extends JsonLiteral ? Input : never;
+export {};

package/src/internal/json/path.ts

@@ -1,4 +1,4 @@
-import type * as Expression from ".././expression.js"
+import type * as Expression from "../scalar.js"
 import type { JsonPathUsageError } from "./errors.js"
 import type {
   JsonBuildArray as JsonBuildArrayResult,

package/src/internal/json/types.d.ts

@@ -0,0 +1,62 @@
+import type * as JsonPath from "./path.js";
+import type { JsonPathUsageError } from "./errors.js";
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+type OptionalKeyOf<ObjectType extends object, Key extends PropertyKey> = Key extends keyof ObjectType ? {} extends Pick<ObjectType, Key> ? true : false : true;
+type NormalizeJsonTuple<Values extends readonly unknown[]> = Values extends readonly [] ? readonly [] : Values extends readonly [infer Head, ...infer Tail] ? readonly [NormalizeJsonLiteral<Head>, ...NormalizeJsonTuple<Tail>] : readonly NormalizeJsonLiteral<Values[number]>[];
+type NormalizeJsonObject<ObjectType extends object> = {
+    readonly [Key in keyof ObjectType as Key extends string ? Key : never]: NormalizeJsonLiteral<Exclude<ObjectType[Key], undefined>>;
+};
+export type NormalizeJsonLiteral<Value> = [
+    Value
+] extends [never] ? never : Value extends JsonPrimitive ? Value : Value extends undefined | bigint | symbol | Date | ((...args: readonly any[]) => any) ? never : Value extends readonly unknown[] ? NormalizeJsonTuple<Value> : Value extends object ? NormalizeJsonObject<Value> : never;
+export type JsonLiteralInput = JsonPrimitive | readonly JsonLiteralInput[] | {
+    readonly [key: string]: JsonLiteralInput;
+};
+type StripNull<Value> = Exclude<Value, null>;
+type KeyStep<Root, Key extends string, Operation extends string> = Root extends readonly unknown[] ? JsonPathUsageError<Operation, Root, JsonPath.KeySegment<Key>, "key segments cannot be applied to arrays"> : Root extends object ? Key extends keyof Root ? NormalizeJsonLiteral<Exclude<Root[Key], undefined>> | (OptionalKeyOf<Root, Key> extends true ? null : never) : Root extends Record<string, infer Value> ? NormalizeJsonLiteral<Value> | null : null : JsonPathUsageError<Operation, Root, JsonPath.KeySegment<Key>, "key segments require an object-like json value">;
+type TupleIndex<Values extends readonly unknown[], Index extends number, Count extends readonly unknown[] = []> = Values extends readonly [infer Head, ...infer Tail] ? Count["length"] extends Index ? Head : TupleIndex<Tail, Index, [...Count, unknown]> : never;
+type DropTupleIndex<Values extends readonly unknown[], Index extends number, Count extends readonly unknown[] = []> = Values extends readonly [infer Head, ...infer Tail] ? Count["length"] extends Index ? readonly [...Tail] : readonly [Head, ...DropTupleIndex<Tail, Index, [...Count, unknown]>] : readonly [];
+type SetTupleIndex<Values extends readonly unknown[], Index extends number, Next, Count extends readonly unknown[] = []> = Values extends readonly [infer Head, ...infer Tail] ? Count["length"] extends Index ? readonly [Next, ...Tail] : readonly [Head, ...SetTupleIndex<Tail, Index, Next, [...Count, unknown]>] : readonly NormalizeJsonLiteral<Next>[];
+type InsertTupleIndex<Values extends readonly unknown[], Index extends number, Next, After extends boolean, Count extends readonly unknown[] = []> = Values extends readonly [infer Head, ...infer Tail] ? Count["length"] extends Index ? After extends true ? readonly [Head, NormalizeJsonLiteral<Next>, ...Tail] : readonly [NormalizeJsonLiteral<Next>, Head, ...Tail] : readonly [Head, ...InsertTupleIndex<Tail, Index, Next, After, [...Count, unknown]>] : readonly NormalizeJsonLiteral<Next>[];
+type IndexStep<Root, Index extends number, Operation extends string> = Root extends readonly unknown[] ? number extends Root["length"] ? NormalizeJsonLiteral<Root[number]> | null : NormalizeJsonLiteral<TupleIndex<Root, Index>> | (TupleIndex<Root, Index> extends never ? null : never) : JsonPathUsageError<Operation, Root, JsonPath.IndexSegment<Index>, "index segments require an array-like json value">;
+type NonExactStep<Root, Segment extends JsonPath.CanonicalSegment> = Segment extends JsonPath.WildcardSegment ? NormalizeJsonLiteral<Root> | null : Segment extends JsonPath.SliceSegment<any, any> ? NormalizeJsonLiteral<Root> | null : Segment extends JsonPath.DescendSegment ? NormalizeJsonLiteral<Root> | null : never;
+type StepValue<Root, Segment extends JsonPath.CanonicalSegment, Operation extends string> = Segment extends JsonPath.KeySegment<infer Key extends string> ? KeyStep<Root, Key, Operation> : Segment extends JsonPath.IndexSegment<infer Index extends number> ? IndexStep<Root, Index, Operation> : NonExactStep<Root, Segment>;
+type StepSet<Root, Segment extends JsonPath.CanonicalSegment, Next, Operation extends string> = Segment extends JsonPath.KeySegment<infer Key extends string> ? Root extends readonly unknown[] ? JsonPathUsageError<Operation, Root, Segment, "key segments cannot update arrays"> : Root extends object ? Omit<Root, Key> & {
+    readonly [K in Key]: NormalizeJsonLiteral<Next>;
+} : JsonPathUsageError<Operation, Root, Segment, "key segments require an object-like json value"> : Segment extends JsonPath.IndexSegment<infer Index extends number> ? Root extends readonly unknown[] ? number extends Root["length"] ? readonly (NormalizeJsonLiteral<Root[number]> | NormalizeJsonLiteral<Next>)[] : SetTupleIndex<Root, Index, Next> : JsonPathUsageError<Operation, Root, Segment, "index segments require an array-like json value"> : NormalizeJsonLiteral<Root>;
+type StepDelete<Root, Segment extends JsonPath.CanonicalSegment, Operation extends string> = Segment extends JsonPath.KeySegment<infer Key extends string> ? Root extends readonly unknown[] ? JsonPathUsageError<Operation, Root, Segment, "key segments cannot delete from arrays"> : Root extends object ? Omit<Root, Key> : JsonPathUsageError<Operation, Root, Segment, "key segments require an object-like json value"> : Segment extends JsonPath.IndexSegment<infer Index extends number> ? Root extends readonly unknown[] ? number extends Root["length"] ? Root : DropTupleIndex<Root, Index> : JsonPathUsageError<Operation, Root, Segment, "index segments require an array-like json value"> : NormalizeJsonLiteral<Root>;
+type StepInsert<Root, Segment extends JsonPath.CanonicalSegment, Next, After extends boolean, Operation extends string> = Segment extends JsonPath.IndexSegment<infer Index extends number> ? Root extends readonly unknown[] ? number extends Root["length"] ? readonly (NormalizeJsonLiteral<Root[number]> | NormalizeJsonLiteral<Next>)[] : InsertTupleIndex<Root, Index, Next, After> : JsonPathUsageError<Operation, Root, Segment, "index segments require an array-like json value"> : Segment extends JsonPath.KeySegment<infer Key extends string> ? Root extends readonly unknown[] ? JsonPathUsageError<Operation, Root, Segment, "key segments cannot insert into arrays"> : Root extends object ? Key extends keyof Root ? Root : Root & {
+    readonly [K in Key]: NormalizeJsonLiteral<Next>;
+} : JsonPathUsageError<Operation, Root, Segment, "key segments require an object-like json value"> : NormalizeJsonLiteral<Root>;
+type RecurseValue<Current, Segments extends readonly JsonPath.CanonicalSegment[], Operation extends string> = Segments extends readonly [infer Head extends JsonPath.CanonicalSegment, ...infer Tail extends readonly JsonPath.CanonicalSegment[]] ? StepValue<Current, Head, Operation> extends infer Next ? Next extends JsonPathUsageError<any, any, any, any> ? Next : Tail extends readonly [] ? Next : null extends Next ? RecurseValue<StripNull<Next>, Tail, Operation> | null : RecurseValue<Next, Tail, Operation> : never : NormalizeJsonLiteral<Current>;
+type RecurseSet<Current, Segments extends readonly JsonPath.CanonicalSegment[], Next, Operation extends string> = Segments extends readonly [infer Head extends JsonPath.CanonicalSegment, ...infer Tail extends readonly JsonPath.CanonicalSegment[]] ? Tail extends readonly [] ? StepSet<Current, Head, Next, Operation> : StepValue<Current, Head, Operation> extends infer Child ? Child extends JsonPathUsageError<any, any, any, any> ? Child : StepSet<Current, Head, RecurseSet<StripNull<Child>, Tail, Next, Operation>, Operation> : never : NormalizeJsonLiteral<Next>;
+type RecurseDelete<Current, Segments extends readonly JsonPath.CanonicalSegment[], Operation extends string> = Segments extends readonly [infer Head extends JsonPath.CanonicalSegment, ...infer Tail extends readonly JsonPath.CanonicalSegment[]] ? Tail extends readonly [] ? StepDelete<Current, Head, Operation> : StepValue<Current, Head, Operation> extends infer Child ? Child extends JsonPathUsageError<any, any, any, any> ? Child : StepSet<Current, Head, RecurseDelete<StripNull<Child>, Tail, Operation>, Operation> : never : NormalizeJsonLiteral<Current>;
+type RecurseInsert<Current, Segments extends readonly JsonPath.CanonicalSegment[], Next, After extends boolean, Operation extends string> = Segments extends readonly [infer Head extends JsonPath.CanonicalSegment, ...infer Tail extends readonly JsonPath.CanonicalSegment[]] ? Tail extends readonly [] ? StepInsert<Current, Head, Next, After, Operation> : StepValue<Current, Head, Operation> extends infer Child ? Child extends JsonPathUsageError<any, any, any, any> ? Child : StepSet<Current, Head, RecurseInsert<StripNull<Child>, Tail, Next, After, Operation>, Operation> : never : NormalizeJsonLiteral<Current>;
+export type JsonValueAtPath<Root, PathValue extends JsonPath.Path<any>, Operation extends string = "json.get"> = RecurseValue<NormalizeJsonLiteral<Root>, JsonPath.SegmentsOf<PathValue>, Operation>;
+export type JsonSetAtPath<Root, PathValue extends JsonPath.Path<any>, Next, Operation extends string = "json.set"> = RecurseSet<NormalizeJsonLiteral<Root>, JsonPath.SegmentsOf<PathValue>, Next, Operation>;
+export type JsonInsertAtPath<Root, PathValue extends JsonPath.Path<any>, Next, After extends boolean = false, Operation extends string = "json.insert"> = RecurseInsert<NormalizeJsonLiteral<Root>, JsonPath.SegmentsOf<PathValue>, Next, After, Operation>;
+export type JsonDeleteAtPath<Root, PathValue extends JsonPath.Path<any>, Operation extends string = "json.delete"> = RecurseDelete<NormalizeJsonLiteral<Root>, JsonPath.SegmentsOf<PathValue>, Operation>;
+type ArrayElement<Value> = Value extends readonly (infer Element)[] ? Element : never;
+type MergeJsonObjects<Left extends object, Right extends object> = Omit<Left, keyof Right> & Right;
+type StripNullsTuple<Values extends readonly unknown[]> = Values extends readonly [] ? readonly [] : Values extends readonly [infer Head, ...infer Tail] ? readonly [JsonStripNullsResult<Head>, ...StripNullsTuple<Tail>] : readonly JsonStripNullsResult<Values[number]>[];
+type StripNullsObject<ObjectType extends object> = ({
+    readonly [Key in keyof ObjectType as Key extends string ? null extends NormalizeJsonLiteral<Exclude<ObjectType[Key], undefined>> ? never : Key : never]-?: JsonStripNullsResult<Exclude<ObjectType[Key], null>>;
+} & {
+    readonly [Key in keyof ObjectType as Key extends string ? null extends NormalizeJsonLiteral<Exclude<ObjectType[Key], undefined>> ? Key : never : never]?: JsonStripNullsResult<Exclude<ObjectType[Key], null>>;
+});
+export type JsonStripNullsResult<Value> = Value extends null ? null : Value extends readonly unknown[] ? StripNullsTuple<Value> : Value extends object ? StripNullsObject<Value> : Value;
+export type JsonConcatResult<Left, Right> = NormalizeJsonLiteral<Left> extends infer NormalizedLeft ? NormalizeJsonLiteral<Right> extends infer NormalizedRight ? NormalizedLeft extends readonly unknown[] ? NormalizedRight extends readonly unknown[] ? number extends NormalizedLeft["length"] | NormalizedRight["length"] ? readonly (ArrayElement<NormalizedLeft> | ArrayElement<NormalizedRight>)[] : readonly [...NormalizedLeft, ...NormalizedRight] : unknown : NormalizedLeft extends object ? NormalizedRight extends object ? MergeJsonObjects<NormalizedLeft, NormalizedRight> : unknown : unknown : never : never;
+export type JsonBuildObject<Shape extends Record<string, unknown>> = {
+    readonly [K in keyof Shape]: NormalizeJsonLiteral<Shape[K]>;
+};
+export type JsonBuildArray<Values extends readonly unknown[]> = {
+    readonly [K in keyof Values]: NormalizeJsonLiteral<Values[K]>;
+} & readonly unknown[];
+export type JsonTextResult<Value> = Value extends JsonPrimitive ? `${Value}` : string;
+export type JsonTypeName<Value> = NormalizeJsonLiteral<Value> extends null ? "null" : NormalizeJsonLiteral<Value> extends string ? "string" : NormalizeJsonLiteral<Value> extends number ? "number" : NormalizeJsonLiteral<Value> extends boolean ? "boolean" : NormalizeJsonLiteral<Value> extends readonly unknown[] ? "array" : NormalizeJsonLiteral<Value> extends object ? "object" : "unknown";
+export type JsonLengthResult<Value> = NormalizeJsonLiteral<Value> extends readonly unknown[] ? number : NormalizeJsonLiteral<Value> extends object ? number : null;
+export type JsonKeysResult<Value> = NormalizeJsonLiteral<Value> extends object ? NormalizeJsonLiteral<Value> extends readonly unknown[] ? readonly [] : readonly Extract<keyof NormalizeJsonLiteral<Value>, string>[] : null;
+export {};

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

@@ -0,0 +1,20 @@
+import type { AnalyzeFormula } 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 GuaranteedNonNullKeys<Assumptions extends PredicateFormula> = ContextOf<Assumptions>["nonNullKeys"];
+export type GuaranteedNullKeys<Assumptions extends PredicateFormula> = ContextOf<Assumptions>["nullKeys"];
+export type GuaranteedSourceNames<Assumptions extends PredicateFormula> = ContextOf<Assumptions>["sourceNames"];
+export type GuaranteedEqLiteral<Assumptions extends PredicateFormula, Key extends string> = Key extends keyof ContextOf<Assumptions>["eqLiterals"] ? ContextOf<Assumptions>["eqLiterals"][Key] : never;
+type IsContradiction<Formula extends PredicateFormula> = ContextOf<Formula>["contradiction"] extends true ? true : false;
+type ContradictoryAssumption<Assumptions extends PredicateFormula, Formula extends PredicateFormula> = IsContradiction<And<Assumptions, Formula>>;
+type ContradictionFromNegation<Assumptions extends PredicateFormula, Formula extends PredicateFormula> = IsContradiction<And<Assumptions, Not<Formula>>>;
+export type ContradictsFormula<Assumptions extends PredicateFormula, Formula extends PredicateFormula> = ContradictoryAssumption<Assumptions, Formula>;
+export type ImpliesFormula<Assumptions extends PredicateFormula, Formula extends PredicateFormula> = ContradictionFromNegation<Assumptions, Formula>;
+export type AssumeFormulaTrue<Assumptions extends PredicateFormula, Formula extends PredicateFormula> = Assumptions extends TrueFormula ? Formula : And<Assumptions, Formula>;
+export type AssumeFormulaFalse<Assumptions extends PredicateFormula, Formula extends PredicateFormula> = Assumptions extends TrueFormula ? Not<Formula> : And<Assumptions, Not<Formula>>;
+export type AssumeTrue<Assumptions extends PredicateFormula, Predicate> = AssumeFormulaTrue<Assumptions, FormulaOfPredicate<Predicate>>;
+export type AssumeFalse<Assumptions extends PredicateFormula, Predicate> = AssumeFormulaFalse<Assumptions, FormulaOfPredicate<Predicate>>;
+export type Contradicts<Assumptions extends PredicateFormula, Predicate> = ContradictoryAssumption<Assumptions, FormulaOfPredicate<Predicate>>;
+export type Implies<Assumptions extends PredicateFormula, Predicate> = ContradictionFromNegation<Assumptions, FormulaOfPredicate<Predicate>>;
+export {};

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

@@ -1,6 +1,6 @@
-import type { AnalyzeFormula } from "./predicate-context.js"
-import type { FormulaOfPredicate } from "./predicate-normalize.js"
-import type { And, Not, PredicateFormula, TrueFormula } from "./predicate-formula.js"
+import type { AnalyzeFormula } 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>
 

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

@@ -0,0 +1,28 @@
+export interface NullAtom<Key extends string> {
+    readonly kind: "is-null";
+    readonly key: Key;
+}
+export interface NonNullAtom<Key extends string> {
+    readonly kind: "is-not-null";
+    readonly key: Key;
+}
+export interface EqLiteralAtom<Key extends string, Value extends string> {
+    readonly kind: "eq-literal";
+    readonly key: Key;
+    readonly value: Value;
+}
+export interface NeqLiteralAtom<Key extends string, Value extends string> {
+    readonly kind: "neq-literal";
+    readonly key: Key;
+    readonly value: Value;
+}
+export interface EqColumnAtom<LeftKey extends string, RightKey extends string> {
+    readonly kind: "eq-column";
+    readonly left: LeftKey;
+    readonly right: RightKey;
+}
+export interface UnknownAtom<Tag extends string> {
+    readonly kind: "unknown";
+    readonly tag: Tag;
+}
+export type PredicateAtom = NullAtom<string> | NonNullAtom<string> | EqLiteralAtom<string, string> | NeqLiteralAtom<string, string> | EqColumnAtom<string, string> | UnknownAtom<string>;

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

@@ -1,5 +1,5 @@
-import type { PredicateAtom } from "./predicate-atom.js"
-import type { AtomFormula, FalseFormula, PredicateFormula, TrueFormula } from "./predicate-formula.js"
+import type { PredicateAtom } from "./atom.js"
+import type { AtomFormula, FalseFormula, PredicateFormula, TrueFormula } from "./formula.js"
 
 export interface BranchLimitExceeded {
   readonly kind: "branch-limit-exceeded"

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"
 
@@ -246,9 +246,12 @@ type ApplyNegativeAtom<
 type FramesFromItems<
   Items extends readonly PredicateFormula[],
   Direction extends Polarity
-> = {
-  readonly [K in keyof Items]: Items[K] extends PredicateFormula ? Frame<Items[K], Direction> : never
-} & readonly Frame[]
+> = Items extends readonly [
+  infer Head extends PredicateFormula,
+  ...infer Tail extends readonly PredicateFormula[]
+]
+  ? readonly [Frame<Head, Direction>, ...FramesFromItems<Tail, Direction>]
+  : readonly []
 
 type IntersectEqLiteralMaps<
   Left,

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"

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 {};