@tanstack/db-ivm 0.1.25 → 0.2.0

package/dist/cjs/operators/index.d.cts

@@ -1,21 +1,15 @@
-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 './groupedOrderBy.js';
-export * from './filterBy.js';
-export { groupBy, groupByOperators } from './groupBy.js';
+export * from "./pipe.cjs";
+export * from "./map.cjs";
+export * from "./tap.cjs";
+export * from "./filter.cjs";
+export * from "./concat.cjs";
+export * from "./output.cjs";
+export * from "./consolidate.cjs";
+export * from "./join.cjs";
+export * from "./reduce.cjs";
+export * from "./distinct.cjs";
+export * from "./topKWithFractionalIndex.cjs";
+export * from "./groupedTopKWithFractionalIndex.cjs";
+export * from "./orderBy.cjs";
+export * from "./groupedOrderBy.cjs";
+export { groupBy, groupByOperators } from "./groupBy.cjs";

package/dist/cjs/operators/join.cjs

@@ -130,26 +130,6 @@ function join(other, type = `inner`) {
     return output;
   };
 }
-function innerJoin(other) {
-  return join(other, `inner`);
-}
-function antiJoin(other) {
-  return join(other, `anti`);
-}
-function leftJoin(other) {
-  return join(other, `left`);
-}
-function rightJoin(other) {
-  return join(other, `right`);
-}
-function fullJoin(other) {
-  return join(other, `full`);
-}
 exports.JoinOperator = JoinOperator;
-exports.antiJoin = antiJoin;
-exports.fullJoin = fullJoin;
-exports.innerJoin = innerJoin;
 exports.join = join;
-exports.leftJoin = leftJoin;
-exports.rightJoin = rightJoin;
 //# sourceMappingURL=join.cjs.map

