@tanstack/db-ivm 0.0.0 → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kyle Mathews
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cjs/d2.cjs

@@ -0,0 +1,111 @@
+"use strict";
+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 __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var _streams, _operators, _nextOperatorId, _finalized, _D2_instances, checkNotFinalized_fn, _graph, _writer;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const graph = require("./graph.cjs");
+class D2 {
+  constructor() {
+    __privateAdd(this, _D2_instances);
+    __privateAdd(this, _streams, []);
+    __privateAdd(this, _operators, []);
+    __privateAdd(this, _nextOperatorId, 0);
+    __privateAdd(this, _finalized, false);
+  }
+  getNextOperatorId() {
+    __privateMethod(this, _D2_instances, checkNotFinalized_fn).call(this);
+    return __privateWrapper(this, _nextOperatorId)._++;
+  }
+  newInput() {
+    __privateMethod(this, _D2_instances, checkNotFinalized_fn).call(this);
+    const writer = new graph.DifferenceStreamWriter();
+    const streamBuilder = new RootStreamBuilder(this, writer);
+    __privateGet(this, _streams).push(streamBuilder.connectReader());
+    return streamBuilder;
+  }
+  addOperator(operator) {
+    __privateMethod(this, _D2_instances, checkNotFinalized_fn).call(this);
+    __privateGet(this, _operators).push(operator);
+  }
+  addStream(stream) {
+    __privateMethod(this, _D2_instances, checkNotFinalized_fn).call(this);
+    __privateGet(this, _streams).push(stream);
+  }
+  finalize() {
+    __privateMethod(this, _D2_instances, checkNotFinalized_fn).call(this);
+    __privateSet(this, _finalized, true);
+  }
+  step() {
+    if (!__privateGet(this, _finalized)) {
+      throw new Error(`Graph not finalized`);
+    }
+    for (const op of __privateGet(this, _operators)) {
+      op.run();
+    }
+  }
+  pendingWork() {
+    return __privateGet(this, _operators).some((op) => op.hasPendingWork());
+  }
+  run() {
+    while (this.pendingWork()) {
+      this.step();
+    }
+  }
+}
+_streams = new WeakMap();
+_operators = new WeakMap();
+_nextOperatorId = new WeakMap();
+_finalized = new WeakMap();
+_D2_instances = new WeakSet();
+checkNotFinalized_fn = function() {
+  if (__privateGet(this, _finalized)) {
+    throw new Error(`Graph already finalized`);
+  }
+};
+class StreamBuilder {
+  constructor(graph2, writer) {
+    __privateAdd(this, _graph);
+    __privateAdd(this, _writer);
+    __privateSet(this, _graph, graph2);
+    __privateSet(this, _writer, writer);
+  }
+  connectReader() {
+    return __privateGet(this, _writer).newReader();
+  }
+  get writer() {
+    return __privateGet(this, _writer);
+  }
+  get graph() {
+    return __privateGet(this, _graph);
+  }
+  pipe(...operators) {
+    return operators.reduce((stream, operator) => {
+      return operator(stream);
+    }, this);
+  }
+}
+_graph = new WeakMap();
+_writer = new WeakMap();
+class RootStreamBuilder extends StreamBuilder {
+  sendData(collection) {
+    this.writer.sendData(collection);
+  }
+}
+exports.D2 = D2;
+exports.RootStreamBuilder = RootStreamBuilder;
+exports.StreamBuilder = StreamBuilder;
+//# sourceMappingURL=d2.cjs.map

