@tanstack/db-ivm 0.0.0 → 0.1.1

package/dist/esm/operators/topKWithFractionalIndex.d.ts

@@ -0,0 +1,58 @@
+import { DifferenceStreamWriter, UnaryOperator, DifferenceStreamReader } from '../graph.js';
+import { PipedOperator } from '../types.js';
+export interface TopKWithFractionalIndexOptions {
+    limit?: number;
+    offset?: number;
+}
+export type TopKChanges<V> = {
+    /** Indicates which element moves into the topK (if any) */
+    moveIn: IndexedValue<V> | null;
+    /** Indicates which element moves out of the topK (if any) */
+    moveOut: IndexedValue<V> | null;
+};
+/**
+ * A topK data structure that supports insertions and deletions
+ * and returns changes to the topK.
+ */
+export interface TopK<V> {
+    insert: (value: V) => TopKChanges<V>;
+    delete: (value: V) => TopKChanges<V>;
+}
+/**
+ * Operator for fractional indexed topK operations
+ * This operator maintains fractional indices for sorted elements
+ * and only updates indices when elements move position
+ */
+export declare class TopKWithFractionalIndexOperator<K, T> extends UnaryOperator<[
+    K,
+    T
+], [
+    K,
+    IndexedValue<T>
+]> {
+    #private;
+    constructor(id: number, inputA: DifferenceStreamReader<[K, T]>, output: DifferenceStreamWriter<[K, IndexedValue<T>]>, comparator: (a: T, b: T) => number, options: TopKWithFractionalIndexOptions);
+    protected createTopK(offset: number, limit: number, comparator: (a: TaggedValue<K, T>, b: TaggedValue<K, T>) => number): TopK<TaggedValue<K, T>>;
+    run(): void;
+    processElement(key: K, value: T, multiplicity: number, result: Array<[[K, IndexedValue<T>], number]>): void;
+    private getMultiplicity;
+    private addKey;
+}
+/**
+ * Limits the number of results 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.
+ *
+ * @param comparator - A function that compares two elements
+ * @param options - An optional object containing limit and offset properties
+ * @returns A piped operator that orders the elements and limits the number of results
+ */
+export declare function topKWithFractionalIndex<KType, T>(comparator: (a: T, b: T) => number, options?: TopKWithFractionalIndexOptions): PipedOperator<[KType, T], [KType, IndexedValue<T>]>;
+export type FractionalIndex = string;
+export type IndexedValue<V> = [V, FractionalIndex];
+export declare function indexedValue<V>(value: V, index: FractionalIndex): IndexedValue<V>;
+export declare function getValue<V>(indexedVal: IndexedValue<V>): V;
+export declare function getIndex<V>(indexedVal: IndexedValue<V>): FractionalIndex;
+export type Tag = number;
+export type TaggedValue<K, V> = [K, V, Tag];

package/dist/esm/operators/topKWithFractionalIndex.js

