@rocicorp/zero 1.10.0-canary.21 → 1.10.0-canary.23

package/out/zql/src/query/query-impl.js

@@ -1,18 +1,63 @@
 import { assert } from "../../../shared/src/asserts.js";
-import { SUBQ_PREFIX } from "../../../zero-protocol/src/ast.js";
+import { deepEqual } from "../../../shared/src/json.js";
+import { SUBQ_PREFIX, insertRelated, normalizeAST, normalizeCondition, normalizedRelated, tableAST } from "../../../zero-protocol/src/ast.js";
 import { defaultFormat } from "../../../zero-types/src/format.js";
-import { hashOfAST } from "../../../zero-protocol/src/query-hash.js";
+import { hashOfQueryInternals } from "../../../zero-protocol/src/query-hash-visitor.js";
 import { NotImplementedError } from "../error.js";
 import { ExpressionBuilder, and, cmp, simplifyCondition } from "./expression.js";
 import { queryInternalsTag } from "./query-internals.js";
+import { HashIndex, Transitions } from "./query-transitions.js";
 //#region ../zql/src/query/query-impl.ts
 function newQuery(schema, table) {
-	return newQueryImpl(schema, table, { table }, defaultFormat, "client");
+	return newQueryInternal(schema, table, tableAST(table), defaultFormat, "client");
 }
 function newQueryImpl(schema, tableName, ast, format, system) {
+	return newQueryInternal(schema, tableName, normalizeAST(ast), format, system);
+}
+/**
+* Root queries are interned per schema so that two `createBuilder(schema)` calls
+* hand out the same starting point, and therefore share the whole transition
+* tree below it. Only cleared entries accumulate here, at most one per
+* system/table pair, so no sweeping is needed.
+*/
+var rootsBySchema = /* @__PURE__ */ new WeakMap();
+/**
+* Whether this is the AST `tableAST(tableName)` produces -- the whole table,
+* nothing else. A normalized AST carries every field, so this cannot be a key
+* count; each one has to be checked.
+*/
+function isRootAST(ast, tableName) {
+	return ast.table === tableName && ast.schema === void 0 && ast.alias === void 0 && ast.where === void 0 && ast.related === void 0 && ast.start === void 0 && ast.limit === void 0 && ast.orderBy === void 0;
+}
+function newQueryInternal(schema, tableName, ast, format, system) {
+	const interned = format === defaultFormat && isRootAST(ast, tableName);
+	const key = `${system}:${tableName}`;
+	let roots;
+	if (interned) {
+		roots = rootsBySchema.get(schema);
+		const existing = roots?.get(key)?.deref();
+		if (existing) return existing;
+	}
 	const inner = (tableName, ast, format, customQueryID, currentJunction) => new QueryImpl(schema, tableName, ast, format, system, customQueryID, currentJunction, inner);
-	return inner(tableName, ast, format, void 0, void 0);
+	const created = inner(tableName, ast, format, void 0, void 0);
+	if (interned) {
+		if (!roots) {
+			roots = /* @__PURE__ */ new Map();
+			rootsBySchema.set(schema, roots);
+		}
+		roots.set(key, new WeakRef(created));
+	}
+	return created;
 }
