@tanstack/db-ivm 0.1.13 → 0.1.15

package/src/operators/groupedTopKWithFractionalIndex.ts

@@ -0,0 +1,192 @@
+import { DifferenceStreamWriter, UnaryOperator } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import { MultiSet } from '../multiset.js'
+import { TopKState, handleMoveIn, handleMoveOut } from './topKState.js'
+import { TopKArray, createKeyedComparator } from './topKArray.js'
+import type { IndexedValue, TopK } from './topKArray.js'
+import type { DifferenceStreamReader } from '../graph.js'
+import type { IStreamBuilder, PipedOperator } from '../types.js'
+
+export interface GroupedTopKWithFractionalIndexOptions<K, T> {
+  limit?: number
+  offset?: number
+  setSizeCallback?: (getSize: () => number) => void
+  setWindowFn?: (
+    windowFn: (options: { offset?: number; limit?: number }) => void,
+  ) => void
+  /**
+   * Function to extract a group key from the element's key and value.
+   * Elements with the same group key will be sorted and limited together.
+   */
+  groupKeyFn: (key: K, value: T) => unknown
+}
+
+/**
+ * Operator for grouped fractional indexed topK operations.
+ * This operator maintains separate topK windows for each group,
+ * allowing per-group limits and ordering.
+ *
+ * The input is a keyed stream [K, T] and outputs [K, IndexedValue<T>].
+ * Elements are grouped by the groupKeyFn, and each group maintains
+ * its own sorted collection with independent limit/offset.
+ */
+export class GroupedTopKWithFractionalIndexOperator<
+  K extends string | number,
+  T,
+> extends UnaryOperator<[K, T], [K, IndexedValue<T>]> {
+  #groupStates: Map<unknown, TopKState<K, T>> = new Map()
+  #groupKeyFn: (key: K, value: T) => unknown
+  #comparator: (a: [K, T], b: [K, T]) => number
+  #offset: number
+  #limit: number
+
+  constructor(
+    id: number,
+    inputA: DifferenceStreamReader<[K, T]>,
+    output: DifferenceStreamWriter<[K, IndexedValue<T>]>,
+    comparator: (a: T, b: T) => number,
+    options: GroupedTopKWithFractionalIndexOptions<K, T>,
+  ) {
+    super(id, inputA, output)
+    this.#groupKeyFn = options.groupKeyFn
+    this.#limit = options.limit ?? Infinity
+    this.#offset = options.offset ?? 0
+    this.#comparator = createKeyedComparator(comparator)
+    options.setSizeCallback?.(() => this.#getTotalSize())
+    options.setWindowFn?.(this.#moveTopK.bind(this))
+  }
+
+  /**
+   * Creates a new TopK data structure for a group.
+   * Can be overridden in subclasses to use different implementations (e.g., B+ tree).
+   */
+  protected createTopK(
+    offset: number,
+    limit: number,
+    comparator: (a: [K, T], b: [K, T]) => number,
+  ): TopK<[K, T]> {
+    return new TopKArray(offset, limit, comparator)
+  }
+
+  #getTotalSize(): number {
+    let size = 0
+    for (const state of this.#groupStates.values()) {
+      size += state.size
+    }
+    return size
+  }
+
+  #getOrCreateGroupState(groupKey: unknown): TopKState<K, T> {
+    let state = this.#groupStates.get(groupKey)
+    if (!state) {
+      const topK = this.createTopK(this.#offset, this.#limit, this.#comparator)
+      state = new TopKState(topK)
+      this.#groupStates.set(groupKey, state)
+    }
+    return state
+  }
+
+  #cleanupGroupIfEmpty(groupKey: unknown, state: TopKState<K, T>): void {
+    if (state.isEmpty) {
+      this.#groupStates.delete(groupKey)
+    }
+  }
+
+  /**
+   * Moves the topK window for all groups based on the provided offset and limit.
+   * Any changes to the topK are sent to the output.
+   */
+  #moveTopK({ offset, limit }: { offset?: number; limit?: number }): void {
+    if (offset !== undefined) {
+      this.#offset = offset
+    }
+    if (limit !== undefined) {
+      this.#limit = limit
+    }
+
+    const result: Array<[[K, IndexedValue<T>], number]> = []
+    let hasChanges = false
+
+    for (const state of this.#groupStates.values()) {
+      const diff = state.move({ offset: this.#offset, limit: this.#limit }) // TODO: think we should just pass offset and limit
+
+      diff.moveIns.forEach((moveIn) => handleMoveIn(moveIn, result))
+      diff.moveOuts.forEach((moveOut) => handleMoveOut(moveOut, result))
+
+      if (diff.changes) {
+        hasChanges = true
+      }
+    }
+
+    if (hasChanges) {
+      this.output.sendData(new MultiSet(result))
+    }
+  }
+
+  run(): void {
+    const result: Array<[[K, IndexedValue<T>], number]> = []
+    for (const message of this.inputMessages()) {
+      for (const [item, multiplicity] of message.getInner()) {
+        const [key, value] = item
+        this.#processElement(key, value, multiplicity, result)
+      }
+    }
+
+    if (result.length > 0) {
+      this.output.sendData(new MultiSet(result))
+    }
+  }
+
+  #processElement(
+    key: K,
+    value: T,
+    multiplicity: number,
+    result: Array<[[K, IndexedValue<T>], number]>,
+  ): void {
+    const groupKey = this.#groupKeyFn(key, value)
+    const state = this.#getOrCreateGroupState(groupKey)
+
+    const changes = state.processElement(key, value, multiplicity)
+    handleMoveIn(changes.moveIn, result)
+    handleMoveOut(changes.moveOut, result)
+
+    // Cleanup empty groups to prevent memory leaks
+    this.#cleanupGroupIfEmpty(groupKey, state)
+  }
+}
+
+/**
+ * Limits the number of results per group based on a comparator, with optional offset.
+ * Uses fractional indexing to minimize the number of changes when elements move positions.
+ * Each element is assigned a fractional index that is lexicographically sortable.
+ * When elements move, only the indices of the moved elements are updated, not all elements.
+ *
+ * This operator groups elements by the provided groupKeyFn and applies the limit/offset
+ * independently to each group.
+ *
+ * @param comparator - A function that compares two elements for ordering
+ * @param options - Configuration including groupKeyFn, limit, and offset
+ * @returns A piped operator that orders elements per group and limits results per group
+ */
+export function groupedTopKWithFractionalIndex<K extends string | number, T>(
+  comparator: (a: T, b: T) => number,
+  options: GroupedTopKWithFractionalIndexOptions<K, T>,
+): PipedOperator<[K, T], [K, IndexedValue<T>]> {
+  return (
+    stream: IStreamBuilder<[K, T]>,
+  ): IStreamBuilder<[K, IndexedValue<T>]> => {
+    const output = new StreamBuilder<[K, IndexedValue<T>]>(
+      stream.graph,
+      new DifferenceStreamWriter<[K, IndexedValue<T>]>(),
+    )
+    const operator = new GroupedTopKWithFractionalIndexOperator<K, T>(
+      stream.graph.getNextOperatorId(),
+      stream.connectReader(),
+      output.writer,
+      comparator,
+      options,
+    )
+    stream.graph.addOperator(operator)
+    return output
+  }
+}

