effect-qb 0.15.0 → 0.17.0

package/src/internal/grouping-key.ts

@@ -1,5 +1,23 @@
 import * as Expression from "./scalar.js"
 import * as ExpressionAst from "./expression-ast.js"
+import * as JsonPath from "./json/path.js"
+import { columnPredicateKey } from "./predicate/runtime.js"
+
+const subqueryPlanIds = new WeakMap<object, string>()
+let nextSubqueryPlanId = 0
+
+const subqueryPlanGroupingKey = (plan: unknown): string => {
+  if (plan === null || typeof plan !== "object") {
+    return "unknown"
+  }
+  const existing = subqueryPlanIds.get(plan)
+  if (existing !== undefined) {
+    return existing
+  }
+  const next = `${nextSubqueryPlanId++}`
+  subqueryPlanIds.set(plan, next)
+  return next
+}
 
 const literalGroupingKey = (value: unknown): string => {
   if (value instanceof Date) {
@@ -20,17 +38,84 @@ const literalGroupingKey = (value: unknown): string => {
   }
 }
 
+const isExpression = (value: unknown): value is Expression.Any =>
+  value !== null && typeof value === "object" && Expression.TypeId in value
+
+const expressionGroupingKey = (value: unknown): string =>
+  isExpression(value) ? groupingKeyOfExpression(value) : "missing"
+
+const escapeGroupingText = (value: string): string =>
+  value
+    .replace(/\\/g, "\\\\")
+    .replace(/,/g, "\\,")
+    .replace(/\|/g, "\\|")
+    .replace(/=/g, "\\=")
+    .replace(/>/g, "\\>")
+
+const jsonSegmentGroupingKey = (segment: unknown): string => {
+  if (segment !== null && typeof segment === "object" && "kind" in segment) {
+    switch ((segment as { readonly kind: string }).kind) {
+      case "key":
+        return `key:${escapeGroupingText((segment as JsonPath.KeySegment).key)}`
+      case "index":
+        return `index:${(segment as JsonPath.IndexSegment).index}`
+      case "wildcard":
+        return "wildcard"
+      case "slice": {
+        const slice = segment as JsonPath.SliceSegment
+        return `slice:${slice.start ?? ""}:${slice.end ?? ""}`
+      }
+      case "descend":
+        return "descend"
+    }
+  }
+  if (typeof segment === "string") {
+    return `key:${escapeGroupingText(segment)}`
+  }
+  if (typeof segment === "number") {
+    return `index:${segment}`
+  }
+  return "unknown"
+}
+
+const jsonPathGroupingKey = (segments: readonly unknown[] | undefined): string =>
+  (segments ?? []).map(jsonSegmentGroupingKey).join(",")
+
+const isJsonPath = (value: unknown): value is JsonPath.Path =>
+  value !== null && typeof value === "object" && JsonPath.TypeId in value
+
+const jsonOpaquePathGroupingKey = (value: unknown): string => {
+  if (isJsonPath(value)) {
+    return `jsonpath:${jsonPathGroupingKey(value.segments)}`
+  }
+  if (typeof value === "string") {
+    return `jsonpath:${escapeGroupingText(value)}`
+  }
+  if (isExpression(value)) {
+    return `jsonpath:${groupingKeyOfExpression(value)}`
+  }
+  return "jsonpath:unknown"
+}
+
+const jsonEntryGroupingKey = (
+  entry: { readonly key: string; readonly value: Expression.Any }
+): string => `${escapeGroupingText(entry.key)}=>${groupingKeyOfExpression(entry.value)}`
+
 export const groupingKeyOfExpression = (expression: Expression.Any): string => {
   const ast = (expression as Expression.Any & {
     readonly [ExpressionAst.TypeId]: ExpressionAst.Any
   })[ExpressionAst.TypeId]
   switch (ast.kind) {
     case "column":
-      return `column:${ast.tableName}.${ast.columnName}`
+      return `column:${columnPredicateKey(ast.tableName, ast.columnName)}`
     case "literal":
       return `literal:${literalGroupingKey(ast.value)}`
     case "cast":
       return `cast(${groupingKeyOfExpression(ast.value)} as ${ast.target.dialect}:${ast.target.kind})`
+    case "collate":
+      return `collate(${groupingKeyOfExpression(ast.value)},${ast.collation.map(escapeGroupingText).join(",")})`
+    case "function":
+      return `function(${escapeGroupingText(ast.name)},${ast.args.map(groupingKeyOfExpression).join(",")})`
     case "isNull":
     case "isNotNull":
     case "not":
@@ -48,8 +133,15 @@ export const groupingKeyOfExpression = (expression: Expression.Any): string => {
     case "gte":
     case "like":
     case "ilike":
+    case "regexMatch":
+    case "regexIMatch":
+    case "regexNotMatch":
+    case "regexNotIMatch":
     case "isDistinctFrom":
     case "isNotDistinctFrom":
+    case "contains":
+    case "containedBy":
+    case "overlaps":
       return `${ast.kind}(${groupingKeyOfExpression(ast.left)},${groupingKeyOfExpression(ast.right)})`
     case "and":
     case "or":
@@ -62,6 +154,54 @@ export const groupingKeyOfExpression = (expression: Expression.Any): string => {
     case "case":
       return `case(${ast.branches.map((branch: ExpressionAst.CaseBranchNode) =>
         `when:${groupingKeyOfExpression(branch.when)}=>${groupingKeyOfExpression(branch.then)}`).join("|")};else:${groupingKeyOfExpression(ast.else)})`
+    case "exists":
+      return `exists(${subqueryPlanGroupingKey(ast.plan)})`
+    case "scalarSubquery":
+      return `scalarSubquery(${subqueryPlanGroupingKey(ast.plan)})`
+    case "inSubquery":
+      return `inSubquery(${groupingKeyOfExpression(ast.left)},${subqueryPlanGroupingKey(ast.plan)})`
+    case "comparisonAny":
+    case "comparisonAll":
+      return `${ast.kind}(${ast.operator},${groupingKeyOfExpression(ast.left)},${subqueryPlanGroupingKey(ast.plan)})`
+    case "jsonGet":
+    case "jsonPath":
+    case "jsonAccess":
+    case "jsonTraverse":
+    case "jsonGetText":
+    case "jsonPathText":
+    case "jsonAccessText":
+    case "jsonTraverseText":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${jsonPathGroupingKey(ast.segments)})`
+    case "jsonHasKey":
+    case "jsonKeyExists":
+    case "jsonHasAnyKeys":
+    case "jsonHasAllKeys":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${(ast.keys ?? []).map(escapeGroupingText).join(",")})`
+    case "jsonConcat":
+    case "jsonMerge":
+      return `json(${ast.kind},${expressionGroupingKey(ast.left)},${expressionGroupingKey(ast.right)},)`
+    case "jsonDelete":
+    case "jsonDeletePath":
+    case "jsonRemove":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${expressionGroupingKey(undefined)},${jsonPathGroupingKey(ast.segments)})`
+    case "jsonSet":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${expressionGroupingKey(ast.newValue)},${jsonPathGroupingKey(ast.segments)})`
+    case "jsonInsert":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${expressionGroupingKey(ast.insert)},${jsonPathGroupingKey(ast.segments)})`
+    case "jsonPathExists":
+    case "jsonPathMatch":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${jsonOpaquePathGroupingKey(ast.query)})`
+    case "jsonBuildObject":
+      return `json(${ast.kind},${(ast.entries ?? []).map(jsonEntryGroupingKey).join("|")})`
+    case "jsonBuildArray":
+      return `json(${ast.kind},${(ast.values ?? []).map(groupingKeyOfExpression).join(",")})`
+    case "jsonToJson":
+    case "jsonToJsonb":
+    case "jsonTypeOf":
+    case "jsonLength":
+    case "jsonKeys":
+    case "jsonStripNulls":
+      return `json(${ast.kind},${expressionGroupingKey(ast.value)})`
     default:
       throw new Error("Unsupported expression for grouping key generation")
   }

package/src/internal/implication-runtime.ts

@@ -5,6 +5,7 @@ import * as Table from "./table.js"
 import type { PredicateFormula } from "./predicate/formula.js"
 import {
   assumeFormulaTrue,
+  columnPredicateKey,
   contradictsFormula,
   guaranteedNonNullKeys,
   guaranteedNullKeys,
@@ -43,7 +44,7 @@ const collectPresenceWitnesses = (
     const expression = selection as unknown as AstBackedExpression
     const ast = expression[ExpressionAst.TypeId]
     if (ast.kind === "column" && expression[Expression.TypeId].nullability === "never") {
-      output.add(`${ast.tableName}.${ast.columnName}`)
+      output.add(columnPredicateKey(ast.tableName, ast.columnName))
     }
     return
   }

package/src/internal/json/types.ts

@@ -63,6 +63,23 @@ type TupleIndex<
     : TupleIndex<Tail, Index, [...Count, unknown]>
   : never
 
+type TupleIndexFromEnd<
+  Values extends readonly unknown[],
+  Distance extends number,
+  Count extends readonly unknown[] = [unknown]
+> = Values extends readonly [...infer Rest, infer Last]
+  ? Count["length"] extends Distance
+    ? Last
+    : TupleIndexFromEnd<Rest, Distance, [...Count, unknown]>
+  : never
+
+type TupleIndexAt<
+  Values extends readonly unknown[],
+  Index extends number
+> = `${Index}` extends `-${infer Distance extends number}`
+  ? TupleIndexFromEnd<Values, Distance>
+  : TupleIndex<Values, Index>
+
 type DropTupleIndex<
   Values extends readonly unknown[],
   Index extends number,
@@ -73,6 +90,23 @@ type DropTupleIndex<
     : readonly [Head, ...DropTupleIndex<Tail, Index, [...Count, unknown]>]
   : readonly []
 
+type DropTupleIndexFromEnd<
+  Values extends readonly unknown[],
+  Distance extends number,
+  Count extends readonly unknown[] = [unknown]
+> = Values extends readonly [...infer Rest, infer Last]
+  ? Count["length"] extends Distance
+    ? readonly [...Rest]
+    : readonly [...DropTupleIndexFromEnd<Rest, Distance, [...Count, unknown]>, Last]
+  : readonly []
+
+type DropTupleIndexAt<
+  Values extends readonly unknown[],
+  Index extends number
+> = `${Index}` extends `-${infer Distance extends number}`
+  ? DropTupleIndexFromEnd<Values, Distance>
+  : DropTupleIndex<Values, Index>
+
 type SetTupleIndex<
   Values extends readonly unknown[],
   Index extends number,
@@ -84,6 +118,25 @@ type SetTupleIndex<
     : readonly [Head, ...SetTupleIndex<Tail, Index, Next, [...Count, unknown]>]
   : readonly NormalizeJsonLiteral<Next>[]
 
+type SetTupleIndexFromEnd<
+  Values extends readonly unknown[],
+  Distance extends number,
+  Next,
+  Count extends readonly unknown[] = [unknown]
+> = Values extends readonly [...infer Rest, infer Last]
+  ? Count["length"] extends Distance
+    ? readonly [...Rest, NormalizeJsonLiteral<Next>]
+    : readonly [...SetTupleIndexFromEnd<Rest, Distance, Next, [...Count, unknown]>, Last]
+  : readonly NormalizeJsonLiteral<Next>[]
+
+type SetTupleIndexAt<
+  Values extends readonly unknown[],
+  Index extends number,
+  Next
+> = `${Index}` extends `-${infer Distance extends number}`
+  ? SetTupleIndexFromEnd<Values, Distance, Next>
+  : SetTupleIndex<Values, Index, Next>
+
 type InsertTupleIndex<
   Values extends readonly unknown[],
   Index extends number,
@@ -98,6 +151,29 @@ type InsertTupleIndex<
     : readonly [Head, ...InsertTupleIndex<Tail, Index, Next, After, [...Count, unknown]>]
   : readonly NormalizeJsonLiteral<Next>[]
 
+type InsertTupleIndexFromEnd<
+  Values extends readonly unknown[],
+  Distance extends number,
+  Next,
+  After extends boolean,
+  Count extends readonly unknown[] = [unknown]
+> = Values extends readonly [...infer Rest, infer Last]
+  ? Count["length"] extends Distance
+    ? After extends true
+      ? readonly [...Rest, Last, NormalizeJsonLiteral<Next>]
+      : readonly [...Rest, NormalizeJsonLiteral<Next>, Last]
+    : readonly [...InsertTupleIndexFromEnd<Rest, Distance, Next, After, [...Count, unknown]>, Last]
+  : readonly NormalizeJsonLiteral<Next>[]
+
+type InsertTupleIndexAt<
+  Values extends readonly unknown[],
+  Index extends number,
+  Next,
+  After extends boolean
+> = `${Index}` extends `-${infer Distance extends number}`
+  ? InsertTupleIndexFromEnd<Values, Distance, Next, After>
+  : InsertTupleIndex<Values, Index, Next, After>
+
 type IndexStep<
   Root,
   Index extends number,
@@ -105,7 +181,7 @@ type IndexStep<
 > = Root extends readonly unknown[]
   ? number extends Root["length"]
     ? NormalizeJsonLiteral<Root[number]> | null
-    : NormalizeJsonLiteral<TupleIndex<Root, Index>> | (TupleIndex<Root, Index> extends never ? null : never)
+    : NormalizeJsonLiteral<TupleIndexAt<Root, Index>> | (TupleIndexAt<Root, Index> extends never ? null : never)
   : JsonPathUsageError<Operation, Root, JsonPath.IndexSegment<Index>, "index segments require an array-like json value">
 
 type NonExactStep<
@@ -146,9 +222,9 @@ type StepSet<
     ? Root extends readonly unknown[]
       ? number extends Root["length"]
         ? readonly (NormalizeJsonLiteral<Root[number]> | NormalizeJsonLiteral<Next>)[]
-        : SetTupleIndex<Root, Index, Next>
+        : SetTupleIndexAt<Root, Index, Next>
       : JsonPathUsageError<Operation, Root, Segment, "index segments require an array-like json value">
-    : NormalizeJsonLiteral<Root>
+    : JsonPathUsageError<Operation, Root, Segment, "mutation paths require exact key/index segments">
 
 type StepDelete<
   Root,
@@ -164,9 +240,9 @@ type StepDelete<
     ? Root extends readonly unknown[]
       ? number extends Root["length"]
         ? Root
-        : DropTupleIndex<Root, Index>
+        : DropTupleIndexAt<Root, Index>
       : JsonPathUsageError<Operation, Root, Segment, "index segments require an array-like json value">
-    : NormalizeJsonLiteral<Root>
+    : JsonPathUsageError<Operation, Root, Segment, "mutation paths require exact key/index segments">
 
 type StepInsert<
   Root,
@@ -178,7 +254,7 @@ type StepInsert<
   ? Root extends readonly unknown[]
     ? number extends Root["length"]
       ? readonly (NormalizeJsonLiteral<Root[number]> | NormalizeJsonLiteral<Next>)[]
-      : InsertTupleIndex<Root, Index, Next, After>
+      : InsertTupleIndexAt<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[]
@@ -190,7 +266,7 @@ type StepInsert<
               readonly [K in Key]: NormalizeJsonLiteral<Next>
             }
         : JsonPathUsageError<Operation, Root, Segment, "key segments require an object-like json value">
-    : NormalizeJsonLiteral<Root>
+    : JsonPathUsageError<Operation, Root, Segment, "mutation paths require exact key/index segments">
 
 type RecurseValue<
   Current,
@@ -219,12 +295,16 @@ type RecurseSet<
     : 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
-          >
+        : RecurseSet<StripNull<Child>, Tail, Next, Operation> extends infer UpdatedChild
+          ? UpdatedChild extends JsonPathUsageError<any, any, any, any>
+            ? UpdatedChild
+            : StepSet<
+                Current,
+                Head,
+                UpdatedChild,
+                Operation
+              >
+          : never
       : never
   : NormalizeJsonLiteral<Next>
 
@@ -238,12 +318,16 @@ type RecurseDelete<
     : StepValue<Current, Head, Operation> extends infer Child
       ? Child extends JsonPathUsageError<any, any, any, any>
         ? Child
-        : StepSet<
-            Current,
-            Head,
-            RecurseDelete<StripNull<Child>, Tail, Operation>,
-            Operation
-          >
+        : RecurseDelete<StripNull<Child>, Tail, Operation> extends infer UpdatedChild
+          ? UpdatedChild extends JsonPathUsageError<any, any, any, any>
+            ? UpdatedChild
+            : StepSet<
+                Current,
+                Head,
+                UpdatedChild,
+                Operation
+              >
+          : never
       : never
   : NormalizeJsonLiteral<Current>
 
@@ -259,12 +343,16 @@ type RecurseInsert<
     : 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
-          >
+        : RecurseInsert<StripNull<Child>, Tail, Next, After, Operation> extends infer UpdatedChild
+          ? UpdatedChild extends JsonPathUsageError<any, any, any, any>
+            ? UpdatedChild
+            : StepSet<
+                Current,
+                Head,
+                UpdatedChild,
+                Operation
+              >
+          : never
       : never
   : NormalizeJsonLiteral<Current>
 
@@ -364,23 +452,50 @@ export type JsonBuildArray<
 
 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"
+type JsonTypeNameOfNormalized<Value> =
+  Value extends null ? "null"
+    : Value extends string ? "string"
+      : Value extends number ? "number"
+        : Value extends boolean ? "boolean"
+          : Value extends readonly unknown[] ? "array"
+            : Value extends object ? "object"
               : "unknown"
 
-export type JsonLengthResult<Value> =
-  NormalizeJsonLiteral<Value> extends readonly unknown[] ? number :
-    NormalizeJsonLiteral<Value> extends object ? number :
+export type JsonTypeName<Value> =
+  [NormalizeJsonLiteral<Value>] extends [never]
+    ? "unknown"
+    : NormalizeJsonLiteral<Value> extends infer Normalized
+      ? Normalized extends unknown
+        ? JsonTypeNameOfNormalized<Normalized>
+        : never
+      : never
+
+type JsonLengthResultOfNormalized<Value> =
+  Value extends readonly unknown[] ? number :
+    Value extends object ? number :
       null
 
+export type JsonLengthResult<Value> =
+  [NormalizeJsonLiteral<Value>] extends [never]
+    ? null
+    : NormalizeJsonLiteral<Value> extends infer Normalized
+      ? Normalized extends unknown
+        ? JsonLengthResultOfNormalized<Normalized>
+        : never
+      : never
+
+type JsonKeysResultOfNormalized<Value> =
+  Value extends readonly unknown[]
+    ? null
+    : Value extends object
+      ? readonly Extract<keyof Value, string>[]
+      : null
+
 export type JsonKeysResult<Value> =
-  NormalizeJsonLiteral<Value> extends object
-    ? NormalizeJsonLiteral<Value> extends readonly unknown[]
-      ? readonly []
-      : readonly Extract<keyof NormalizeJsonLiteral<Value>, string>[]
-    : null
+  [NormalizeJsonLiteral<Value>] extends [never]
+    ? null
+    : NormalizeJsonLiteral<Value> extends infer Normalized
+      ? Normalized extends unknown
+        ? JsonKeysResultOfNormalized<Normalized>
+        : never
+      : never

package/src/internal/predicate/analysis.ts

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

package/src/internal/predicate/atom.ts

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