@rocicorp/zero 1.10.0-canary.24 → 1.10.0-canary.26

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

@@ -1,64 +1,18 @@
 import { assert } from "../../../shared/src/asserts.js";
-import { deepEqual } from "../../../shared/src/json.js";
-import { getOrInsertComputed, newMap } from "../../../shared/src/map.js";
-import { SUBQ_PREFIX, insertRelated, normalizeAST, normalizeCondition, normalizedRelated, tableAST } from "../../../zero-protocol/src/ast.js";
+import { SUBQ_PREFIX } from "../../../zero-protocol/src/ast.js";
 import { defaultFormat } from "../../../zero-types/src/format.js";
-import { hashOfQueryInternals } from "../../../zero-protocol/src/query-hash-visitor.js";
+import { hashOfAST } from "../../../zero-protocol/src/query-hash.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 newQueryInternal(schema, table, tableAST(table), defaultFormat, "client");
+	return newQueryImpl(schema, table, { 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);
-	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;
+	return inner(tableName, ast, format, void 0, void 0);
 }
-/**
-* 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;
@@ -70,26 +24,6 @@ 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;
@@ -100,44 +34,6 @@ 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();
 	}
@@ -148,204 +44,150 @@ var QueryImpl = class {
 		throwQueryNotRunnable();
 	}
 	nameAndArgs(name, args) {
-		return this.#derive("nameAndArgs", name, args, () => this.#newQuery(this.#tableName, this.#ast, this.format, {
+		return this.#newQuery(this.#tableName, this.#ast, this.format, {
 			name,
 			args
-		}, this.#currentJunction));
+		}, this.#currentJunction);
 	}
 	hash() {
-		if (!this.#hash) {
-			this.#hash = hashOfQueryInternals(this.#ast, this.format, this.#system, this.#currentJunction, this.customQueryID?.name, this.customQueryID?.args);
-			this.#canonicalize();
-		}
+		if (!this.#hash) this.#hash = hashOfAST(this.#ast);
 		return this.#hash;
 	}
-	/**
-	* 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) {
+	one = () => 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.#deriveBounded(`relatedBase:${relationship}`, () => this.#newQuery(destSchema, tableAST(destSchema, relationship), {
+			const q = this.#newQuery(destSchema, {
+				table: destSchema,
+				alias: 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.#derive(relatedKey(relationship), astID(subQuery.#ast), void 0, () => this.#newQuery(this.#tableName, {
+			return this.#newQuery(this.#tableName, {
 				...this.#ast,
-				related: insertRelated(this.#ast.related, {
+				related: [...this.#ast.related ?? [], {
+					system: this.#system,
 					correlation: {
 						parentField: sourceField,
 						childField: destField
 					},
-					subquery: subQuery.#ast,
-					system: this.#system
-				})
+					subquery: subQuery.#ast
+				}]
 			}, {
 				...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.#deriveBounded(`relatedBase:${relationship}`, () => this.#newQuery(destSchema, tableAST(destSchema, relationship), {
+			const sq = asQueryImpl(cb(this.#newQuery(destSchema, {
+				table: destSchema,
+				alias: relationship
+			}, {
 				relationships: {},
 				singular: secondRelation.cardinality === "one"
-			}, 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.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.#ast,
-				related: insertRelated(this.#ast.related, {
+				related: [...this.#ast.related ?? [], {
+					system: this.#system,
 					correlation: {
-						parentField: firstSource,
-						childField: firstDest
+						parentField: firstRelation.sourceField,
+						childField: firstRelation.destField
 					},
 					hidden: true,
 					subquery: {
-						...tableAST(junctionSchema, relationship),
-						related: [normalizedRelated({
+						table: junctionSchema,
+						alias: relationship,
+						related: [{
+							system: this.#system,
 							correlation: {
-								parentField: secondSource,
-								childField: secondDest
+								parentField: secondRelation.sourceField,
+								childField: secondRelation.destField
 							},
-							subquery: sq.#ast,
-							system: this.#system
-						})]
-					},
-					system: this.#system
-				})
+							subquery: sq.#ast
+						}]
+					}
+				}]
 			}, {
 				...this.format,
 				relationships: {
 					...this.format.relationships,
 					[relationship]: sq.format
 				}
-			}, this.customQueryID, this.#currentJunction));
+			}, this.customQueryID, this.#currentJunction);
 		}
 		throw new Error(`Invalid relationship ${relationship}`);
-	}
-	where(fieldOrExpressionFactory, opOrValue, value) {
+	};
+	where = function(fieldOrExpressionFactory, opOrValue, value) {
 		let cond;
 		if (typeof fieldOrExpressionFactory === "function") cond = fieldOrExpressionFactory(this.expressionBuilder());
 		else {
 			assert(arguments.length >= 2, "Invalid condition. Too few arguments.");
-			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);
+			if (arguments.length === 2) cond = cmp(fieldOrExpressionFactory, opOrValue);
+			else cond = cmp(fieldOrExpressionFactory, opOrValue, value);
 		}
-		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;
-			}
-		}
-		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, {
+		const existingWhere = this.#ast.where;
+		if (existingWhere) cond = and(existingWhere, cond);
+		const where = simplifyCondition(cond);
+		return this.#newQuery(this.#tableName, {
 			...this.#ast,
-			start: {
-				row,
-				exclusive: !opts?.inclusive
-			}
-		}, this.format, this.customQueryID, this.#currentJunction));
-	}
-	limit(limit) {
+			where
+		}, this.format, this.customQueryID, this.#currentJunction);
+	}.bind(this);
+	start = (row, opts) => 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.#derive("limit", limit, void 0, () => this.#newQuery(this.#tableName, {
+		return 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.#derive(direction === "asc" ? "orderBy:asc" : "orderBy:desc", field, void 0, () => this.#newQuery(this.#tableName, {
+		return 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;
@@ -355,8 +197,10 @@ 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.#deriveBounded(`existsBase:${relationship}`, () => this.#newQuery(destTableName, tableAST(destTableName, `${SUBQ_PREFIX}${relationship}`), defaultFormat, this.customQueryID, void 0))));
-			astID(subQuery.#ast);
+			const subQuery = asQueryImpl(cb(this.#newQuery(destTableName, {
+				table: destTableName,
+				alias: `${SUBQ_PREFIX}${relationship}`
+			}, defaultFormat, this.customQueryID, void 0)));
 			return {
 				type: "correlatedSubquery",
 				related: {
@@ -380,7 +224,10 @@ var QueryImpl = class {
 			assert(isCompoundKey(secondRelation.destField), "Invalid relationship");
 			const { destSchema } = secondRelation;
 			const junctionSchema = firstRelation.destSchema;
-			const queryToDest = cb(this.#deriveBounded(`existsJunctionBase:${relationship}`, () => this.#newQuery(destSchema, tableAST(destSchema, `${SUBQ_PREFIX}zhidden_${relationship}`), defaultFormat, this.customQueryID, relationship)));
+			const queryToDest = cb(this.#newQuery(destSchema, {
+				table: destSchema,
+				alias: `${SUBQ_PREFIX}zhidden_${relationship}`
+			}, defaultFormat, this.customQueryID, relationship));
 			return {
 				type: "correlatedSubquery",
 				related: {
@@ -390,8 +237,9 @@ var QueryImpl = class {
 						childField: firstRelation.destField
 					},
 					subquery: {
-						...tableAST(junctionSchema, `${SUBQ_PREFIX}${relationship}`),
-						where: normalizeCondition({
+						table: junctionSchema,
+						alias: `${SUBQ_PREFIX}${relationship}`,
+						where: {
 							type: "correlatedSubquery",
 							related: {
 								system: this.#system,
@@ -404,7 +252,7 @@ var QueryImpl = class {
 							op: "EXISTS",
 							...flip !== void 0 ? { flip } : {},
 							...scalar !== void 0 ? { scalar } : {}
-						})
+						}
 					}
 				},
 				op: "EXISTS",
@@ -412,169 +260,18 @@ var QueryImpl = class {
 			};
 		}
 		throw new Error(`Invalid relationship ${relationship}`);
-	}
+	};
 	get ast() {
 		return this.#ast;
 	}
 	expressionBuilder() {
-		return this.#expressionBuilder ??= new ExpressionBuilder(this.#exists.bind(this));
+		return new ExpressionBuilder(this.#exists);
 	}
 };
 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;
-var newASTID = () => ++nextASTID;
-function astID(ast) {
-	return getOrInsertComputed(astIDs, ast, newASTID);
-}
-/**
-* 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) {
-	return getOrInsertComputed(getOrInsertComputed(whereKeys, column, newMap), op, (op) => `where:${column}:${op}`);
-}
-var relatedKeys = /* @__PURE__ */ new Map();
-var newRelatedKey = (relationship) => `related:${relationship}`;
-function relatedKey(relationship) {
-	return getOrInsertComputed(relatedKeys, relationship, newRelatedKey);
-}
-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");
 }