+/**
+* The AST of a QueryImpl is always normalized. Each step builds its AST in
+* normalized form rather than normalizing afterwards: a normalized AST has
+* every field, so spreading one and replacing a field keeps the field order
+* intact, and only the field a step actually changes needs normalizing (the
+* conditions of a `where`, the position of a new `related`). The ASTs that
+* come in from the outside are normalized by {@link newQueryImpl}, which is
+* what the `NormalizedAST` of the AST it holds stands for.
+*/
 var QueryImpl = class {
 	[queryInternalsTag] = true;
 	#schema;
@@ -24,6 +69,26 @@ var QueryImpl = class {
 	#currentJunction;
 	customQueryID;
 	#newQuery;
+	/**
+	* The query this one was derived from, held *strongly*, and the queries
+	* derived from this one, held *weakly*. This is the arrangement V8 uses for
+	* hidden-class transitions, and it is what makes interning stable: as long as
+	* a query is reachable its whole ancestor spine is too, so re-deriving it from
+	* the root yields the same instance. See `query-transitions.ts`.
+	*/
+	#parent;
+	#transitions;
+	/**
+	* The second level of interning, keyed by hash; see `HashIndex`. Set on the
+	* root only, which is what scopes it to one schema and one delegate.
+	*/
+	#byHash;
+	/**
+	* Memoized because a query is interned: the same node serves every rebuild of
+	* a chain, so building this once rather than per `where(fn)` call takes the
+	* whole thing -- the builder and the bound `#exists` -- off the repeat path.
+	*/
+	#expressionBuilder;
 	constructor(schema, tableName, ast, format, system, customQueryID, currentJunction, newQuery) {
 		this.#schema = schema;
 		this.#tableName = tableName;
@@ -34,6 +99,44 @@ var QueryImpl = class {
 		this.customQueryID = customQueryID;
 		this.#newQuery = newQuery;
 	}
+	/**
+	* Interns a transition whose key space is finite and schema-derived; see
+	* {@linkcode Transitions.storeBounded}. Used for the base sub-query handed to
+	* a `related`/`exists` callback, which is determined entirely by the
+	* relationship name.
+	*/
+	#deriveBounded(key, build) {
+		const existing = this.#transitions?.lookupBounded(key);
+		if (existing !== void 0) return existing;
+		return this.#record(key, void 0, void 0, build(), true);
+	}
+	/**
+	* Interns the result of applying a builder operation to this query.
+	*
+	* `key` names the operation and `value` carries its varying argument, kept
+	* apart so the key stays a string V8 has already hashed. When the two do not
+	* settle it, `delta` carries the rest and is compared with `deepEqual`. Only
+	* the delta is compared, never the whole AST: this query is already canonical,
+	* so two of its children are equal exactly when the operations that produced
+	* them are.
+	*
+	* `T` is deliberately unconstrained so that the contextual return type at each
+	* call site still drives `#newQuery`'s inference, exactly as it did when the
+	* call sites returned `this.#newQuery(...)` directly.
+	*/
+	#derive(key, value, delta, build) {
+		const existing = this.#transitions?.lookup(key, value, delta);
+		if (existing !== void 0) return existing;
+		return this.#record(key, value, delta, build(), false);
+	}
+	#record(key, value, delta, created, bounded) {
+		const q = created;
+		q.#parent = this;
+		const transitions = this.#transitions ??= new Transitions();
+		if (bounded) transitions.storeBounded(key, q);
+		else transitions.store(key, value, delta, q);
+		return created;
+	}
 	run(_options) {
 		throwQueryNotRunnable();
 	}