package/src/operators/index.ts

@@ -1,19 +1,20 @@
-export * from "./pipe.js"
-export * from "./map.js"
-export * from "./tap.js"
-export * from "./filter.js"
-export * from "./negate.js"
-export * from "./concat.js"
-export * from "./debug.js"
-export * from "./output.js"
-export * from "./consolidate.js"
-export * from "./join.js"
-export * from "./reduce.js"
-export * from "./count.js"
-export * from "./distinct.js"
-export * from "./keying.js"
-export * from "./topK.js"
-export * from "./topKWithFractionalIndex.js"
-export * from "./orderBy.js"
-export * from "./filterBy.js"
-export { groupBy, groupByOperators } from "./groupBy.js"
+export * from './pipe.js'
+export * from './map.js'
+export * from './tap.js'
+export * from './filter.js'
+export * from './negate.js'
+export * from './concat.js'
+export * from './debug.js'
+export * from './output.js'
+export * from './consolidate.js'
+export * from './join.js'
+export * from './reduce.js'
+export * from './count.js'
+export * from './distinct.js'
+export * from './keying.js'
+export * from './topK.js'
+export * from './topKWithFractionalIndex.js'
+export * from './groupedTopKWithFractionalIndex.js'
+export * from './orderBy.js'
+export * from './filterBy.js'
+export { groupBy, groupByOperators } from './groupBy.js'

package/src/operators/join.ts

@@ -48,12 +48,12 @@
  * - **Bag semantics**: Proper multiplicity handling including negatives
  */
 