@@ -0,0 +1,218 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _sortedValues, _comparator, _topKStart, _topKEnd, _TopKArray_instances, findIndex_fn, _index, _topK;
+import { generateKeyBetween } from "fractional-indexing";
+import { UnaryOperator, DifferenceStreamWriter } from "../graph.js";
+import { StreamBuilder } from "../d2.js";
+import { MultiSet } from "../multiset.js";
+import { binarySearch, globalObjectIdGenerator } from "../utils.js";
+class TopKArray {
+  constructor(offset, limit, comparator) {
+    __privateAdd(this, _TopKArray_instances);
+    __privateAdd(this, _sortedValues, []);
+    __privateAdd(this, _comparator);
+    __privateAdd(this, _topKStart);
+    __privateAdd(this, _topKEnd);
+    __privateSet(this, _topKStart, offset);
+    __privateSet(this, _topKEnd, offset + limit);
+    __privateSet(this, _comparator, comparator);
+  }
+  insert(value) {
+    const result = { moveIn: null, moveOut: null };
+    const index = __privateMethod(this, _TopKArray_instances, findIndex_fn).call(this, value);
+    const indexBefore = index === 0 ? null : getIndex(__privateGet(this, _sortedValues)[index - 1]);
+    const indexAfter = index === __privateGet(this, _sortedValues).length ? null : getIndex(__privateGet(this, _sortedValues)[index]);
+    const fractionalIndex = generateKeyBetween(indexBefore, indexAfter);
+    const val = indexedValue(value, fractionalIndex);
+    __privateGet(this, _sortedValues).splice(index, 0, val);
+    if (index < __privateGet(this, _topKEnd)) {
+      const moveInIndex = Math.max(index, __privateGet(this, _topKStart));
+      if (moveInIndex < __privateGet(this, _sortedValues).length) {
+        result.moveIn = __privateGet(this, _sortedValues)[moveInIndex];
+        if (__privateGet(this, _topKEnd) < __privateGet(this, _sortedValues).length) {
+          result.moveOut = __privateGet(this, _sortedValues)[__privateGet(this, _topKEnd)];
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Deletes a value that may or may not be in the topK.
+   * IMPORTANT: this assumes that the value is present in the collection
+   *            if it's not the case it will remove the element
+   *            that is on the position where the provided `value` would be.
+   */
+  delete(value) {
+    const result = { moveIn: null, moveOut: null };
+    const index = __privateMethod(this, _TopKArray_instances, findIndex_fn).call(this, value);
+    const [removedElem] = __privateGet(this, _sortedValues).splice(index, 1);
+    if (index < __privateGet(this, _topKEnd)) {
+      result.moveOut = removedElem;
+      if (index < __privateGet(this, _topKStart)) {
+        const moveOutIndex = __privateGet(this, _topKStart) - 1;
+        if (moveOutIndex < __privateGet(this, _sortedValues).length) {
+          result.moveOut = __privateGet(this, _sortedValues)[moveOutIndex];
+        } else {
+          result.moveOut = null;
+        }
+      }
+      const moveInIndex = __privateGet(this, _topKEnd) - 1;
+      if (moveInIndex < __privateGet(this, _sortedValues).length) {
+        result.moveIn = __privateGet(this, _sortedValues)[moveInIndex];
+      }
+    }
+    return result;
+  }
+}
+_sortedValues = new WeakMap();
+_comparator = new WeakMap();
+_topKStart = new WeakMap();
+_topKEnd = new WeakMap();
+_TopKArray_instances = new WeakSet();
+// TODO: see if there is a way to refactor the code for insert and delete in the topK above
+//       because they are very similar, one is shifting the topK window to the left and the other is shifting it to the right
+//       so i have the feeling there is a common pattern here and we can implement both cases using that pattern
+findIndex_fn = function(value) {
+  return binarySearch(
+    __privateGet(this, _sortedValues),
+    indexedValue(value, ``),
+    (a, b) => __privateGet(this, _comparator).call(this, getValue(a), getValue(b))
+  );
+};
+class TopKWithFractionalIndexOperator extends UnaryOperator {
+  constructor(id, inputA, output, comparator, options) {
+    super(id, inputA, output);
+    __privateAdd(this, _index, /* @__PURE__ */ new Map());
+    // maps keys to their multiplicity
+    /**
+     * topK data structure that supports insertions and deletions
+     * and returns changes to the topK.
+     */
+    __privateAdd(this, _topK);
+    const limit = options.limit ?? Infinity;
+    const offset = options.offset ?? 0;
+    const compareTaggedValues = (a, b) => {
+      const valueComparison = comparator(getVal(a), getVal(b));
+      if (valueComparison !== 0) {
+        return valueComparison;
+      }
+      const tieBreakerA = getTag(a);
+      const tieBreakerB = getTag(b);
+      return tieBreakerA - tieBreakerB;
+    };
+    __privateSet(this, _topK, this.createTopK(offset, limit, compareTaggedValues));
+  }
+  createTopK(offset, limit, comparator) {
+    return new TopKArray(offset, limit, comparator);
+  }
+  run() {
+    const result = [];
+    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, value, multiplicity, result) {
+    const { oldMultiplicity, newMultiplicity } = this.addKey(key, multiplicity);
+    let res = {
+      moveIn: null,
+      moveOut: null
+    };
+    if (oldMultiplicity <= 0 && newMultiplicity > 0) {
+      const taggedValue = tagValue(key, value);
+      res = __privateGet(this, _topK).insert(taggedValue);
+    } else if (oldMultiplicity > 0 && newMultiplicity <= 0) {
+      const taggedValue = tagValue(key, value);
+      res = __privateGet(this, _topK).delete(taggedValue);
+    } else ;
+    if (res.moveIn) {
+      const index = getIndex(res.moveIn);
+      const taggedValue = getValue(res.moveIn);
+      const k = getKey(taggedValue);
+      const val = getVal(taggedValue);
+      result.push([[k, [val, index]], 1]);
+    }
+    if (res.moveOut) {
+      const index = getIndex(res.moveOut);
+      const taggedValue = getValue(res.moveOut);
+      const k = getKey(taggedValue);
+      const val = getVal(taggedValue);
+      result.push([[k, [val, index]], -1]);
+    }
+    return;
+  }
+  getMultiplicity(key) {
+    return __privateGet(this, _index).get(key) ?? 0;
+  }
+  addKey(key, multiplicity) {
+    const oldMultiplicity = this.getMultiplicity(key);
+    const newMultiplicity = oldMultiplicity + multiplicity;
+    if (newMultiplicity === 0) {
+      __privateGet(this, _index).delete(key);
+    } else {
+      __privateGet(this, _index).set(key, newMultiplicity);
+    }
+    return { oldMultiplicity, newMultiplicity };
+  }
+}
+_index = new WeakMap();
+_topK = new WeakMap();
+function topKWithFractionalIndex(comparator, options) {
+  const opts = options || {};
+  return (stream) => {
+    const output = new StreamBuilder(
+      stream.graph,
+      new DifferenceStreamWriter()
+    );
+    const operator = new TopKWithFractionalIndexOperator(
+      stream.graph.getNextOperatorId(),
+      stream.connectReader(),
+      output.writer,
+      comparator,
+      opts
+    );
+    stream.graph.addOperator(operator);
+    stream.graph.addStream(output.connectReader());
+    return output;
+  };
+}
+function indexedValue(value, index) {
+  return [value, index];
+}
+function getValue(indexedVal) {
+  return indexedVal[0];
+}
+function getIndex(indexedVal) {
+  return indexedVal[1];
+}
+function tagValue(key, value) {
+  return [key, value, globalObjectIdGenerator.getId(key)];
+}
+function getKey(tieBreakerTaggedValue) {
+  return tieBreakerTaggedValue[0];
+}
+function getVal(tieBreakerTaggedValue) {
+  return tieBreakerTaggedValue[1];
+}
+function getTag(tieBreakerTaggedValue) {
+  return tieBreakerTaggedValue[2];
+}
+export {
+  TopKWithFractionalIndexOperator,
+  getIndex,
+  getValue,
+  indexedValue,
+  topKWithFractionalIndex
+};
+//# sourceMappingURL=topKWithFractionalIndex.js.map

package/dist/esm/operators/topKWithFractionalIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"topKWithFractionalIndex.js","sources":["../../../src/operators/topKWithFractionalIndex.ts"],"sourcesContent":["import { generateKeyBetween } from \"fractional-indexing\"\nimport { DifferenceStreamWriter, UnaryOperator } from \"../graph.js\"\nimport { StreamBuilder } from \"../d2.js\"\nimport { MultiSet } from \"../multiset.js\"\nimport { binarySearch, globalObjectIdGenerator } from \"../utils.js\"\nimport type { DifferenceStreamReader } from \"../graph.js\"\nimport type { IStreamBuilder, PipedOperator } from \"../types.js\"\n\nexport interface TopKWithFractionalIndexOptions {\n  limit?: number\n  offset?: number\n}\n\nexport type TopKChanges<V> = {\n  /** Indicates which element moves into the topK (if any) */\n  moveIn: IndexedValue<V> | null\n  /** Indicates which element moves out of the topK (if any) */\n  moveOut: IndexedValue<V> | null\n}\n\n/**\n * A topK data structure that supports insertions and deletions\n * and returns changes to the topK.\n */\nexport interface TopK<V> {\n  insert: (value: V) => TopKChanges<V>\n  delete: (value: V) => TopKChanges<V>\n}\n\n/**\n * Implementation of a topK data structure.\n * Uses a sorted array internally to store the values and keeps a topK window over that array.\n * Inserts and deletes are O(n) operations because worst case an element is inserted/deleted\n * at the start of the array which causes all the elements to shift to the right/left.\n */\nclass TopKArray<V> implements TopK<V> {\n  #sortedValues: Array<IndexedValue<V>> = []\n  #comparator: (a: V, b: V) => number\n  #topKStart: number\n  #topKEnd: number\n\n  constructor(\n    offset: number,\n    limit: number,\n    comparator: (a: V, b: V) => number\n  ) {\n    this.#topKStart = offset\n    this.#topKEnd = offset + limit\n    this.#comparator = comparator\n  }\n\n  insert(value: V): TopKChanges<V> {\n    const result: TopKChanges<V> = { moveIn: null, moveOut: null }\n\n    // Lookup insert position\n    const index = this.#findIndex(value)\n    // Generate fractional index based on the fractional indices of the elements before and after it\n    const indexBefore =\n      index === 0 ? null : getIndex(this.#sortedValues[index - 1]!)\n    const indexAfter =\n      index === this.#sortedValues.length\n        ? null\n        : getIndex(this.#sortedValues[index]!)\n    const fractionalIndex = generateKeyBetween(indexBefore, indexAfter)\n\n    // Insert the value at the correct position\n    const val = indexedValue(value, fractionalIndex)\n    // Splice is O(n) where n = all elements in the collection (i.e. n >= k) !\n    this.#sortedValues.splice(index, 0, val)\n\n    // Check if the topK changed\n    if (index < this.#topKEnd) {\n      // The inserted element is either before the top K or within the top K\n      // If it is before the top K then it moves the element that was right before the topK into the topK\n      // If it is within the top K then the inserted element moves into the top K\n      // In both cases the last element of the old top K now moves out of the top K\n      const moveInIndex = Math.max(index, this.#topKStart)\n      if (moveInIndex < this.#sortedValues.length) {\n        // We actually have a topK\n        // because in some cases there may not be enough elements in the array to reach the start of the topK\n        // e.g. [1, 2, 3] with K = 2 and offset = 3 does not have a topK\n        result.moveIn = this.#sortedValues[moveInIndex]!\n\n        // We need to remove the element that falls out of the top K\n        // The element that falls out of the top K has shifted one to the right\n        // because of the element we inserted, so we find it at index topKEnd\n        if (this.#topKEnd < this.#sortedValues.length) {\n          result.moveOut = this.#sortedValues[this.#topKEnd]!\n        }\n      }\n    }\n\n    return result\n  }\n\n  /**\n   * Deletes a value that may or may not be in the topK.\n   * IMPORTANT: this assumes that the value is present in the collection\n   *            if it's not the case it will remove the element\n   *            that is on the position where the provided `value` would be.\n   */\n  delete(value: V): TopKChanges<V> {\n    const result: TopKChanges<V> = { moveIn: null, moveOut: null }\n\n    // Lookup delete position\n    const index = this.#findIndex(value)\n    // Remove the value at that position\n    const [removedElem] = this.#sortedValues.splice(index, 1)\n\n    // Check if the topK changed\n    if (index < this.#topKEnd) {\n      // The removed element is either before the top K or within the top K\n      // If it is before the top K then the first element of the topK moves out of the topK\n      // If it is within the top K then the removed element moves out of the topK\n      result.moveOut = removedElem!\n      if (index < this.#topKStart) {\n        // The removed element is before the topK\n        // so actually, the first element of the topK moves out of the topK\n        // and not the element that we removed\n        // The first element of the topK is now at index topKStart - 1\n        // since we removed an element before the topK\n        const moveOutIndex = this.#topKStart - 1\n        if (moveOutIndex < this.#sortedValues.length) {\n          result.moveOut = this.#sortedValues[moveOutIndex]!\n        } else {\n          // No value is moving out of the topK\n          // because there are no elements in the topK\n          result.moveOut = null\n        }\n      }\n\n      // Since we removed an element that was before or in the topK\n      // the first element after the topK moved one position to the left\n      // and thus falls into the topK now\n      const moveInIndex = this.#topKEnd - 1\n      if (moveInIndex < this.#sortedValues.length) {\n        result.moveIn = this.#sortedValues[moveInIndex]!\n      }\n    }\n\n    return result\n  }\n\n  // TODO: see if there is a way to refactor the code for insert and delete in the topK above\n  //       because they are very similar, one is shifting the topK window to the left and the other is shifting it to the right\n  //       so i have the feeling there is a common pattern here and we can implement both cases using that pattern\n\n  #findIndex(value: V): number {\n    return binarySearch(this.#sortedValues, indexedValue(value, ``), (a, b) =>\n      this.#comparator(getValue(a), getValue(b))\n    )\n  }\n}\n\n/**\n * Operator for fractional indexed topK operations\n * This operator maintains fractional indices for sorted elements\n * and only updates indices when elements move position\n */\nexport class TopKWithFractionalIndexOperator<K, T> extends UnaryOperator<\n  [K, T],\n  [K, IndexedValue<T>]\n> {\n  #index: Map<K, number> = new Map() // maps keys to their multiplicity\n\n  /**\n   * topK data structure that supports insertions and deletions\n   * and returns changes to the topK.\n   */\n  #topK: TopK<TaggedValue<K, T>>\n\n  constructor(\n    id: number,\n    inputA: DifferenceStreamReader<[K, T]>,\n    output: DifferenceStreamWriter<[K, IndexedValue<T>]>,\n    comparator: (a: T, b: T) => number,\n    options: TopKWithFractionalIndexOptions\n  ) {\n    super(id, inputA, output)\n    const limit = options.limit ?? Infinity\n    const offset = options.offset ?? 0\n    const compareTaggedValues = (\n      a: TaggedValue<K, T>,\n      b: TaggedValue<K, T>\n    ) => {\n      // First compare on the value\n      const valueComparison = comparator(getVal(a), getVal(b))\n      if (valueComparison !== 0) {\n        return valueComparison\n      }\n      // If the values are equal, compare on the tag (object identity)\n      const tieBreakerA = getTag(a)\n      const tieBreakerB = getTag(b)\n      return tieBreakerA - tieBreakerB\n    }\n    this.#topK = this.createTopK(offset, limit, compareTaggedValues)\n  }\n\n  protected createTopK(\n    offset: number,\n    limit: number,\n    comparator: (a: TaggedValue<K, T>, b: TaggedValue<K, T>) => number\n  ): TopK<TaggedValue<K, T>> {\n    return new TopKArray(offset, limit, comparator)\n  }\n\n  run(): void {\n    const result: Array<[[K, IndexedValue<T>], number]> = []\n    for (const message of this.inputMessages()) {\n      for (const [item, multiplicity] of message.getInner()) {\n        const [key, value] = item\n        this.processElement(key, value, multiplicity, result)\n      }\n    }\n\n    if (result.length > 0) {\n      this.output.sendData(new MultiSet(result))\n    }\n  }\n\n  processElement(\n    key: K,\n    value: T,\n    multiplicity: number,\n    result: Array<[[K, IndexedValue<T>], number]>\n  ): void {\n    const { oldMultiplicity, newMultiplicity } = this.addKey(key, multiplicity)\n\n    let res: TopKChanges<TaggedValue<K, T>> = {\n      moveIn: null,\n      moveOut: null,\n    }\n    if (oldMultiplicity <= 0 && newMultiplicity > 0) {\n      // The value was invisible but should now be visible\n      // Need to insert it into the array of sorted values\n      const taggedValue = tagValue(key, value)\n      res = this.#topK.insert(taggedValue)\n    } else if (oldMultiplicity > 0 && newMultiplicity <= 0) {\n      // The value was visible but should now be invisible\n      // Need to remove it from the array of sorted values\n      const taggedValue = tagValue(key, value)\n      res = this.#topK.delete(taggedValue)\n    } else {\n      // The value was invisible and it remains invisible\n      // or it was visible and remains visible\n      // so it doesn't affect the topK\n    }\n\n    if (res.moveIn) {\n      const index = getIndex(res.moveIn)\n      const taggedValue = getValue(res.moveIn)\n      const k = getKey(taggedValue)\n      const val = getVal(taggedValue)\n      result.push([[k, [val, index]], 1])\n    }\n\n    if (res.moveOut) {\n      const index = getIndex(res.moveOut)\n      const taggedValue = getValue(res.moveOut)\n      const k = getKey(taggedValue)\n      const val = getVal(taggedValue)\n      result.push([[k, [val, index]], -1])\n    }\n\n    return\n  }\n\n  private getMultiplicity(key: K): number {\n    return this.#index.get(key) ?? 0\n  }\n\n  private addKey(\n    key: K,\n    multiplicity: number\n  ): { oldMultiplicity: number; newMultiplicity: number } {\n    const oldMultiplicity = this.getMultiplicity(key)\n    const newMultiplicity = oldMultiplicity + multiplicity\n    if (newMultiplicity === 0) {\n      this.#index.delete(key)\n    } else {\n      this.#index.set(key, newMultiplicity)\n    }\n    return { oldMultiplicity, newMultiplicity }\n  }\n}\n\n/**\n * Limits the number of results based on a comparator, with optional offset.\n * Uses fractional indexing to minimize the number of changes when elements move positions.\n * Each element is assigned a fractional index that is lexicographically sortable.\n * When elements move, only the indices of the moved elements are updated, not all elements.\n *\n * @param comparator - A function that compares two elements\n * @param options - An optional object containing limit and offset properties\n * @returns A piped operator that orders the elements and limits the number of results\n */\nexport function topKWithFractionalIndex<KType, T>(\n  comparator: (a: T, b: T) => number,\n  options?: TopKWithFractionalIndexOptions\n): PipedOperator<[KType, T], [KType, IndexedValue<T>]> {\n  const opts = options || {}\n\n  return (\n    stream: IStreamBuilder<[KType, T]>\n  ): IStreamBuilder<[KType, IndexedValue<T>]> => {\n    const output = new StreamBuilder<[KType, IndexedValue<T>]>(\n      stream.graph,\n      new DifferenceStreamWriter<[KType, IndexedValue<T>]>()\n    )\n    const operator = new TopKWithFractionalIndexOperator<KType, T>(\n      stream.graph.getNextOperatorId(),\n      stream.connectReader(),\n      output.writer,\n      comparator,\n      opts\n    )\n    stream.graph.addOperator(operator)\n    stream.graph.addStream(output.connectReader())\n    return output\n  }\n}\n\n// Abstraction for fractionally indexed values\nexport type FractionalIndex = string\nexport type IndexedValue<V> = [V, FractionalIndex]\n\nexport function indexedValue<V>(\n  value: V,\n  index: FractionalIndex\n): IndexedValue<V> {\n  return [value, index]\n}\n\nexport function getValue<V>(indexedVal: IndexedValue<V>): V {\n  return indexedVal[0]\n}\n\nexport function getIndex<V>(indexedVal: IndexedValue<V>): FractionalIndex {\n  return indexedVal[1]\n}\n\nexport type Tag = number\nexport type TaggedValue<K, V> = [K, V, Tag]\n\nfunction tagValue<K, V>(key: K, value: V): TaggedValue<K, V> {\n  return [key, value, globalObjectIdGenerator.getId(key)]\n}\n\nfunction getKey<K, V>(tieBreakerTaggedValue: TaggedValue<K, V>): K {\n  return tieBreakerTaggedValue[0]\n}\n\nfunction getVal<K, V>(tieBreakerTaggedValue: TaggedValue<K, V>): V {\n  return tieBreakerTaggedValue[1]\n}\n\nfunction getTag<K, V>(tieBreakerTaggedValue: TaggedValue<K, V>): Tag {\n  return tieBreakerTaggedValue[2]\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/operators/topKWithFractionalIndexBTree.d.ts

@@ -0,0 +1,27 @@
+import { TopKWithFractionalIndexOperator, IndexedValue, TaggedValue, TopK, TopKWithFractionalIndexOptions } from './topKWithFractionalIndex.js';
+import { PipedOperator } from '../types.js';
+export declare function loadBTree(): Promise<void>;
+/**
+ * Operator for fractional indexed topK operations
+ * This operator maintains fractional indices for sorted elements
+ * and only updates indices when elements move position
+ */
+export declare class TopKWithFractionalIndexBTreeOperator<K, T> extends TopKWithFractionalIndexOperator<K, T> {
+    protected createTopK(offset: number, limit: number, comparator: (a: TaggedValue<K, T>, b: TaggedValue<K, T>) => number): TopK<TaggedValue<K, T>>;
+}
+/**
+ * Limits the number of results based on a comparator, with optional offset.
+ * This works on a keyed stream, where the key is the first element of the tuple.
+ * The ordering is within a key group, i.e. elements are sorted within a key group
+ * and the limit + offset is applied to that sorted group.
+ * To order the entire stream, key by the same value for all elements such as null.
+ *
+ * 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.
+ *
+ * @param comparator - A function that compares two elements
+ * @param options - An optional object containing limit and offset properties
+ * @returns A piped operator that orders the elements and limits the number of results
+ */
+export declare function topKWithFractionalIndexBTree<KType, T>(comparator: (a: T, b: T) => number, options?: TopKWithFractionalIndexOptions): PipedOperator<[KType, T], [KType, IndexedValue<T>]>;

package/dist/esm/types.d.ts

@@ -0,0 +1,30 @@
+import { MultiSet, MultiSetArray } from './multiset.js';
+import { BinaryOperator, DifferenceStreamReader, DifferenceStreamWriter, UnaryOperator } from './graph.js';
+export type KeyValue<K, V> = [K, V];
+export interface IOperator<_T> {
+    run: () => void;
+    hasPendingWork: () => boolean;
+}
+export interface IDifferenceStreamReader<T> {
+    drain: () => Array<MultiSet<T>>;
+    isEmpty: () => boolean;
+}
+export interface IDifferenceStreamWriter<T> {
+    sendData: (collection: MultiSet<T> | MultiSetArray<T>) => void;
+    newReader: () => IDifferenceStreamReader<T>;
+}
+export interface ID2 {
+    getNextOperatorId: () => number;
+    newInput: <T>() => IStreamBuilder<T>;
+    addOperator: (operator: UnaryOperator<any> | BinaryOperator<any>) => void;
+    addStream: (stream: DifferenceStreamReader<any>) => void;
+    finalize: () => void;
+    step: () => void;
+}
+export interface IStreamBuilder<T> {
+    writer: DifferenceStreamWriter<T>;
+    connectReader: () => DifferenceStreamReader<T>;
+    graph: ID2;
+    pipe: (<O>(o1: PipedOperator<T, O>) => IStreamBuilder<O>) & (<T2, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, O>) => IStreamBuilder<O>) & (<T2, T3, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, O>) => IStreamBuilder<O>) & (<T2, T3, T4, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, O>) => IStreamBuilder<O>) & (<T2, T3, T4, T5, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, O>) => IStreamBuilder<O>) & (<T2, T3, T4, T5, T6, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, O>) => IStreamBuilder<O>) & (<T2, T3, T4, T5, T6, T7, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, O>) => IStreamBuilder<O>) & (<T2, T3, T4, T5, T6, T7, T8, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, O>) => IStreamBuilder<O>) & (<T2, T3, T4, T5, T6, T7, T8, T9, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, O>) => IStreamBuilder<O>) & (<T2, T3, T4, T5, T6, T7, T8, T9, T10, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, O>) => IStreamBuilder<O>) & (<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, O>) => IStreamBuilder<O>) & (<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, O>) => IStreamBuilder<O>) & (<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, O>) => IStreamBuilder<O>) & (<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, T14>, o14: PipedOperator<T14, O>) => IStreamBuilder<O>) & (<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, T14>, o14: PipedOperator<T14, T15>, o15: PipedOperator<T15, O>) => IStreamBuilder<O>) & (<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, T14>, o14: PipedOperator<T14, T15>, o15: PipedOperator<T15, T16>, o16: PipedOperator<T16, O>) => IStreamBuilder<O>) & (<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, T14>, o14: PipedOperator<T14, T15>, o15: PipedOperator<T15, T16>, o16: PipedOperator<T16, T17>, o17: PipedOperator<T17, O>) => IStreamBuilder<O>) & (<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, T14>, o14: PipedOperator<T14, T15>, o15: PipedOperator<T15, T16>, o16: PipedOperator<T16, T17>, o17: PipedOperator<T17, T18>, o18: PipedOperator<T18, O>) => IStreamBuilder<O>) & (<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, T14>, o14: PipedOperator<T14, T15>, o15: PipedOperator<T15, T16>, o16: PipedOperator<T16, T17>, o17: PipedOperator<T17, T18>, o18: PipedOperator<T18, T19>, o19: PipedOperator<T19, O>) => IStreamBuilder<O>) & (<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, T5>, o5: PipedOperator<T5, T6>, o6: PipedOperator<T6, T7>, o7: PipedOperator<T7, T8>, o8: PipedOperator<T8, T9>, o9: PipedOperator<T9, T10>, o10: PipedOperator<T10, T11>, o11: PipedOperator<T11, T12>, o12: PipedOperator<T12, T13>, o13: PipedOperator<T13, T14>, o14: PipedOperator<T14, T15>, o15: PipedOperator<T15, T16>, o16: PipedOperator<T16, T17>, o17: PipedOperator<T17, T18>, o18: PipedOperator<T18, T19>, o19: PipedOperator<T19, T20>, o20: PipedOperator<T20, O>) => IStreamBuilder<O>) & (<O>(...operators: Array<PipedOperator<any, any>>) => IStreamBuilder<O>);
+}
+export type PipedOperator<I, O> = (stream: IStreamBuilder<I>) => IStreamBuilder<O>;