package/dist/cjs/d2.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"d2.cjs","sources":["../../src/d2.ts"],"sourcesContent":["import { DifferenceStreamWriter } from \"./graph.js\"\nimport type {\n  BinaryOperator,\n  DifferenceStreamReader,\n  UnaryOperator,\n} from \"./graph.js\"\nimport type { MultiSet, MultiSetArray } from \"./multiset.js\"\nimport type { ID2, IStreamBuilder, PipedOperator } from \"./types.js\"\n\nexport class D2 implements ID2 {\n  #streams: Array<DifferenceStreamReader<any>> = []\n  #operators: Array<UnaryOperator<any> | BinaryOperator<any>> = []\n  #nextOperatorId = 0\n  #finalized = false\n\n  constructor() {}\n\n  #checkNotFinalized(): void {\n    if (this.#finalized) {\n      throw new Error(`Graph already finalized`)\n    }\n  }\n\n  getNextOperatorId(): number {\n    this.#checkNotFinalized()\n    return this.#nextOperatorId++\n  }\n\n  newInput<T>(): RootStreamBuilder<T> {\n    this.#checkNotFinalized()\n    const writer = new DifferenceStreamWriter<T>()\n    // Use the root stream builder that exposes the sendData and sendFrontier methods\n    const streamBuilder = new RootStreamBuilder<T>(this, writer)\n    this.#streams.push(streamBuilder.connectReader())\n    return streamBuilder\n  }\n\n  addOperator(operator: UnaryOperator<any> | BinaryOperator<any>): void {\n    this.#checkNotFinalized()\n    this.#operators.push(operator)\n  }\n\n  addStream(stream: DifferenceStreamReader<any>): void {\n    this.#checkNotFinalized()\n    this.#streams.push(stream)\n  }\n\n  finalize() {\n    this.#checkNotFinalized()\n    this.#finalized = true\n  }\n\n  step(): void {\n    if (!this.#finalized) {\n      throw new Error(`Graph not finalized`)\n    }\n    for (const op of this.#operators) {\n      op.run()\n    }\n  }\n\n  pendingWork(): boolean {\n    return this.#operators.some((op) => op.hasPendingWork())\n  }\n\n  run(): void {\n    while (this.pendingWork()) {\n      this.step()\n    }\n  }\n}\n\nexport class StreamBuilder<T> implements IStreamBuilder<T> {\n  #graph: ID2\n  #writer: DifferenceStreamWriter<T>\n\n  constructor(graph: ID2, writer: DifferenceStreamWriter<T>) {\n    this.#graph = graph\n    this.#writer = writer\n  }\n\n  connectReader(): DifferenceStreamReader<T> {\n    return this.#writer.newReader()\n  }\n\n  get writer(): DifferenceStreamWriter<T> {\n    return this.#writer\n  }\n\n  get graph(): ID2 {\n    return this.#graph\n  }\n\n  // Don't judge, this is the only way to type this function.\n  // rxjs has very similar code to type its pipe function\n  // https://github.com/ReactiveX/rxjs/blob/master/packages/rxjs/src/internal/util/pipe.ts\n  // We go to 20 operators deep, because surly that's enough for anyone...\n  // A user can always split the pipe into multiple pipes to get around this.\n  pipe<O>(o1: PipedOperator<T, O>): IStreamBuilder<O>\n  // prettier-ignore\n  pipe<T2, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, O>): IStreamBuilder<O>\n  // prettier-ignore\n  pipe<T2, T3, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, O>): IStreamBuilder<O>\n  // prettier-ignore\n  pipe<T2, T3, T4, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, O>): IStreamBuilder<O>\n  // prettier-ignore\n  pipe<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>\n  // prettier-ignore\n  pipe<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>\n  // prettier-ignore\n  pipe<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>\n  // prettier-ignore\n  pipe<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>\n  // prettier-ignore\n  pipe<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>\n  // prettier-ignore\n  pipe<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>\n  // prettier-ignore\n  pipe<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>\n  // prettier-ignore\n  pipe<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>\n  // prettier-ignore\n  pipe<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>\n  // prettier-ignore\n  pipe<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>\n  // prettier-ignore\n  pipe<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>\n  // prettier-ignore\n  pipe<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>\n  // prettier-ignore\n  pipe<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>\n  // prettier-ignore\n  pipe<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>\n  // prettier-ignore\n  pipe<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>\n  // prettier-ignore\n  pipe<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>\n\n  pipe(...operators: Array<PipedOperator<any, any>>): IStreamBuilder<any> {\n    return operators.reduce((stream, operator) => {\n      return operator(stream)\n    }, this as IStreamBuilder<any>)\n  }\n}\n\nexport class RootStreamBuilder<T> extends StreamBuilder<T> {\n  sendData(collection: MultiSet<T> | MultiSetArray<T>): void {\n    this.writer.sendData(collection)\n  }\n}\n"],"names":["DifferenceStreamWriter","graph"],"mappings":";;;;;;;;;;;;;;;;;;;;AASO,MAAM,GAAkB;AAAA,EAM7B,cAAc;AANT;AACL,iCAA+C,CAAA;AAC/C,mCAA8D,CAAA;AAC9D,wCAAkB;AAClB,mCAAa;AAAA,EAEE;AAAA,EAQf,oBAA4B;AAC1B,0BAAK,qCAAL;AACA,WAAO,uBAAK,iBAAL;AAAA,EACT;AAAA,EAEA,WAAoC;AAClC,0BAAK,qCAAL;AACA,UAAM,SAAS,IAAIA,6BAAA;AAEnB,UAAM,gBAAgB,IAAI,kBAAqB,MAAM,MAAM;AAC3D,uBAAK,UAAS,KAAK,cAAc,cAAA,CAAe;AAChD,WAAO;AAAA,EACT;AAAA,EAEA,YAAY,UAA0D;AACpE,0BAAK,qCAAL;AACA,uBAAK,YAAW,KAAK,QAAQ;AAAA,EAC/B;AAAA,EAEA,UAAU,QAA2C;AACnD,0BAAK,qCAAL;AACA,uBAAK,UAAS,KAAK,MAAM;AAAA,EAC3B;AAAA,EAEA,WAAW;AACT,0BAAK,qCAAL;AACA,uBAAK,YAAa;AAAA,EACpB;AAAA,EAEA,OAAa;AACX,QAAI,CAAC,mBAAK,aAAY;AACpB,YAAM,IAAI,MAAM,qBAAqB;AAAA,IACvC;AACA,eAAW,MAAM,mBAAK,aAAY;AAChC,SAAG,IAAA;AAAA,IACL;AAAA,EACF;AAAA,EAEA,cAAuB;AACrB,WAAO,mBAAK,YAAW,KAAK,CAAC,OAAO,GAAG,gBAAgB;AAAA,EACzD;AAAA,EAEA,MAAY;AACV,WAAO,KAAK,eAAe;AACzB,WAAK,KAAA;AAAA,IACP;AAAA,EACF;AACF;AA5DE;AACA;AACA;AACA;AAJK;AAQL,uBAAA,WAA2B;AACzB,MAAI,mBAAK,aAAY;AACnB,UAAM,IAAI,MAAM,yBAAyB;AAAA,EAC3C;AACF;AAmDK,MAAM,cAA8C;AAAA,EAIzD,YAAYC,QAAY,QAAmC;AAH3D;AACA;AAGE,uBAAK,QAASA;AACd,uBAAK,SAAU;AAAA,EACjB;AAAA,EAEA,gBAA2C;AACzC,WAAO,mBAAK,SAAQ,UAAA;AAAA,EACtB;AAAA,EAEA,IAAI,SAAoC;AACtC,WAAO,mBAAK;AAAA,EACd;AAAA,EAEA,IAAI,QAAa;AACf,WAAO,mBAAK;AAAA,EACd;AAAA,EA+CA,QAAQ,WAAgE;AACtE,WAAO,UAAU,OAAO,CAAC,QAAQ,aAAa;AAC5C,aAAO,SAAS,MAAM;AAAA,IACxB,GAAG,IAA2B;AAAA,EAChC;AACF;AAtEE;AACA;AAuEK,MAAM,0BAA6B,cAAiB;AAAA,EACzD,SAAS,YAAkD;AACzD,SAAK,OAAO,SAAS,UAAU;AAAA,EACjC;AACF;;;;"}