-import { BinaryOperator, DifferenceStreamWriter } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import { MultiSet } from "../multiset.js"
-import { Index } from "../indexes.js"
-import type { DifferenceStreamReader } from "../graph.js"
-import type { IStreamBuilder, KeyValue, PipedOperator } from "../types.js"
+import { BinaryOperator, DifferenceStreamWriter } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import { MultiSet } from '../multiset.js'
+import { Index } from '../indexes.js'
+import type { DifferenceStreamReader } from '../graph.js'
+import type { IStreamBuilder, KeyValue, PipedOperator } from '../types.js'
 
 /**
  * Type of join to perform
@@ -75,7 +75,7 @@ export class JoinOperator<K, V1, V2> extends BinaryOperator<
     inputA: DifferenceStreamReader<[K, V1]>,
     inputB: DifferenceStreamReader<[K, V2]>,
     output: DifferenceStreamWriter<any>,
-    mode: JoinType = `inner`
+    mode: JoinType = `inner`,
   ) {
     super(id, inputA, inputB, output)
     this.#mode = mode
@@ -84,10 +84,10 @@ export class JoinOperator<K, V1, V2> extends BinaryOperator<
   run(): void {
     // Build deltas from input messages
     const deltaA = Index.fromMultiSets<K, V1>(
-      this.inputAMessages() as Array<MultiSet<[K, V1]>>
+      this.inputAMessages() as Array<MultiSet<[K, V1]>>,
     )
     const deltaB = Index.fromMultiSets<K, V2>(
-      this.inputBMessages() as Array<MultiSet<[K, V2]>>
+      this.inputBMessages() as Array<MultiSet<[K, V2]>>,
     )
 
     // Early-out if nothing changed
@@ -130,7 +130,7 @@ export class JoinOperator<K, V1, V2> extends BinaryOperator<
   private emitInnerResults(
     deltaA: Index<K, V1>,
     deltaB: Index<K, V2>,
-    results: MultiSet<any>
+    results: MultiSet<any>,
   ): void {
     // Emit the three standard delta terms: ΔA⋈B_old, A_old⋈ΔB, ΔA⋈ΔB
     if (deltaA.size > 0) results.extend(deltaA.join(this.#indexB))
@@ -141,7 +141,7 @@ export class JoinOperator<K, V1, V2> extends BinaryOperator<
   private emitLeftOuterResults(
     deltaA: Index<K, V1>,
     deltaB: Index<K, V2>,
-    results: MultiSet<any>
+    results: MultiSet<any>,
   ): void {
     // Emit unmatched left rows from deltaA
     if (deltaA.size > 0) {
@@ -184,7 +184,7 @@ export class JoinOperator<K, V1, V2> extends BinaryOperator<
           if (multiplicity !== 0) {
             results.add(
               [key, [value, null]],
-              transitioningToMatched ? -multiplicity : +multiplicity
+              transitioningToMatched ? -multiplicity : +multiplicity,
             )
           }
         }
@@ -195,7 +195,7 @@ export class JoinOperator<K, V1, V2> extends BinaryOperator<
   private emitRightOuterResults(
     deltaA: Index<K, V1>,
     deltaB: Index<K, V2>,
-    results: MultiSet<any>
+    results: MultiSet<any>,
   ): void {
     // Emit unmatched right rows from deltaB
     if (deltaB.size > 0) {
@@ -238,7 +238,7 @@ export class JoinOperator<K, V1, V2> extends BinaryOperator<
           if (multiplicity !== 0) {
             results.add(
               [key, [null, value]],
-              transitioningToMatched ? -multiplicity : +multiplicity
+              transitioningToMatched ? -multiplicity : +multiplicity,
             )
           }
         }
@@ -259,24 +259,24 @@ export function join<
   T,
 >(
   other: IStreamBuilder<KeyValue<K, V2>>,
-  type: JoinType = `inner`
+  type: JoinType = `inner`,
 ): PipedOperator<T, KeyValue<K, [V1 | null, V2 | null]>> {
   return (
-    stream: IStreamBuilder<T>
+    stream: IStreamBuilder<T>,
   ): IStreamBuilder<KeyValue<K, [V1 | null, V2 | null]>> => {
     if (stream.graph !== other.graph) {
       throw new Error(`Cannot join streams from different graphs`)
     }
     const output = new StreamBuilder<KeyValue<K, [V1 | null, V2 | null]>>(
       stream.graph,
-      new DifferenceStreamWriter<KeyValue<K, [V1 | null, V2 | null]>>()
+      new DifferenceStreamWriter<KeyValue<K, [V1 | null, V2 | null]>>(),
     )
     const operator = new JoinOperator<K, V1, V2>(
       stream.graph.getNextOperatorId(),
       stream.connectReader() as DifferenceStreamReader<KeyValue<K, V1>>,
       other.connectReader(),
       output.writer,
-      type
+      type,
     )
     stream.graph.addOperator(operator)
     return output
@@ -293,7 +293,7 @@ export function innerJoin<
   V2,
   T,
 >(
-  other: IStreamBuilder<KeyValue<K, V2>>
+  other: IStreamBuilder<KeyValue<K, V2>>,
 ): PipedOperator<T, KeyValue<K, [V1, V2]>> {
   return join(other, `inner`) as unknown as PipedOperator<
     T,
@@ -311,7 +311,7 @@ export function antiJoin<
   V2,
   T,
 >(
-  other: IStreamBuilder<KeyValue<K, V2>>
+  other: IStreamBuilder<KeyValue<K, V2>>,
 ): PipedOperator<T, KeyValue<K, [V1, null]>> {
   return join(other, `anti`) as unknown as PipedOperator<
     T,
@@ -329,7 +329,7 @@ export function leftJoin<
   V2,
   T,
 >(
-  other: IStreamBuilder<KeyValue<K, V2>>
+  other: IStreamBuilder<KeyValue<K, V2>>,
 ): PipedOperator<T, KeyValue<K, [V1, V2 | null]>> {
   return join(other, `left`) as unknown as PipedOperator<
     T,
@@ -347,7 +347,7 @@ export function rightJoin<
   V2,
   T,
 >(
-  other: IStreamBuilder<KeyValue<K, V2>>
+  other: IStreamBuilder<KeyValue<K, V2>>,
 ): PipedOperator<T, KeyValue<K, [V1 | null, V2]>> {
   return join(other, `right`) as unknown as PipedOperator<
     T,
@@ -365,7 +365,7 @@ export function fullJoin<
   V2,
   T,
 >(
-  other: IStreamBuilder<KeyValue<K, V2>>
+  other: IStreamBuilder<KeyValue<K, V2>>,
 ): PipedOperator<T, KeyValue<K, [V1 | null, V2 | null]>> {
   return join(other, `full`) as unknown as PipedOperator<
     T,

package/src/operators/keying.ts

@@ -1,5 +1,5 @@
-import { map } from "./map.js"
-import type { PipedOperator } from "../types.js"
+import { map } from './map.js'
+import type { PipedOperator } from '../types.js'
 
 /**
  * Type for a keyed value
@@ -11,7 +11,7 @@ export type Keyed<K, V> = [K, V]
  * @param keyFn - Function to generate the key for each value
  */
 export function keyBy<T, K>(
-  keyFn: (value: T) => K
+  keyFn: (value: T) => K,
 ): PipedOperator<T, Keyed<K, T>> {
   return map((value: T): Keyed<K, T> => [keyFn(value), value])
 }