@@ -44,150 +147,204 @@ var QueryImpl = class {
 		throwQueryNotRunnable();
 	}
 	nameAndArgs(name, args) {
-		return this.#newQuery(this.#tableName, this.#ast, this.format, {
+		return this.#derive("nameAndArgs", name, args, () => this.#newQuery(this.#tableName, this.#ast, this.format, {
 			name,
 			args
-		}, this.#currentJunction);
+		}, this.#currentJunction));
 	}
 	hash() {
-		if (!this.#hash) this.#hash = hashOfAST(this.#ast);
+		if (!this.#hash) {
+			this.#hash = hashOfQueryInternals(this.#ast, this.format, this.#system, this.#currentJunction, this.customQueryID?.name, this.customQueryID?.args);
+			this.#canonicalize();
+		}
 		return this.#hash;
 	}
-	one = () => this.#newQuery(this.#tableName, {
-		...this.#ast,
-		limit: 1
-	}, {
-		...this.format,
-		singular: true
-	}, this.customQueryID, this.#currentJunction);
-	whereExists = (relationship, cbOrOptions, options) => {
+	/**
+	* Folds this query into its root's hash index, now that its hash is known.
+	*
+	* If an equal query is already indexed, the transition that produced this
+	* one is re-pointed at it, so the next rebuild along this path yields that
+	* instance rather than a second copy. This query itself is left alone: its
+	* identity has already been handed out. Content is verified with `#sameAs`
+	* before anything is redirected, so a hash collision costs nothing worse
+	* than a missed unification.
+	*/
+	#canonicalize() {
+		const parent = this.#parent;
+		if (parent === void 0) return;
+		let root = parent;
+		while (root.#parent !== void 0) root = root.#parent;
+		const index = root.#byHash ??= new HashIndex();
+		const existing = index.get(this.#hash);
+		if (existing === void 0) index.set(this.#hash, this);
+		else if (existing !== this && this.#sameAs(existing)) parent.#transitions?.replace(this, existing);
+	}
+	/**
+	* Whether `other` is interchangeable with this query: everything `hash()`
+	* covers, compared structurally. Schema and delegate are not compared. Both
+	* are fixed by the root, and this only ever compares queries under one root.
+	*/
+	#sameAs(other) {
+		return this.#system === other.#system && this.#currentJunction === other.#currentJunction && this.customQueryID?.name === other.customQueryID?.name && deepEqual(this.customQueryID?.args, other.customQueryID?.args) && deepEqual(this.format, other.format) && deepEqual(this.#ast, other.#ast);
+	}
+	one() {
+		return this.#derive("one", void 0, void 0, () => this.#newQuery(this.#tableName, {
+			...this.#ast,
+			limit: 1
+		}, {
+			...this.format,
+			singular: true
+		}, this.customQueryID, this.#currentJunction));
+	}
+	whereExists(relationship, cbOrOptions, options) {
 		const cb = typeof cbOrOptions === "function" ? cbOrOptions : void 0;
 		const opts = typeof cbOrOptions === "function" ? options : cbOrOptions;
 		return this.where(({ exists }) => exists(relationship, cb, opts));
-	};
-	related = (relationship, cb) => {
+	}
+	related(relationship, cb) {
 		if (relationship.startsWith("zsubq_")) throw new Error(`Relationship names may not start with "${SUBQ_PREFIX}". That is a reserved prefix.`);
 		cb = cb ?? ((q) => q);
 		const related = this.#schema.relationships[this.#tableName][relationship];
 		assert(related, "Invalid relationship");
 		if (isOneHop(related)) {
 			const { destSchema, destField, sourceField, cardinality } = related[0];
-			const q = this.#newQuery(destSchema, {
-				table: destSchema,
-				alias: relationship
-			}, {
+			const q = this.#deriveBounded(`relatedBase:${relationship}`, () => this.#newQuery(destSchema, tableAST(destSchema, relationship), {
 				relationships: {},
 				singular: cardinality === "one"
-			}, this.customQueryID, void 0);
+			}, this.customQueryID, void 0));
 			const subQuery = asQueryImpl(cb(q));
 			assert(isCompoundKey(sourceField), "The source of a relationship must specify at last 1 field");
 			assert(isCompoundKey(destField), "The destination of a relationship must specify at last 1 field");
 			assert(sourceField.length === destField.length, "The source and destination of a relationship must have the same number of fields");
-			return this.#newQuery(this.#tableName, {
+			return this.#derive(relatedKey(relationship), astID(subQuery.#ast), void 0, () => this.#newQuery(this.#tableName, {
 				...this.#ast,