package/dist/cjs/d2.d.cts

@@ -0,0 +1,45 @@
+import { DifferenceStreamWriter, BinaryOperator, DifferenceStreamReader, UnaryOperator } from './graph.js';
+import { MultiSet, MultiSetArray } from './multiset.js';
+import { ID2, IStreamBuilder, PipedOperator } from './types.js';
+export declare class D2 implements ID2 {
+    #private;
+    constructor();
+    getNextOperatorId(): number;
+    newInput<T>(): RootStreamBuilder<T>;
+    addOperator(operator: UnaryOperator<any> | BinaryOperator<any>): void;
+    addStream(stream: DifferenceStreamReader<any>): void;
+    finalize(): void;
+    step(): void;
+    pendingWork(): boolean;
+    run(): void;
+}
+export declare class StreamBuilder<T> implements IStreamBuilder<T> {
+    #private;
+    constructor(graph: ID2, writer: DifferenceStreamWriter<T>);
+    connectReader(): DifferenceStreamReader<T>;
+    get writer(): DifferenceStreamWriter<T>;
+    get graph(): ID2;
+    pipe<O>(o1: PipedOperator<T, O>): IStreamBuilder<O>;
+    pipe<T2, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, O>): IStreamBuilder<O>;
+    pipe<T2, T3, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, O>): IStreamBuilder<O>;
+    pipe<T2, T3, T4, O>(o1: PipedOperator<T, T2>, o2: PipedOperator<T2, T3>, o3: PipedOperator<T3, T4>, o4: PipedOperator<T4, O>): IStreamBuilder<O>;
+    pipe<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>;
+    pipe<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>;
+    pipe<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>;
+    pipe<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>;
+    pipe<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>;
+    pipe<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>;
+    pipe<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>;
+    pipe<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>;
+    pipe<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>;
+    pipe<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>;
+    pipe<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>;
+    pipe<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>;
+    pipe<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>;
+    pipe<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>;
+    pipe<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>;
+    pipe<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>;
+}
+export declare class RootStreamBuilder<T> extends StreamBuilder<T> {
+    sendData(collection: MultiSet<T> | MultiSetArray<T>): void;
+}

package/dist/cjs/graph.cjs

