@rocicorp/zero 1.11.0-canary.3 → 1.11.0-canary.30

package/out/zql/src/ivm/take.js

@@ -5,7 +5,6 @@ import { makeAddChange, makeRemoveChange } from "./change.js";
 import { assertOrderingIncludesPK } from "../query/complete-ordering.js";
 import { compareValues } from "./data.js";
 //#region ../zql/src/ivm/take.ts
-var MAX_BOUND_KEY = "maxBound";
 /**
 * The Take operator is for implementing limit queries. It takes the first n
 * nodes of its input as determined by the input’s comparator. It then keeps
@@ -24,7 +23,18 @@ var Take = class {
 	#partitionKey;
 	#partitionKeyComparator;
 	#rowHiddenFromFetch;
+	#takeGate;
+	/**
+	* Partitions that incurred removals in Phase 1 and require deficit refills in
+	* Phase 2 (reconcile). Keyed by `takeStateKey` (see `getTakeStateKey`), matching
+	* `#storage` keys: `'["take"]'` when unpartitioned, or `'["take", ...partitionValues]'`
+	* when partitioned.
+	*/
+	#dirtyPartitions = /* @__PURE__ */ new Map();
 	#output = throwOutput;
+	setTakeGate(gate) {
+		this.#takeGate = gate;
+	}
 	constructor(input, storage, limit, partitionKey) {
 		assert(limit >= 0, "Limit must be non-negative");
 		const { sort } = input.getSchema();
@@ -43,37 +53,35 @@ var Take = class {
 	getSchema() {
 		return this.#input.getSchema();
 	}
+	getBound(constraint) {
+		if (this.#partitionKey && !constraintContainsPartitionKey(constraint, this.#partitionKey)) return;
+		const takeStateKey = getTakeStateKey(this.#partitionKey, constraint);
+		const dirty = this.#dirtyPartitions.get(takeStateKey);
+		if (dirty) return dirty.gateBound;
+		const takeState = this.#storage.get(takeStateKey);
+		if (!takeState || takeState.size < this.#limit) return;
+		return takeState.bound;
+	}
 	*fetch(req) {
-		if (!this.#partitionKey || req.constraint && constraintMatchesPartitionKey(req.constraint, this.#partitionKey)) {
-			const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);
-			const takeState = this.#storage.get(takeStateKey);
-			if (!takeState) {
-				yield* this.#initialFetch(req);
-				return;
-			}
-			if (takeState.bound === void 0) return;
-			for (const inputNode of this.#input.fetch(req)) {
-				if (inputNode === "yield") {
-					yield inputNode;
-					continue;
-				}
-				if (this.getSchema().compareRows(takeState.bound, inputNode.row) < 0) return;
-				if (this.#rowHiddenFromFetch && this.getSchema().compareRows(this.#rowHiddenFromFetch, inputNode.row) === 0) continue;
-				yield inputNode;
-			}
+		assert(!this.#partitionKey || req.constraint !== void 0 && constraintContainsPartitionKey(req.constraint, this.#partitionKey), "Partitioned take does not allow unpartitioned fetches");
+		const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);
+		const takeState = this.#storage.get(takeStateKey);
+		if (!takeState) {
+			if (constraintMatchesPartitionKey(req.constraint, this.#partitionKey)) yield* this.#initialFetch(req);
 			return;
 		}
-		const maxBound = this.#storage.get(MAX_BOUND_KEY);
-		if (maxBound === void 0) return;
+		if (takeState.bound === void 0) return;
+		let count = 0;
 		for (const inputNode of this.#input.fetch(req)) {
 			if (inputNode === "yield") {
 				yield inputNode;
 				continue;
 			}
-			if (this.getSchema().compareRows(inputNode.row, maxBound) > 0) return;
-			const takeStateKey = getTakeStateKey(this.#partitionKey, inputNode.row);
-			const takeState = this.#storage.get(takeStateKey);
-			if (takeState?.bound !== void 0 && this.getSchema().compareRows(takeState.bound, inputNode.row) >= 0) yield inputNode;
+			if (this.getSchema().compareRows(takeState.bound, inputNode.row) < 0) return;
+			if (this.#rowHiddenFromFetch && this.getSchema().compareRows(this.#rowHiddenFromFetch, inputNode.row) === 0) continue;
+			yield inputNode;
+			count++;
+			if (count >= this.#limit) return;
 		}
 	}
 	*#initialFetch(req) {
@@ -104,7 +112,7 @@ var Take = class {
 			throw e;
 		} finally {
 			if (!exceptionThrown) {
-				this.#setTakeState(takeStateKey, size, bound, this.#storage.get(MAX_BOUND_KEY));
+				this.#setTakeState(takeStateKey, size, bound);
 				assert(!downstreamEarlyReturn, "Unexpected early return prevented full hydration");
 			}
 		}
@@ -112,16 +120,11 @@ var Take = class {
 	#getStateAndConstraint(row) {
 		const takeStateKey = getTakeStateKey(this.#partitionKey, row);
 		const takeState = this.#storage.get(takeStateKey);
-		let maxBound;
 		let constraint;
-		if (takeState) {
-			maxBound = this.#storage.get(MAX_BOUND_KEY);
-			constraint = this.#partitionKey && Object.fromEntries(this.#partitionKey.map((key) => [key, row[key]]));
-		}
+		if (takeState) constraint = this.#partitionKey && Object.fromEntries(this.#partitionKey.map((key) => [key, row[key]]));
 		return {
 			takeState,
 			takeStateKey,
-			maxBound,
 			constraint
 		};
 	}
@@ -130,12 +133,17 @@ var Take = class {
 			yield* this.#pushEditChange(change);
 			return;
 		}
-		const { takeState, takeStateKey, maxBound, constraint } = this.#getStateAndConstraint(change[1].row);
+		const { takeState, takeStateKey, constraint } = this.#getStateAndConstraint(change[1].row);
 		if (!takeState) return;
 		const { compareRows } = this.getSchema();
 		if (change[0] === 0) {
 			if (takeState.size < this.#limit) {
-				this.#setTakeState(takeStateKey, takeState.size + 1, takeState.bound === void 0 || compareRows(takeState.bound, change[1].row) < 0 ? change[1].row : takeState.bound, maxBound);
+				if (this.#dirtyPartitions.has(takeStateKey)) {
+					if (takeState.bound === void 0 || compareRows(change[1].row, takeState.bound) >= 0) return;
+				}
+				const nextSize = takeState.size + 1;
+				if (nextSize === this.#limit) this.#dirtyPartitions.delete(takeStateKey);
+				this.#setTakeState(takeStateKey, nextSize, takeState.bound === void 0 || compareRows(takeState.bound, change[1].row) < 0 ? change[1].row : takeState.bound);
 				yield* this.#output.push(change, this);
 				return;
 			}
@@ -173,12 +181,13 @@ var Take = class {
 			}
 			assert(boundNode !== void 0, "Take: boundNode must be found during fetch");
 			const removeChange = makeRemoveChange(boundNode);
-			this.#setTakeState(takeStateKey, takeState.size, beforeBoundNode === void 0 || compareRows(change[1].row, beforeBoundNode.row) > 0 ? change[1].row : beforeBoundNode.row, maxBound);
+			this.#setTakeState(takeStateKey, takeState.size, beforeBoundNode === void 0 || compareRows(change[1].row, beforeBoundNode.row) > 0 ? change[1].row : beforeBoundNode.row);
 			yield* this.#pushWithRowHiddenFromFetch(change[1].row, removeChange);
 			yield* this.#output.push(change, this);
 		} else if (change[0] === 1) {
 			if (takeState.bound === void 0) return;
-			if (compareRows(change[1].row, takeState.bound) > 0) return;
+			const compToBound = compareRows(change[1].row, takeState.bound);
+			if (compToBound > 0 || compToBound < 0 && this.#limit === 1) return;
 			let beforeBoundNode;
 			for (const node of this.#input.fetch({
 				start: {
@@ -195,39 +204,12 @@ var Take = class {
 				beforeBoundNode = node;
 				break;
 			}
-			let newBound;
-			if (beforeBoundNode) {
-				const push = compareRows(beforeBoundNode.row, takeState.bound) > 0;
-				newBound = {
-					node: beforeBoundNode,
-					push
-				};
-			}
-			if (!newBound?.push) for (const node of this.#input.fetch({
-				start: {
-					row: takeState.bound,
-					basis: "at"
-				},
-				constraint
-			})) {
-				if (node === "yield") {
-					yield node;
-					continue;
-				}
-				const push = compareRows(node.row, takeState.bound) > 0;
-				newBound = {
-					node,
-					push
-				};
-				if (push) break;
-			}
-			if (newBound?.push) {
-				yield* this.#output.push(change, this);
-				this.#setTakeState(takeStateKey, takeState.size, newBound.node.row, maxBound);
-				yield* this.#output.push(makeAddChange(newBound.node), this);
-				return;
-			}
-			this.#setTakeState(takeStateKey, takeState.size - 1, newBound?.node.row, maxBound);
+			const finalBound = takeState.size - 1 === 0 ? void 0 : compToBound < 0 ? takeState.bound : beforeBoundNode?.row;
+			if (!this.#dirtyPartitions.has(takeStateKey)) this.#dirtyPartitions.set(takeStateKey, {
+				constraint,
+				gateBound: takeState.bound
+			});
+			this.#setTakeState(takeStateKey, takeState.size - 1, finalBound);
 			yield* this.#output.push(change, this);
 		} else if (change[0] === 3) {
 			if (takeState.bound && compareRows(change[1].row, takeState.bound) <= 0) yield* this.#output.push(change, this);
@@ -235,16 +217,15 @@ var Take = class {
 	}
 	*#pushEditChange(change) {
 		assert(!this.#partitionKeyComparator || this.#partitionKeyComparator(change[2].row, change[1].row) === 0, "Unexpected change of partition key");
-		const { takeState, takeStateKey, maxBound, constraint } = this.#getStateAndConstraint(change[2].row);
+		const { takeState, takeStateKey, constraint } = this.#getStateAndConstraint(change[2].row);
 		if (!takeState) return;
 		assert(takeState.bound, "Bound should be set");
 		const { compareRows } = this.getSchema();
 		const oldCmp = compareRows(change[2].row, takeState.bound);
 		const newCmp = compareRows(change[1].row, takeState.bound);
-		const that = this;
-		const replaceBoundAndForwardChange = function* () {
-			that.#setTakeState(takeStateKey, takeState.size, change[1].row, maxBound);
-			yield* that.#output.push(change, that);
+		const replaceBoundAndForwardChange = () => {
+			this.#setTakeState(takeStateKey, takeState.size, change[1].row);
+			return this.#output.push(change, this);
 		};
 		if (oldCmp === 0) {
 			if (newCmp === 0) {
@@ -273,32 +254,37 @@ var Take = class {
 					break;
 				}
 				assert(beforeBoundNode !== void 0, "Take: beforeBoundNode must be found during fetch");
-				this.#setTakeState(takeStateKey, takeState.size, beforeBoundNode.row, maxBound);
+				this.#setTakeState(takeStateKey, takeState.size, beforeBoundNode.row);
 				yield* this.#output.push(change, this);
 				return;
 			}
 			assert(newCmp > 0, "New comparison must be greater than 0");
 			let newBoundNode;
-			for (const node of this.#input.fetch({
-				start: {
-					row: takeState.bound,
-					basis: "at"
-				},
-				constraint
-			})) {
-				if (node === "yield") {
-					yield node;
-					continue;
+			this.#takeGate?.open();
+			try {
+				for (const node of this.#input.fetch({
+					start: {
+						row: takeState.bound,
+						basis: "at"
+					},
+					constraint
+				})) {
+					if (node === "yield") {
+						yield node;
+						continue;
+					}
+					newBoundNode = node;
+					break;
 				}
-				newBoundNode = node;
-				break;
+			} finally {
+				this.#takeGate?.close();
 			}
 			assert(newBoundNode !== void 0, "Take: newBoundNode must be found during fetch");
 			if (compareRows(newBoundNode.row, change[1].row) === 0) {
 				yield* replaceBoundAndForwardChange();
 				return;
 			}
-			this.#setTakeState(takeStateKey, takeState.size, newBoundNode.row, maxBound);
+			this.#setTakeState(takeStateKey, takeState.size, newBoundNode.row);
 			yield* this.#pushWithRowHiddenFromFetch(newBoundNode.row, makeRemoveChange(change[2]));
 			yield* this.#output.push(makeAddChange(newBoundNode), this);
 			return;
@@ -326,7 +312,7 @@ var Take = class {
 			}
 			assert(oldBoundNode !== void 0, "Take: oldBoundNode must be found during fetch");
 			assert(newBoundNode !== void 0, "Take: newBoundNode must be found during fetch");
-			this.#setTakeState(takeStateKey, takeState.size, newBoundNode.row, maxBound);
+			this.#setTakeState(takeStateKey, takeState.size, newBoundNode.row);
 			yield* this.#pushWithRowHiddenFromFetch(change[1].row, makeRemoveChange(oldBoundNode));
 			yield* this.#output.push(makeAddChange(change[1]), this);
 			return;
@@ -339,19 +325,24 @@ var Take = class {
 			}
 			assert(newCmp > 0, "New comparison must be greater than 0");
 			let afterBoundNode;
-			for (const node of this.#input.fetch({
-				start: {
-					row: takeState.bound,
-					basis: "after"
-				},
-				constraint
-			})) {
-				if (node === "yield") {
-					yield node;
-					continue;
+			this.#takeGate?.open();
+			try {
+				for (const node of this.#input.fetch({
+					start: {
+						row: takeState.bound,
+						basis: "after"
+					},
+					constraint
+				})) {
+					if (node === "yield") {
+						yield node;
+						continue;
+					}
+					afterBoundNode = node;
+					break;
 				}
-				afterBoundNode = node;
-				break;
+			} finally {
+				this.#takeGate?.close();
 			}
 			assert(afterBoundNode !== void 0, "Take: afterBoundNode must be found during fetch");
 			if (compareRows(afterBoundNode.row, change[1].row) === 0) {
@@ -359,7 +350,7 @@ var Take = class {
 				return;
 			}
 			yield* this.#output.push(makeRemoveChange(change[2]), this);
-			this.#setTakeState(takeStateKey, takeState.size, afterBoundNode.row, maxBound);
+			this.#setTakeState(takeStateKey, takeState.size, afterBoundNode.row);
 			yield* this.#output.push(makeAddChange(afterBoundNode), this);
 			return;
 		}
@@ -373,15 +364,55 @@ var Take = class {
 			this.#rowHiddenFromFetch = void 0;
 		}
 	}
-	#setTakeState(takeStateKey, size, bound, maxBound) {
+	#setTakeState(takeStateKey, size, bound) {
 		this.#storage.set(takeStateKey, {
 			size,
 			bound
 		});
-		if (bound !== void 0 && (maxBound === void 0 || this.getSchema().compareRows(bound, maxBound) > 0)) this.#storage.set(MAX_BOUND_KEY, bound);
 	}
 	destroy() {
 		this.#input.destroy();
+		this.#storage.destroy();
+	}
+	*reconcile(_pusher) {
+		if (this.#dirtyPartitions.size > 0) {
+			const dirty = [...this.#dirtyPartitions.entries()];
+			this.#dirtyPartitions.clear();
+			for (const [takeStateKey, { constraint }] of dirty) {
+				const takeState = this.#storage.get(takeStateKey);
+				assert(takeState !== void 0, "Take: dirty partition must exist in storage");
+				const deficit = this.#limit - takeState.size;
+				assert(deficit > 0, "Take: dirty partition must have a deficit");
+				const toPush = [];
+				this.#takeGate?.open();
+				try {
+					const stream = this.#input.fetch({
+						start: takeState.bound ? {
+							row: takeState.bound,
+							basis: "after"
+						} : void 0,
+						constraint
+					});
+					for (const node of stream) {
+						if (node === "yield") {
+							yield "yield";
+							continue;
+						}
+						toPush.push(node);
+						if (toPush.length === deficit) break;
+					}
+				} finally {
+					this.#takeGate?.close();
+				}
+				let currentSize = takeState.size;
+				for (const node of toPush) {
+					currentSize++;
+					this.#setTakeState(takeStateKey, currentSize, node.row);
+					yield* this.#output.push(makeAddChange(node), this);
+				}
+			}
+		}
+		if (this.#output.reconcile) yield* this.#output.reconcile(this);
 	}
 };
 function getTakeStateKey(partitionKey, rowOrConstraint) {
@@ -395,6 +426,11 @@ function constraintMatchesPartitionKey(constraint, partitionKey) {
 	for (const key of partitionKey) if (!hasOwn(constraint, key)) return false;
 	return true;
 }
+function constraintContainsPartitionKey(constraint, partitionKey) {
+	if (constraint === void 0 || partitionKey === void 0) return false;
+	for (const key of partitionKey) if (!hasOwn(constraint, key)) return false;
+	return true;
+}
 function makePartitionKeyComparator(partitionKey) {
 	return (a, b) => {
 		for (const key of partitionKey) {

package/out/zql/src/ivm/take.js.map

@@ -1 +1 @@
-{"version":3,"file":"take.js","names":["#input","#storage","#limit","#partitionKey","#partitionKeyComparator","#output","#initialFetch","#rowHiddenFromFetch","#setTakeState","#pushEditChange","#getStateAndConstraint","#pushWithRowHiddenFromFetch"],"sources":["../../../../../zql/src/ivm/take.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {hasOwn} from '../../../shared/src/has-own.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\nimport {assertOrderingIncludesPK} from '../query/complete-ordering.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {\n  makeAddChange,\n  makeRemoveChange,\n  type Change,\n  type EditChange,\n} from './change.ts';\nimport type {Constraint} from './constraint.ts';\nimport {compareValues, type Comparator, type Node} from './data.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type Operator,\n  type Output,\n  type Storage,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {type Stream} from './stream.ts';\n\nconst MAX_BOUND_KEY = 'maxBound';\n\ntype TakeState = {\n  size: number;\n  bound: Row | undefined;\n};\n\ninterface TakeStorage {\n  get(key: typeof MAX_BOUND_KEY): Row | undefined;\n  get(key: string): TakeState | undefined;\n  set(key: typeof MAX_BOUND_KEY, value: Row): void;\n  set(key: string, value: TakeState): void;\n  del(key: string): void;\n}\n\nexport type PartitionKey = PrimaryKey;\n\n/**\n * The Take operator is for implementing limit queries. It takes the first n\n * nodes of its input as determined by the input’s comparator. It then keeps\n * a *bound* of the last item it has accepted so that it can evaluate whether\n * new incoming pushes should be accepted or rejected.\n *\n * Take can count rows globally or by unique value of some field.\n *\n * Maintains the invariant that its output size is always <= limit, even\n * mid processing of a push.\n */\nexport class Take implements Operator {\n  readonly #input: Input;\n  readonly #storage: TakeStorage;\n  readonly #limit: number;\n  readonly #partitionKey: PartitionKey | undefined;\n  readonly #partitionKeyComparator: Comparator | undefined;\n  // Fetch overlay needed for some split push cases.\n  #rowHiddenFromFetch: Row | undefined;\n\n  #output: Output = throwOutput;\n\n  constructor(\n    input: Input,\n    storage: Storage,\n    limit: number,\n    partitionKey?: PartitionKey,\n  ) {\n    assert(limit >= 0, 'Limit must be non-negative');\n    const {sort} = input.getSchema();\n    assert(sort !== undefined, 'Take requires sorted input');\n    assertOrderingIncludesPK(sort, input.getSchema().primaryKey);\n    input.setOutput(this);\n    this.#input = input;\n    this.#storage = storage as TakeStorage;\n    this.#limit = limit;\n    this.#partitionKey = partitionKey;\n    this.#partitionKeyComparator =\n      partitionKey && makePartitionKeyComparator(partitionKey);\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    if (\n      !this.#partitionKey ||\n      (req.constraint &&\n        constraintMatchesPartitionKey(req.constraint, this.#partitionKey))\n    ) {\n      const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);\n      const takeState = this.#storage.get(takeStateKey);\n      if (!takeState) {\n        yield* this.#initialFetch(req);\n        return;\n      }\n      if (takeState.bound === undefined) {\n        return;\n      }\n      for (const inputNode of this.#input.fetch(req)) {\n        if (inputNode === 'yield') {\n          yield inputNode;\n          continue;\n        }\n        if (this.getSchema().compareRows(takeState.bound, inputNode.row) < 0) {\n          return;\n        }\n        if (\n          this.#rowHiddenFromFetch &&\n          this.getSchema().compareRows(\n            this.#rowHiddenFromFetch,\n            inputNode.row,\n          ) === 0\n        ) {\n          continue;\n        }\n        yield inputNode;\n      }\n      return;\n    }\n    // There is a partition key, but the fetch is not constrained or constrained\n    // on a different key.  Thus we don't have a single take state to bound by.\n    // This currently only happens with nested sub-queries\n    // e.g. issues include issuelabels include label.  We could remove this\n    // case if we added a translation layer (powered by some state) in join.\n    // Specifically we need joinKeyValue => parent constraint key\n    const maxBound = this.#storage.get(MAX_BOUND_KEY);\n    if (maxBound === undefined) {\n      return;\n    }\n    for (const inputNode of this.#input.fetch(req)) {\n      if (inputNode === 'yield') {\n        yield inputNode;\n        continue;\n      }\n      if (this.getSchema().compareRows(inputNode.row, maxBound) > 0) {\n        return;\n      }\n      const takeStateKey = getTakeStateKey(this.#partitionKey, inputNode.row);\n      const takeState = this.#storage.get(takeStateKey);\n      if (\n        takeState?.bound !== undefined &&\n        this.getSchema().compareRows(takeState.bound, inputNode.row) >= 0\n      ) {\n        yield inputNode;\n      }\n    }\n  }\n\n  *#initialFetch(req: FetchRequest): Stream<Node | 'yield'> {\n    assert(req.start === undefined, 'Start should be undefined');\n    assert(!req.reverse, 'Reverse should be false');\n\n    if (this.#limit === 0) {\n      return;\n    }\n\n    assert(\n      constraintMatchesPartitionKey(req.constraint, this.#partitionKey),\n      'Constraint should match partition key',\n    );\n\n    const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);\n    assert(\n      this.#storage.get(takeStateKey) === undefined,\n      'Take state should be undefined',\n    );\n\n    let size = 0;\n    let bound: Row | undefined;\n    let downstreamEarlyReturn = true;\n    let exceptionThrown = false;\n    try {\n      for (const inputNode of this.#input.fetch(req)) {\n        if (inputNode === 'yield') {\n          yield 'yield';\n          continue;\n        }\n        yield inputNode;\n        bound = inputNode.row;\n        size++;\n        if (size === this.#limit) {\n          break;\n        }\n      }\n      downstreamEarlyReturn = false;\n    } catch (e) {\n      exceptionThrown = true;\n      throw e;\n    } finally {\n      if (!exceptionThrown) {\n        this.#setTakeState(\n          takeStateKey,\n          size,\n          bound,\n          this.#storage.get(MAX_BOUND_KEY),\n        );\n        // If it becomes necessary to support downstream early return, this\n        // assert should be removed, and replaced with code that consumes\n        // the input stream until limit is reached or the input stream is\n        // exhausted so that takeState is properly hydrated.\n        assert(\n          !downstreamEarlyReturn,\n          'Unexpected early return prevented full hydration',\n        );\n      }\n    }\n  }\n\n  #getStateAndConstraint(row: Row) {\n    const takeStateKey = getTakeStateKey(this.#partitionKey, row);\n    const takeState = this.#storage.get(takeStateKey);\n    let maxBound: Row | undefined;\n    let constraint: Constraint | undefined;\n    if (takeState) {\n      maxBound = this.#storage.get(MAX_BOUND_KEY);\n      constraint =\n        this.#partitionKey &&\n        Object.fromEntries(\n          this.#partitionKey.map(key => [key, row[key]] as const),\n        );\n    }\n\n    return {takeState, takeStateKey, maxBound, constraint} as\n      | {\n          takeState: undefined;\n          takeStateKey: string;\n          maxBound: undefined;\n          constraint: undefined;\n        }\n      | {\n          takeState: TakeState;\n          takeStateKey: string;\n          maxBound: Row | undefined;\n          constraint: Constraint | undefined;\n        };\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    if (change[ChangeIndex.TYPE] === ChangeType.EDIT) {\n      yield* this.#pushEditChange(change);\n      return;\n    }\n\n    const {takeState, takeStateKey, maxBound, constraint} =\n      this.#getStateAndConstraint(change[ChangeIndex.NODE].row);\n    if (!takeState) {\n      return;\n    }\n\n    const {compareRows} = this.getSchema();\n\n    if (change[ChangeIndex.TYPE] === ChangeType.ADD) {\n      if (takeState.size < this.#limit) {\n        this.#setTakeState(\n          takeStateKey,\n          takeState.size + 1,\n          takeState.bound === undefined ||\n            compareRows(takeState.bound, change[ChangeIndex.NODE].row) < 0\n            ? change[ChangeIndex.NODE].row\n            : takeState.bound,\n          maxBound,\n        );\n        yield* this.#output.push(change, this);\n        return;\n      }\n      // size === limit\n      if (\n        takeState.bound === undefined ||\n        compareRows(change[ChangeIndex.NODE].row, takeState.bound) >= 0\n      ) {\n        return;\n      }\n      // added row < bound\n      let beforeBoundNode: Node | undefined;\n      let boundNode: Node | undefined;\n      if (this.#limit === 1) {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'at',\n          },\n          constraint,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          boundNode = node;\n          break;\n        }\n      } else {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'at',\n          },\n          constraint,\n          reverse: true,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          } else if (boundNode === undefined) {\n            boundNode = node;\n          } else {\n            beforeBoundNode = node;\n            break;\n          }\n        }\n      }\n      assert(\n        boundNode !== undefined,\n        'Take: boundNode must be found during fetch',\n      );\n      const removeChange = makeRemoveChange(boundNode);\n      // Remove before add to maintain invariant that\n      // output size <= limit.\n      this.#setTakeState(\n        takeStateKey,\n        takeState.size,\n        beforeBoundNode === undefined ||\n          compareRows(change[ChangeIndex.NODE].row, beforeBoundNode.row) > 0\n          ? change[ChangeIndex.NODE].row\n          : beforeBoundNode.row,\n        maxBound,\n      );\n      yield* this.#pushWithRowHiddenFromFetch(\n        change[ChangeIndex.NODE].row,\n        removeChange,\n      );\n      yield* this.#output.push(change, this);\n    } else if (change[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n      if (takeState.bound === undefined) {\n        // change is after bound\n        return;\n      }\n      const compToBound = compareRows(\n        change[ChangeIndex.NODE].row,\n        takeState.bound,\n      );\n      if (compToBound > 0) {\n        // change is after bound\n        return;\n      }\n      let beforeBoundNode: Node | undefined;\n      for (const node of this.#input.fetch({\n        start: {\n          row: takeState.bound,\n          basis: 'after',\n        },\n        constraint,\n        reverse: true,\n      })) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        }\n        beforeBoundNode = node;\n        break;\n      }\n\n      let newBound: {node: Node; push: boolean} | undefined;\n      if (beforeBoundNode) {\n        const push = compareRows(beforeBoundNode.row, takeState.bound) > 0;\n        newBound = {\n          node: beforeBoundNode,\n          push,\n        };\n      }\n      if (!newBound?.push) {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'at',\n          },\n          constraint,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          const push = compareRows(node.row, takeState.bound) > 0;\n          newBound = {\n            node,\n            push,\n          };\n          if (push) {\n            break;\n          }\n        }\n      }\n\n      if (newBound?.push) {\n        yield* this.#output.push(change, this);\n        this.#setTakeState(\n          takeStateKey,\n          takeState.size,\n          newBound.node.row,\n          maxBound,\n        );\n        yield* this.#output.push(makeAddChange(newBound.node), this);\n        return;\n      }\n      this.#setTakeState(\n        takeStateKey,\n        takeState.size - 1,\n        newBound?.node.row,\n        maxBound,\n      );\n      yield* this.#output.push(change, this);\n    } else if (change[ChangeIndex.TYPE] === ChangeType.CHILD) {\n      // A 'child' change should be pushed to output if its row\n      // is <= bound.\n      if (\n        takeState.bound &&\n        compareRows(change[ChangeIndex.NODE].row, takeState.bound) <= 0\n      ) {\n        yield* this.#output.push(change, this);\n      }\n    }\n  }\n\n  *#pushEditChange(change: EditChange): Stream<'yield'> {\n    assert(\n      !this.#partitionKeyComparator ||\n        this.#partitionKeyComparator(\n          change[ChangeIndex.OLD_NODE].row,\n          change[ChangeIndex.NODE].row,\n        ) === 0,\n      'Unexpected change of partition key',\n    );\n\n    const {takeState, takeStateKey, maxBound, constraint} =\n      this.#getStateAndConstraint(change[ChangeIndex.OLD_NODE].row);\n    if (!takeState) {\n      return;\n    }\n\n    assert(takeState.bound, 'Bound should be set');\n    const {compareRows} = this.getSchema();\n    const oldCmp = compareRows(\n      change[ChangeIndex.OLD_NODE].row,\n      takeState.bound,\n    );\n    const newCmp = compareRows(change[ChangeIndex.NODE].row, takeState.bound);\n\n    const that = this;\n    const replaceBoundAndForwardChange = function* () {\n      that.#setTakeState(\n        takeStateKey,\n        takeState.size,\n        change[ChangeIndex.NODE].row,\n        maxBound,\n      );\n      yield* that.#output.push(change, that);\n    };\n\n    // The bounds row was changed.\n    if (oldCmp === 0) {\n      // The new row is the new bound.\n      if (newCmp === 0) {\n        // no need to update the state since we are keeping the bounds\n        yield* this.#output.push(change, this);\n        return;\n      }\n\n      if (newCmp < 0) {\n        if (this.#limit === 1) {\n          yield* replaceBoundAndForwardChange();\n          return;\n        }\n\n        // New row will be in the result but it might not be the bounds any\n        // more. We need to find the row before the bounds to determine the new\n        // bounds.\n\n        let beforeBoundNode: Node | undefined;\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'after',\n          },\n          constraint,\n          reverse: true,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          beforeBoundNode = node;\n          break;\n        }\n        assert(\n          beforeBoundNode !== undefined,\n          'Take: beforeBoundNode must be found during fetch',\n        );\n\n        this.#setTakeState(\n          takeStateKey,\n          takeState.size,\n          beforeBoundNode.row,\n          maxBound,\n        );\n        yield* this.#output.push(change, this);\n        return;\n      }\n\n      assert(newCmp > 0, 'New comparison must be greater than 0');\n      // Find the first item at the old bounds. This will be the new bounds.\n      let newBoundNode: Node | undefined;\n      for (const node of this.#input.fetch({\n        start: {\n          row: takeState.bound,\n          basis: 'at',\n        },\n        constraint,\n      })) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        }\n        newBoundNode = node;\n        break;\n      }\n      assert(\n        newBoundNode !== undefined,\n        'Take: newBoundNode must be found during fetch',\n      );\n\n      // The next row is the new row. We can replace the bounds and keep the\n      // edit change.\n      if (compareRows(newBoundNode.row, change[ChangeIndex.NODE].row) === 0) {\n        yield* replaceBoundAndForwardChange();\n        return;\n      }\n\n      // The new row is now outside the bounds, so we need to remove the old\n      // row and add the new bounds row.\n      this.#setTakeState(\n        takeStateKey,\n        takeState.size,\n        newBoundNode.row,\n        maxBound,\n      );\n      yield* this.#pushWithRowHiddenFromFetch(\n        newBoundNode.row,\n        makeRemoveChange(change[ChangeIndex.OLD_NODE]),\n      );\n      yield* this.#output.push(makeAddChange(newBoundNode), this);\n      return;\n    }\n\n    if (oldCmp > 0) {\n      assert(newCmp !== 0, 'Invalid state. Row has duplicate primary key');\n\n      // Both old and new outside of bounds\n      if (newCmp > 0) {\n        return;\n      }\n\n      // old was outside, new is inside. Pushing out the old bounds\n      assert(newCmp < 0, 'New comparison must be less than 0');\n\n      let oldBoundNode: Node | undefined;\n      let newBoundNode: Node | undefined;\n      for (const node of this.#input.fetch({\n        start: {\n          row: takeState.bound,\n          basis: 'at',\n        },\n        constraint,\n        reverse: true,\n      })) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        } else if (oldBoundNode === undefined) {\n          oldBoundNode = node;\n        } else {\n          newBoundNode = node;\n          break;\n        }\n      }\n      assert(\n        oldBoundNode !== undefined,\n        'Take: oldBoundNode must be found during fetch',\n      );\n      assert(\n        newBoundNode !== undefined,\n        'Take: newBoundNode must be found during fetch',\n      );\n\n      // Remove before add to maintain invariant that\n      // output size <= limit.\n      this.#setTakeState(\n        takeStateKey,\n        takeState.size,\n        newBoundNode.row,\n        maxBound,\n      );\n      yield* this.#pushWithRowHiddenFromFetch(\n        change[ChangeIndex.NODE].row,\n        makeRemoveChange(oldBoundNode),\n      );\n      yield* this.#output.push(makeAddChange(change[ChangeIndex.NODE]), this);\n\n      return;\n    }\n\n    if (oldCmp < 0) {\n      assert(newCmp !== 0, 'Invalid state. Row has duplicate primary key');\n\n      // Both old and new inside of bounds\n      if (newCmp < 0) {\n        yield* this.#output.push(change, this);\n        return;\n      }\n\n      // old was inside, new is larger than old bound\n\n      assert(newCmp > 0, 'New comparison must be greater than 0');\n\n      // at this point we need to find the row after the bound and use that or\n      // the newRow as the new bound.\n      let afterBoundNode: Node | undefined;\n      for (const node of this.#input.fetch({\n        start: {\n          row: takeState.bound,\n          basis: 'after',\n        },\n        constraint,\n      })) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        }\n        afterBoundNode = node;\n        break;\n      }\n      assert(\n        afterBoundNode !== undefined,\n        'Take: afterBoundNode must be found during fetch',\n      );\n\n      // The new row is the new bound. Use an edit change.\n      if (compareRows(afterBoundNode.row, change[ChangeIndex.NODE].row) === 0) {\n        yield* replaceBoundAndForwardChange();\n        return;\n      }\n\n      yield* this.#output.push(\n        makeRemoveChange(change[ChangeIndex.OLD_NODE]),\n        this,\n      );\n      this.#setTakeState(\n        takeStateKey,\n        takeState.size,\n        afterBoundNode.row,\n        maxBound,\n      );\n      yield* this.#output.push(makeAddChange(afterBoundNode), this);\n      return;\n    }\n\n    unreachable();\n  }\n\n  *#pushWithRowHiddenFromFetch(row: Row, change: Change) {\n    this.#rowHiddenFromFetch = row;\n    try {\n      yield* this.#output.push(change, this);\n    } finally {\n      this.#rowHiddenFromFetch = undefined;\n    }\n  }\n\n  #setTakeState(\n    takeStateKey: string,\n    size: number,\n    bound: Row | undefined,\n    maxBound: Row | undefined,\n  ) {\n    this.#storage.set(takeStateKey, {\n      size,\n      bound,\n    });\n    if (\n      bound !== undefined &&\n      (maxBound === undefined ||\n        this.getSchema().compareRows(bound, maxBound) > 0)\n    ) {\n      this.#storage.set(MAX_BOUND_KEY, bound);\n    }\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n}\n\nfunction getTakeStateKey(\n  partitionKey: PartitionKey | undefined,\n  rowOrConstraint: Row | Constraint | undefined,\n): string {\n  // The order must be consistent. We always use the order as defined by the\n  // partition key.\n  const partitionValues: Value[] = [];\n\n  if (partitionKey && rowOrConstraint) {\n    for (const key of partitionKey) {\n      partitionValues.push(rowOrConstraint[key]);\n    }\n  }\n\n  return JSON.stringify(['take', ...partitionValues]);\n}\n\nexport function constraintMatchesPartitionKey(\n  constraint: Constraint | undefined,\n  partitionKey: PartitionKey | undefined,\n): boolean {\n  if (constraint === undefined || partitionKey === undefined) {\n    return constraint === partitionKey;\n  }\n  if (partitionKey.length !== Object.keys(constraint).length) {\n    return false;\n  }\n  for (const key of partitionKey) {\n    if (!hasOwn(constraint, key)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function makePartitionKeyComparator(\n  partitionKey: PartitionKey,\n): Comparator {\n  return (a, b) => {\n    for (const key of partitionKey) {\n      const cmp = compareValues(a[key], b[key]);\n      if (cmp !== 0) {\n        return cmp;\n      }\n    }\n    return 0;\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"take.js","names":["#input","#storage","#limit","#partitionKey","#partitionKeyComparator","#dirtyPartitions","#takeGate","#output","#initialFetch","#rowHiddenFromFetch","#setTakeState","#pushEditChange","#getStateAndConstraint","#pushWithRowHiddenFromFetch"],"sources":["../../../../../zql/src/ivm/take.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {hasOwn} from '../../../shared/src/has-own.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\nimport {assertOrderingIncludesPK} from '../query/complete-ordering.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {\n  makeAddChange,\n  makeRemoveChange,\n  type Change,\n  type EditChange,\n} from './change.ts';\nimport type {Constraint} from './constraint.ts';\nimport {compareValues, type Comparator, type Node} from './data.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type InputBase,\n  type Operator,\n  type Output,\n  type Storage,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {type Stream} from './stream.ts';\nimport type {TakeBoundProvider, TakeGate} from './take-gate.ts';\n\ntype TakeState = {\n  size: number;\n  bound: Row | undefined;\n};\n\ninterface TakeStorage {\n  get(key: string): TakeState | undefined;\n  set(key: string, value: TakeState): void;\n  del(key: string): void;\n  destroy(): void;\n}\n\nexport type PartitionKey = PrimaryKey;\n\ntype DirtyPartitionState = {\n  constraint: Constraint | undefined;\n  /**\n   * The bound to report to upstream TakeGate via getBound() until Phase 2\n   * reconciliation completes.\n   *\n   * When removals reduce partition size below limit in Phase 1, normal getBound()\n   * would return undefined (unbounded), which would cause upstream TakeGate to open\n   * and allow unbounded parent pushes through. Preserving gateBound keeps TakeGate\n   * capped at the pre-removal boundary until Phase 2 refills the deficit.\n   */\n  gateBound: Row | undefined;\n};\n\n/**\n * The Take operator is for implementing limit queries. It takes the first n\n * nodes of its input as determined by the input’s comparator. It then keeps\n * a *bound* of the last item it has accepted so that it can evaluate whether\n * new incoming pushes should be accepted or rejected.\n *\n * Take can count rows globally or by unique value of some field.\n *\n * Maintains the invariant that its output size is always <= limit, even\n * mid processing of a push.\n */\nexport class Take implements Operator, TakeBoundProvider {\n  readonly #input: Input;\n  readonly #storage: TakeStorage;\n  readonly #limit: number;\n  readonly #partitionKey: PartitionKey | undefined;\n  readonly #partitionKeyComparator: Comparator | undefined;\n  // Fetch overlay needed for some split push cases.\n  #rowHiddenFromFetch: Row | undefined;\n\n  #takeGate: TakeGate | undefined;\n  /**\n   * Partitions that incurred removals in Phase 1 and require deficit refills in\n   * Phase 2 (reconcile). Keyed by `takeStateKey` (see `getTakeStateKey`), matching\n   * `#storage` keys: `'[\"take\"]'` when unpartitioned, or `'[\"take\", ...partitionValues]'`\n   * when partitioned.\n   */\n  readonly #dirtyPartitions = new Map<string, DirtyPartitionState>();\n\n  #output: Output = throwOutput;\n\n  setTakeGate(gate: TakeGate): void {\n    this.#takeGate = gate;\n  }\n\n  constructor(\n    input: Input,\n    storage: Storage,\n    limit: number,\n    partitionKey?: PartitionKey,\n  ) {\n    assert(limit >= 0, 'Limit must be non-negative');\n    const {sort} = input.getSchema();\n    assert(sort !== undefined, 'Take requires sorted input');\n    assertOrderingIncludesPK(sort, input.getSchema().primaryKey);\n    input.setOutput(this);\n    this.#input = input;\n    this.#storage = storage as TakeStorage;\n    this.#limit = limit;\n    this.#partitionKey = partitionKey;\n    this.#partitionKeyComparator =\n      partitionKey && makePartitionKeyComparator(partitionKey);\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  getBound(constraint?: Constraint): Row | undefined {\n    if (\n      this.#partitionKey &&\n      !constraintContainsPartitionKey(constraint, this.#partitionKey)\n    ) {\n      return undefined;\n    }\n    const takeStateKey = getTakeStateKey(this.#partitionKey, constraint);\n    const dirty = this.#dirtyPartitions.get(takeStateKey);\n    if (dirty) {\n      // While dirty in Phase 1, return gateBound (the bound prior to removals) so\n      // upstream operators (e.g. TakeGate) remain capped rather than unbounding during push.\n      return dirty.gateBound;\n    }\n    const takeState = this.#storage.get(takeStateKey);\n    if (!takeState || takeState.size < this.#limit) {\n      return undefined;\n    }\n    return takeState.bound;\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    assert(\n      !this.#partitionKey ||\n        (req.constraint !== undefined &&\n          constraintContainsPartitionKey(req.constraint, this.#partitionKey)),\n      'Partitioned take does not allow unpartitioned fetches',\n    );\n\n    const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);\n    const takeState = this.#storage.get(takeStateKey);\n    if (!takeState) {\n      if (constraintMatchesPartitionKey(req.constraint, this.#partitionKey)) {\n        yield* this.#initialFetch(req);\n      }\n      return;\n    }\n    if (takeState.bound === undefined) {\n      return;\n    }\n    let count = 0;\n    for (const inputNode of this.#input.fetch(req)) {\n      if (inputNode === 'yield') {\n        yield inputNode;\n        continue;\n      }\n      if (this.getSchema().compareRows(takeState.bound, inputNode.row) < 0) {\n        return;\n      }\n      if (\n        this.#rowHiddenFromFetch &&\n        this.getSchema().compareRows(\n          this.#rowHiddenFromFetch,\n          inputNode.row,\n        ) === 0\n      ) {\n        continue;\n      }\n      yield inputNode;\n      count++;\n      if (count >= this.#limit) {\n        return;\n      }\n    }\n  }\n\n  *#initialFetch(req: FetchRequest): Stream<Node | 'yield'> {\n    assert(req.start === undefined, 'Start should be undefined');\n    assert(!req.reverse, 'Reverse should be false');\n\n    if (this.#limit === 0) {\n      return;\n    }\n\n    assert(\n      constraintMatchesPartitionKey(req.constraint, this.#partitionKey),\n      'Constraint should match partition key',\n    );\n\n    const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);\n    assert(\n      this.#storage.get(takeStateKey) === undefined,\n      'Take state should be undefined',\n    );\n\n    let size = 0;\n    let bound: Row | undefined;\n    let downstreamEarlyReturn = true;\n    let exceptionThrown = false;\n    try {\n      for (const inputNode of this.#input.fetch(req)) {\n        if (inputNode === 'yield') {\n          yield 'yield';\n          continue;\n        }\n        yield inputNode;\n        bound = inputNode.row;\n        size++;\n        if (size === this.#limit) {\n          break;\n        }\n      }\n      downstreamEarlyReturn = false;\n    } catch (e) {\n      exceptionThrown = true;\n      throw e;\n    } finally {\n      if (!exceptionThrown) {\n        this.#setTakeState(takeStateKey, size, bound);\n        // If it becomes necessary to support downstream early return, this\n        // assert should be removed, and replaced with code that consumes\n        // the input stream until limit is reached or the input stream is\n        // exhausted so that takeState is properly hydrated.\n        assert(\n          !downstreamEarlyReturn,\n          'Unexpected early return prevented full hydration',\n        );\n      }\n    }\n  }\n\n  #getStateAndConstraint(row: Row) {\n    const takeStateKey = getTakeStateKey(this.#partitionKey, row);\n    const takeState = this.#storage.get(takeStateKey);\n    let constraint: Constraint | undefined;\n    if (takeState) {\n      constraint =\n        this.#partitionKey &&\n        Object.fromEntries(\n          this.#partitionKey.map(key => [key, row[key]] as const),\n        );\n    }\n\n    return {takeState, takeStateKey, constraint} as\n      | {\n          takeState: undefined;\n          takeStateKey: string;\n          constraint: undefined;\n        }\n      | {\n          takeState: TakeState;\n          takeStateKey: string;\n          constraint: Constraint | undefined;\n        };\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    if (change[ChangeIndex.TYPE] === ChangeType.EDIT) {\n      yield* this.#pushEditChange(change);\n      return;\n    }\n\n    const {takeState, takeStateKey, constraint} = this.#getStateAndConstraint(\n      change[ChangeIndex.NODE].row,\n    );\n    if (!takeState) {\n      return;\n    }\n\n    const {compareRows} = this.getSchema();\n\n    if (change[ChangeIndex.TYPE] === ChangeType.ADD) {\n      if (takeState.size < this.#limit) {\n        if (this.#dirtyPartitions.has(takeStateKey)) {\n          // While dirty with an unresolved deficit in Phase 1, only admit rows that\n          // sort strictly before the current window boundary. We refuse to expand the\n          // bound forward during Phase 1 so that Phase 2 can backfill earlier candidate\n          // rows from storage in sort order.\n          if (\n            takeState.bound === undefined ||\n            compareRows(change[ChangeIndex.NODE].row, takeState.bound) >= 0\n          ) {\n            return;\n          }\n        }\n        const nextSize = takeState.size + 1;\n        if (nextSize === this.#limit) {\n          this.#dirtyPartitions.delete(takeStateKey);\n        }\n        this.#setTakeState(\n          takeStateKey,\n          nextSize,\n          takeState.bound === undefined ||\n            compareRows(takeState.bound, change[ChangeIndex.NODE].row) < 0\n            ? change[ChangeIndex.NODE].row\n            : takeState.bound,\n        );\n        yield* this.#output.push(change, this);\n        return;\n      }\n      // size === limit\n      if (\n        takeState.bound === undefined ||\n        compareRows(change[ChangeIndex.NODE].row, takeState.bound) >= 0\n      ) {\n        return;\n      }\n      // added row < bound\n      let beforeBoundNode: Node | undefined;\n      let boundNode: Node | undefined;\n      if (this.#limit === 1) {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'at',\n          },\n          constraint,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          boundNode = node;\n          break;\n        }\n      } else {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'at',\n          },\n          constraint,\n          reverse: true,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          } else if (boundNode === undefined) {\n            boundNode = node;\n          } else {\n            beforeBoundNode = node;\n            break;\n          }\n        }\n      }\n      assert(\n        boundNode !== undefined,\n        'Take: boundNode must be found during fetch',\n      );\n      const removeChange = makeRemoveChange(boundNode);\n      // Remove before add to maintain invariant that\n      // output size <= limit.\n      this.#setTakeState(\n        takeStateKey,\n        takeState.size,\n        beforeBoundNode === undefined ||\n          compareRows(change[ChangeIndex.NODE].row, beforeBoundNode.row) > 0\n          ? change[ChangeIndex.NODE].row\n          : beforeBoundNode.row,\n      );\n      yield* this.#pushWithRowHiddenFromFetch(\n        change[ChangeIndex.NODE].row,\n        removeChange,\n      );\n      yield* this.#output.push(change, this);\n    } else if (change[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n      if (takeState.bound === undefined) {\n        // change is after bound\n        return;\n      }\n      const compToBound = compareRows(\n        change[ChangeIndex.NODE].row,\n        takeState.bound,\n      );\n      if (compToBound > 0 || (compToBound < 0 && this.#limit === 1)) {\n        // change is not in window\n        return;\n      }\n      let beforeBoundNode: Node | undefined;\n      for (const node of this.#input.fetch({\n        start: {\n          row: takeState.bound,\n          basis: 'after',\n        },\n        constraint,\n        reverse: true,\n      })) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        }\n        beforeBoundNode = node;\n        break;\n      }\n\n      const finalBound =\n        takeState.size - 1 === 0\n          ? undefined\n          : compToBound < 0\n            ? takeState.bound\n            : beforeBoundNode?.row;\n      if (!this.#dirtyPartitions.has(takeStateKey)) {\n        // Snapshot the pre-removal bound as the gate bound on the first removal that\n        // dirties this partition. Subsequent getBound() calls throughout Phase 1 will return\n        // this bound to keep upstream TakeGate bounded until Phase 2 refills deficits.\n        this.#dirtyPartitions.set(takeStateKey, {\n          constraint,\n          gateBound: takeState.bound,\n        });\n      }\n      this.#setTakeState(takeStateKey, takeState.size - 1, finalBound);\n      yield* this.#output.push(change, this);\n    } else if (change[ChangeIndex.TYPE] === ChangeType.CHILD) {\n      // A 'child' change should be pushed to output if its row\n      // is <= bound.\n      if (\n        takeState.bound &&\n        compareRows(change[ChangeIndex.NODE].row, takeState.bound) <= 0\n      ) {\n        yield* this.#output.push(change, this);\n      }\n    }\n  }\n\n  *#pushEditChange(change: EditChange): Stream<'yield'> {\n    assert(\n      !this.#partitionKeyComparator ||\n        this.#partitionKeyComparator(\n          change[ChangeIndex.OLD_NODE].row,\n          change[ChangeIndex.NODE].row,\n        ) === 0,\n      'Unexpected change of partition key',\n    );\n\n    const {takeState, takeStateKey, constraint} = this.#getStateAndConstraint(\n      change[ChangeIndex.OLD_NODE].row,\n    );\n    if (!takeState) {\n      return;\n    }\n\n    assert(takeState.bound, 'Bound should be set');\n    const {compareRows} = this.getSchema();\n    const oldCmp = compareRows(\n      change[ChangeIndex.OLD_NODE].row,\n      takeState.bound,\n    );\n    const newCmp = compareRows(change[ChangeIndex.NODE].row, takeState.bound);\n\n    const replaceBoundAndForwardChange = () => {\n      this.#setTakeState(\n        takeStateKey,\n        takeState.size,\n        change[ChangeIndex.NODE].row,\n      );\n      return this.#output.push(change, this);\n    };\n\n    // The bounds row was changed.\n    if (oldCmp === 0) {\n      // The new row is the new bound.\n      if (newCmp === 0) {\n        // no need to update the state since we are keeping the bounds\n        yield* this.#output.push(change, this);\n        return;\n      }\n\n      if (newCmp < 0) {\n        if (this.#limit === 1) {\n          yield* replaceBoundAndForwardChange();\n          return;\n        }\n\n        // New row will be in the result but it might not be the bounds any\n        // more. We need to find the row before the bounds to determine the new\n        // bounds.\n\n        let beforeBoundNode: Node | undefined;\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'after',\n          },\n          constraint,\n          reverse: true,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          beforeBoundNode = node;\n          break;\n        }\n        assert(\n          beforeBoundNode !== undefined,\n          'Take: beforeBoundNode must be found during fetch',\n        );\n\n        this.#setTakeState(takeStateKey, takeState.size, beforeBoundNode.row);\n        yield* this.#output.push(change, this);\n        return;\n      }\n\n      assert(newCmp > 0, 'New comparison must be greater than 0');\n      // Find the first item at the old bounds. This will be the new bounds.\n      let newBoundNode: Node | undefined;\n      this.#takeGate?.open();\n      try {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'at',\n          },\n          constraint,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          newBoundNode = node;\n          break;\n        }\n      } finally {\n        this.#takeGate?.close();\n      }\n      assert(\n        newBoundNode !== undefined,\n        'Take: newBoundNode must be found during fetch',\n      );\n\n      // The next row is the new row. We can replace the bounds and keep the\n      // edit change.\n      if (compareRows(newBoundNode.row, change[ChangeIndex.NODE].row) === 0) {\n        yield* replaceBoundAndForwardChange();\n        return;\n      }\n\n      // The new row is now outside the bounds, so we need to remove the old\n      // row and add the new bounds row.\n      this.#setTakeState(takeStateKey, takeState.size, newBoundNode.row);\n      yield* this.#pushWithRowHiddenFromFetch(\n        newBoundNode.row,\n        makeRemoveChange(change[ChangeIndex.OLD_NODE]),\n      );\n      yield* this.#output.push(makeAddChange(newBoundNode), this);\n      return;\n    }\n\n    if (oldCmp > 0) {\n      assert(newCmp !== 0, 'Invalid state. Row has duplicate primary key');\n\n      // Both old and new outside of bounds\n      if (newCmp > 0) {\n        return;\n      }\n\n      // old was outside, new is inside. Pushing out the old bounds\n      assert(newCmp < 0, 'New comparison must be less than 0');\n\n      let oldBoundNode: Node | undefined;\n      let newBoundNode: Node | undefined;\n      for (const node of this.#input.fetch({\n        start: {\n          row: takeState.bound,\n          basis: 'at',\n        },\n        constraint,\n        reverse: true,\n      })) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        } else if (oldBoundNode === undefined) {\n          oldBoundNode = node;\n        } else {\n          newBoundNode = node;\n          break;\n        }\n      }\n      assert(\n        oldBoundNode !== undefined,\n        'Take: oldBoundNode must be found during fetch',\n      );\n      assert(\n        newBoundNode !== undefined,\n        'Take: newBoundNode must be found during fetch',\n      );\n\n      // Remove before add to maintain invariant that\n      // output size <= limit.\n      this.#setTakeState(takeStateKey, takeState.size, newBoundNode.row);\n      yield* this.#pushWithRowHiddenFromFetch(\n        change[ChangeIndex.NODE].row,\n        makeRemoveChange(oldBoundNode),\n      );\n      yield* this.#output.push(makeAddChange(change[ChangeIndex.NODE]), this);\n\n      return;\n    }\n\n    if (oldCmp < 0) {\n      assert(newCmp !== 0, 'Invalid state. Row has duplicate primary key');\n\n      // Both old and new inside of bounds\n      if (newCmp < 0) {\n        yield* this.#output.push(change, this);\n        return;\n      }\n\n      // old was inside, new is larger than old bound\n\n      assert(newCmp > 0, 'New comparison must be greater than 0');\n\n      // at this point we need to find the row after the bound and use that or\n      // the newRow as the new bound.\n      let afterBoundNode: Node | undefined;\n      this.#takeGate?.open();\n      try {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'after',\n          },\n          constraint,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          afterBoundNode = node;\n          break;\n        }\n      } finally {\n        this.#takeGate?.close();\n      }\n      assert(\n        afterBoundNode !== undefined,\n        'Take: afterBoundNode must be found during fetch',\n      );\n\n      // The new row is the new bound. Use an edit change.\n      if (compareRows(afterBoundNode.row, change[ChangeIndex.NODE].row) === 0) {\n        yield* replaceBoundAndForwardChange();\n        return;\n      }\n\n      yield* this.#output.push(\n        makeRemoveChange(change[ChangeIndex.OLD_NODE]),\n        this,\n      );\n      this.#setTakeState(takeStateKey, takeState.size, afterBoundNode.row);\n      yield* this.#output.push(makeAddChange(afterBoundNode), this);\n      return;\n    }\n\n    unreachable();\n  }\n\n  *#pushWithRowHiddenFromFetch(row: Row, change: Change) {\n    this.#rowHiddenFromFetch = row;\n    try {\n      yield* this.#output.push(change, this);\n    } finally {\n      this.#rowHiddenFromFetch = undefined;\n    }\n  }\n\n  #setTakeState(takeStateKey: string, size: number, bound: Row | undefined) {\n    this.#storage.set(takeStateKey, {\n      size,\n      bound,\n    });\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n    this.#storage.destroy();\n  }\n\n  *reconcile(_pusher?: InputBase): Stream<'yield'> {\n    if (this.#dirtyPartitions.size > 0) {\n      const dirty = [...this.#dirtyPartitions.entries()];\n      this.#dirtyPartitions.clear();\n\n      for (const [takeStateKey, {constraint}] of dirty) {\n        const takeState = this.#storage.get(takeStateKey);\n        assert(\n          takeState !== undefined,\n          'Take: dirty partition must exist in storage',\n        );\n        const deficit = this.#limit - takeState.size;\n        assert(deficit > 0, 'Take: dirty partition must have a deficit');\n\n        const toPush: Node[] = [];\n        this.#takeGate?.open();\n        try {\n          const stream = this.#input.fetch({\n            start: takeState.bound\n              ? {\n                  row: takeState.bound,\n                  basis: 'after',\n                }\n              : undefined,\n            constraint,\n          });\n\n          for (const node of stream) {\n            if (node === 'yield') {\n              yield 'yield';\n              continue;\n            }\n            toPush.push(node);\n            if (toPush.length === deficit) {\n              break;\n            }\n          }\n        } finally {\n          this.#takeGate?.close();\n        }\n\n        let currentSize = takeState.size;\n        for (const node of toPush) {\n          currentSize++;\n          this.#setTakeState(takeStateKey, currentSize, node.row);\n          yield* this.#output.push(makeAddChange(node), this);\n        }\n      }\n    }\n\n    if (this.#output.reconcile) {\n      yield* this.#output.reconcile(this);\n    }\n  }\n}\n\nfunction getTakeStateKey(\n  partitionKey: PartitionKey | undefined,\n  rowOrConstraint: Row | Constraint | undefined,\n): string {\n  // The order must be consistent. We always use the order as defined by the\n  // partition key.\n  const partitionValues: Value[] = [];\n\n  if (partitionKey && rowOrConstraint) {\n    for (const key of partitionKey) {\n      partitionValues.push(rowOrConstraint[key]);\n    }\n  }\n\n  return JSON.stringify(['take', ...partitionValues]);\n}\n\nexport function constraintMatchesPartitionKey(\n  constraint: Constraint | undefined,\n  partitionKey: PartitionKey | undefined,\n): boolean {\n  if (constraint === undefined || partitionKey === undefined) {\n    return constraint === partitionKey;\n  }\n  if (partitionKey.length !== Object.keys(constraint).length) {\n    return false;\n  }\n  for (const key of partitionKey) {\n    if (!hasOwn(constraint, key)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function constraintContainsPartitionKey(\n  constraint: Constraint | undefined,\n  partitionKey: PartitionKey | undefined,\n): boolean {\n  if (constraint === undefined || partitionKey === undefined) {\n    return false;\n  }\n  for (const key of partitionKey) {\n    if (!hasOwn(constraint, key)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function makePartitionKeyComparator(\n  partitionKey: PartitionKey,\n): Comparator {\n  return (a, b) => {\n    for (const key of partitionKey) {\n      const cmp = compareValues(a[key], b[key]);\n      if (cmp !== 0) {\n        return cmp;\n      }\n    }\n    return 0;\n  };\n}\n"],"mappings":"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"}

package/out/zql/src/ivm/union-fan-in.d.ts

@@ -14,7 +14,10 @@ export declare class UnionFanIn implements Operator {
     push(change: Change, pusher: InputBase): Stream<'yield'>;
     fanOutStartedPushing(): void;
     fanOutDonePushing(fanOutChangeType: ChangeType): Stream<'yield'>;
+    fanOutStartedReconciling(): void;
+    fanOutDoneReconciling(): Stream<'yield'>;
     setOutput(output: Output): void;
+    reconcile(_pusher: InputBase): Stream<'yield'>;
 }
 export declare function mergeFetches(fetches: Iterable<Node | 'yield'>[], comparator: (l: Node, r: Node) => number): IterableIterator<Node | 'yield'>;
 //# sourceMappingURL=union-fan-in.d.ts.map

package/out/zql/src/ivm/union-fan-in.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"union-fan-in.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/union-fan-in.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAC5C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AACpC,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,MAAM,EACZ,MAAM,eAAe,CAAC;AAMvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAEpD,qBAAa,UAAW,YAAW,QAAQ;;IAOzC,YAAY,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,EA+D/C;IAED,OAAO,IAAI,IAAI,CAId;IAED,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAO/C;IAED,SAAS,IAAI,YAAY,CAExB;IAEA,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,CAMxD;IAgFD,oBAAoB,SAMnB;IAEA,iBAAiB,CAAC,gBAAgB,EAAE,UAAU,GAAG,MAAM,CAAC,OAAO,CAAC,CAwBhE;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9B;CACF;AAED,wBAAiB,YAAY,CAC3B,OAAO,EAAE,QAAQ,CAAC,IAAI,GAAG,OAAO,CAAC,EAAE,EACnC,UAAU,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,KAAK,MAAM,GACvC,gBAAgB,CAAC,IAAI,GAAG,OAAO,CAAC,CAuElC"}
+{"version":3,"file":"union-fan-in.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/union-fan-in.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAC5C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AACpC,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,MAAM,EACZ,MAAM,eAAe,CAAC;AAQvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAEpD,qBAAa,UAAW,YAAW,QAAQ;;IASzC,YAAY,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,EAgE/C;IAED,OAAO,IAAI,IAAI,CAId;IAED,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAY/C;IAED,SAAS,IAAI,YAAY,CAExB;IAED,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,CAMvD;IAwFD,oBAAoB,SAMnB;IAED,iBAAiB,CAAC,gBAAgB,EAAE,UAAU,GAAG,MAAM,CAAC,OAAO,CAAC,CAyB/D;IAED,wBAAwB,SAMvB;IAEA,qBAAqB,IAAI,MAAM,CAAC,OAAO,CAAC,CAYxC;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9B;IAEA,SAAS,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,CAO9C;CACF;AAWD,wBAAiB,YAAY,CAC3B,OAAO,EAAE,QAAQ,CAAC,IAAI,GAAG,OAAO,CAAC,EAAE,EACnC,UAAU,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,KAAK,MAAM,GACvC,gBAAgB,CAAC,IAAI,GAAG,OAAO,CAAC,CA0FlC"}