package/dist/cjs/operators/join.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"join.cjs","sources":["../../../src/operators/join.ts"],"sourcesContent":["/**\n * # Direct Join Algorithms for Incremental View Maintenance\n *\n * High-performance join operations implementing all join types (inner, left, right, full, anti)\n * with minimal state and optimized performance.\n *\n * ## Algorithm\n *\n * For each tick, the algorithm processes incoming changes (deltas) and emits join results:\n *\n * 1. **Build deltas**: Create delta indexes from input messages using `Index.fromMultiSet()`\n * 2. **Inner results**: Emit `ΔA⋈B_old + A_old⋈ΔB + ΔA⋈ΔB` (matched pairs)\n * 3. **Outer results**: For unmatched rows, emit null-extended tuples:\n *    - New unmatched rows from deltas (when opposite side empty)\n *    - Presence transitions: when key goes `0→>0` (retract nulls) or `>0→0` (emit nulls)\n * 4. **Update state**: Append deltas to indexes (consolidated multiplicity tracking automatic)\n *\n * **Consolidated multiplicity tracking** enables O(1) presence checks instead of scanning index buckets.\n *\n * ## State\n *\n * **Indexes** store the actual data:\n * - `indexA: Index<K, V1>` - all left-side rows accumulated over time\n * - `indexB: Index<K, V2>` - all right-side rows accumulated over time\n *\n * **Consolidated multiplicity tracking** (built into Index):\n * - Each Index maintains sum of multiplicities per key internally\n * - Provides O(1) presence checks: `index.hasPresence(key)` and `index.getConsolidatedMultiplicity(key)`\n * - Avoids scanning entire index buckets just to check if key has any rows\n *\n * ## Join Types\n *\n * - **Inner**: Standard delta terms only\n * - **Outer**: Inner results + null-extended unmatched rows with transition handling\n * - **Anti**: Unmatched rows only (no inner results)\n *\n * ## Key Optimizations\n *\n * - **No temp copying**: Uses `(A⊎ΔA)⋈ΔB = A⋈ΔB ⊎ ΔA⋈ΔB` distributive property\n * - **Early-out checks**: Skip phases when no deltas present\n * - **Zero-entry pruning**: Keep maps compact, O(distinct keys) memory\n * - **Final presence logic**: Avoid emit→retract churn within same tick\n *\n * ## Correctness\n *\n * - **Ordering**: Pre-append snapshots for emissions, post-emit state updates\n * - **Presence**: Key matched iff mass ≠ 0, transitions trigger null handling\n * - **Bag semantics**: Proper multiplicity handling including negatives\n */\n\nimport { BinaryOperator, DifferenceStreamWriter } from '../graph.js'\nimport { StreamBuilder } from '../d2.js'\nimport { MultiSet } from '../multiset.js'\nimport { Index } from '../indexes.js'\nimport type { DifferenceStreamReader } from '../graph.js'\nimport type { IStreamBuilder, KeyValue, PipedOperator } from '../types.js'\n\n/**\n * Type of join to perform\n */\nexport type JoinType = `inner` | `left` | `right` | `full` | `anti`\n\n/**\n * Operator that joins two input streams using direct join algorithms\n */\nexport class JoinOperator<K, V1, V2> extends BinaryOperator<\n  [K, V1] | [K, V2] | [K, [V1, V2]] | [K, [V1 | null, V2 | null]]\n> {\n  #indexA = new Index<K, V1>()\n  #indexB = new Index<K, V2>()\n  #mode: JoinType\n\n  constructor(\n    id: number,\n    inputA: DifferenceStreamReader<[K, V1]>,\n    inputB: DifferenceStreamReader<[K, V2]>,\n    output: DifferenceStreamWriter<any>,\n    mode: JoinType = `inner`,\n  ) {\n    super(id, inputA, inputB, output)\n    this.#mode = mode\n  }\n\n  run(): void {\n    // Build deltas from input messages\n    const deltaA = Index.fromMultiSets<K, V1>(\n      this.inputAMessages() as Array<MultiSet<[K, V1]>>,\n    )\n    const deltaB = Index.fromMultiSets<K, V2>(\n      this.inputBMessages() as Array<MultiSet<[K, V2]>>,\n    )\n\n    // Early-out if nothing changed\n    if (deltaA.size === 0 && deltaB.size === 0) return\n\n    const results = new MultiSet<any>()\n\n    // Emit inner results (all modes except anti)\n    if (this.#mode !== `anti`) {\n      this.emitInnerResults(deltaA, deltaB, results)\n    }\n\n    // Emit left outer/anti results\n    if (\n      this.#mode === `left` ||\n      this.#mode === `full` ||\n      this.#mode === `anti`\n    ) {\n      this.emitLeftOuterResults(deltaA, deltaB, results)\n    }\n\n    // Emit right outer results\n    if (this.#mode === `right` || this.#mode === `full`) {\n      this.emitRightOuterResults(deltaA, deltaB, results)\n    }\n\n    // Update state and send results\n    // IMPORTANT: All emissions use pre-append snapshots of indexA/indexB.\n    // Now append ALL deltas to indices - this happens unconditionally for every key,\n    // regardless of whether presence flipped. Consolidated multiplicity tracking is automatic.\n    this.#indexA.append(deltaA)\n    this.#indexB.append(deltaB)\n\n    // Send results\n    if (results.getInner().length > 0) {\n      this.output.sendData(results)\n    }\n  }\n\n  private emitInnerResults(\n    deltaA: Index<K, V1>,\n    deltaB: Index<K, V2>,\n    results: MultiSet<any>,\n  ): void {\n    // Emit the three standard delta terms: ΔA⋈B_old, A_old⋈ΔB, ΔA⋈ΔB\n    if (deltaA.size > 0) results.extend(deltaA.join(this.#indexB))\n    if (deltaB.size > 0) results.extend(this.#indexA.join(deltaB))\n    if (deltaA.size > 0 && deltaB.size > 0) results.extend(deltaA.join(deltaB))\n  }\n\n  private emitLeftOuterResults(\n    deltaA: Index<K, V1>,\n    deltaB: Index<K, V2>,\n    results: MultiSet<any>,\n  ): void {\n    // Emit unmatched left rows from deltaA\n    if (deltaA.size > 0) {\n      for (const [key, valueIterator] of deltaA.entriesIterators()) {\n        const currentMultiplicityB =\n          this.#indexB.getConsolidatedMultiplicity(key)\n        const deltaMultiplicityB = deltaB.getConsolidatedMultiplicity(key)\n        const finalMultiplicityB = currentMultiplicityB + deltaMultiplicityB\n\n        if (finalMultiplicityB === 0) {\n          for (const [value, multiplicity] of valueIterator) {\n            if (multiplicity !== 0) {\n              results.add([key, [value, null]], multiplicity)\n            }\n          }\n        }\n      }\n    }\n\n    // Handle presence transitions from right side changes\n    if (deltaB.size > 0) {\n      for (const key of deltaB.getPresenceKeys()) {\n        const before = this.#indexB.getConsolidatedMultiplicity(key)\n        const deltaMult = deltaB.getConsolidatedMultiplicity(key)\n        if (deltaMult === 0) continue\n        const after = before + deltaMult\n\n        // Skip transition handling if presence doesn't flip (both zero or both non-zero)\n        // Note: Index updates happen later regardless - we're only skipping null-extension emissions here\n        if ((before === 0) === (after === 0)) continue\n\n        // Determine the type of transition:\n        // - 0 → non-zero: Right becomes non-empty, left rows transition from unmatched to matched\n        //   → RETRACT previously emitted null-extended rows (emit with negative multiplicity)\n        // - non-zero → 0: Right becomes empty, left rows transition from matched to unmatched\n        //   → EMIT new null-extended rows (emit with positive multiplicity)\n        const transitioningToMatched = before === 0\n\n        for (const [value, multiplicity] of this.#indexA.getIterator(key)) {\n          if (multiplicity !== 0) {\n            results.add(\n              [key, [value, null]],\n              transitioningToMatched ? -multiplicity : +multiplicity,\n            )\n          }\n        }\n      }\n    }\n  }\n\n  private emitRightOuterResults(\n    deltaA: Index<K, V1>,\n    deltaB: Index<K, V2>,\n    results: MultiSet<any>,\n  ): void {\n    // Emit unmatched right rows from deltaB\n    if (deltaB.size > 0) {\n      for (const [key, valueIterator] of deltaB.entriesIterators()) {\n        const currentMultiplicityA =\n          this.#indexA.getConsolidatedMultiplicity(key)\n        const deltaMultiplicityA = deltaA.getConsolidatedMultiplicity(key)\n        const finalMultiplicityA = currentMultiplicityA + deltaMultiplicityA\n\n        if (finalMultiplicityA === 0) {\n          for (const [value, multiplicity] of valueIterator) {\n            if (multiplicity !== 0) {\n              results.add([key, [null, value]], multiplicity)\n            }\n          }\n        }\n      }\n    }\n\n    // Handle presence transitions from left side changes\n    if (deltaA.size > 0) {\n      for (const key of deltaA.getPresenceKeys()) {\n        const before = this.#indexA.getConsolidatedMultiplicity(key)\n        const deltaMult = deltaA.getConsolidatedMultiplicity(key)\n        if (deltaMult === 0) continue\n        const after = before + deltaMult\n\n        // Skip transition handling if presence doesn't flip (both zero or both non-zero)\n        // Note: Index updates happen later regardless - we're only skipping null-extension emissions here\n        if ((before === 0) === (after === 0)) continue\n\n        // Determine the type of transition:\n        // - 0 → non-zero: Left becomes non-empty, right rows transition from unmatched to matched\n        //   → RETRACT previously emitted null-extended rows (emit with negative multiplicity)\n        // - non-zero → 0: Left becomes empty, right rows transition from matched to unmatched\n        //   → EMIT new null-extended rows (emit with positive multiplicity)\n        const transitioningToMatched = before === 0\n\n        for (const [value, multiplicity] of this.#indexB.getIterator(key)) {\n          if (multiplicity !== 0) {\n            results.add(\n              [key, [null, value]],\n              transitioningToMatched ? -multiplicity : +multiplicity,\n            )\n          }\n        }\n      }\n    }\n  }\n}\n\n/**\n * Joins two input streams\n * @param other - The other stream to join with\n * @param type - The type of join to perform\n */\nexport function join<\n  K,\n  V1 extends T extends KeyValue<infer _KT, infer VT> ? VT : never,\n  V2,\n  T,\n>(\n  other: IStreamBuilder<KeyValue<K, V2>>,\n  type: JoinType = `inner`,\n): PipedOperator<T, KeyValue<K, [V1 | null, V2 | null]>> {\n  return (\n    stream: IStreamBuilder<T>,\n  ): IStreamBuilder<KeyValue<K, [V1 | null, V2 | null]>> => {\n    if (stream.graph !== other.graph) {\n      throw new Error(`Cannot join streams from different graphs`)\n    }\n    const output = new StreamBuilder<KeyValue<K, [V1 | null, V2 | null]>>(\n      stream.graph,\n      new DifferenceStreamWriter<KeyValue<K, [V1 | null, V2 | null]>>(),\n    )\n    const operator = new JoinOperator<K, V1, V2>(\n      stream.graph.getNextOperatorId(),\n      stream.connectReader() as DifferenceStreamReader<KeyValue<K, V1>>,\n      other.connectReader(),\n      output.writer,\n      type,\n    )\n    stream.graph.addOperator(operator)\n    return output\n  }\n}\n\n/**\n * Joins two input streams (inner join)\n * @param other - The other stream to join with\n */\nexport function innerJoin<\n  K,\n  V1 extends T extends KeyValue<infer _KT, infer VT> ? VT : never,\n  V2,\n  T,\n>(\n  other: IStreamBuilder<KeyValue<K, V2>>,\n): PipedOperator<T, KeyValue<K, [V1, V2]>> {\n  return join(other, `inner`) as unknown as PipedOperator<\n    T,\n    KeyValue<K, [V1, V2]>\n  >\n}\n\n/**\n * Joins two input streams (anti join)\n * @param other - The other stream to join with\n */\nexport function antiJoin<\n  K,\n  V1 extends T extends KeyValue<infer _KT, infer VT> ? VT : never,\n  V2,\n  T,\n>(\n  other: IStreamBuilder<KeyValue<K, V2>>,\n): PipedOperator<T, KeyValue<K, [V1, null]>> {\n  return join(other, `anti`) as unknown as PipedOperator<\n    T,\n    KeyValue<K, [V1, null]>\n  >\n}\n\n/**\n * Joins two input streams (left join)\n * @param other - The other stream to join with\n */\nexport function leftJoin<\n  K,\n  V1 extends T extends KeyValue<infer _KT, infer VT> ? VT : never,\n  V2,\n  T,\n>(\n  other: IStreamBuilder<KeyValue<K, V2>>,\n): PipedOperator<T, KeyValue<K, [V1, V2 | null]>> {\n  return join(other, `left`) as unknown as PipedOperator<\n    T,\n    KeyValue<K, [V1, V2 | null]>\n  >\n}\n\n/**\n * Joins two input streams (right join)\n * @param other - The other stream to join with\n */\nexport function rightJoin<\n  K,\n  V1 extends T extends KeyValue<infer _KT, infer VT> ? VT : never,\n  V2,\n  T,\n>(\n  other: IStreamBuilder<KeyValue<K, V2>>,\n): PipedOperator<T, KeyValue<K, [V1 | null, V2]>> {\n  return join(other, `right`) as unknown as PipedOperator<\n    T,\n    KeyValue<K, [V1 | null, V2]>\n  >\n}\n\n/**\n * Joins two input streams (full join)\n * @param other - The other stream to join with\n */\nexport function fullJoin<\n  K,\n  V1 extends T extends KeyValue<infer _KT, infer VT> ? VT : never,\n  V2,\n  T,\n>(\n  other: IStreamBuilder<KeyValue<K, V2>>,\n): PipedOperator<T, KeyValue<K, [V1 | null, V2 | null]>> {\n  return join(other, `full`) as unknown as PipedOperator<\n    T,\n    KeyValue<K, [V1 | null, V2 | null]>\n  >\n}\n"],"names":["BinaryOperator","Index","MultiSet","StreamBuilder","DifferenceStreamWriter"],"mappings":"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"}
+{"version":3,"file":"join.cjs","sources":["../../../src/operators/join.ts"],"sourcesContent":["/**\n * # Direct Join Algorithms for Incremental View Maintenance\n *\n * High-performance join operations implementing all join types (inner, left, right, full, anti)\n * with minimal state and optimized performance.\n *\n * ## Algorithm\n *\n * For each tick, the algorithm processes incoming changes (deltas) and emits join results:\n *\n * 1. **Build deltas**: Create delta indexes from input messages using `Index.fromMultiSet()`\n * 2. **Inner results**: Emit `ΔA⋈B_old + A_old⋈ΔB + ΔA⋈ΔB` (matched pairs)\n * 3. **Outer results**: For unmatched rows, emit null-extended tuples:\n *    - New unmatched rows from deltas (when opposite side empty)\n *    - Presence transitions: when key goes `0→>0` (retract nulls) or `>0→0` (emit nulls)\n * 4. **Update state**: Append deltas to indexes (consolidated multiplicity tracking automatic)\n *\n * **Consolidated multiplicity tracking** enables O(1) presence checks instead of scanning index buckets.\n *\n * ## State\n *\n * **Indexes** store the actual data:\n * - `indexA: Index<K, V1>` - all left-side rows accumulated over time\n * - `indexB: Index<K, V2>` - all right-side rows accumulated over time\n *\n * **Consolidated multiplicity tracking** (built into Index):\n * - Each Index maintains sum of multiplicities per key internally\n * - Provides O(1) presence checks: `index.hasPresence(key)` and `index.getConsolidatedMultiplicity(key)`\n * - Avoids scanning entire index buckets just to check if key has any rows\n *\n * ## Join Types\n *\n * - **Inner**: Standard delta terms only\n * - **Outer**: Inner results + null-extended unmatched rows with transition handling\n * - **Anti**: Unmatched rows only (no inner results)\n *\n * ## Key Optimizations\n *\n * - **No temp copying**: Uses `(A⊎ΔA)⋈ΔB = A⋈ΔB ⊎ ΔA⋈ΔB` distributive property\n * - **Early-out checks**: Skip phases when no deltas present\n * - **Zero-entry pruning**: Keep maps compact, O(distinct keys) memory\n * - **Final presence logic**: Avoid emit→retract churn within same tick\n *\n * ## Correctness\n *\n * - **Ordering**: Pre-append snapshots for emissions, post-emit state updates\n * - **Presence**: Key matched iff mass ≠ 0, transitions trigger null handling\n * - **Bag semantics**: Proper multiplicity handling including negatives\n */\n\nimport { BinaryOperator, DifferenceStreamWriter } from '../graph.js'\nimport { StreamBuilder } from '../d2.js'\nimport { MultiSet } from '../multiset.js'\nimport { Index } from '../indexes.js'\nimport type { DifferenceStreamReader } from '../graph.js'\nimport type { IStreamBuilder, KeyValue, PipedOperator } from '../types.js'\n\n/**\n * Type of join to perform\n */\nexport type JoinType = `inner` | `left` | `right` | `full` | `anti`\n\n/**\n * Operator that joins two input streams using direct join algorithms\n */\nexport class JoinOperator<K, V1, V2> extends BinaryOperator<\n  [K, V1] | [K, V2] | [K, [V1, V2]] | [K, [V1 | null, V2 | null]]\n> {\n  #indexA = new Index<K, V1>()\n  #indexB = new Index<K, V2>()\n  #mode: JoinType\n\n  constructor(\n    id: number,\n    inputA: DifferenceStreamReader<[K, V1]>,\n    inputB: DifferenceStreamReader<[K, V2]>,\n    output: DifferenceStreamWriter<any>,\n    mode: JoinType = `inner`,\n  ) {\n    super(id, inputA, inputB, output)\n    this.#mode = mode\n  }\n\n  run(): void {\n    // Build deltas from input messages\n    const deltaA = Index.fromMultiSets<K, V1>(\n      this.inputAMessages() as Array<MultiSet<[K, V1]>>,\n    )\n    const deltaB = Index.fromMultiSets<K, V2>(\n      this.inputBMessages() as Array<MultiSet<[K, V2]>>,\n    )\n\n    // Early-out if nothing changed\n    if (deltaA.size === 0 && deltaB.size === 0) return\n\n    const results = new MultiSet<any>()\n\n    // Emit inner results (all modes except anti)\n    if (this.#mode !== `anti`) {\n      this.emitInnerResults(deltaA, deltaB, results)\n    }\n\n    // Emit left outer/anti results\n    if (\n      this.#mode === `left` ||\n      this.#mode === `full` ||\n      this.#mode === `anti`\n    ) {\n      this.emitLeftOuterResults(deltaA, deltaB, results)\n    }\n\n    // Emit right outer results\n    if (this.#mode === `right` || this.#mode === `full`) {\n      this.emitRightOuterResults(deltaA, deltaB, results)\n    }\n\n    // Update state and send results\n    // IMPORTANT: All emissions use pre-append snapshots of indexA/indexB.\n    // Now append ALL deltas to indices - this happens unconditionally for every key,\n    // regardless of whether presence flipped. Consolidated multiplicity tracking is automatic.\n    this.#indexA.append(deltaA)\n    this.#indexB.append(deltaB)\n\n    // Send results\n    if (results.getInner().length > 0) {\n      this.output.sendData(results)\n    }\n  }\n\n  private emitInnerResults(\n    deltaA: Index<K, V1>,\n    deltaB: Index<K, V2>,\n    results: MultiSet<any>,\n  ): void {\n    // Emit the three standard delta terms: ΔA⋈B_old, A_old⋈ΔB, ΔA⋈ΔB\n    if (deltaA.size > 0) results.extend(deltaA.join(this.#indexB))\n    if (deltaB.size > 0) results.extend(this.#indexA.join(deltaB))\n    if (deltaA.size > 0 && deltaB.size > 0) results.extend(deltaA.join(deltaB))\n  }\n\n  private emitLeftOuterResults(\n    deltaA: Index<K, V1>,\n    deltaB: Index<K, V2>,\n    results: MultiSet<any>,\n  ): void {\n    // Emit unmatched left rows from deltaA\n    if (deltaA.size > 0) {\n      for (const [key, valueIterator] of deltaA.entriesIterators()) {\n        const currentMultiplicityB =\n          this.#indexB.getConsolidatedMultiplicity(key)\n        const deltaMultiplicityB = deltaB.getConsolidatedMultiplicity(key)\n        const finalMultiplicityB = currentMultiplicityB + deltaMultiplicityB\n\n        if (finalMultiplicityB === 0) {\n          for (const [value, multiplicity] of valueIterator) {\n            if (multiplicity !== 0) {\n              results.add([key, [value, null]], multiplicity)\n            }\n          }\n        }\n      }\n    }\n\n    // Handle presence transitions from right side changes\n    if (deltaB.size > 0) {\n      for (const key of deltaB.getPresenceKeys()) {\n        const before = this.#indexB.getConsolidatedMultiplicity(key)\n        const deltaMult = deltaB.getConsolidatedMultiplicity(key)\n        if (deltaMult === 0) continue\n        const after = before + deltaMult\n\n        // Skip transition handling if presence doesn't flip (both zero or both non-zero)\n        // Note: Index updates happen later regardless - we're only skipping null-extension emissions here\n        if ((before === 0) === (after === 0)) continue\n\n        // Determine the type of transition:\n        // - 0 → non-zero: Right becomes non-empty, left rows transition from unmatched to matched\n        //   → RETRACT previously emitted null-extended rows (emit with negative multiplicity)\n        // - non-zero → 0: Right becomes empty, left rows transition from matched to unmatched\n        //   → EMIT new null-extended rows (emit with positive multiplicity)\n        const transitioningToMatched = before === 0\n\n        for (const [value, multiplicity] of this.#indexA.getIterator(key)) {\n          if (multiplicity !== 0) {\n            results.add(\n              [key, [value, null]],\n              transitioningToMatched ? -multiplicity : +multiplicity,\n            )\n          }\n        }\n      }\n    }\n  }\n\n  private emitRightOuterResults(\n    deltaA: Index<K, V1>,\n    deltaB: Index<K, V2>,\n    results: MultiSet<any>,\n  ): void {\n    // Emit unmatched right rows from deltaB\n    if (deltaB.size > 0) {\n      for (const [key, valueIterator] of deltaB.entriesIterators()) {\n        const currentMultiplicityA =\n          this.#indexA.getConsolidatedMultiplicity(key)\n        const deltaMultiplicityA = deltaA.getConsolidatedMultiplicity(key)\n        const finalMultiplicityA = currentMultiplicityA + deltaMultiplicityA\n\n        if (finalMultiplicityA === 0) {\n          for (const [value, multiplicity] of valueIterator) {\n            if (multiplicity !== 0) {\n              results.add([key, [null, value]], multiplicity)\n            }\n          }\n        }\n      }\n    }\n\n    // Handle presence transitions from left side changes\n    if (deltaA.size > 0) {\n      for (const key of deltaA.getPresenceKeys()) {\n        const before = this.#indexA.getConsolidatedMultiplicity(key)\n        const deltaMult = deltaA.getConsolidatedMultiplicity(key)\n        if (deltaMult === 0) continue\n        const after = before + deltaMult\n\n        // Skip transition handling if presence doesn't flip (both zero or both non-zero)\n        // Note: Index updates happen later regardless - we're only skipping null-extension emissions here\n        if ((before === 0) === (after === 0)) continue\n\n        // Determine the type of transition:\n        // - 0 → non-zero: Left becomes non-empty, right rows transition from unmatched to matched\n        //   → RETRACT previously emitted null-extended rows (emit with negative multiplicity)\n        // - non-zero → 0: Left becomes empty, right rows transition from matched to unmatched\n        //   → EMIT new null-extended rows (emit with positive multiplicity)\n        const transitioningToMatched = before === 0\n\n        for (const [value, multiplicity] of this.#indexB.getIterator(key)) {\n          if (multiplicity !== 0) {\n            results.add(\n              [key, [null, value]],\n              transitioningToMatched ? -multiplicity : +multiplicity,\n            )\n          }\n        }\n      }\n    }\n  }\n}\n\n/**\n * Joins two input streams\n * @param other - The other stream to join with\n * @param type - The type of join to perform\n */\nexport function join<\n  K,\n  V1 extends (T extends KeyValue<infer _KT, infer VT> ? VT : never),\n  V2,\n  T,\n>(\n  other: IStreamBuilder<KeyValue<K, V2>>,\n  type: JoinType = `inner`,\n): PipedOperator<T, KeyValue<K, [V1 | null, V2 | null]>> {\n  return (\n    stream: IStreamBuilder<T>,\n  ): IStreamBuilder<KeyValue<K, [V1 | null, V2 | null]>> => {\n    if (stream.graph !== other.graph) {\n      throw new Error(`Cannot join streams from different graphs`)\n    }\n    const output = new StreamBuilder<KeyValue<K, [V1 | null, V2 | null]>>(\n      stream.graph,\n      new DifferenceStreamWriter<KeyValue<K, [V1 | null, V2 | null]>>(),\n    )\n    const operator = new JoinOperator<K, V1, V2>(\n      stream.graph.getNextOperatorId(),\n      stream.connectReader() as DifferenceStreamReader<KeyValue<K, V1>>,\n      other.connectReader(),\n      output.writer,\n      type,\n    )\n    stream.graph.addOperator(operator)\n    return output\n  }\n}\n"],"names":["BinaryOperator","Index","MultiSet","StreamBuilder","DifferenceStreamWriter"],"mappings":"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"}