@@ -0,0 +1,90 @@
+"use strict";
+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 _queue, _queues;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const multiset = require("./multiset.cjs");
+class DifferenceStreamReader {
+  constructor(queue) {
+    __privateAdd(this, _queue);
+    __privateSet(this, _queue, queue);
+  }
+  drain() {
+    const out = [...__privateGet(this, _queue)].reverse();
+    __privateGet(this, _queue).length = 0;
+    return out;
+  }
+  isEmpty() {
+    return __privateGet(this, _queue).length === 0;
+  }
+}
+_queue = new WeakMap();
+class DifferenceStreamWriter {
+  constructor() {
+    __privateAdd(this, _queues, []);
+  }
+  sendData(collection) {
+    if (!(collection instanceof multiset.MultiSet)) {
+      collection = new multiset.MultiSet(collection);
+    }
+    for (const q of __privateGet(this, _queues)) {
+      q.unshift(collection);
+    }
+  }
+  newReader() {
+    const q = [];
+    __privateGet(this, _queues).push(q);
+    return new DifferenceStreamReader(q);
+  }
+}
+_queues = new WeakMap();
+class Operator {
+  constructor(id, inputs, output) {
+    this.id = id;
+    this.inputs = inputs;
+    this.output = output;
+  }
+  hasPendingWork() {
+    return this.inputs.some((input) => !input.isEmpty());
+  }
+}
+class UnaryOperator extends Operator {
+  constructor(id, inputA, output) {
+    super(id, [inputA], output);
+    this.id = id;
+  }
+  inputMessages() {
+    return this.inputs[0].drain();
+  }
+}
+class BinaryOperator extends Operator {
+  constructor(id, inputA, inputB, output) {
+    super(id, [inputA, inputB], output);
+    this.id = id;
+  }
+  inputAMessages() {
+    return this.inputs[0].drain();
+  }
+  inputBMessages() {
+    return this.inputs[1].drain();
+  }
+}
+class LinearUnaryOperator extends UnaryOperator {
+  run() {
+    for (const message of this.inputMessages()) {
+      this.output.sendData(this.inner(message));
+    }
+  }
+}
+exports.BinaryOperator = BinaryOperator;
+exports.DifferenceStreamReader = DifferenceStreamReader;
+exports.DifferenceStreamWriter = DifferenceStreamWriter;
+exports.LinearUnaryOperator = LinearUnaryOperator;
+exports.Operator = Operator;
+exports.UnaryOperator = UnaryOperator;
+//# sourceMappingURL=graph.cjs.map