-				related: [...this.#ast.related ?? [], {
-					system: this.#system,
+				related: insertRelated(this.#ast.related, {
 					correlation: {
 						parentField: sourceField,
 						childField: destField
 					},
-					subquery: subQuery.#ast
-				}]
+					subquery: subQuery.#ast,
+					system: this.#system
+				})
 			}, {
 				...this.format,
 				relationships: {
 					...this.format.relationships,
 					[relationship]: subQuery.format
 				}
-			}, this.customQueryID, this.#currentJunction);
+			}, this.customQueryID, this.#currentJunction));
 		}
 		if (isTwoHop(related)) {
 			const [firstRelation, secondRelation] = related;
 			const { destSchema } = secondRelation;
 			const junctionSchema = firstRelation.destSchema;
-			const sq = asQueryImpl(cb(this.#newQuery(destSchema, {
-				table: destSchema,
-				alias: relationship
-			}, {
+			const sq = asQueryImpl(cb(this.#deriveBounded(`relatedBase:${relationship}`, () => this.#newQuery(destSchema, tableAST(destSchema, relationship), {
 				relationships: {},
 				singular: secondRelation.cardinality === "one"
-			}, this.customQueryID, relationship)));
-			assert(isCompoundKey(firstRelation.sourceField), "Invalid relationship");
-			assert(isCompoundKey(firstRelation.destField), "Invalid relationship");
-			assert(isCompoundKey(secondRelation.sourceField), "Invalid relationship");
-			assert(isCompoundKey(secondRelation.destField), "Invalid relationship");
-			return this.#newQuery(this.#tableName, {
+			}, this.customQueryID, relationship))));
+			const { sourceField: firstSource, destField: firstDest } = firstRelation;
+			const { sourceField: secondSource, destField: secondDest } = secondRelation;
+			assert(isCompoundKey(firstSource), "Invalid relationship");
+			assert(isCompoundKey(firstDest), "Invalid relationship");
+			assert(isCompoundKey(secondSource), "Invalid relationship");
+			assert(isCompoundKey(secondDest), "Invalid relationship");
+			return this.#derive(relatedKey(relationship), astID(sq.#ast), void 0, () => this.#newQuery(this.#tableName, {
 				...this.#ast,
-				related: [...this.#ast.related ?? [], {
-					system: this.#system,
+				related: insertRelated(this.#ast.related, {
 					correlation: {
-						parentField: firstRelation.sourceField,
-						childField: firstRelation.destField
+						parentField: firstSource,
+						childField: firstDest
 					},
 					hidden: true,
 					subquery: {
-						table: junctionSchema,
-						alias: relationship,
-						related: [{
-							system: this.#system,
+						...tableAST(junctionSchema, relationship),
+						related: [normalizedRelated({
 							correlation: {
-								parentField: secondRelation.sourceField,
-								childField: secondRelation.destField
+								parentField: secondSource,
+								childField: secondDest
 							},
-							subquery: sq.#ast
-						}]
-					}
-				}]
+							subquery: sq.#ast,
+							system: this.#system
+						})]
+					},
+					system: this.#system
+				})
 			}, {
 				...this.format,
 				relationships: {
 					...this.format.relationships,
 					[relationship]: sq.format
 				}
-			}, this.customQueryID, this.#currentJunction);
+			}, this.customQueryID, this.#currentJunction));
 		}
 		throw new Error(`Invalid relationship ${relationship}`);
