@rocicorp/zero 1.11.0-canary.2 → 1.11.0-canary.20

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

@@ -0,0 +1,106 @@
+import { assert } from "../../../shared/src/asserts.js";
+import { throwOutput } from "./operator.js";
+import { constraintMatchesRow } from "./constraint.js";
+//#region ../zql/src/ivm/take-gate.ts
+/**
+* Reads the bounds for the parent fetches of a child push before the join
+* starts them. TakeGate reads its bound once, when a fetch starts, so the set
+* of parents that get the push stays fixed even when Take moves its bound
+* during the push. Split-push overlays must use these bounds, not the bound
+* Take reports later in the push.
+*/
+function readParentFetchBounds(boundProvider, constraints) {
+	return constraints.map((constraint) => ({
+		constraint,
+		bound: boundProvider.getBound(constraint)
+	}));
+}
+/**
+* Returns true if one of the parent fetches of the push yields `row`: `row`
+* matches the fetch's constraint and is not after the fetch's bound.
+*/
+function isInParentFetch(bounds, row, compareRows) {
+	for (const { constraint, bound } of bounds) if (constraintMatchesRow(constraint, row)) return bound === void 0 || compareRows(row, bound) <= 0;
+	return false;
+}
+/**
+* TakeGate bounds upstream parent fetches using the active bound from a
+* downstream Take operator.
+*
+* When a child table changes, joins fetch matching parent rows. Without
+* TakeGate, this fetch scans all matching parent rows (which may be thousands)
+* even if downstream Take only needs a few. TakeGate intercepts this fetch and
+* stops the upstream stream once rows exceed Take's bound.
+*/
+var TakeGate = class {
+	#input;
+	#comparator;
+	#boundProvider;
+	#output = throwOutput;
+	#openDepth = 0;
+	constructor(input) {
+		const { sort, compareRows } = input.getSchema();
+		assert(sort !== void 0, "TakeGate requires sorted input");
+		this.#input = input;
+		this.#comparator = compareRows;
+		input.setOutput(this);
+	}
+	open() {
+		this.#openDepth++;
+	}
+	close() {
+		assert(this.#openDepth > 0, "TakeGate.close called without matching open");
+		this.#openDepth--;
+	}
+	isOpen() {
+		return this.#openDepth > 0;
+	}
+	setBoundProvider(provider) {
+		this.#boundProvider = provider;
+	}
+	getBoundProvider() {
+		return this.#boundProvider;
+	}
+	getBound(constraint) {
+		if (this.#openDepth > 0) return;
+		return this.#boundProvider?.getBound(constraint);
+	}
+	getSchema() {
+		return this.#input.getSchema();
+	}
+	setOutput(output) {
+		this.#output = output;
+	}
+	destroy() {
+		this.#input.destroy();
+	}
+	*push(change, _pusher) {
+		yield* this.#output.push(change, this);
+	}
+	*reconcile(_pusher) {
+		if (this.#output.reconcile) yield* this.#output.reconcile(this);
+	}
+	*fetch(req) {
+		if (this.#openDepth > 0 || req.reverse) {
+			yield* this.#input.fetch(req);
+			return;
+		}
+		const bound = this.#boundProvider?.getBound(req.constraint);
+		if (!bound) {
+			yield* this.#input.fetch(req);
+			return;
+		}
+		for (const node of this.#input.fetch(req)) {
+			if (node === "yield") {
+				yield "yield";
+				continue;
+			}
+			if (this.#comparator(node.row, bound) > 0) return;
+			yield node;
+		}
+	}
+};
+//#endregion
+export { TakeGate, isInParentFetch, readParentFetchBounds };
+
+//# sourceMappingURL=take-gate.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"take-gate.js","names":["#input","#comparator","#openDepth","#boundProvider","#output"],"sources":["../../../../../zql/src/ivm/take-gate.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport type {Change} from './change.ts';\nimport {constraintMatchesRow, type Constraint} from './constraint.ts';\nimport type {Comparator, Node} from './data.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type InputBase,\n  type Operator,\n  type Output,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Stream} from './stream.ts';\n\nexport interface TakeBoundProvider {\n  getBound(constraint?: Constraint): Row | undefined;\n}\n\n/**\n * The bound that a TakeGate caps one parent fetch of a join's child push at.\n * `undefined` means the fetch is not capped.\n */\nexport type ParentFetchBound = {\n  readonly constraint: Constraint;\n  readonly bound: Row | undefined;\n};\n\n/**\n * Reads the bounds for the parent fetches of a child push before the join\n * starts them. TakeGate reads its bound once, when a fetch starts, so the set\n * of parents that get the push stays fixed even when Take moves its bound\n * during the push. Split-push overlays must use these bounds, not the bound\n * Take reports later in the push.\n */\nexport function readParentFetchBounds(\n  boundProvider: TakeBoundProvider,\n  constraints: readonly Constraint[],\n): ParentFetchBound[] {\n  return constraints.map(constraint => ({\n    constraint,\n    bound: boundProvider.getBound(constraint),\n  }));\n}\n\n/**\n * Returns true if one of the parent fetches of the push yields `row`: `row`\n * matches the fetch's constraint and is not after the fetch's bound.\n */\nexport function isInParentFetch(\n  bounds: readonly ParentFetchBound[],\n  row: Row,\n  compareRows: Comparator,\n): boolean {\n  for (const {constraint, bound} of bounds) {\n    if (constraintMatchesRow(constraint, row)) {\n      return bound === undefined || compareRows(row, bound) <= 0;\n    }\n  }\n  return false;\n}\n\n/**\n * TakeGate bounds upstream parent fetches using the active bound from a\n * downstream Take operator.\n *\n * When a child table changes, joins fetch matching parent rows. Without\n * TakeGate, this fetch scans all matching parent rows (which may be thousands)\n * even if downstream Take only needs a few. TakeGate intercepts this fetch and\n * stops the upstream stream once rows exceed Take's bound.\n */\nexport class TakeGate implements Operator, TakeBoundProvider {\n  readonly #input: Input;\n  readonly #comparator: Comparator;\n  #boundProvider: TakeBoundProvider | undefined;\n  #output: Output = throwOutput;\n  #openDepth = 0;\n\n  constructor(input: Input) {\n    const {sort, compareRows} = input.getSchema();\n    assert(sort !== undefined, 'TakeGate requires sorted input');\n    this.#input = input;\n    this.#comparator = compareRows;\n    input.setOutput(this);\n  }\n\n  open(): void {\n    this.#openDepth++;\n  }\n\n  close(): void {\n    assert(this.#openDepth > 0, 'TakeGate.close called without matching open');\n    this.#openDepth--;\n  }\n\n  isOpen(): boolean {\n    return this.#openDepth > 0;\n  }\n\n  setBoundProvider(provider: TakeBoundProvider): void {\n    this.#boundProvider = provider;\n  }\n\n  getBoundProvider(): TakeBoundProvider | undefined {\n    return this.#boundProvider;\n  }\n\n  getBound(constraint?: Constraint): Row | undefined {\n    if (this.#openDepth > 0) {\n      return undefined;\n    }\n    return this.#boundProvider?.getBound(constraint);\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n\n  *push(change: Change, _pusher: InputBase): Stream<'yield'> {\n    yield* this.#output.push(change, this);\n  }\n\n  *reconcile(_pusher: InputBase): Stream<'yield'> {\n    if (this.#output.reconcile) {\n      yield* this.#output.reconcile(this);\n    }\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    if (this.#openDepth > 0 || req.reverse) {\n      yield* this.#input.fetch(req);\n      return;\n    }\n\n    const bound = this.#boundProvider?.getBound(req.constraint);\n    if (!bound) {\n      yield* this.#input.fetch(req);\n      return;\n    }\n\n    for (const node of this.#input.fetch(req)) {\n      if (node === 'yield') {\n        yield 'yield';\n        continue;\n      }\n      if (this.#comparator(node.row, bound) > 0) {\n        return;\n      }\n      yield node;\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;AAoCA,SAAgB,sBACd,eACA,aACoB;CACpB,OAAO,YAAY,KAAI,gBAAe;EACpC;EACA,OAAO,cAAc,SAAS,UAAU;CAC1C,EAAE;AACJ;;;;;AAMA,SAAgB,gBACd,QACA,KACA,aACS;CACT,KAAK,MAAM,EAAC,YAAY,WAAU,QAChC,IAAI,qBAAqB,YAAY,GAAG,GACtC,OAAO,UAAU,KAAA,KAAa,YAAY,KAAK,KAAK,KAAK;CAG7D,OAAO;AACT;;;;;;;;;;AAWA,IAAa,WAAb,MAA6D;CAC3D;CACA;CACA;CACA,UAAkB;CAClB,aAAa;CAEb,YAAY,OAAc;EACxB,MAAM,EAAC,MAAM,gBAAe,MAAM,UAAU;EAC5C,OAAO,SAAS,KAAA,GAAW,gCAAgC;EAC3D,KAAKA,SAAS;EACd,KAAKC,cAAc;EACnB,MAAM,UAAU,IAAI;CACtB;CAEA,OAAa;EACX,KAAKC;CACP;CAEA,QAAc;EACZ,OAAO,KAAKA,aAAa,GAAG,6CAA6C;EACzE,KAAKA;CACP;CAEA,SAAkB;EAChB,OAAO,KAAKA,aAAa;CAC3B;CAEA,iBAAiB,UAAmC;EAClD,KAAKC,iBAAiB;CACxB;CAEA,mBAAkD;EAChD,OAAO,KAAKA;CACd;CAEA,SAAS,YAA0C;EACjD,IAAI,KAAKD,aAAa,GACpB;EAEF,OAAO,KAAKC,gBAAgB,SAAS,UAAU;CACjD;CAEA,YAA0B;EACxB,OAAO,KAAKH,OAAO,UAAU;CAC/B;CAEA,UAAU,QAAsB;EAC9B,KAAKI,UAAU;CACjB;CAEA,UAAgB;EACd,KAAKJ,OAAO,QAAQ;CACtB;CAEA,CAAC,KAAK,QAAgB,SAAqC;EACzD,OAAO,KAAKI,QAAQ,KAAK,QAAQ,IAAI;CACvC;CAEA,CAAC,UAAU,SAAqC;EAC9C,IAAI,KAAKA,QAAQ,WACf,OAAO,KAAKA,QAAQ,UAAU,IAAI;CAEtC;CAEA,CAAC,MAAM,KAA2C;EAChD,IAAI,KAAKF,aAAa,KAAK,IAAI,SAAS;GACtC,OAAO,KAAKF,OAAO,MAAM,GAAG;GAC5B;EACF;EAEA,MAAM,QAAQ,KAAKG,gBAAgB,SAAS,IAAI,UAAU;EAC1D,IAAI,CAAC,OAAO;GACV,OAAO,KAAKH,OAAO,MAAM,GAAG;GAC5B;EACF;EAEA,KAAK,MAAM,QAAQ,KAAKA,OAAO,MAAM,GAAG,GAAG;GACzC,IAAI,SAAS,SAAS;IACpB,MAAM;IACN;GACF;GACA,IAAI,KAAKC,YAAY,KAAK,KAAK,KAAK,IAAI,GACtC;GAEF,MAAM;EACR;CACF;AACF"}

package/out/zql/src/ivm/take.d.ts

@@ -1,10 +1,12 @@
+import type { Row } from '../../../zero-protocol/src/data.ts';
 import type { PrimaryKey } from '../../../zero-protocol/src/primary-key.ts';
 import { type Change } from './change.ts';
 import type { Constraint } from './constraint.ts';
 import { type Comparator, type Node } from './data.ts';
-import { type FetchRequest, type Input, type Operator, type Output, type Storage } from './operator.ts';
+import { type FetchRequest, type Input, type InputBase, type Operator, type Output, type Storage } from './operator.ts';
 import type { SourceSchema } from './schema.ts';
 import { type Stream } from './stream.ts';
+import type { TakeBoundProvider, TakeGate } from './take-gate.ts';
 export type PartitionKey = PrimaryKey;
 /**
  * The Take operator is for implementing limit queries. It takes the first n
@@ -17,15 +19,19 @@ export type PartitionKey = PrimaryKey;
  * Maintains the invariant that its output size is always <= limit, even
  * mid processing of a push.
  */
-export declare class Take implements Operator {
+export declare class Take implements Operator, TakeBoundProvider {
     #private;
+    setTakeGate(gate: TakeGate): void;
     constructor(input: Input, storage: Storage, limit: number, partitionKey?: PartitionKey);
     setOutput(output: Output): void;
     getSchema(): SourceSchema;
+    getBound(constraint?: Constraint): Row | undefined;
     fetch(req: FetchRequest): Stream<Node | 'yield'>;
     push(change: Change): Stream<'yield'>;
     destroy(): void;
+    reconcile(_pusher?: InputBase): Stream<'yield'>;
 }
 export declare function constraintMatchesPartitionKey(constraint: Constraint | undefined, partitionKey: PartitionKey | undefined): boolean;
+export declare function constraintContainsPartitionKey(constraint: Constraint | undefined, partitionKey: PartitionKey | undefined): boolean;
 export declare function makePartitionKeyComparator(partitionKey: PartitionKey): Comparator;
 //# sourceMappingURL=take.d.ts.map

package/out/zql/src/ivm/take.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"take.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/take.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,2CAA2C,CAAC;AAI1E,OAAO,EAGL,KAAK,MAAM,EAEZ,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAgB,KAAK,UAAU,EAAE,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AACpE,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,QAAQ,EACb,KAAK,MAAM,EACX,KAAK,OAAO,EACb,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AAiBxC,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC;AAEtC;;;;;;;;;;GAUG;AACH,qBAAa,IAAK,YAAW,QAAQ;;IAWnC,YACE,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,EACb,YAAY,CAAC,EAAE,YAAY,EAa5B;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9B;IAED,SAAS,IAAI,YAAY,CAExB;IAEA,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CA+DhD;IA2FA,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAuLrC;IAmRD,OAAO,IAAI,IAAI,CAEd;CACF;AAmBD,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,YAAY,EAAE,YAAY,GAAG,SAAS,GACrC,OAAO,CAaT;AAED,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,YAAY,GACzB,UAAU,CAUZ"}
+{"version":3,"file":"take.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/take.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,GAAG,EAAQ,MAAM,oCAAoC,CAAC;AACnE,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,2CAA2C,CAAC;AAI1E,OAAO,EAGL,KAAK,MAAM,EAEZ,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAgB,KAAK,UAAU,EAAE,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AACpE,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,MAAM,EACX,KAAK,OAAO,EACb,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAC,iBAAiB,EAAE,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AAchE,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC;AAgBtC;;;;;;;;;;GAUG;AACH,qBAAa,IAAK,YAAW,QAAQ,EAAE,iBAAiB;;IAoBtD,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAEhC;IAED,YACE,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,EACb,YAAY,CAAC,EAAE,YAAY,EAa5B;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9B;IAED,SAAS,IAAI,YAAY,CAExB;IAED,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,GAAG,GAAG,GAAG,SAAS,CAmBjD;IAEA,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CA2ChD;IAkFA,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAsKrC;IA4PD,OAAO,IAAI,IAAI,CAGd;IAEA,SAAS,CAAC,OAAO,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,CAqD/C;CACF;AAmBD,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,YAAY,EAAE,YAAY,GAAG,SAAS,GACrC,OAAO,CAaT;AAED,wBAAgB,8BAA8B,CAC5C,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,YAAY,EAAE,YAAY,GAAG,SAAS,GACrC,OAAO,CAUT;AAED,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,YAAY,GACzB,UAAU,CAUZ"}

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) {