package/dist/cjs/graph.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.cjs","sources":["../../src/graph.ts"],"sourcesContent":["import { MultiSet } from \"./multiset.js\"\nimport type { MultiSetArray } from \"./multiset.js\"\nimport type {\n  IDifferenceStreamReader,\n  IDifferenceStreamWriter,\n  IOperator,\n} from \"./types.js\"\n\n/**\n * A read handle to a dataflow edge that receives data from a writer.\n */\nexport class DifferenceStreamReader<T> implements IDifferenceStreamReader<T> {\n  #queue: Array<MultiSet<T>>\n\n  constructor(queue: Array<MultiSet<T>>) {\n    this.#queue = queue\n  }\n\n  drain(): Array<MultiSet<T>> {\n    const out = [...this.#queue].reverse()\n    this.#queue.length = 0\n    return out\n  }\n\n  isEmpty(): boolean {\n    return this.#queue.length === 0\n  }\n}\n\n/**\n * A write handle to a dataflow edge that is allowed to publish data.\n */\nexport class DifferenceStreamWriter<T> implements IDifferenceStreamWriter<T> {\n  #queues: Array<Array<MultiSet<T>>> = []\n\n  sendData(collection: MultiSet<T> | MultiSetArray<T>): void {\n    if (!(collection instanceof MultiSet)) {\n      collection = new MultiSet(collection)\n    }\n\n    for (const q of this.#queues) {\n      q.unshift(collection)\n    }\n  }\n\n  newReader(): DifferenceStreamReader<T> {\n    const q: Array<MultiSet<T>> = []\n    this.#queues.push(q)\n    return new DifferenceStreamReader(q)\n  }\n}\n\n/**\n * A generic implementation of a dataflow operator (node) that has multiple incoming edges (read handles) and\n * one outgoing edge (write handle).\n */\nexport abstract class Operator<T> implements IOperator<T> {\n  protected inputs: Array<DifferenceStreamReader<T>>\n  protected output: DifferenceStreamWriter<T>\n\n  constructor(\n    public id: number,\n    inputs: Array<DifferenceStreamReader<T>>,\n    output: DifferenceStreamWriter<T>\n  ) {\n    this.inputs = inputs\n    this.output = output\n  }\n\n  abstract run(): void\n\n  hasPendingWork(): boolean {\n    return this.inputs.some((input) => !input.isEmpty())\n  }\n}\n\n/**\n * A convenience implementation of a dataflow operator that has a handle to one\n * incoming stream of data, and one handle to an outgoing stream of data.\n */\nexport abstract class UnaryOperator<Tin, Tout = Tin> extends Operator<\n  Tin | Tout\n> {\n  constructor(\n    public id: number,\n    inputA: DifferenceStreamReader<Tin>,\n    output: DifferenceStreamWriter<Tout>\n  ) {\n    super(id, [inputA], output)\n  }\n\n  inputMessages(): Array<MultiSet<Tin>> {\n    return this.inputs[0]!.drain() as Array<MultiSet<Tin>>\n  }\n}\n\n/**\n * A convenience implementation of a dataflow operator that has a handle to two\n * incoming streams of data, and one handle to an outgoing stream of data.\n */\nexport abstract class BinaryOperator<T> extends Operator<T> {\n  constructor(\n    public id: number,\n    inputA: DifferenceStreamReader<T>,\n    inputB: DifferenceStreamReader<T>,\n    output: DifferenceStreamWriter<T>\n  ) {\n    super(id, [inputA, inputB], output)\n  }\n\n  inputAMessages(): Array<MultiSet<T>> {\n    return this.inputs[0]!.drain()\n  }\n\n  inputBMessages(): Array<MultiSet<T>> {\n    return this.inputs[1]!.drain()\n  }\n}\n\n/**\n * Base class for operators that process a single input stream\n */\nexport abstract class LinearUnaryOperator<T, U> extends UnaryOperator<T | U> {\n  abstract inner(collection: MultiSet<T | U>): MultiSet<U>\n\n  run(): void {\n    for (const message of this.inputMessages()) {\n      this.output.sendData(this.inner(message))\n    }\n  }\n}\n"],"names":["MultiSet"],"mappings":";;;;;;;;;;;AAWO,MAAM,uBAAgE;AAAA,EAG3E,YAAY,OAA2B;AAFvC;AAGE,uBAAK,QAAS;AAAA,EAChB;AAAA,EAEA,QAA4B;AAC1B,UAAM,MAAM,CAAC,GAAG,mBAAK,OAAM,EAAE,QAAA;AAC7B,uBAAK,QAAO,SAAS;AACrB,WAAO;AAAA,EACT;AAAA,EAEA,UAAmB;AACjB,WAAO,mBAAK,QAAO,WAAW;AAAA,EAChC;AACF;AAfE;AAoBK,MAAM,uBAAgE;AAAA,EAAtE;AACL,gCAAqC,CAAA;AAAA;AAAA,EAErC,SAAS,YAAkD;AACzD,QAAI,EAAE,sBAAsBA,SAAAA,WAAW;AACrC,mBAAa,IAAIA,SAAAA,SAAS,UAAU;AAAA,IACtC;AAEA,eAAW,KAAK,mBAAK,UAAS;AAC5B,QAAE,QAAQ,UAAU;AAAA,IACtB;AAAA,EACF;AAAA,EAEA,YAAuC;AACrC,UAAM,IAAwB,CAAA;AAC9B,uBAAK,SAAQ,KAAK,CAAC;AACnB,WAAO,IAAI,uBAAuB,CAAC;AAAA,EACrC;AACF;AAjBE;AAuBK,MAAe,SAAoC;AAAA,EAIxD,YACS,IACP,QACA,QACA;AAHO,SAAA,KAAA;AAIP,SAAK,SAAS;AACd,SAAK,SAAS;AAAA,EAChB;AAAA,EAIA,iBAA0B;AACxB,WAAO,KAAK,OAAO,KAAK,CAAC,UAAU,CAAC,MAAM,SAAS;AAAA,EACrD;AACF;AAMO,MAAe,sBAAuC,SAE3D;AAAA,EACA,YACS,IACP,QACA,QACA;AACA,UAAM,IAAI,CAAC,MAAM,GAAG,MAAM;AAJnB,SAAA,KAAA;AAAA,EAKT;AAAA,EAEA,gBAAsC;AACpC,WAAO,KAAK,OAAO,CAAC,EAAG,MAAA;AAAA,EACzB;AACF;AAMO,MAAe,uBAA0B,SAAY;AAAA,EAC1D,YACS,IACP,QACA,QACA,QACA;AACA,UAAM,IAAI,CAAC,QAAQ,MAAM,GAAG,MAAM;AAL3B,SAAA,KAAA;AAAA,EAMT;AAAA,EAEA,iBAAqC;AACnC,WAAO,KAAK,OAAO,CAAC,EAAG,MAAA;AAAA,EACzB;AAAA,EAEA,iBAAqC;AACnC,WAAO,KAAK,OAAO,CAAC,EAAG,MAAA;AAAA,EACzB;AACF;AAKO,MAAe,4BAAkC,cAAqB;AAAA,EAG3E,MAAY;AACV,eAAW,WAAW,KAAK,iBAAiB;AAC1C,WAAK,OAAO,SAAS,KAAK,MAAM,OAAO,CAAC;AAAA,IAC1C;AAAA,EACF;AACF;;;;;;;"}

package/dist/cjs/graph.d.cts