@@ -28,7 +28,7 @@ export function unkey<K, V>(): PipedOperator<Keyed<K, V>, V> {
  * @param keyFn - Function to generate the new key for each value
  */
 export function rekey<K1, K2, V>(
-  keyFn: (value: V) => K2
+  keyFn: (value: V) => K2,
 ): PipedOperator<Keyed<K1, V>, Keyed<K2, V>> {
   return map(([_, value]: Keyed<K1, V>): Keyed<K2, V> => [keyFn(value), value])
 }

package/src/operators/map.ts

@@ -1,8 +1,8 @@
-import { DifferenceStreamWriter, LinearUnaryOperator } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import type { IStreamBuilder, PipedOperator } from "../types.js"
-import type { DifferenceStreamReader } from "../graph.js"
-import type { MultiSet } from "../multiset.js"
+import { DifferenceStreamWriter, LinearUnaryOperator } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import type { IStreamBuilder, PipedOperator } from '../types.js'
+import type { DifferenceStreamReader } from '../graph.js'
+import type { MultiSet } from '../multiset.js'
 
 /**
  * Operator that applies a function to each element in the input stream
@@ -14,7 +14,7 @@ export class MapOperator<T, U> extends LinearUnaryOperator<T, U> {
     id: number,
     inputA: DifferenceStreamReader<T>,
     output: DifferenceStreamWriter<U>,
-    f: (data: T) => U
+    f: (data: T) => U,
   ) {
     super(id, inputA, output)
     this.#f = f
@@ -33,13 +33,13 @@ export function map<T, O>(f: (data: T) => O): PipedOperator<T, O> {
   return (stream: IStreamBuilder<T>): IStreamBuilder<O> => {
     const output = new StreamBuilder<O>(
       stream.graph,
-      new DifferenceStreamWriter<O>()
+      new DifferenceStreamWriter<O>(),
     )
     const operator = new MapOperator<T, O>(
       stream.graph.getNextOperatorId(),
       stream.connectReader(),
       output.writer,
-      f
+      f,
     )
     stream.graph.addOperator(operator)
     return output

package/src/operators/negate.ts

@@ -1,7 +1,7 @@
-import { DifferenceStreamWriter, LinearUnaryOperator } from "../graph.js"
-import { StreamBuilder } from "../d2.js"
-import type { IStreamBuilder, PipedOperator } from "../types.js"
-import type { MultiSet } from "../multiset.js"
+import { DifferenceStreamWriter, LinearUnaryOperator } from '../graph.js'
+import { StreamBuilder } from '../d2.js'
+import type { IStreamBuilder, PipedOperator } from '../types.js'
+import type { MultiSet } from '../multiset.js'
 
 /**
  * Operator that negates the multiplicities in the input stream
@@ -19,12 +19,12 @@ export function negate<T>(): PipedOperator<T, T> {
   return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {
     const output = new StreamBuilder<T>(
       stream.graph,
-      new DifferenceStreamWriter<T>()
+      new DifferenceStreamWriter<T>(),
     )
     const operator = new NegateOperator<T>(
       stream.graph.getNextOperatorId(),
       stream.connectReader(),
-      output.writer
+      output.writer,
     )
     stream.graph.addOperator(operator)
     return output

package/src/operators/orderBy.ts

@@ -1,9 +1,9 @@
-import { topK, topKWithIndex } from "./topK.js"
-import { topKWithFractionalIndex } from "./topKWithFractionalIndex.js"
-import { map } from "./map.js"
-import { innerJoin } from "./join.js"
-import { consolidate } from "./consolidate.js"
-import type { IStreamBuilder, KeyValue } from "../types.js"
+import { topK, topKWithIndex } from './topK.js'
+import { topKWithFractionalIndex } from './topKWithFractionalIndex.js'
+import { map } from './map.js'
+import { innerJoin } from './join.js'
+import { consolidate } from './consolidate.js'
+import type { IStreamBuilder, KeyValue } from '../types.js'
 
 export interface OrderByOptions<Ve> {
   comparator?: (a: Ve, b: Ve) => number
@@ -14,7 +14,7 @@ export interface OrderByOptions<Ve> {
 type OrderByWithFractionalIndexOptions<Ve> = OrderByOptions<Ve> & {
   setSizeCallback?: (getSize: () => number) => void
   setWindowFn?: (
-    windowFn: (options: { offset?: number; limit?: number }) => void
+    windowFn: (options: { offset?: number; limit?: number }) => void,
   ) => void
 }
 
@@ -28,9 +28,9 @@ type OrderByWithFractionalIndexOptions<Ve> = OrderByOptions<Ve> & {
  */
 export function orderBy<T extends KeyValue<unknown, unknown>, Ve = unknown>(
   valueExtractor: (
-    value: T extends KeyValue<unknown, infer V> ? V : never
+    value: T extends KeyValue<unknown, infer V> ? V : never,
   ) => Ve,
-  options?: OrderByOptions<Ve>
+  options?: OrderByOptions<Ve>,
 ) {
   const limit = options?.limit ?? Infinity
   const offset = options?.offset ?? 0
@@ -54,10 +54,10 @@ export function orderBy<T extends KeyValue<unknown, unknown>, Ve = unknown>(
             [
               key,
               valueExtractor(
-                value as T extends KeyValue<unknown, infer V> ? V : never
+                value as T extends KeyValue<unknown, infer V> ? V : never,
               ),
             ],
-          ] as KeyValue<null, [KeyType, Ve]>
+          ] as KeyValue<null, [KeyType, Ve]>,
       ),
       topK((a, b) => comparator(a[1], b[1]), { limit, offset }),
       map(([_, [key]]) => [key, null] as KeyValue<KeyType, null>),