-	};
-	where = function(fieldOrExpressionFactory, opOrValue, value) {
+	}
+	where(fieldOrExpressionFactory, opOrValue, value) {
 		let cond;
 		if (typeof fieldOrExpressionFactory === "function") cond = fieldOrExpressionFactory(this.expressionBuilder());
 		else {
 			assert(arguments.length >= 2, "Invalid condition. Too few arguments.");
-			if (arguments.length === 2) cond = cmp(fieldOrExpressionFactory, opOrValue);
-			else cond = cmp(fieldOrExpressionFactory, opOrValue, value);
+			const twoArg = arguments.length === 2;
+			const op = twoArg ? "=" : opOrValue;
+			const raw = twoArg ? opOrValue : value;
+			if (raw === null || typeof raw !== "object") {
+				const hit = this.#transitions?.lookup(whereKey(fieldOrExpressionFactory, op), raw ?? null, void 0);
+				if (hit !== void 0) return hit;
+			}
+			cond = twoArg ? cmp(fieldOrExpressionFactory, opOrValue) : cmp(fieldOrExpressionFactory, opOrValue, value);
 		}
-		const existingWhere = this.#ast.where;
-		if (existingWhere) cond = and(existingWhere, cond);
-		const where = simplifyCondition(cond);
-		return this.#newQuery(this.#tableName, {
-			...this.#ast,
-			where
-		}, this.format, this.customQueryID, this.#currentJunction);
-	}.bind(this);
-	start = (row, opts) => this.#newQuery(this.#tableName, {
-		...this.#ast,
-		start: {
-			row,
-			exclusive: !opts?.inclusive
+		let key;
+		let tValue;
+		let delta = cond;
+		if (cond.type === "simple" && cond.left.type === "column") {
+			key = whereKey(cond.left.name, cond.op);
+			const right = cond.right;
+			tValue = right.type === "literal" && isPrimitive(right.value) ? right.value : rightTag(right);
+			delta = void 0;
+		} else {
+			const exact = condKey(cond);
+			if (exact === void 0) key = treeKey(cond);
+			else {
+				key = "where:tree";
+				tValue = exact;
+				delta = void 0;
+			}
 		}
-	}, this.format, this.customQueryID, this.#currentJunction);
-	limit = (limit) => {
+		return this.#derive(key, tValue, delta, () => {
+			const existingWhere = this.#ast.where;
+			const merged = existingWhere ? and(existingWhere, cond) : cond;
+			return this.#newQuery(this.#tableName, {
+				...this.#ast,
+				where: normalizeCondition(simplifyCondition(merged))
+			}, this.format, this.customQueryID, this.#currentJunction);
+		});
+	}
+	start(row, opts) {
+		return this.#derive(opts?.inclusive ? "start:inclusive" : "start:exclusive", valueTag(row), void 0, () => this.#newQuery(this.#tableName, {
+			...this.#ast,
+			start: {
+				row,
+				exclusive: !opts?.inclusive
+			}
+		}, this.format, this.customQueryID, this.#currentJunction));
+	}
+	limit(limit) {
 		if (limit < 0) throw new Error("Limit must be non-negative");
 		if ((limit | 0) !== limit) throw new Error("Limit must be an integer");
 		if (this.#currentJunction) throw new NotImplementedError("Limit is not supported in junction relationships yet. Junction relationship being limited: " + this.#currentJunction);
-		return this.#newQuery(this.#tableName, {
+		return this.#derive("limit", limit, void 0, () => this.#newQuery(this.#tableName, {
 			...this.#ast,
 			limit
-		}, this.format, this.customQueryID, this.#currentJunction);
-	};
-	orderBy = (field, direction) => {
+		}, this.format, this.customQueryID, this.#currentJunction));
+	}
+	orderBy(field, direction) {
 		if (this.#currentJunction) throw new NotImplementedError("Order by is not supported in junction relationships yet. Junction relationship being ordered: " + this.#currentJunction);
-		return this.#newQuery(this.#tableName, {
+		return this.#derive(direction === "asc" ? "orderBy:asc" : "orderBy:desc", field, void 0, () => this.#newQuery(this.#tableName, {
 			...this.#ast,
 			orderBy: [...this.#ast.orderBy ?? [], [field, direction]]
-		}, this.format, this.customQueryID, this.#currentJunction);
-	};
-	#exists = (relationship, cb, options) => {
+		}, this.format, this.customQueryID, this.#currentJunction));
+	}
+	#exists(relationship, cb, options) {
 		cb = cb ?? ((q) => q);
 		const flip = options?.flip;
 		const scalar = options?.scalar;