@@ -0,0 +1,57 @@
+import { MultiSet, MultiSetArray } from './multiset.js';
+import { IDifferenceStreamReader, IDifferenceStreamWriter, IOperator } from './types.js';
+/**
+ * A read handle to a dataflow edge that receives data from a writer.
+ */
+export declare class DifferenceStreamReader<T> implements IDifferenceStreamReader<T> {
+    #private;
+    constructor(queue: Array<MultiSet<T>>);
+    drain(): Array<MultiSet<T>>;
+    isEmpty(): boolean;
+}
+/**
+ * A write handle to a dataflow edge that is allowed to publish data.
+ */
+export declare class DifferenceStreamWriter<T> implements IDifferenceStreamWriter<T> {
+    #private;
+    sendData(collection: MultiSet<T> | MultiSetArray<T>): void;
+    newReader(): DifferenceStreamReader<T>;
+}
+/**
+ * A generic implementation of a dataflow operator (node) that has multiple incoming edges (read handles) and
+ * one outgoing edge (write handle).
+ */
+export declare abstract class Operator<T> implements IOperator<T> {
+    id: number;
+    protected inputs: Array<DifferenceStreamReader<T>>;
+    protected output: DifferenceStreamWriter<T>;
+    constructor(id: number, inputs: Array<DifferenceStreamReader<T>>, output: DifferenceStreamWriter<T>);
+    abstract run(): void;
+    hasPendingWork(): boolean;
+}
+/**
+ * A convenience implementation of a dataflow operator that has a handle to one
+ * incoming stream of data, and one handle to an outgoing stream of data.
+ */
+export declare abstract class UnaryOperator<Tin, Tout = Tin> extends Operator<Tin | Tout> {
+    id: number;
+    constructor(id: number, inputA: DifferenceStreamReader<Tin>, output: DifferenceStreamWriter<Tout>);
+    inputMessages(): Array<MultiSet<Tin>>;
+}
+/**
+ * A convenience implementation of a dataflow operator that has a handle to two
+ * incoming streams of data, and one handle to an outgoing stream of data.
+ */
+export declare abstract class BinaryOperator<T> extends Operator<T> {
+    id: number;
+    constructor(id: number, inputA: DifferenceStreamReader<T>, inputB: DifferenceStreamReader<T>, output: DifferenceStreamWriter<T>);
+    inputAMessages(): Array<MultiSet<T>>;
+    inputBMessages(): Array<MultiSet<T>>;
+}
+/**
+ * Base class for operators that process a single input stream
+ */
+export declare abstract class LinearUnaryOperator<T, U> extends UnaryOperator<T | U> {
+    abstract inner(collection: MultiSet<T | U>): MultiSet<U>;
+    run(): void;
+}

package/dist/cjs/index.cjs

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const d2 = require("./d2.cjs");
+const multiset = require("./multiset.cjs");
+const groupBy = require("./operators/groupBy.cjs");
+const pipe = require("./operators/pipe.cjs");
+const map = require("./operators/map.cjs");
+const filter = require("./operators/filter.cjs");
+const negate = require("./operators/negate.cjs");
+const concat = require("./operators/concat.cjs");
+const debug = require("./operators/debug.cjs");
+const output = require("./operators/output.cjs");
+const consolidate = require("./operators/consolidate.cjs");
+const join = require("./operators/join.cjs");
+const reduce = require("./operators/reduce.cjs");
+const count = require("./operators/count.cjs");
+const distinct = require("./operators/distinct.cjs");
+const keying = require("./operators/keying.cjs");
+const topK = require("./operators/topK.cjs");
+const topKWithFractionalIndex = require("./operators/topKWithFractionalIndex.cjs");
+const orderBy = require("./operators/orderBy.cjs");
+const filterBy = require("./operators/filterBy.cjs");
+exports.D2 = d2.D2;
+exports.RootStreamBuilder = d2.RootStreamBuilder;
+exports.StreamBuilder = d2.StreamBuilder;
+exports.MultiSet = multiset.MultiSet;
+exports.groupBy = groupBy.groupBy;
+exports.groupByOperators = groupBy.groupByOperators;
+exports.pipe = pipe.pipe;
+exports.MapOperator = map.MapOperator;
+exports.map = map.map;
+exports.FilterOperator = filter.FilterOperator;
+exports.filter = filter.filter;
+exports.NegateOperator = negate.NegateOperator;
+exports.negate = negate.negate;
+exports.ConcatOperator = concat.ConcatOperator;
+exports.concat = concat.concat;
+exports.DebugOperator = debug.DebugOperator;
+exports.debug = debug.debug;
+exports.OutputOperator = output.OutputOperator;
+exports.output = output.output;
+exports.ConsolidateOperator = consolidate.ConsolidateOperator;
+exports.consolidate = consolidate.consolidate;
+exports.JoinOperator = join.JoinOperator;
+exports.antiJoin = join.antiJoin;
+exports.fullJoin = join.fullJoin;
+exports.innerJoin = join.innerJoin;
+exports.join = join.join;
+exports.leftJoin = join.leftJoin;
+exports.rightJoin = join.rightJoin;
+exports.ReduceOperator = reduce.ReduceOperator;
+exports.reduce = reduce.reduce;
+exports.CountOperator = count.CountOperator;
+exports.count = count.count;
+exports.DistinctOperator = distinct.DistinctOperator;
+exports.distinct = distinct.distinct;
+exports.keyBy = keying.keyBy;
+exports.rekey = keying.rekey;
+exports.unkey = keying.unkey;
+exports.topK = topK.topK;
+exports.topKWithIndex = topK.topKWithIndex;
+exports.TopKWithFractionalIndexOperator = topKWithFractionalIndex.TopKWithFractionalIndexOperator;
+exports.getIndex = topKWithFractionalIndex.getIndex;
+exports.getValue = topKWithFractionalIndex.getValue;
+exports.indexedValue = topKWithFractionalIndex.indexedValue;
+exports.topKWithFractionalIndex = topKWithFractionalIndex.topKWithFractionalIndex;
+exports.orderBy = orderBy.orderBy;
+exports.orderByWithFractionalIndex = orderBy.orderByWithFractionalIndex;
+exports.orderByWithFractionalIndexBase = orderBy.orderByWithFractionalIndexBase;
+exports.orderByWithIndex = orderBy.orderByWithIndex;
+exports.filterBy = filterBy.filterBy;
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/index.d.cts