package/dist/esm/utils.d.ts

@@ -0,0 +1,40 @@
+/**
+ * A map that returns a default value for keys that are not present.
+ */
+export declare class DefaultMap<K, V> extends Map<K, V> {
+    private defaultValue;
+    constructor(defaultValue: () => V, entries?: Iterable<[K, V]>);
+    get(key: K): V;
+    /**
+     * Update the value for a key using a function.
+     */
+    update(key: K, updater: (value: V) => V): V;
+}
+export declare function chunkedArrayPush(array: Array<unknown>, other: Array<unknown>): void;
+/**
+ * A hash method that caches the hash of a value in a week map
+ */
+export declare function hash(data: any): string;
+export declare function binarySearch<T>(array: Array<T>, value: T, comparator: (a: T, b: T) => number): number;
+/**
+ * Utility for generating unique IDs for objects and values.
+ * Uses WeakMap for object reference tracking and consistent hashing for primitives.
+ */
+export declare class ObjectIdGenerator {
+    private objectIds;
+    private nextId;
+    /**
+     * Get a unique identifier for any value.
+     * - Objects: Uses WeakMap for reference-based identity
+     * - Primitives: Uses consistent string-based hashing
+     */
+    getId(value: any): number;
+    /**
+     * Get a string representation of the ID for use in composite keys.
+     */
+    getStringId(value: any): string;
+}
+/**
+ * Global instance for cases where a shared object ID space is needed.
+ */
+export declare const globalObjectIdGenerator: ObjectIdGenerator;