@@ -197,10 +354,8 @@ var QueryImpl = class {
 			const { destSchema: destTableName, sourceField, destField } = related[0];
 			assert(isCompoundKey(sourceField), "Invalid relationship");
 			assert(isCompoundKey(destField), "Invalid relationship");
-			const subQuery = asQueryImpl(cb(this.#newQuery(destTableName, {
-				table: destTableName,
-				alias: `${SUBQ_PREFIX}${relationship}`
-			}, defaultFormat, this.customQueryID, void 0)));
+			const subQuery = asQueryImpl(cb(this.#deriveBounded(`existsBase:${relationship}`, () => this.#newQuery(destTableName, tableAST(destTableName, `${SUBQ_PREFIX}${relationship}`), defaultFormat, this.customQueryID, void 0))));
+			astID(subQuery.#ast);
 			return {
 				type: "correlatedSubquery",
 				related: {
@@ -224,10 +379,7 @@ var QueryImpl = class {
 			assert(isCompoundKey(secondRelation.destField), "Invalid relationship");
 			const { destSchema } = secondRelation;
 			const junctionSchema = firstRelation.destSchema;
-			const queryToDest = cb(this.#newQuery(destSchema, {
-				table: destSchema,
-				alias: `${SUBQ_PREFIX}zhidden_${relationship}`
-			}, defaultFormat, this.customQueryID, relationship));
+			const queryToDest = cb(this.#deriveBounded(`existsJunctionBase:${relationship}`, () => this.#newQuery(destSchema, tableAST(destSchema, `${SUBQ_PREFIX}zhidden_${relationship}`), defaultFormat, this.customQueryID, relationship)));
 			return {
 				type: "correlatedSubquery",
 				related: {
@@ -237,9 +389,8 @@ var QueryImpl = class {
 						childField: firstRelation.destField
 					},
 					subquery: {
-						table: junctionSchema,
-						alias: `${SUBQ_PREFIX}${relationship}`,
-						where: {
+						...tableAST(junctionSchema, `${SUBQ_PREFIX}${relationship}`),
+						where: normalizeCondition({
 							type: "correlatedSubquery",
 							related: {
 								system: this.#system,
@@ -252,7 +403,7 @@ var QueryImpl = class {
 							op: "EXISTS",
 							...flip !== void 0 ? { flip } : {},
 							...scalar !== void 0 ? { scalar } : {}
-						}
+						})
 					}
 				},
 				op: "EXISTS",
@@ -260,18 +411,187 @@ var QueryImpl = class {
 			};
 		}
 		throw new Error(`Invalid relationship ${relationship}`);
-	};
+	}
 	get ast() {
 		return this.#ast;
 	}
 	expressionBuilder() {
-		return new ExpressionBuilder(this.#exists);
+		return this.#expressionBuilder ??= new ExpressionBuilder(this.#exists.bind(this));
 	}
 };
 function asQueryImpl(q) {
 	assert(q instanceof QueryImpl, "Expected QueryImpl instance");
 	return q;
 }
+/**
+* A stable id per query AST.
+*
+* Every `QueryImpl` allocates its own AST object, so these are one-to-one with
+* queries, and interning makes the object identity stable across rebuilds. That
+* lets a `related` or `exists` transition key on *which* sub-query it points at
+* rather than comparing the sub-tree.
+*
+* Assigned only where it is needed. A `WeakMap.set` costs on the order of a
+* hundred nanoseconds, so doing this for every query rather than for the few
+* that are sub-queries was one of the largest single costs of building a query
+* from cold. ASTs that never pass through here -- including the junction AST a
+* two-hop `exists` builds inline -- are absent, and fall back to a delta.
+*/
+var astIDs = /* @__PURE__ */ new WeakMap();
+var nextASTID = 0;
+function astID(ast) {
+	let id = astIDs.get(ast);
+	if (id === void 0) {
+		id = ++nextASTID;
+		astIDs.set(ast, id);
+	}
+	return id;
+}
+/**
+* Memoized transition keys.
+*
+* A transition key must be a string V8 has already hashed, or the `Map` lookup
+* has to hash it from scratch -- measured at ~148ns against ~10ns, which dwarfs
+* everything else a lookup does. Both tables are keyed by schema-derived names,
+* so they are bounded by the schema.
+*/
+var whereKeys = /* @__PURE__ */ new Map();
+function whereKey(column, op) {
+	let byOp = whereKeys.get(column);
+	if (byOp === void 0) {
+		byOp = /* @__PURE__ */ new Map();
+		whereKeys.set(column, byOp);
+	}
+	let key = byOp.get(op);
+	if (key === void 0) {
+		key = `where:${column}:${op}`;
+		byOp.set(op, key);
+	}
+	return key;
+}
+var relatedKeys = /* @__PURE__ */ new Map();
+function relatedKey(relationship) {
+	let key = relatedKeys.get(relationship);
+	if (key === void 0) {
+		key = `related:${relationship}`;
+		relatedKeys.set(relationship, key);
+	}
+	return key;
+}
+function isPrimitive(v) {
+	return v === null || typeof v !== "object";
+}
+/**
+* Folds a JSON value into a self-delimiting token: a string is
+* length-prefixed, a number is terminated, an array or object is
+* count-prefixed and encodes its members recursively, and the rest are fixed
+* width. Tokens can therefore be concatenated into a key with no way for one
+* to run into the next, and the leading tag keeps `'1'` and `1` apart.
+*
+* Not `JSON.stringify`: it writes `Infinity`, `NaN` and `null` all as `null`,
+* and this token is trusted as exact, so a nested value that serialized like
+* another's would hand back a query with the wrong value in its AST. Numbers
+* are written the way `String` writes them, which keeps those apart. An
+* `undefined` property is skipped, as `deepEqual` would skip it; property
+* order is part of the encoding, so an object spelled in another order
+* interns separately.
+*/
+function valueTag(v) {
+	switch (typeof v) {
+		case "string": return `:s${enc(v)}`;
+		case "number": return `:n${v};`;
+		case "boolean": return v ? ":t" : ":f";
+		default: {
+			if (v === null) return ":z";
+			if (Array.isArray(v)) {
+				let out = `:a${v.length}:`;
+				for (const e of v) out += valueTag(e);
+				return out;
+			}
+			const o = v;
+			let body = "";
+			let n = 0;
+			for (const key in o) {
+				const e = o[key];
+				if (e !== void 0 && Object.hasOwn(o, key)) {
+					body += enc(key) + valueTag(e);
+					n++;
+				}
+			}
+			return `:o${n}:${body}`;
+		}
+	}
+}
+/**
+* Folds the right-hand side of a simple condition into a transition value, so
+* that the transition is exact and the lookup needs no comparison at all.
+*
+* Arrays (`IN`) and parameter references are encoded in full: that is one
+* pass over a small value, where leaving them in the delta would instead cost
+* a `deepEqual` over the whole condition for every sibling a lookup walks
+* past.
+*/
+function rightTag(right) {
+	if (right.type !== "literal") return `:p${valueTag(right)}`;
+	return valueTag(right.value);
+}
+/**
+* Length-prefixes a free-form string so it can be concatenated into a key
+* without a separator being ambiguous with the content.
+*/
+function enc(s) {
+	return `${s.length}:${s}`;
+}
+/** Encodes an optional boolean without collapsing `undefined` into `false`. */
+function tri(b) {
+	return b === void 0 ? "-" : b ? "t" : "f";
+}
+/**
+* An exact key for a whole condition tree, or `undefined` for a shape we cannot
+* encode (which falls back to {@linkcode treeKey} plus a delta).
+*
+* Everything variable-length is length-prefixed, so distinct trees cannot
+* produce the same string and the key needs no `deepEqual` to back it up. That
+* matters because the alternative -- one coarse bucket per shape -- turns N
+* sibling conditions off the same parent into an N-deep scan of tree
+* comparisons, which measured far slower than not interning at all.
+*/
+function condKey(cond) {
+	switch (cond.type) {
+		case "simple":
+			if (cond.left.type !== "column") return;
+			return `S${enc(cond.left.name)}${enc(cond.op)}${rightTag(cond.right)}`;
+		case "correlatedSubquery": {
+			const id = astIDs.get(cond.related.subquery);
+			return id === void 0 ? void 0 : `E${id}:${enc(cond.op)}${tri(cond.flip)}${tri(cond.scalar)}`;
+		}
+		case "and":
+		case "or": {
+			let out = `${cond.type === "and" ? "A" : "O"}${cond.conditions.length}:`;
+			for (const c of cond.conditions) {
+				const k = condKey(c);
+				if (k === void 0) return;
+				out += k;
+			}
+			return out;
+		}
+		default: return;
+	}
+}
+/**
+* A coarse bucket key for the conditions {@linkcode condKey} cannot encode --
+* a two-hop `exists`, whose junction AST is built inline and so has no identity
+* of its own. Reads only the top of the tree, so it is cheap; the delta tells
+* apart what shares it.
+*/
+function treeKey(cond) {
+	switch (cond.type) {
+		case "correlatedSubquery": return `where:e:${cond.related.subquery.alias}:${cond.op}`;
+		case "and":
+		case "or": return `where:${cond.type}:${cond.conditions.length}`;
+		default: return "where:*";
+	}
+}
 function throwQueryNotRunnable() {
 	throw new Error("Query is not runnable");
 }