* Keeps only one active timeout: whichever task is due next.

* Equality that follows PostgreSQL float semantics for `NaN`/invalid Dates: * such values are equal to one another and unequal to anything else. For

* Private method for consolidating keyed multisets where keys are strings/numbers * and values are compared by reference equality. * * This m

* Handle the transition from a single value to either a ValueMap or PrefixMap

* Folds a drained delta into a nested setup's cumulative snapshot, tracking the * net multiplicity per child row and dropping rows (and empty keys) o

* Increment the active subscribers count and start sync if needed

* Checks if two aggregate expressions are equal

* Analyzes join expressions to determine which refers to which source * and returns them in the correct order (available source expression first, joi

* Step 4: Apply optimizations by lifting single-source clauses into subqueries. * * Creates a new QueryIR with single-source WHERE clauses moved to

* Applies single-level predicate pushdown optimization (existing logic)

* Check if all values in an array are primitives

* Compare two Uint8Arrays for content equality

* Check if two where clauses are structurally equal. * Used for limited query subset checks where subset relationship isn't sufficient.

* Check if a value is in an array, with optional pre-built Set for optimization. * The primitiveSet is cached in InField during extraction and reused

* Attaches a child Collection to parent rows that match a given correlation key. * Uses the reverse index to look up parent keys directly instead of

* Builds the index from a collection of entries

* Build a predicate function from expression tree * * Two paths: * 1. Simple expressions (eq, gt, etc.) with parsed filters -> buildSimplePredicate

* Build subscription options for an alias based on whether it uses ordered * loading, is lazy, or should pass orderBy/limit hints.

* Checks if an AND expression can be optimized

* Checks if an IN array expression can be optimized

* Checks if an OR expression can be optimized

* Checks if a simple comparison can be optimized