package/dist/esm/utils.js

@@ -0,0 +1,125 @@
+import murmurhash from "murmurhash-js";
+class DefaultMap extends Map {
+  constructor(defaultValue, entries) {
+    super(entries);
+    this.defaultValue = defaultValue;
+  }
+  get(key) {
+    if (!this.has(key)) {
+      this.set(key, this.defaultValue());
+    }
+    return super.get(key);
+  }
+  /**
+   * Update the value for a key using a function.
+   */
+  update(key, updater) {
+    const value = this.get(key);
+    const newValue = updater(value);
+    this.set(key, newValue);
+    return newValue;
+  }
+}
+const chunkSize = 3e4;
+function chunkedArrayPush(array, other) {
+  if (other.length <= chunkSize) {
+    array.push(...other);
+  } else {
+    for (let i = 0; i < other.length; i += chunkSize) {
+      const chunk = other.slice(i, i + chunkSize);
+      array.push(...chunk);
+    }
+  }
+}
+const hashCache = /* @__PURE__ */ new WeakMap();
+function hashReplacer(_key, value) {
+  if (typeof value === `bigint`) {
+    return String(value);
+  } else if (typeof value === `symbol`) {
+    return String(value);
+  } else if (typeof value === `function`) {
+    return String(value);
+  } else if (value === void 0) {
+    return `undefined`;
+  } else if (value instanceof Map) {
+    return `Map(${JSON.stringify(Array.from(value.entries()), hashReplacer)})`;
+  } else if (value instanceof Set) {
+    return `Set(${JSON.stringify(Array.from(value.values()), hashReplacer)})`;
+  }
+  return value;
+}
+function hash(data) {
+  if (data === null || data === void 0 || typeof data !== `object` && typeof data !== `function`) {
+    const serialized2 = JSON.stringify(data, hashReplacer);
+    return murmurhash.murmur3(serialized2).toString(16);
+  }
+  if (hashCache.has(data)) {
+    return hashCache.get(data);
+  }
+  const serialized = JSON.stringify(data, hashReplacer);
+  const hashValue = murmurhash.murmur3(serialized).toString(16);
+  hashCache.set(data, hashValue);
+  return hashValue;
+}
+function binarySearch(array, value, comparator) {
+  let low = 0;
+  let high = array.length;
+  while (low < high) {
+    const mid = Math.floor((low + high) / 2);
+    const comparison = comparator(array[mid], value);
+    if (comparison < 0) {
+      low = mid + 1;
+    } else if (comparison > 0) {
+      high = mid;
+    } else {
+      return mid;
+    }
+  }
+  return low;
+}
+class ObjectIdGenerator {
+  constructor() {
+    this.objectIds = /* @__PURE__ */ new WeakMap();
+    this.nextId = 0;
+  }
+  /**
+   * Get a unique identifier for any value.
+   * - Objects: Uses WeakMap for reference-based identity
+   * - Primitives: Uses consistent string-based hashing
+   */
+  getId(value) {
+    if (typeof value !== `object` || value === null) {
+      const str = String(value);
+      let hashValue = 0;
+      for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hashValue = (hashValue << 5) - hashValue + char;
+        hashValue = hashValue & hashValue;
+      }
+      return hashValue;
+    }
+    if (!this.objectIds.has(value)) {
+      this.objectIds.set(value, this.nextId++);
+    }
+    return this.objectIds.get(value);
+  }
+  /**
+   * Get a string representation of the ID for use in composite keys.
+   */
+  getStringId(value) {
+    if (value === null) return `null`;
+    if (value === void 0) return `undefined`;
+    if (typeof value !== `object`) return `str_${String(value)}`;
+    return `obj_${this.getId(value)}`;
+  }
+}
+const globalObjectIdGenerator = new ObjectIdGenerator();
+export {
+  DefaultMap,
+  ObjectIdGenerator,
+  binarySearch,
+  chunkedArrayPush,
+  globalObjectIdGenerator,
+  hash
+};
+//# sourceMappingURL=utils.js.map