@@ -65,7 +65,7 @@ export function orderBy<T extends KeyValue<unknown, unknown>, Ve = unknown>(
       map(([key, value]) => {
         return [key, value[1]] as T
       }),
-      consolidate()
+      consolidate(),
     )
   }
 }
@@ -84,9 +84,9 @@ export function orderByWithIndex<
   Ve = unknown,
 >(
   valueExtractor: (
-    value: T extends KeyValue<unknown, infer V> ? V : never
+    value: T extends KeyValue<unknown, infer V> ? V : never,
   ) => Ve,
-  options?: OrderByOptions<Ve>
+  options?: OrderByOptions<Ve>,
 ) {
   const limit = options?.limit ?? Infinity
   const offset = options?.offset ?? 0
@@ -100,7 +100,7 @@ export function orderByWithIndex<
     })
 
   return (
-    stream: IStreamBuilder<T>
+    stream: IStreamBuilder<T>,
   ): IStreamBuilder<
     KeyValue<
       T extends KeyValue<infer K, unknown> ? K : never,
@@ -118,10 +118,10 @@ export function orderByWithIndex<
             [
               key,
               valueExtractor(
-                value as T extends KeyValue<unknown, infer V> ? V : never
+                value as T extends KeyValue<unknown, infer V> ? V : never,
               ),
             ],