package/dist/cjs/operators/join.d.cts

@@ -1,5 +1,5 @@
-import { BinaryOperator, DifferenceStreamWriter, DifferenceStreamReader } from '../graph.js';
-import { IStreamBuilder, KeyValue, PipedOperator } from '../types.js';
+import { BinaryOperator, DifferenceStreamWriter, DifferenceStreamReader } from "../graph.cjs";
+import { IStreamBuilder, KeyValue, PipedOperator } from "../types.cjs";
 /**
  * Type of join to perform
  */
@@ -10,9 +10,30 @@ export type JoinType = `inner` | `left` | `right` | `full` | `anti`;
 export declare class JoinOperator<K, V1, V2> extends BinaryOperator<[
     K,
     V1
-] | [K, V2] | [K, [V1, V2]] | [K, [V1 | null, V2 | null]]> {
+] | [
+    K,
+    V2
+] | [
+    K,
+    [
+        V1,
+        V2
+    ]
+] | [
+    K,
+    [
+        V1 | null,
+        V2 | null
+    ]
+]> {
     #private;
-    constructor(id: number, inputA: DifferenceStreamReader<[K, V1]>, inputB: DifferenceStreamReader<[K, V2]>, output: DifferenceStreamWriter<any>, mode?: JoinType);
+    constructor(id: number, inputA: DifferenceStreamReader<[
+        K,
+        V1
+    ]>, inputB: DifferenceStreamReader<[
+        K,
+        V2
+    ]>, output: DifferenceStreamWriter<any>, mode?: JoinType);
     run(): void;
     private emitInnerResults;
     private emitLeftOuterResults;
@@ -23,29 +44,7 @@ export declare class JoinOperator<K, V1, V2> extends BinaryOperator<[
  * @param other - The other stream to join with
  * @param type - The type of join to perform
  */
-export declare function join<K, V1 extends T extends KeyValue<infer _KT, infer VT> ? VT : never, V2, T>(other: IStreamBuilder<KeyValue<K, V2>>, type?: JoinType): PipedOperator<T, KeyValue<K, [V1 | null, V2 | null]>>;
-/**
- * Joins two input streams (inner join)
- * @param other - The other stream to join with
- */
-export declare function innerJoin<K, V1 extends T extends KeyValue<infer _KT, infer VT> ? VT : never, V2, T>(other: IStreamBuilder<KeyValue<K, V2>>): PipedOperator<T, KeyValue<K, [V1, V2]>>;
-/**
- * Joins two input streams (anti join)
- * @param other - The other stream to join with
- */
-export declare function antiJoin<K, V1 extends T extends KeyValue<infer _KT, infer VT> ? VT : never, V2, T>(other: IStreamBuilder<KeyValue<K, V2>>): PipedOperator<T, KeyValue<K, [V1, null]>>;
-/**
- * Joins two input streams (left join)
- * @param other - The other stream to join with
- */
-export declare function leftJoin<K, V1 extends T extends KeyValue<infer _KT, infer VT> ? VT : never, V2, T>(other: IStreamBuilder<KeyValue<K, V2>>): PipedOperator<T, KeyValue<K, [V1, V2 | null]>>;
-/**
- * Joins two input streams (right join)
- * @param other - The other stream to join with
- */
-export declare function rightJoin<K, V1 extends T extends KeyValue<infer _KT, infer VT> ? VT : never, V2, T>(other: IStreamBuilder<KeyValue<K, V2>>): PipedOperator<T, KeyValue<K, [V1 | null, V2]>>;
-/**
- * Joins two input streams (full join)
- * @param other - The other stream to join with
- */
-export declare function fullJoin<K, V1 extends T extends KeyValue<infer _KT, infer VT> ? VT : never, V2, T>(other: IStreamBuilder<KeyValue<K, V2>>): PipedOperator<T, KeyValue<K, [V1 | null, V2 | null]>>;
+export declare function join<K, V1 extends (T extends KeyValue<infer _KT, infer VT> ? VT : never), V2, T>(other: IStreamBuilder<KeyValue<K, V2>>, type?: JoinType): PipedOperator<T, KeyValue<K, [
+    V1 | null,
+    V2 | null
+]>>;

package/dist/cjs/operators/map.d.cts

@@ -1,6 +1,6 @@
-import { DifferenceStreamWriter, LinearUnaryOperator, DifferenceStreamReader } from '../graph.js';
-import { PipedOperator } from '../types.js';
-import { MultiSet } from '../multiset.js';
+import { DifferenceStreamWriter, LinearUnaryOperator, DifferenceStreamReader } from "../graph.cjs";
+import { PipedOperator } from "../types.cjs";
+import { MultiSet } from "../multiset.cjs";
 /**
  * Operator that applies a function to each element in the input stream
  */

package/dist/cjs/operators/orderBy.cjs

@@ -1,73 +1,8 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const topK = require("./topK.cjs");
 const topKWithFractionalIndex = require("./topKWithFractionalIndex.cjs");
-const map = require("./map.cjs");
-const join = require("./join.cjs");
 const consolidate = require("./consolidate.cjs");
-function orderBy(valueExtractor, options) {
-  const limit = options?.limit ?? Infinity;
-  const offset = options?.offset ?? 0;
-  const comparator = options?.comparator ?? ((a, b) => {
-    if (a === b) return 0;
-    if (a < b) return -1;
-    return 1;
-  });
-  return (stream) => {
-    return stream.pipe(
-      map.map(
-        ([key, value]) => [
-          null,
-          [
-            key,
-            valueExtractor(
-              value
-            )
-          ]
-        ]
-      ),
-      topK.topK((a, b) => comparator(a[1], b[1]), { limit, offset }),
-      map.map(([_, [key]]) => [key, null]),
-      join.innerJoin(stream),
-      map.map(([key, value]) => {
-        return [key, value[1]];
-      }),
-      consolidate.consolidate()
-    );
-  };
-}
-function orderByWithIndex(valueExtractor, options) {
-  const limit = options?.limit ?? Infinity;
-  const offset = options?.offset ?? 0;
-  const comparator = options?.comparator ?? ((a, b) => {
-    if (a === b) return 0;
-    if (a < b) return -1;
-    return 1;
-  });
-  return (stream) => {
-    return stream.pipe(
-      map.map(
-        ([key, value]) => [
-          null,
-          [
-            key,
-            valueExtractor(
-              value
-            )
-          ]
-        ]
-      ),
-      topK.topKWithIndex((a, b) => comparator(a[1], b[1]), { limit, offset }),
-      map.map(([_, [[key], index]]) => [key, index]),
-      join.innerJoin(stream),
-      map.map(([key, [index, value]]) => {
-        return [key, [value, index]];
-      }),
-      consolidate.consolidate()
-    );
-  };
-}
-function orderByWithFractionalIndexBase(topKFunction, valueExtractor, options) {
+function orderByWithFractionalIndex(valueExtractor, options) {
   const limit = options?.limit ?? Infinity;
   const offset = options?.offset ?? 0;
   const setSizeCallback = options?.setSizeCallback;
@@ -79,7 +14,7 @@ function orderByWithFractionalIndexBase(topKFunction, valueExtractor, options) {
   });
   return (stream) => {
     return stream.pipe(
-      topKFunction(
+      topKWithFractionalIndex.topKWithFractionalIndex(
         (a, b) => comparator(valueExtractor(a), valueExtractor(b)),
         {
           limit,
@@ -92,15 +27,5 @@ function orderByWithFractionalIndexBase(topKFunction, valueExtractor, options) {
     );
   };
 }
-function orderByWithFractionalIndex(valueExtractor, options) {
-  return orderByWithFractionalIndexBase(
-    topKWithFractionalIndex.topKWithFractionalIndex,
-    valueExtractor,
-    options
-  );
-}
-exports.orderBy = orderBy;
 exports.orderByWithFractionalIndex = orderByWithFractionalIndex;
-exports.orderByWithFractionalIndexBase = orderByWithFractionalIndexBase;
-exports.orderByWithIndex = orderByWithIndex;
 //# sourceMappingURL=orderBy.cjs.map

package/dist/cjs/operators/orderBy.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"orderBy.cjs","sources":["../../../src/operators/orderBy.ts"],"sourcesContent":["import { topK, topKWithIndex } from './topK.js'\nimport { topKWithFractionalIndex } from './topKWithFractionalIndex.js'\nimport { map } from './map.js'\nimport { innerJoin } from './join.js'\nimport { consolidate } from './consolidate.js'\nimport type { IStreamBuilder, KeyValue } from '../types.js'\n\nexport interface OrderByOptions<Ve> {\n  comparator?: (a: Ve, b: Ve) => number\n  limit?: number\n  offset?: number\n}\n\ntype OrderByWithFractionalIndexOptions<Ve> = OrderByOptions<Ve> & {\n  setSizeCallback?: (getSize: () => number) => void\n  setWindowFn?: (\n    windowFn: (options: { offset?: number; limit?: number }) => void,\n  ) => void\n}\n\n/**\n * Orders the elements and limits the number of results, with optional offset\n * This requires a keyed stream, and uses the `topK` operator to order all the elements.\n *\n * @param valueExtractor - A function that extracts the value to order by from the element\n * @param options - An optional object containing comparator, limit and offset properties\n * @returns A piped operator that orders the elements and limits the number of results\n */\nexport function orderBy<T extends KeyValue<unknown, unknown>, Ve = unknown>(\n  valueExtractor: (\n    value: T extends KeyValue<unknown, infer V> ? V : never,\n  ) => Ve,\n  options?: OrderByOptions<Ve>,\n) {\n  const limit = options?.limit ?? Infinity\n  const offset = options?.offset ?? 0\n  const comparator =\n    options?.comparator ??\n    ((a, b) => {\n      // Default to JS like ordering\n      if (a === b) return 0\n      if (a < b) return -1\n      return 1\n    })\n\n  return (stream: IStreamBuilder<T>): IStreamBuilder<T> => {\n    type KeyType = T extends KeyValue<infer K, unknown> ? K : never\n\n    return stream.pipe(\n      map(\n        ([key, value]) =>\n          [\n            null,\n            [\n              key,\n              valueExtractor(\n                value as T extends KeyValue<unknown, infer V> ? V : never,\n              ),\n            ],\n          ] as KeyValue<null, [KeyType, Ve]>,\n      ),\n      topK((a, b) => comparator(a[1], b[1]), { limit, offset }),\n      map(([_, [key]]) => [key, null] as KeyValue<KeyType, null>),\n      innerJoin(stream),\n      map(([key, value]) => {\n        return [key, value[1]] as T\n      }),\n      consolidate(),\n    )\n  }\n}\n\n/**\n * Orders the elements and limits the number of results, with optional offset and\n * annotates the value with the index.\n * This requires a keyed stream, and uses the `topKWithIndex` operator to order all the elements.\n *\n * @param valueExtractor - A function that extracts the value to order by from the element\n * @param options - An optional object containing comparator, limit and offset properties\n * @returns A piped operator that orders the elements and limits the number of results\n */\nexport function orderByWithIndex<\n  T extends KeyValue<unknown, unknown>,\n  Ve = unknown,\n>(\n  valueExtractor: (\n    value: T extends KeyValue<unknown, infer V> ? V : never,\n  ) => Ve,\n  options?: OrderByOptions<Ve>,\n) {\n  const limit = options?.limit ?? Infinity\n  const offset = options?.offset ?? 0\n  const comparator =\n    options?.comparator ??\n    ((a, b) => {\n      // Default to JS like ordering\n      if (a === b) return 0\n      if (a < b) return -1\n      return 1\n    })\n\n  return (\n    stream: IStreamBuilder<T>,\n  ): IStreamBuilder<\n    KeyValue<\n      T extends KeyValue<infer K, unknown> ? K : never,\n      [T extends KeyValue<unknown, infer V> ? V : never, number]\n    >\n  > => {\n    type KeyType = T extends KeyValue<infer K, unknown> ? K : never\n    type ValueType = T extends KeyValue<unknown, infer V> ? V : never\n\n    return stream.pipe(\n      map(\n        ([key, value]) =>\n          [\n            null,\n            [\n              key,\n              valueExtractor(\n                value as T extends KeyValue<unknown, infer V> ? V : never,\n              ),\n            ],\n          ] as KeyValue<null, [KeyType, Ve]>,\n      ),\n      topKWithIndex((a, b) => comparator(a[1], b[1]), { limit, offset }),\n      map(([_, [[key], index]]) => [key, index] as KeyValue<KeyType, number>),\n      innerJoin(stream),\n      map(([key, [index, value]]) => {\n        return [key, [value, index]] as KeyValue<KeyType, [ValueType, number]>\n      }),\n      consolidate(),\n    )\n  }\n}\n\nexport function orderByWithFractionalIndexBase<\n  T extends KeyValue<unknown, unknown>,\n  Ve = unknown,\n>(\n  topKFunction: typeof topKWithFractionalIndex,\n  valueExtractor: (\n    value: T extends KeyValue<unknown, infer V> ? V : never,\n  ) => Ve,\n  options?: OrderByWithFractionalIndexOptions<Ve>,\n) {\n  type KeyType = T extends KeyValue<infer K, unknown> ? K : never\n  type ValueType = T extends KeyValue<unknown, infer V> ? V : never\n\n  const limit = options?.limit ?? Infinity\n  const offset = options?.offset ?? 0\n  const setSizeCallback = options?.setSizeCallback\n  const setWindowFn = options?.setWindowFn\n  const comparator =\n    options?.comparator ??\n    ((a, b) => {\n      // Default to JS like ordering\n      if (a === b) return 0\n      if (a < b) return -1\n      return 1\n    })\n\n  return (\n    stream: IStreamBuilder<T>,\n  ): IStreamBuilder<[KeyType, [ValueType, string]]> => {\n    return stream.pipe(\n      topKFunction(\n        (a: ValueType, b: ValueType) =>\n          comparator(valueExtractor(a), valueExtractor(b)),\n        {\n          limit,\n          offset,\n          setSizeCallback,\n          setWindowFn,\n        },\n      ),\n      consolidate(),\n    )\n  }\n}\n\n/**\n * Orders the elements and limits the number of results, with optional offset and\n * annotates the value with a fractional index.\n * This requires a keyed stream, and uses the `topKWithFractionalIndex` operator to order all the elements.\n *\n * @param valueExtractor - A function that extracts the value to order by from the element\n * @param options - An optional object containing comparator, limit and offset properties\n * @returns A piped operator that orders the elements and limits the number of results\n */\nexport function orderByWithFractionalIndex<\n  T extends KeyValue<unknown, unknown>,\n  Ve = unknown,\n>(\n  valueExtractor: (\n    value: T extends KeyValue<unknown, infer V> ? V : never,\n  ) => Ve,\n  options?: OrderByWithFractionalIndexOptions<Ve>,\n) {\n  return orderByWithFractionalIndexBase(\n    topKWithFractionalIndex,\n    valueExtractor,\n    options,\n  )\n}\n"],"names":["map","topK","innerJoin","consolidate","topKWithIndex","topKWithFractionalIndex"],"mappings":"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"}
+{"version":3,"file":"orderBy.cjs","sources":["../../../src/operators/orderBy.ts"],"sourcesContent":["import { topKWithFractionalIndex } from './topKWithFractionalIndex.js'\nimport { consolidate } from './consolidate.js'\nimport type { IStreamBuilder, KeyValue } from '../types.js'\nimport type { SetSizeCallback } from './topKWithFractionalIndex.js'\n\nexport interface OrderByOptions<Ve> {\n  comparator?: (a: Ve, b: Ve) => number\n  limit?: number\n  offset?: number\n}\n\ntype OrderByWithFractionalIndexOptions<Ve> = OrderByOptions<Ve> & {\n  setSizeCallback?: SetSizeCallback\n  setWindowFn?: (\n    windowFn: (options: { offset?: number; limit?: number }) => void,\n  ) => void\n}\n\n/**\n * Orders the elements and limits the number of results, with optional offset and\n * annotates the value with a fractional index.\n * This requires a keyed stream, and uses the `topKWithFractionalIndex` operator to order all the elements.\n *\n * @param valueExtractor - A function that extracts the value to order by from the element\n * @param options - An optional object containing comparator, limit and offset properties\n * @returns A piped operator that orders the elements and limits the number of results\n */\nexport function orderByWithFractionalIndex<\n  T extends KeyValue<unknown, unknown>,\n  Ve = unknown,\n>(\n  valueExtractor: (\n    value: T extends KeyValue<unknown, infer V> ? V : never,\n  ) => Ve,\n  options?: OrderByWithFractionalIndexOptions<Ve>,\n) {\n  type KeyType = T extends KeyValue<infer K, unknown> ? K : never\n  type ValueType = T extends KeyValue<unknown, infer V> ? V : never\n\n  const limit = options?.limit ?? Infinity\n  const offset = options?.offset ?? 0\n  const setSizeCallback = options?.setSizeCallback\n  const setWindowFn = options?.setWindowFn\n  const comparator =\n    options?.comparator ??\n    ((a, b) => {\n      // Default to JS like ordering\n      if (a === b) return 0\n      if (a < b) return -1\n      return 1\n    })\n\n  return (\n    stream: IStreamBuilder<T>,\n  ): IStreamBuilder<[KeyType, [ValueType, string]]> => {\n    return stream.pipe(\n      topKWithFractionalIndex(\n        (a: ValueType, b: ValueType) =>\n          comparator(valueExtractor(a), valueExtractor(b)),\n        {\n          limit,\n          offset,\n          setSizeCallback,\n          setWindowFn,\n        },\n      ),\n      consolidate(),\n    )\n  }\n}\n"],"names":["topKWithFractionalIndex","consolidate"],"mappings":";;;;AA2BO,SAAS,2BAId,gBAGA,SACA;AAIA,QAAM,QAAQ,SAAS,SAAS;AAChC,QAAM,SAAS,SAAS,UAAU;AAClC,QAAM,kBAAkB,SAAS;AACjC,QAAM,cAAc,SAAS;AAC7B,QAAM,aACJ,SAAS,eACR,CAAC,GAAG,MAAM;AAET,QAAI,MAAM,EAAG,QAAO;AACpB,QAAI,IAAI,EAAG,QAAO;AAClB,WAAO;AAAA,EACT;AAEF,SAAO,CACL,WACmD;AACnD,WAAO,OAAO;AAAA,MACZA,wBAAAA;AAAAA,QACE,CAAC,GAAc,MACb,WAAW,eAAe,CAAC,GAAG,eAAe,CAAC,CAAC;AAAA,QACjD;AAAA,UACE;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QAAA;AAAA,MACF;AAAA,MAEFC,YAAAA,YAAA;AAAA,IAAY;AAAA,EAEhB;AACF;;"}

package/dist/cjs/operators/orderBy.d.cts

@@ -1,37 +1,17 @@
-import { topKWithFractionalIndex } from './topKWithFractionalIndex.js';
-import { IStreamBuilder, KeyValue } from '../types.js';
+import { IStreamBuilder, KeyValue } from "../types.cjs";
+import { SetSizeCallback } from "./topKWithFractionalIndex.cjs";
 export interface OrderByOptions<Ve> {
     comparator?: (a: Ve, b: Ve) => number;
     limit?: number;
     offset?: number;
 }
 type OrderByWithFractionalIndexOptions<Ve> = OrderByOptions<Ve> & {
-    setSizeCallback?: (getSize: () => number) => void;
+    setSizeCallback?: SetSizeCallback;
     setWindowFn?: (windowFn: (options: {
         offset?: number;
         limit?: number;
     }) => void) => void;
 };
-/**
- * Orders the elements and limits the number of results, with optional offset
- * This requires a keyed stream, and uses the `topK` operator to order all the elements.
- *
- * @param valueExtractor - A function that extracts the value to order by from the element
- * @param options - An optional object containing comparator, limit and offset properties
- * @returns A piped operator that orders the elements and limits the number of results
- */
-export declare function orderBy<T extends KeyValue<unknown, unknown>, Ve = unknown>(valueExtractor: (value: T extends KeyValue<unknown, infer V> ? V : never) => Ve, options?: OrderByOptions<Ve>): (stream: IStreamBuilder<T>) => IStreamBuilder<T>;
-/**
- * Orders the elements and limits the number of results, with optional offset and
- * annotates the value with the index.
- * This requires a keyed stream, and uses the `topKWithIndex` operator to order all the elements.
- *
- * @param valueExtractor - A function that extracts the value to order by from the element
- * @param options - An optional object containing comparator, limit and offset properties
- * @returns A piped operator that orders the elements and limits the number of results
- */
-export declare function orderByWithIndex<T extends KeyValue<unknown, unknown>, Ve = unknown>(valueExtractor: (value: T extends KeyValue<unknown, infer V> ? V : never) => Ve, options?: OrderByOptions<Ve>): (stream: IStreamBuilder<T>) => IStreamBuilder<KeyValue<T extends KeyValue<infer K, unknown> ? K : never, [T extends KeyValue<unknown, infer V> ? V : never, number]>>;
-export declare function orderByWithFractionalIndexBase<T extends KeyValue<unknown, unknown>, Ve = unknown>(topKFunction: typeof topKWithFractionalIndex, valueExtractor: (value: T extends KeyValue<unknown, infer V> ? V : never) => Ve, options?: OrderByWithFractionalIndexOptions<Ve>): (stream: IStreamBuilder<T>) => IStreamBuilder<[T extends KeyValue<infer K, unknown> ? K : never, [T extends KeyValue<unknown, infer V> ? V : never, string]]>;
 /**
  * Orders the elements and limits the number of results, with optional offset and
  * annotates the value with a fractional index.
@@ -41,5 +21,11 @@ export declare function orderByWithFractionalIndexBase<T extends KeyValue<unknow
  * @param options - An optional object containing comparator, limit and offset properties
  * @returns A piped operator that orders the elements and limits the number of results
  */
-export declare function orderByWithFractionalIndex<T extends KeyValue<unknown, unknown>, Ve = unknown>(valueExtractor: (value: T extends KeyValue<unknown, infer V> ? V : never) => Ve, options?: OrderByWithFractionalIndexOptions<Ve>): (stream: IStreamBuilder<T>) => IStreamBuilder<[T extends KeyValue<infer K, unknown> ? K : never, [T extends KeyValue<unknown, infer V> ? V : never, string]]>;
+export declare function orderByWithFractionalIndex<T extends KeyValue<unknown, unknown>, Ve = unknown>(valueExtractor: (value: T extends KeyValue<unknown, infer V> ? V : never) => Ve, options?: OrderByWithFractionalIndexOptions<Ve>): (stream: IStreamBuilder<T>) => IStreamBuilder<[
+    T extends KeyValue<infer K, unknown> ? K : never,
+    [
+        T extends KeyValue<unknown, infer V> ? V : never,
+        string
+    ]
+]>;
 export {};

package/dist/cjs/operators/output.d.cts

@@ -1,6 +1,6 @@
-import { DifferenceStreamWriter, UnaryOperator, DifferenceStreamReader } from '../graph.js';
-import { PipedOperator } from '../types.js';
-import { MultiSet } from '../multiset.js';
+import { DifferenceStreamWriter, UnaryOperator, DifferenceStreamReader } from "../graph.cjs";
+import { PipedOperator } from "../types.cjs";
+import { MultiSet } from "../multiset.cjs";
 /**
  * Operator that outputs the messages in the stream
  */

package/dist/cjs/operators/pipe.d.cts

@@ -1,4 +1,4 @@
-import { PipedOperator } from '../types.js';
+import { PipedOperator } from "../types.cjs";
 export declare function pipe<T, O>(o1: PipedOperator<T, O>): PipedOperator<T, O>;
 export declare function pipe<T, T2, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, O>): PipedOperator<T, O>;
 export declare function pipe<T, T2, T3, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, O>): PipedOperator<T, O>;

package/dist/cjs/operators/reduce.cjs

@@ -4,12 +4,20 @@ const graph = require("../graph.cjs");
 const d2 = require("../d2.cjs");
 const multiset = require("../multiset.cjs");
 const indexes = require("../indexes.cjs");
+function sameOutput(left, right) {
+  return left === right || left !== left && right !== right;
+}
+function asMapKey(value) {
+  return value === 0 ? 0 : value;
+}
 class ReduceOperator extends graph.UnaryOperator {
-  #index = new indexes.Index();
-  #indexOut = new indexes.Index();
+  // Reduce never reads presence, so its indexes skip that bookkeeping.
+  #index;
+  #indexOut = new indexes.Index({ trackPresence: false });
   #f;
-  constructor(id, inputA, output, f) {
+  constructor(id, inputA, output, f, options) {
     super(id, inputA, output);
+    this.#index = new indexes.Index({ ...options, trackPresence: false });
     this.#f = f;
   }
   run() {
@@ -26,6 +34,28 @@ class ReduceOperator extends graph.UnaryOperator {
       const curr = this.#index.get(key);
       const currOut = this.#indexOut.get(key);
       const out = this.#f(curr);
+      if (out.length <= 1 && currOut.length <= 1) {
+        const before = currOut[0];
+        const after = out[0];
+        const value = after === void 0 ? void 0 : asMapKey(after[0]);
+        if (before !== void 0 && after !== void 0 && sameOutput(before[0], value)) {
+          const delta = after[1] - before[1];
+          if (delta !== 0) {
+            result.push([[key, before[0]], delta]);
+            this.#indexOut.addValue(key, [before[0], delta]);
+          }
+          continue;
+        }
+        if (before !== void 0) {
+          result.push([[key, before[0]], -before[1]]);
+          this.#indexOut.addValue(key, [before[0], -before[1]]);
+        }
+        if (after !== void 0 && after[1] !== 0) {
+          result.push([[key, value], after[1]]);
+          this.#indexOut.addValue(key, [value, after[1]]);
+        }
+        continue;
+      }
       const newOutputMap = /* @__PURE__ */ new Map();
       const oldOutputMap = /* @__PURE__ */ new Map();
       for (const [value, multiplicity] of out) {
@@ -66,7 +96,7 @@ class ReduceOperator extends graph.UnaryOperator {
     }
   }
 }
-function reduce(f) {
+function reduce(f, options) {
   return (stream) => {
     const output = new d2.StreamBuilder(
       stream.graph,
@@ -76,7 +106,8 @@ function reduce(f) {
       stream.graph.getNextOperatorId(),
       stream.connectReader(),
       output.writer,
-      f
+      f,
+      options
     );
     stream.graph.addOperator(operator);
     return output;

package/dist/cjs/operators/reduce.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"reduce.cjs","sources":["../../../src/operators/reduce.ts"],"sourcesContent":["import { DifferenceStreamWriter, UnaryOperator } from '../graph.js'\nimport { StreamBuilder } from '../d2.js'\nimport { MultiSet } from '../multiset.js'\nimport { Index } from '../indexes.js'\nimport type { DifferenceStreamReader } from '../graph.js'\nimport type { IStreamBuilder, KeyValue } from '../types.js'\n\n/**\n * Base operator for reduction operations (version-free)\n */\nexport class ReduceOperator<K, V1, V2> extends UnaryOperator<[K, V1], [K, V2]> {\n  #index = new Index<K, V1>()\n  #indexOut = new Index<K, V2>()\n  #f: (values: Array<[V1, number]>) => Array<[V2, number]>\n\n  constructor(\n    id: number,\n    inputA: DifferenceStreamReader<[K, V1]>,\n    output: DifferenceStreamWriter<[K, V2]>,\n    f: (values: Array<[V1, number]>) => Array<[V2, number]>,\n  ) {\n    super(id, inputA, output)\n    this.#f = f\n  }\n\n  run(): void {\n    // Collect all input messages and update the index\n    const keysTodo = new Set<K>()\n    for (const message of this.inputMessages()) {\n      for (const [item, multiplicity] of message.getInner()) {\n        const [key, value] = item\n        this.#index.addValue(key, [value, multiplicity])\n        keysTodo.add(key)\n      }\n    }\n\n    // For each key, compute the reduction and delta\n    const result: Array<[[K, V2], number]> = []\n    for (const key of keysTodo) {\n      const curr = this.#index.get(key)\n      const currOut = this.#indexOut.get(key)\n      const out = this.#f(curr)\n\n      // Create maps for current and previous outputs using values directly as keys\n      const newOutputMap = new Map<V2, number>()\n      const oldOutputMap = new Map<V2, number>()\n\n      // Process new output\n      for (const [value, multiplicity] of out) {\n        const existing = newOutputMap.get(value) ?? 0\n        newOutputMap.set(value, existing + multiplicity)\n      }\n\n      // Process previous output\n      for (const [value, multiplicity] of currOut) {\n        const existing = oldOutputMap.get(value) ?? 0\n        oldOutputMap.set(value, existing + multiplicity)\n      }\n\n      // First, emit removals for old values that are no longer present\n      for (const [value, multiplicity] of oldOutputMap) {\n        if (!newOutputMap.has(value)) {\n          // Remove the old value entirely\n          result.push([[key, value], -multiplicity])\n          this.#indexOut.addValue(key, [value, -multiplicity])\n        }\n      }\n\n      // Then, emit additions for new values that are not present in old\n      for (const [value, multiplicity] of newOutputMap) {\n        if (!oldOutputMap.has(value)) {\n          // Add the new value only if it has non-zero multiplicity\n          if (multiplicity !== 0) {\n            result.push([[key, value], multiplicity])\n            this.#indexOut.addValue(key, [value, multiplicity])\n          }\n        }\n      }\n\n      // Finally, emit multiplicity changes for values that were present and are still present\n      for (const [value, newMultiplicity] of newOutputMap) {\n        const oldMultiplicity = oldOutputMap.get(value)\n        if (oldMultiplicity !== undefined) {\n          const delta = newMultiplicity - oldMultiplicity\n          // Only emit actual changes, i.e. non-zero deltas\n          if (delta !== 0) {\n            result.push([[key, value], delta])\n            this.#indexOut.addValue(key, [value, delta])\n          }\n        }\n      }\n    }\n\n    if (result.length > 0) {\n      this.output.sendData(new MultiSet(result))\n    }\n  }\n}\n\n/**\n * Reduces the elements in the stream by key (version-free)\n */\nexport function reduce<\n  KType extends T extends KeyValue<infer K, infer _V> ? K : never,\n  V1Type extends T extends KeyValue<KType, infer V> ? V : never,\n  R,\n  T,\n>(f: (values: Array<[V1Type, number]>) => Array<[R, number]>) {\n  return (stream: IStreamBuilder<T>): IStreamBuilder<KeyValue<KType, R>> => {\n    const output = new StreamBuilder<KeyValue<KType, R>>(\n      stream.graph,\n      new DifferenceStreamWriter<KeyValue<KType, R>>(),\n    )\n    const operator = new ReduceOperator<KType, V1Type, R>(\n      stream.graph.getNextOperatorId(),\n      stream.connectReader() as DifferenceStreamReader<KeyValue<KType, V1Type>>,\n      output.writer,\n      f,\n    )\n    stream.graph.addOperator(operator)\n    return output\n  }\n}\n"],"names":["UnaryOperator","Index","MultiSet","StreamBuilder","DifferenceStreamWriter"],"mappings":";;;;;;AAUO,MAAM,uBAAkCA,MAAAA,cAAgC;AAAA,EAC7E,SAAS,IAAIC,QAAAA,MAAA;AAAA,EACb,YAAY,IAAIA,QAAAA,MAAA;AAAA,EAChB;AAAA,EAEA,YACE,IACA,QACA,QACA,GACA;AACA,UAAM,IAAI,QAAQ,MAAM;AACxB,SAAK,KAAK;AAAA,EACZ;AAAA,EAEA,MAAY;AAEV,UAAM,+BAAe,IAAA;AACrB,eAAW,WAAW,KAAK,iBAAiB;AAC1C,iBAAW,CAAC,MAAM,YAAY,KAAK,QAAQ,YAAY;AACrD,cAAM,CAAC,KAAK,KAAK,IAAI;AACrB,aAAK,OAAO,SAAS,KAAK,CAAC,OAAO,YAAY,CAAC;AAC/C,iBAAS,IAAI,GAAG;AAAA,MAClB;AAAA,IACF;AAGA,UAAM,SAAmC,CAAA;AACzC,eAAW,OAAO,UAAU;AAC1B,YAAM,OAAO,KAAK,OAAO,IAAI,GAAG;AAChC,YAAM,UAAU,KAAK,UAAU,IAAI,GAAG;AACtC,YAAM,MAAM,KAAK,GAAG,IAAI;AAGxB,YAAM,mCAAmB,IAAA;AACzB,YAAM,mCAAmB,IAAA;AAGzB,iBAAW,CAAC,OAAO,YAAY,KAAK,KAAK;AACvC,cAAM,WAAW,aAAa,IAAI,KAAK,KAAK;AAC5C,qBAAa,IAAI,OAAO,WAAW,YAAY;AAAA,MACjD;AAGA,iBAAW,CAAC,OAAO,YAAY,KAAK,SAAS;AAC3C,cAAM,WAAW,aAAa,IAAI,KAAK,KAAK;AAC5C,qBAAa,IAAI,OAAO,WAAW,YAAY;AAAA,MACjD;AAGA,iBAAW,CAAC,OAAO,YAAY,KAAK,cAAc;AAChD,YAAI,CAAC,aAAa,IAAI,KAAK,GAAG;AAE5B,iBAAO,KAAK,CAAC,CAAC,KAAK,KAAK,GAAG,CAAC,YAAY,CAAC;AACzC,eAAK,UAAU,SAAS,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC;AAAA,QACrD;AAAA,MACF;AAGA,iBAAW,CAAC,OAAO,YAAY,KAAK,cAAc;AAChD,YAAI,CAAC,aAAa,IAAI,KAAK,GAAG;AAE5B,cAAI,iBAAiB,GAAG;AACtB,mBAAO,KAAK,CAAC,CAAC,KAAK,KAAK,GAAG,YAAY,CAAC;AACxC,iBAAK,UAAU,SAAS,KAAK,CAAC,OAAO,YAAY,CAAC;AAAA,UACpD;AAAA,QACF;AAAA,MACF;AAGA,iBAAW,CAAC,OAAO,eAAe,KAAK,cAAc;AACnD,cAAM,kBAAkB,aAAa,IAAI,KAAK;AAC9C,YAAI,oBAAoB,QAAW;AACjC,gBAAM,QAAQ,kBAAkB;AAEhC,cAAI,UAAU,GAAG;AACf,mBAAO,KAAK,CAAC,CAAC,KAAK,KAAK,GAAG,KAAK,CAAC;AACjC,iBAAK,UAAU,SAAS,KAAK,CAAC,OAAO,KAAK,CAAC;AAAA,UAC7C;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEA,QAAI,OAAO,SAAS,GAAG;AACrB,WAAK,OAAO,SAAS,IAAIC,SAAAA,SAAS,MAAM,CAAC;AAAA,IAC3C;AAAA,EACF;AACF;AAKO,SAAS,OAKd,GAA4D;AAC5D,SAAO,CAAC,WAAkE;AACxE,UAAM,SAAS,IAAIC,GAAAA;AAAAA,MACjB,OAAO;AAAA,MACP,IAAIC,MAAAA,uBAAA;AAAA,IAA2C;AAEjD,UAAM,WAAW,IAAI;AAAA,MACnB,OAAO,MAAM,kBAAA;AAAA,MACb,OAAO,cAAA;AAAA,MACP,OAAO;AAAA,MACP;AAAA,IAAA;AAEF,WAAO,MAAM,YAAY,QAAQ;AACjC,WAAO;AAAA,EACT;AACF;;;"}
+{"version":3,"file":"reduce.cjs","sources":["../../../src/operators/reduce.ts"],"sourcesContent":["import { DifferenceStreamWriter, UnaryOperator } from '../graph.js'\nimport { StreamBuilder } from '../d2.js'\nimport { MultiSet } from '../multiset.js'\nimport { Index } from '../indexes.js'\nimport type { DifferenceStreamReader } from '../graph.js'\nimport type { IStreamBuilder, KeyValue } from '../types.js'\n\n/** The key identity of a Map: SameValueZero, so NaN equals NaN. */\nfunction sameOutput(left: unknown, right: unknown): boolean {\n  return left === right || (left !== left && right !== right)\n}\n\n/** The value a Map stores as a key: -0 becomes 0. */\nfunction asMapKey<T>(value: T): T {\n  return (value === 0 ? 0 : value) as T\n}\n\n/**\n * Base operator for reduction operations (version-free)\n */\nexport class ReduceOperator<K, V1, V2> extends UnaryOperator<[K, V1], [K, V2]> {\n  // Reduce never reads presence, so its indexes skip that bookkeeping.\n  #index: Index<K, V1>\n  #indexOut = new Index<K, V2>({ trackPresence: false })\n  #f: (values: Array<[V1, number]>) => Array<[V2, number]>\n\n  constructor(\n    id: number,\n    inputA: DifferenceStreamReader<[K, V1]>,\n    output: DifferenceStreamWriter<[K, V2]>,\n    f: (values: Array<[V1, number]>) => Array<[V2, number]>,\n    options?: ReduceOptions,\n  ) {\n    super(id, inputA, output)\n    this.#index = new Index<K, V1>({ ...options, trackPresence: false })\n    this.#f = f\n  }\n\n  run(): void {\n    // Collect all input messages and update the index\n    const keysTodo = new Set<K>()\n    for (const message of this.inputMessages()) {\n      for (const [item, multiplicity] of message.getInner()) {\n        const [key, value] = item\n        this.#index.addValue(key, [value, multiplicity])\n        keysTodo.add(key)\n      }\n    }\n\n    // For each key, compute the reduction and delta\n    const result: Array<[[K, V2], number]> = []\n    for (const key of keysTodo) {\n      const curr = this.#index.get(key)\n      const currOut = this.#indexOut.get(key)\n      const out = this.#f(curr)\n\n      // Most keys have at most one output before and after. Compare the two\n      // directly, by the SameValueZero identity the maps below use.\n      if (out.length <= 1 && currOut.length <= 1) {\n        // Earlier outputs were stored as Map keys, so only the new one needs it.\n        const before = currOut[0]\n        const after = out[0]\n        const value = after === undefined ? undefined : asMapKey(after[0])\n        if (\n          before !== undefined &&\n          after !== undefined &&\n          sameOutput(before[0], value)\n        ) {\n          const delta = after[1] - before[1]\n          if (delta !== 0) {\n            result.push([[key, before[0]], delta])\n            this.#indexOut.addValue(key, [before[0], delta])\n          }\n          continue\n        }\n        if (before !== undefined) {\n          result.push([[key, before[0]], -before[1]])\n          this.#indexOut.addValue(key, [before[0], -before[1]])\n        }\n        if (after !== undefined && after[1] !== 0) {\n          result.push([[key, value as V2], after[1]])\n          this.#indexOut.addValue(key, [value as V2, after[1]])\n        }\n        continue\n      }\n\n      // Create maps for current and previous outputs using values directly as keys\n      const newOutputMap = new Map<V2, number>()\n      const oldOutputMap = new Map<V2, number>()\n\n      // Process new output\n      for (const [value, multiplicity] of out) {\n        const existing = newOutputMap.get(value) ?? 0\n        newOutputMap.set(value, existing + multiplicity)\n      }\n\n      // Process previous output\n      for (const [value, multiplicity] of currOut) {\n        const existing = oldOutputMap.get(value) ?? 0\n        oldOutputMap.set(value, existing + multiplicity)\n      }\n\n      // First, emit removals for old values that are no longer present\n      for (const [value, multiplicity] of oldOutputMap) {\n        if (!newOutputMap.has(value)) {\n          // Remove the old value entirely\n          result.push([[key, value], -multiplicity])\n          this.#indexOut.addValue(key, [value, -multiplicity])\n        }\n      }\n\n      // Then, emit additions for new values that are not present in old\n      for (const [value, multiplicity] of newOutputMap) {\n        if (!oldOutputMap.has(value)) {\n          // Add the new value only if it has non-zero multiplicity\n          if (multiplicity !== 0) {\n            result.push([[key, value], multiplicity])\n            this.#indexOut.addValue(key, [value, multiplicity])\n          }\n        }\n      }\n\n      // Finally, emit multiplicity changes for values that were present and are still present\n      for (const [value, newMultiplicity] of newOutputMap) {\n        const oldMultiplicity = oldOutputMap.get(value)\n        if (oldMultiplicity !== undefined) {\n          const delta = newMultiplicity - oldMultiplicity\n          // Only emit actual changes, i.e. non-zero deltas\n          if (delta !== 0) {\n            result.push([[key, value], delta])\n            this.#indexOut.addValue(key, [value, delta])\n          }\n        }\n      }\n    }\n\n    if (result.length > 0) {\n      this.output.sendData(new MultiSet(result))\n    }\n  }\n}\n\n/** @internal groupBy's option; its producer must keep the identity exact. */\nexport type ReduceOptions = {\n  /**\n   * Input values are `[identity, value]` with a string or number identity\n   * that determines the value: two inputs under one key with an equal\n   * identity are equal. They merge without a structural hash.\n   */\n  prefixIdentity?: boolean\n}\n\n/**\n * Reduces the elements in the stream by key (version-free)\n */\nexport function reduce<\n  KType extends (T extends KeyValue<infer K, infer _V> ? K : never),\n  V1Type extends (T extends KeyValue<KType, infer V> ? V : never),\n  R,\n  T,\n>(\n  f: (values: Array<[V1Type, number]>) => Array<[R, number]>,\n  options?: ReduceOptions,\n) {\n  return (stream: IStreamBuilder<T>): IStreamBuilder<KeyValue<KType, R>> => {\n    const output = new StreamBuilder<KeyValue<KType, R>>(\n      stream.graph,\n      new DifferenceStreamWriter<KeyValue<KType, R>>(),\n    )\n    const operator = new ReduceOperator<KType, V1Type, R>(\n      stream.graph.getNextOperatorId(),\n      stream.connectReader() as DifferenceStreamReader<KeyValue<KType, V1Type>>,\n      output.writer,\n      f,\n      options,\n    )\n    stream.graph.addOperator(operator)\n    return output\n  }\n}\n"],"names":["UnaryOperator","Index","MultiSet","StreamBuilder","DifferenceStreamWriter"],"mappings":";;;;;;AAQA,SAAS,WAAW,MAAe,OAAyB;AAC1D,SAAO,SAAS,SAAU,SAAS,QAAQ,UAAU;AACvD;AAGA,SAAS,SAAY,OAAa;AAChC,SAAQ,UAAU,IAAI,IAAI;AAC5B;AAKO,MAAM,uBAAkCA,MAAAA,cAAgC;AAAA;AAAA,EAE7E;AAAA,EACA,YAAY,IAAIC,QAAAA,MAAa,EAAE,eAAe,OAAO;AAAA,EACrD;AAAA,EAEA,YACE,IACA,QACA,QACA,GACA,SACA;AACA,UAAM,IAAI,QAAQ,MAAM;AACxB,SAAK,SAAS,IAAIA,QAAAA,MAAa,EAAE,GAAG,SAAS,eAAe,OAAO;AACnE,SAAK,KAAK;AAAA,EACZ;AAAA,EAEA,MAAY;AAEV,UAAM,+BAAe,IAAA;AACrB,eAAW,WAAW,KAAK,iBAAiB;AAC1C,iBAAW,CAAC,MAAM,YAAY,KAAK,QAAQ,YAAY;AACrD,cAAM,CAAC,KAAK,KAAK,IAAI;AACrB,aAAK,OAAO,SAAS,KAAK,CAAC,OAAO,YAAY,CAAC;AAC/C,iBAAS,IAAI,GAAG;AAAA,MAClB;AAAA,IACF;AAGA,UAAM,SAAmC,CAAA;AACzC,eAAW,OAAO,UAAU;AAC1B,YAAM,OAAO,KAAK,OAAO,IAAI,GAAG;AAChC,YAAM,UAAU,KAAK,UAAU,IAAI,GAAG;AACtC,YAAM,MAAM,KAAK,GAAG,IAAI;AAIxB,UAAI,IAAI,UAAU,KAAK,QAAQ,UAAU,GAAG;AAE1C,cAAM,SAAS,QAAQ,CAAC;AACxB,cAAM,QAAQ,IAAI,CAAC;AACnB,cAAM,QAAQ,UAAU,SAAY,SAAY,SAAS,MAAM,CAAC,CAAC;AACjE,YACE,WAAW,UACX,UAAU,UACV,WAAW,OAAO,CAAC,GAAG,KAAK,GAC3B;AACA,gBAAM,QAAQ,MAAM,CAAC,IAAI,OAAO,CAAC;AACjC,cAAI,UAAU,GAAG;AACf,mBAAO,KAAK,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,GAAG,KAAK,CAAC;AACrC,iBAAK,UAAU,SAAS,KAAK,CAAC,OAAO,CAAC,GAAG,KAAK,CAAC;AAAA,UACjD;AACA;AAAA,QACF;AACA,YAAI,WAAW,QAAW;AACxB,iBAAO,KAAK,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;AAC1C,eAAK,UAAU,SAAS,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;AAAA,QACtD;AACA,YAAI,UAAU,UAAa,MAAM,CAAC,MAAM,GAAG;AACzC,iBAAO,KAAK,CAAC,CAAC,KAAK,KAAW,GAAG,MAAM,CAAC,CAAC,CAAC;AAC1C,eAAK,UAAU,SAAS,KAAK,CAAC,OAAa,MAAM,CAAC,CAAC,CAAC;AAAA,QACtD;AACA;AAAA,MACF;AAGA,YAAM,mCAAmB,IAAA;AACzB,YAAM,mCAAmB,IAAA;AAGzB,iBAAW,CAAC,OAAO,YAAY,KAAK,KAAK;AACvC,cAAM,WAAW,aAAa,IAAI,KAAK,KAAK;AAC5C,qBAAa,IAAI,OAAO,WAAW,YAAY;AAAA,MACjD;AAGA,iBAAW,CAAC,OAAO,YAAY,KAAK,SAAS;AAC3C,cAAM,WAAW,aAAa,IAAI,KAAK,KAAK;AAC5C,qBAAa,IAAI,OAAO,WAAW,YAAY;AAAA,MACjD;AAGA,iBAAW,CAAC,OAAO,YAAY,KAAK,cAAc;AAChD,YAAI,CAAC,aAAa,IAAI,KAAK,GAAG;AAE5B,iBAAO,KAAK,CAAC,CAAC,KAAK,KAAK,GAAG,CAAC,YAAY,CAAC;AACzC,eAAK,UAAU,SAAS,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC;AAAA,QACrD;AAAA,MACF;AAGA,iBAAW,CAAC,OAAO,YAAY,KAAK,cAAc;AAChD,YAAI,CAAC,aAAa,IAAI,KAAK,GAAG;AAE5B,cAAI,iBAAiB,GAAG;AACtB,mBAAO,KAAK,CAAC,CAAC,KAAK,KAAK,GAAG,YAAY,CAAC;AACxC,iBAAK,UAAU,SAAS,KAAK,CAAC,OAAO,YAAY,CAAC;AAAA,UACpD;AAAA,QACF;AAAA,MACF;AAGA,iBAAW,CAAC,OAAO,eAAe,KAAK,cAAc;AACnD,cAAM,kBAAkB,aAAa,IAAI,KAAK;AAC9C,YAAI,oBAAoB,QAAW;AACjC,gBAAM,QAAQ,kBAAkB;AAEhC,cAAI,UAAU,GAAG;AACf,mBAAO,KAAK,CAAC,CAAC,KAAK,KAAK,GAAG,KAAK,CAAC;AACjC,iBAAK,UAAU,SAAS,KAAK,CAAC,OAAO,KAAK,CAAC;AAAA,UAC7C;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEA,QAAI,OAAO,SAAS,GAAG;AACrB,WAAK,OAAO,SAAS,IAAIC,SAAAA,SAAS,MAAM,CAAC;AAAA,IAC3C;AAAA,EACF;AACF;AAeO,SAAS,OAMd,GACA,SACA;AACA,SAAO,CAAC,WAAkE;AACxE,UAAM,SAAS,IAAIC,GAAAA;AAAAA,MACjB,OAAO;AAAA,MACP,IAAIC,MAAAA,uBAAA;AAAA,IAA2C;AAEjD,UAAM,WAAW,IAAI;AAAA,MACnB,OAAO,MAAM,kBAAA;AAAA,MACb,OAAO,cAAA;AAAA,MACP,OAAO;AAAA,MACP;AAAA,MACA;AAAA,IAAA;AAEF,WAAO,MAAM,YAAY,QAAQ;AACjC,WAAO;AAAA,EACT;AACF;;;"}

package/dist/cjs/operators/reduce.d.cts

@@ -1,14 +1,47 @@
-import { DifferenceStreamWriter, UnaryOperator, DifferenceStreamReader } from '../graph.js';
-import { IStreamBuilder, KeyValue } from '../types.js';
+import { DifferenceStreamWriter, UnaryOperator, DifferenceStreamReader } from "../graph.cjs";
+import { IStreamBuilder, KeyValue } from "../types.cjs";
 /**
  * Base operator for reduction operations (version-free)
  */
-export declare class ReduceOperator<K, V1, V2> extends UnaryOperator<[K, V1], [K, V2]> {
+export declare class ReduceOperator<K, V1, V2> extends UnaryOperator<[
+    K,
+    V1
+], [
+    K,
+    V2
+]> {
     #private;
-    constructor(id: number, inputA: DifferenceStreamReader<[K, V1]>, output: DifferenceStreamWriter<[K, V2]>, f: (values: Array<[V1, number]>) => Array<[V2, number]>);
+    constructor(id: number, inputA: DifferenceStreamReader<[
+        K,
+        V1
+    ]>, output: DifferenceStreamWriter<[
+        K,
+        V2
+    ]>, f: (values: Array<[
+        V1,
+        number
+    ]>) => Array<[
+        V2,
+        number
+    ]>, options?: ReduceOptions);
     run(): void;
 }
+/** @internal groupBy's option; its producer must keep the identity exact. */
+export type ReduceOptions = {
+    /**
+     * Input values are `[identity, value]` with a string or number identity
+     * that determines the value: two inputs under one key with an equal
+     * identity are equal. They merge without a structural hash.
+     */
+    prefixIdentity?: boolean;
+};
 /**
  * Reduces the elements in the stream by key (version-free)
  */
-export declare function reduce<KType extends T extends KeyValue<infer K, infer _V> ? K : never, V1Type extends T extends KeyValue<KType, infer V> ? V : never, R, T>(f: (values: Array<[V1Type, number]>) => Array<[R, number]>): (stream: IStreamBuilder<T>) => IStreamBuilder<KeyValue<KType, R>>;
+export declare function reduce<KType extends (T extends KeyValue<infer K, infer _V> ? K : never), V1Type extends (T extends KeyValue<KType, infer V> ? V : never), R, T>(f: (values: Array<[
+    V1Type,
+    number
+]>) => Array<[
+    R,
+    number
+]>, options?: ReduceOptions): (stream: IStreamBuilder<T>) => IStreamBuilder<KeyValue<KType, R>>;

package/dist/cjs/operators/tap.d.cts

@@ -1,6 +1,6 @@
-import { DifferenceStreamWriter, LinearUnaryOperator, DifferenceStreamReader } from '../graph.js';
-import { PipedOperator } from '../types.js';
-import { MultiSet } from '../multiset.js';
+import { DifferenceStreamWriter, LinearUnaryOperator, DifferenceStreamReader } from "../graph.cjs";
+import { PipedOperator } from "../types.cjs";
+import { MultiSet } from "../multiset.cjs";
 /**
  * Operator that applies a function to each multi-set in the input stream
  */

package/dist/cjs/operators/topKArray.cjs

@@ -36,6 +36,15 @@ class TopKArray {
     const available = this.#sortedValues.length - offset;
     return Math.max(0, Math.min(limit, available));
   }
+  countLeadingInWindow(predicate) {
+    let count = 0;
+    const end = this.#topKStart + this.size;
+    for (let index = this.#topKStart; index < end; index++) {
+      if (!predicate(getValue(this.#sortedValues[index]))) break;
+      count++;
+    }
+    return count;
+  }
   /**
    * Moves the topK window
    */