package/dist/esm/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../src/utils.ts"],"sourcesContent":["import murmurhash from \"murmurhash-js\"\n\n/**\n * A map that returns a default value for keys that are not present.\n */\nexport class DefaultMap<K, V> extends Map<K, V> {\n  constructor(\n    private defaultValue: () => V,\n    entries?: Iterable<[K, V]>\n  ) {\n    super(entries)\n  }\n\n  get(key: K): V {\n    if (!this.has(key)) {\n      this.set(key, this.defaultValue())\n    }\n    return super.get(key)!\n  }\n\n  /**\n   * Update the value for a key using a function.\n   */\n  update(key: K, updater: (value: V) => V): V {\n    const value = this.get(key)\n    const newValue = updater(value)\n    this.set(key, newValue)\n    return newValue\n  }\n}\n\n// JS engines have various limits on how many args can be passed to a function\n// with a spread operator, so we need to split the operation into chunks\n// 32767 is the max for Chrome 14, all others are higher\n// TODO: investigate the performance of this and other approaches\nconst chunkSize = 30000\nexport function chunkedArrayPush(array: Array<unknown>, other: Array<unknown>) {\n  if (other.length <= chunkSize) {\n    array.push(...other)\n  } else {\n    for (let i = 0; i < other.length; i += chunkSize) {\n      const chunk = other.slice(i, i + chunkSize)\n      array.push(...chunk)\n    }\n  }\n}\n\nconst hashCache = new WeakMap()\n\n/**\n * Replacer function for JSON.stringify that converts unsupported types to strings\n */\nfunction hashReplacer(_key: string, value: any): any {\n  if (typeof value === `bigint`) {\n    return String(value)\n  } else if (typeof value === `symbol`) {\n    return String(value)\n  } else if (typeof value === `function`) {\n    return String(value)\n  } else if (value === undefined) {\n    return `undefined`\n  } else if (value instanceof Map) {\n    return `Map(${JSON.stringify(Array.from(value.entries()), hashReplacer)})`\n  } else if (value instanceof Set) {\n    return `Set(${JSON.stringify(Array.from(value.values()), hashReplacer)})`\n  }\n  return value\n}\n\n/**\n * A hash method that caches the hash of a value in a week map\n */\nexport function hash(data: any): string {\n  if (\n    data === null ||\n    data === undefined ||\n    (typeof data !== `object` && typeof data !== `function`)\n  ) {\n    // Can't be cached in the weak map because it's not an object\n    const serialized = JSON.stringify(data, hashReplacer)\n    return murmurhash.murmur3(serialized).toString(16)\n  }\n\n  if (hashCache.has(data)) {\n    return hashCache.get(data)\n  }\n\n  const serialized = JSON.stringify(data, hashReplacer)\n  const hashValue = murmurhash.murmur3(serialized).toString(16)\n  hashCache.set(data, hashValue)\n  return hashValue\n}\n\nexport function binarySearch<T>(\n  array: Array<T>,\n  value: T,\n  comparator: (a: T, b: T) => number\n): number {\n  let low = 0\n  let high = array.length\n  while (low < high) {\n    const mid = Math.floor((low + high) / 2)\n    const comparison = comparator(array[mid]!, value)\n    if (comparison < 0) {\n      low = mid + 1\n    } else if (comparison > 0) {\n      high = mid\n    } else {\n      return mid\n    }\n  }\n  return low\n}\n\n/**\n * Utility for generating unique IDs for objects and values.\n * Uses WeakMap for object reference tracking and consistent hashing for primitives.\n */\nexport class ObjectIdGenerator {\n  private objectIds = new WeakMap<object, number>()\n  private nextId = 0\n\n  /**\n   * Get a unique identifier for any value.\n   * - Objects: Uses WeakMap for reference-based identity\n   * - Primitives: Uses consistent string-based hashing\n   */\n  getId(value: any): number {\n    // For primitives, use a simple hash of their string representation\n    if (typeof value !== `object` || value === null) {\n      const str = String(value)\n      let hashValue = 0\n      for (let i = 0; i < str.length; i++) {\n        const char = str.charCodeAt(i)\n        hashValue = (hashValue << 5) - hashValue + char\n        hashValue = hashValue & hashValue // Convert to 32-bit integer\n      }\n      return hashValue\n    }\n\n    // For objects, use WeakMap to assign unique IDs\n    if (!this.objectIds.has(value)) {\n      this.objectIds.set(value, this.nextId++)\n    }\n    return this.objectIds.get(value)!\n  }\n\n  /**\n   * Get a string representation of the ID for use in composite keys.\n   */\n  getStringId(value: any): string {\n    if (value === null) return `null`\n    if (value === undefined) return `undefined`\n    if (typeof value !== `object`) return `str_${String(value)}`\n\n    return `obj_${this.getId(value)}`\n  }\n}\n\n/**\n * Global instance for cases where a shared object ID space is needed.\n */\nexport const globalObjectIdGenerator = new ObjectIdGenerator()\n"],"names":["serialized"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tanstack/db-ivm",
   "description": "Incremental View Maintenance for TanStack DB based on Differential Dataflow",
-  "version": "0.0.0",
+  "version": "0.1.1",
   "dependencies": {
     "fractional-indexing": "^3.2.0",
     "murmurhash-js": "^1.0.0",
@@ -31,7 +31,6 @@
   ],
   "main": "dist/cjs/index.cjs",
   "module": "dist/esm/index.js",
-  "packageManager": "pnpm@10.6.3",
   "peerDependencies": {
     "typescript": ">=4.7"
   },
@@ -51,13 +50,13 @@
     "ivm",
     "differential-dataflow"
   ],
+  "sideEffects": false,
+  "type": "module",
+  "types": "dist/esm/index.d.ts",
   "scripts": {
     "build": "vite build",
     "dev": "vite build --watch",
     "lint": "eslint . --fix",
     "test": "npx vitest --run"
-  },
-  "sideEffects": false,
-  "type": "module",
-  "types": "dist/esm/index.d.ts"
-}
+  }
+}