-          ] as KeyValue<null, [KeyType, Ve]>
+          ] as KeyValue<null, [KeyType, Ve]>,
       ),
       topKWithIndex((a, b) => comparator(a[1], b[1]), { limit, offset }),
       map(([_, [[key], index]]) => [key, index] as KeyValue<KeyType, number>),
@@ -129,7 +129,7 @@ export function orderByWithIndex<
       map(([key, [index, value]]) => {
         return [key, [value, index]] as KeyValue<KeyType, [ValueType, number]>
       }),
-      consolidate()
+      consolidate(),
     )
   }
 }
@@ -140,9 +140,9 @@ export function orderByWithFractionalIndexBase<
 >(
   topKFunction: typeof topKWithFractionalIndex,
   valueExtractor: (
-    value: T extends KeyValue<unknown, infer V> ? V : never
+    value: T extends KeyValue<unknown, infer V> ? V : never,
   ) => Ve,
-  options?: OrderByWithFractionalIndexOptions<Ve>
+  options?: OrderByWithFractionalIndexOptions<Ve>,
 ) {
   type KeyType = T extends KeyValue<infer K, unknown> ? K : never
   type ValueType = T extends KeyValue<unknown, infer V> ? V : never
@@ -161,7 +161,7 @@ export function orderByWithFractionalIndexBase<
     })
 
   return (
-    stream: IStreamBuilder<T>
+    stream: IStreamBuilder<T>,
   ): IStreamBuilder<[KeyType, [ValueType, string]]> => {
     return stream.pipe(
       topKFunction(
@@ -172,9 +172,9 @@ export function orderByWithFractionalIndexBase<
           offset,
           setSizeCallback,
           setWindowFn,
-        }
+        },
       ),
-      consolidate()
+      consolidate(),
     )
   }
 }
@@ -193,13 +193,13 @@ export function orderByWithFractionalIndex<
   Ve = unknown,
 >(
   valueExtractor: (
-    value: T extends KeyValue<unknown, infer V> ? V : never
+    value: T extends KeyValue<unknown, infer V> ? V : never,
   ) => Ve,
-  options?: OrderByWithFractionalIndexOptions<Ve>
+  options?: OrderByWithFractionalIndexOptions<Ve>,
 ) {
   return orderByWithFractionalIndexBase(
     topKWithFractionalIndex,
     valueExtractor,
-    options
+    options,
   )
 }

package/src/operators/orderByBTree.ts

@@ -1,20 +1,20 @@
-import { orderByWithFractionalIndexBase } from "./orderBy.js"
-import { topKWithFractionalIndexBTree } from "./topKWithFractionalIndexBTree.js"
-import type { KeyValue } from "../types.js"
-import type { OrderByOptions } from "./orderBy.js"
+import { orderByWithFractionalIndexBase } from './orderBy.js'
+import { topKWithFractionalIndexBTree } from './topKWithFractionalIndexBTree.js'
+import type { KeyValue } from '../types.js'
+import type { OrderByOptions } from './orderBy.js'
 
 export function orderByWithFractionalIndexBTree<
   T extends KeyValue<unknown, unknown>,
   Ve = unknown,
 >(
   valueExtractor: (
-    value: T extends KeyValue<unknown, infer V> ? V : never
+    value: T extends KeyValue<unknown, infer V> ? V : never,
   ) => Ve,
-  options?: OrderByOptions<Ve>
+  options?: OrderByOptions<Ve>,
 ) {
   return orderByWithFractionalIndexBase(
     topKWithFractionalIndexBTree,
     valueExtractor,
-    options
+    options,
   )
 }