@@ -0,0 +1,4 @@
+export * from './d2.js';
+export * from './multiset.js';
+export * from './operators/index.js';
+export * from './types.js';

package/dist/cjs/indexes.cjs

@@ -0,0 +1,104 @@
+"use strict";
+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 _inner;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const multiset = require("./multiset.cjs");
+const utils = require("./utils.cjs");
+class Index {
+  constructor() {
+    __privateAdd(this, _inner);
+    __privateSet(this, _inner, new utils.DefaultMap(() => /* @__PURE__ */ new Map()));
+  }
+  toString(indent = false) {
+    return `Index(${JSON.stringify(
+      [...__privateGet(this, _inner)].map(([k, valueMap]) => [k, [...valueMap]]),
+      void 0,
+      indent ? `  ` : void 0
+    )})`;
+  }
+  get(key) {
+    const valueMap = __privateGet(this, _inner).get(key);
+    return [...valueMap.entries()];
+  }
+  getMultiplicity(key, value) {
+    const valueMap = __privateGet(this, _inner).get(key);
+    return valueMap.get(value) ?? 0;
+  }
+  entries() {
+    return __privateGet(this, _inner).entries();
+  }
+  keys() {
+    return __privateGet(this, _inner).keys();
+  }
+  has(key) {
+    return __privateGet(this, _inner).has(key);
+  }
+  get size() {
+    return __privateGet(this, _inner).size;
+  }
+  addValue(key, value) {
+    const [val, multiplicity] = value;
+    const valueMap = __privateGet(this, _inner).get(key);
+    const existingMultiplicity = valueMap.get(val) ?? 0;
+    const newMultiplicity = existingMultiplicity + multiplicity;
+    if (multiplicity !== 0) {
+      if (newMultiplicity === 0) {
+        valueMap.delete(val);
+      } else {
+        valueMap.set(val, newMultiplicity);
+      }
+    }
+  }
+  append(other) {
+    for (const [key, otherValueMap] of other.entries()) {
+      const thisValueMap = __privateGet(this, _inner).get(key);
+      for (const [value, multiplicity] of otherValueMap.entries()) {
+        const existingMultiplicity = thisValueMap.get(value) ?? 0;
+        const newMultiplicity = existingMultiplicity + multiplicity;
+        if (newMultiplicity === 0) {
+          thisValueMap.delete(value);
+        } else {
+          thisValueMap.set(value, newMultiplicity);
+        }
+      }
+    }
+  }
+  join(other) {
+    const result = [];
+    if (this.size <= other.size) {
+      for (const [key, valueMap] of this.entries()) {
+        if (!other.has(key)) continue;
+        const otherValues = other.get(key);
+        for (const [val1, mul1] of valueMap.entries()) {
+          for (const [val2, mul2] of otherValues) {
+            if (mul1 !== 0 && mul2 !== 0) {
+              result.push([[key, [val1, val2]], mul1 * mul2]);
+            }
+          }
+        }
+      }
+    } else {
+      for (const [key, otherValueMap] of other.entries()) {
+        if (!this.has(key)) continue;
+        const values = this.get(key);
+        for (const [val2, mul2] of otherValueMap.entries()) {
+          for (const [val1, mul1] of values) {
+            if (mul1 !== 0 && mul2 !== 0) {
+              result.push([[key, [val1, val2]], mul1 * mul2]);
+            }
+          }
+        }
+      }
+    }
+    return new multiset.MultiSet(result);
+  }
+}
+_inner = new WeakMap();
+exports.Index = Index;
+//# sourceMappingURL=indexes.cjs.map

package/dist/cjs/indexes.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexes.cjs","sources":["../../src/indexes.ts"],"sourcesContent":["import { MultiSet } from \"./multiset.js\"\nimport { DefaultMap } from \"./utils.js\"\n\n/**\n * A map from a difference collection trace's keys -> (value, multiplicities) that changed.\n * Used in operations like join and reduce where the operation needs to\n * exploit the key-value structure of the data to run efficiently.\n */\nexport class Index<K, V> {\n  #inner: DefaultMap<K, Map<V, number>>\n\n  constructor() {\n    this.#inner = new DefaultMap<K, Map<V, number>>(() => new Map<V, number>())\n    // #inner is a map of:\n    // {\n    //   [key]: Map<V, number>  // Direct value-to-multiplicity mapping\n    // }\n  }\n\n  toString(indent = false): string {\n    return `Index(${JSON.stringify(\n      [...this.#inner].map(([k, valueMap]) => [k, [...valueMap]]),\n      undefined,\n      indent ? `  ` : undefined\n    )})`\n  }\n\n  get(key: K): Array<[V, number]> {\n    const valueMap = this.#inner.get(key)\n    return [...valueMap.entries()]\n  }\n\n  getMultiplicity(key: K, value: V): number {\n    const valueMap = this.#inner.get(key)\n    return valueMap.get(value) ?? 0\n  }\n\n  entries() {\n    return this.#inner.entries()\n  }\n\n  keys() {\n    return this.#inner.keys()\n  }\n\n  has(key: K): boolean {\n    return this.#inner.has(key)\n  }\n\n  get size(): number {\n    return this.#inner.size\n  }\n\n  addValue(key: K, value: [V, number]): void {\n    const [val, multiplicity] = value\n    const valueMap = this.#inner.get(key)\n    const existingMultiplicity = valueMap.get(val) ?? 0\n    const newMultiplicity = existingMultiplicity + multiplicity\n\n    if (multiplicity !== 0) {\n      if (newMultiplicity === 0) {\n        valueMap.delete(val)\n      } else {\n        valueMap.set(val, newMultiplicity)\n      }\n    }\n  }\n\n  append(other: Index<K, V>): void {\n    for (const [key, otherValueMap] of other.entries()) {\n      const thisValueMap = this.#inner.get(key)\n      for (const [value, multiplicity] of otherValueMap.entries()) {\n        const existingMultiplicity = thisValueMap.get(value) ?? 0\n        const newMultiplicity = existingMultiplicity + multiplicity\n        if (newMultiplicity === 0) {\n          thisValueMap.delete(value)\n        } else {\n          thisValueMap.set(value, newMultiplicity)\n        }\n      }\n    }\n  }\n\n  join<V2>(other: Index<K, V2>): MultiSet<[K, [V, V2]]> {\n    const result: Array<[[K, [V, V2]], number]> = []\n\n    // We want to iterate over the smaller of the two indexes to reduce the\n    // number of operations we need to do.\n    if (this.size <= other.size) {\n      for (const [key, valueMap] of this.entries()) {\n        if (!other.has(key)) continue\n        const otherValues = other.get(key)\n        for (const [val1, mul1] of valueMap.entries()) {\n          for (const [val2, mul2] of otherValues) {\n            if (mul1 !== 0 && mul2 !== 0) {\n              result.push([[key, [val1, val2]], mul1 * mul2])\n            }\n          }\n        }\n      }\n    } else {\n      for (const [key, otherValueMap] of other.entries()) {\n        if (!this.has(key)) continue\n        const values = this.get(key)\n        for (const [val2, mul2] of otherValueMap.entries()) {\n          for (const [val1, mul1] of values) {\n            if (mul1 !== 0 && mul2 !== 0) {\n              result.push([[key, [val1, val2]], mul1 * mul2])\n            }\n          }\n        }\n      }\n    }\n\n    return new MultiSet(result)\n  }\n}\n"],"names":["DefaultMap","MultiSet"],"mappings":"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"}

package/dist/cjs/indexes.d.cts

@@ -0,0 +1,20 @@
+import { MultiSet } from './multiset.js';
+/**
+ * A map from a difference collection trace's keys -> (value, multiplicities) that changed.
+ * Used in operations like join and reduce where the operation needs to
+ * exploit the key-value structure of the data to run efficiently.
+ */
+export declare class Index<K, V> {
+    #private;
+    constructor();
+    toString(indent?: boolean): string;
+    get(key: K): Array<[V, number]>;
+    getMultiplicity(key: K, value: V): number;
+    entries(): MapIterator<[K, Map<V, number>]>;
+    keys(): MapIterator<K>;
+    has(key: K): boolean;
+    get size(): number;
+    addValue(key: K, value: [V, number]): void;
+    append(other: Index<K, V>): void;
+    join<V2>(other: Index<K, V2>): MultiSet<[K, [V, V2]]>;
+}