@rebasepro/common 0.13.0 → 0.13.1-canary.g1822133

package/dist/index.es.js

@@ -1,5 +1,5 @@
-import { ANONYMOUS_USER_ID, ANONYMOUS_USER_IDS, CANONICAL_TO_REST, DEFAULT_DATA_SOURCE_KEY, EntityReference, EntityRelation, NULL_OPS, REST_TO_CANONICAL, getDataSourceCapabilities, getDeclaredSubcollections, isAnonymousUid, isManyToMany, isPostgresCollectionConfig, isRelationalCollectionConfig, policy, toCanonicalOp } from "@rebasepro/types";
-import { deepClone, generateForeignKeyName, getIn, getPolicyNamesForRules, getPolicyOperations, isDefaultFieldConfigId, mergeDeep, prettifyIdentifier, randomString, removeFunctions, toSnakeCase } from "@rebasepro/utils";
+import { ALL_WHERE_FILTER_OPS, ANONYMOUS_USER_ID, ANONYMOUS_USER_IDS, CANONICAL_TO_REST, DEFAULT_DATA_SOURCE_KEY, DEFAULT_LIST_LIMIT, EntityReference, EntityRelation, NULL_OPS, REST_TO_CANONICAL, RLS_ROLES_SQL, RLS_UID_SQL, getDataSourceCapabilities, getDeclaredSubcollections, isAnonymousUid, isManyToMany, isPostgresCollectionConfig, isRelationalCollectionConfig, policy, rewriteLegacyRlsFunctions, toCanonicalOp } from "@rebasepro/types";
+import { deepClone, firstFreeKey, generateForeignKeyName, getIn, getPolicyNamesForRules, getPolicyOperations, isDefaultFieldConfigId, mergeDeep, prettifyIdentifier, randomString, removeFunctions, toSnakeCase, toWireKey } from "@rebasepro/utils";
 import jsonLogic from "json-logic-js";
 import { deepEqual } from "fast-equals";
 //#region src/util/common.ts
@@ -89,10 +89,21 @@ function getRelationFrom(entity) {
 * have `id` and `path` fields — these are relation-shaped objects from
 * edge cases in the data pipeline (REST fallback, stale cache, custom data source).
 *
+* When `targetPath` is given, also accepts a bare id. A relation column is a
+* foreign key, and the REST layer returns it as the scalar it is; only some
+* fetch paths hydrate it into an object. Which form a caller sees therefore
+* depends on how the row was loaded, and a caller that only accepted objects
+* reported half of its own data as a type error. The declared target is the
+* missing half: with it, an id is a relation that has not been fetched yet.
+*
 * Returns null if the value cannot be coerced.
 */
-function normalizeToEntityRelation(value, propertyType) {
+function normalizeToEntityRelation(value, propertyType, targetPath) {
 	if (value instanceof EntityRelation) return value;
+	if (targetPath && (typeof value === "string" || typeof value === "number")) {
+		if (value === "") return null;
+		return new EntityRelation(value, targetPath);
+	}
 	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
 	const obj = value;
 	if (!(obj.__type === "relation" || obj.__type === "reference" || typeof obj.isEntityRelation === "function" && obj.isEntityRelation() || typeof obj.isEntityReference === "function" && obj.isEntityReference() || propertyType === "relation" && typeof obj.id !== "undefined" && typeof obj.path === "string")) return null;
@@ -215,6 +226,23 @@ function sortProperties(properties, propertiesOrder) {
 		return properties;
 	}
 }
+/**
+* A copy of `collections` ordered by slug.
+*
+* Every generator that turns collections into a file is order-dependent, and
+* every one of them is compared against its own output — `rebase doctor`
+* regenerates in memory and diffs, `generate-sdk && git diff --exit-code` gates
+* CI. While only the *writers* sorted, a project whose `readdirSync` order
+* differed from its slug order was reported permanently out of date, and the
+* fix the message printed rewrote the file in the order it was already in. The
+* generators sort themselves now, so no caller can get this wrong.
+*
+* A slug-less collection is left to the generator's own validation, which names
+* the offending collection; sorting must not throw first.
+*/
+function sortCollectionsBySlug(collections) {
+	return [...collections].sort((a, b) => (a.slug ?? "").localeCompare(b.slug ?? ""));
+}
 function getPrimaryKeys(collection) {
 	const properties = collection.properties;
 	if (!properties) return ["id"];
@@ -608,6 +636,33 @@ function resolveCollectionRelations(collection) {
 	_resolvedRelationsCache.set(collection, relations);
 	return relations;
 }
+/**
+* The path of the collection a relation property points at, derived from the
+* property alone.
+*
+* A preview holds a property and a value and no collection, so it cannot call
+* `resolveRelationProperty`. It does not need to: both forms that carry a
+* target — the stamped `resolvedRelation` and the inline `relation` — name it
+* directly. Only the third form, a relation declared by name in the
+* collection's `relations` array, is out of reach, and that one has no target
+* to read without the collection anyway.
+*
+* This is what lets a preview render a relation column that arrived as a bare
+* foreign key: the id says *which* row, the declared target says *which
+* collection*, and `RelationPreview` fetches the rest. Without it a scalar id
+* is indistinguishable from a value of the wrong type.
+*/
+function getRelationTargetPath(property) {
+	const stamped = property.resolvedRelation?.targetSlug;
+	if (stamped) return stamped;
+	const target = property.relation?.target;
+	if (typeof target !== "function") return void 0;
+	try {
+		return target()?.slug;
+	} catch (_e) {
+		return;
+	}
+}
 function getTableName(collection) {
 	if (isRelationalCollectionConfig(collection)) return collection.table ?? toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
 	return toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
@@ -622,6 +677,48 @@ function getColumnName(fullColumn) {
 	return fullColumn.includes(".") ? fullColumn.split(".").pop() : fullColumn;
 }
 /**
+* The field key a database column is served and addressed under.
+*
+* A column has two names and they are not the same name. `author_id` is what
+* Postgres stores; `authorId` is the key on the JSON row, the key in the
+* generated Drizzle table, and the key a caller writes in `where` and
+* `orderBy`. Every place that starts from a column and has to reach a row, a
+* Drizzle table or a payload goes through here, so there is one answer rather
+* than one per call site — the two that disagreed put `displayName` and
+* `author_id` on the same API.
+*
+* A declared property is the authority when there is one, because its key *is*
+* the wire name and `columnName` is the only thing that ever renamed the
+* column:
+*
+*  1. an explicit `columnName` equal to this column;
+*  2. a property whose key is literally the column (an author who wrote
+*     `author_id:` meant `author_id` on the wire, and gets it);
+*  3. a property whose key snake-cases to the column, which is the default
+*     mapping — `authorId` → `author_id`.
+*
+* With no property in the way — a foreign key derived from a relation, which
+* usually has none — the name is derived: {@link toWireKey}.
+*
+* Note the fallback is *not* the column verbatim. That was the old behaviour
+* and it is precisely the defect: a derived foreign key reached the wire under
+* its column name while every hand-authored field beside it was camelCase.
+*/
+function fieldKeyForColumn(collection, column) {
+	const properties = collection?.properties;
+	if (properties) {
+		for (const [key, prop] of Object.entries(properties)) {
+			const columnName = prop?.columnName;
+			if (typeof columnName === "string" && columnName === column) return key;
+		}
+		for (const key of Object.keys(properties)) {
+			if (key === column) return key;
+			if (toSnakeCase(key) === column) return key;
+		}
+	}
+	return toWireKey(column);
+}
+/**
 * Look up a relation by key with forgiving normalization.
 *
 * `resolveCollectionRelations` stores each relation under a single canonical
@@ -882,6 +979,59 @@ function getEntityChildViews(collection) {
 	return views;
 }
 /**
+* Each of `collection`'s tabs paired with the property that declared it, when a
+* property declared it: child view key → property key.
+*
+* A many-relation can only be declared as a property — that is the documented
+* and only mechanism — and {@link getEntityChildViews} promotes it to a tab. So
+* one declaration reaches the panel twice, and neither surface knew about the
+* other. The form rendered a relation picker beside the tab, and the collection
+* table rendered *two* columns under one heading: the relation's own column,
+* showing the child rows, and a jump-to-tab button carrying the same name.
+*
+* The pairing is what lets each surface decide which half is redundant, and it
+* has to be a pairing rather than two sets because the two keys differ whenever
+* a relation is named. The match is on the resolved `relationName` — the
+* identity `getEntityChildViews` itself dedupes on — so a relation declared in
+* `relations` and pointed at by a differently-named property is recognised too.
+*
+* A relation with no property of its own is absent here, which is the point: it
+* has exactly one surface already, and nothing to weigh it against.
+*
+* Only top-level properties: a relation nested inside a `map` gets no tab.
+*/
+function getChildViewDeclaringProperties(collection) {
+	const pairs = /* @__PURE__ */ new Map();
+	const relationProperties = Object.entries(collection.properties ?? {}).filter(([, property]) => property?.type === "relation");
+	if (relationProperties.length === 0) return pairs;
+	const relationViews = getEntityChildViews(collection).filter((view) => view.source.kind === "relation");
+	if (relationViews.length === 0) return pairs;
+	const resolvedRelations = resolveCollectionRelations(collection);
+	const identityOf = (relationKey) => resolvedRelations[relationKey]?.relationName ?? relationKey;
+	const declaringPropertyByIdentity = /* @__PURE__ */ new Map();
+	for (const [propertyKey, property] of relationProperties) {
+		const relation = property.resolvedRelation ?? resolvedRelations[propertyKey];
+		if (relation?.cardinality !== "many") continue;
+		const identity = relation.relationName ?? propertyKey;
+		if (!declaringPropertyByIdentity.has(identity)) declaringPropertyByIdentity.set(identity, propertyKey);
+	}
+	for (const view of relationViews) {
+		const propertyKey = declaringPropertyByIdentity.get(identityOf(view.source.relationKey));
+		if (propertyKey) pairs.set(view.key, propertyKey);
+	}
+	return pairs;
+}
+/**
+* The property keys of `collection` whose relation is already one of its tabs.
+*
+* What a form asks: the tab is the treatment for a list of child rows, so the
+* picker beside it is the redundant half. See
+* {@link getChildViewDeclaringProperties}.
+*/
+function getChildViewRelationPropertyKeys(collection) {
+	return new Set(getChildViewDeclaringProperties(collection).values());
+}
+/**
 * The child views of `collection` as bare collections.
 *
 * The flattened view of {@link getEntityChildViews}, for navigation code that
@@ -931,9 +1081,9 @@ function isKeywordAt(upper, i, keyword) {
 *
 * This used to be `sql.split(/ AND /i)`, which tore subqueries in half: the
 * `AND` inside
-*   `EXISTS (SELECT 1 FROM organization_members m WHERE m.org = t.org AND m.user_id = auth.uid())`
+*   `EXISTS (SELECT 1 FROM organization_members m WHERE m.org = t.org AND m.user_id = rebase.uid())`
 * split the expression, and re-emitting the halves produced
-*   `(EXISTS (...) AND m.user_id = auth.uid())`
+*   `(EXISTS (...) AND m.user_id = rebase.uid())`
 * where `m` is no longer in scope — SQL that Postgres rejects outright with
 * "missing FROM-clause entry for table". Returning null instead keeps such a
 * clause as a `raw` expression, which round-trips verbatim.
@@ -1007,15 +1157,15 @@ function stripOuterParens(sql) {
 	}
 }
 function sqlToPolicy(sql) {
-	const trimmed = stripOuterParens(sql.trim());
+	const trimmed = stripOuterParens(rewriteLegacyRlsFunctions(sql).trim());
 	if (trimmed.toLowerCase() === "true") return policy.true();
 	if (trimmed.toLowerCase() === "false") return policy.false();
-	const overlapMatch = trimmed.match(/^string_to_array\s*\(\s*auth\.roles\(\)\s*,\s*','\s*\)\s*&&\s*ARRAY\s*\[(.+)\]$/i);
+	const overlapMatch = trimmed.match(/^string_to_array\s*\(\s*rebase\.roles\(\)\s*,\s*','\s*\)\s*&&\s*ARRAY\s*\[(.+)\]$/i);
 	if (overlapMatch) {
 		const roles = overlapMatch[1].split(",").map((s) => s.trim().replace(/^'|'$/g, ""));
 		return policy.rolesOverlap(roles);
 	}
-	const containMatch = trimmed.match(/^string_to_array\s*\(\s*auth\.roles\(\)\s*,\s*','\s*\)\s*@>\s*ARRAY\s*\[(.+)\]$/i);
+	const containMatch = trimmed.match(/^string_to_array\s*\(\s*rebase\.roles\(\)\s*,\s*','\s*\)\s*@>\s*ARRAY\s*\[(.+)\]$/i);
 	if (containMatch) {
 		const roles = containMatch[1].split(",").map((s) => s.trim().replace(/^'|'$/g, ""));
 		return policy.rolesContain(roles);
@@ -1031,32 +1181,60 @@ function sqlToPolicy(sql) {
 		const right = parseOperand(rightStr.trim());
 		if (left && right) return policy.compare(left, op === "=" ? "eq" : "neq", right);
 	}
-	return policy.raw(sql);
+	return policy.raw(trimmed);
 }
 /**
-* Literals from other BaaS platforms that people compare `auth.uid()` against
+* Literals from other BaaS platforms that people compare `rebase.uid()` against
 * out of habit. Mirrors the driver's `FOREIGN_CONVENTION_ROLES` guard on
 * `pgRoles`, one surface over: the same muscle memory inside a `using:` string
 * is the more dangerous spelling, because it inverts a rule instead of
 * emptying a table.
 */
-var FOREIGN_CONVENTION_UIDS = {
-	anon: "Supabase",
-	authenticated: "Supabase",
-	service_role: "Supabase"
-};
-/** `auth.uid() IS NOT NULL` in raw SQL, the clause that is always true. */
-var UID_NOT_NULL = /auth\.uid\(\)\s+IS\s+NOT\s+NULL/i;
+/**
+* A `Map`, not an object literal.
+*
+* As `Record<string, string>` this was indexed with a literal taken straight
+* out of a policy, so every key on `Object.prototype` answered: a rule
+* comparing `rebase.uid()` to `"valueOf"`, `"toString"`, `"constructor"` or
+* `"hasOwnProperty"` found a truthy "platform" and reported an anonymous-grant
+* risk that does not exist — with the matched function interpolated into the
+* explanation as the platform's name. A security warning that fires on
+* innocent input is worse than none: it is what teaches people to skip the
+* warnings that are real.
+*
+* Same shape as the prototype-pollution class swept out of `setIn`, `getIn`,
+* `mergeDeep` and `unflattenObject` — a data-derived key reaching a plain
+* object. Found by a property test, on the input `"valueOf"`.
+*/
+var FOREIGN_CONVENTION_UIDS = /* @__PURE__ */ new Map([
+	["anon", "Supabase"],
+	["authenticated", "Supabase"],
+	["service_role", "Supabase"]
+]);
+/**
+* The same foreign literals, as a pattern for SQL that could not be parsed
+* back into structure.
+*/
+var FOREIGN_UID_LITERAL_SQL = new RegExp(String.raw`rebase\.uid\(\)\s*=\s*'(${[...FOREIGN_CONVENTION_UIDS.keys()].join("|")})'`, "i");
+/**
+* `rebase.uid() IS NOT NULL` in raw SQL, the clause that is always true.
+*
+* Both schema spellings, because this runs over policy bodies read back from a
+* database, and one migrated by a pre-1.0 release still holds `auth.uid()`.
+* A security check that stops recognising a dangerous clause because the
+* framework renamed a function is a check that silently turns off.
+*/
+var UID_NOT_NULL = /\b(?:rebase|auth)\.uid\(\)\s+IS\s+NOT\s+NULL/i;
 /**
 * Find clauses that read as "signed-in users only" but admit anonymous callers.
 *
-* Both spellings come from the same place — Supabase, where `auth.uid()` really
-* is NULL for an anonymous request. Rebase substitutes
+* Both spellings come from the same place — Supabase, where its own `auth.uid()`
+* really is NULL for an anonymous request. Rebase substitutes
 * {@link ANONYMOUS_USER_ID} instead (a blank id would read back as NULL, which
 * is how the trusted *server* context is recognised), so:
 *
-*  - `auth.uid() IS NOT NULL` is a tautology on the user path, and
-*  - `auth.uid() != 'anon'` excludes one spelling of anonymous and admits the
+*  - `rebase.uid() IS NOT NULL` is a tautology on the user path, and
+*  - `rebase.uid() != 'anon'` excludes one spelling of anonymous and admits the
 *    other. This one is not hypothetical and was not only a foreign habit:
 *    rebase's own request path reported `'anon'` while everything that compiled
 *    or checked a policy used `'anonymous'`, so whichever literal an author
@@ -1084,17 +1262,27 @@ function findAnonymousGrants(expr) {
 			case "existsIn":
 				visit(e.where);
 				return;
-			case "raw":
+			case "raw": {
 				if (UID_NOT_NULL.test(e.sql)) found.push({
 					pattern: "uid-not-null",
 					detail: e.sql,
-					explanation: `\`auth.uid() IS NOT NULL\` is true for every request that came from a client, including anonymous ones — they carry '${ANONYMOUS_USER_ID}', not NULL. Use \`condition: policy.authenticated()\` to mean "signed in".`
+					explanation: `\`rebase.uid() IS NOT NULL\` is true for every request that came from a client, including anonymous ones — they carry '${ANONYMOUS_USER_ID}', not NULL. Use \`condition: policy.authenticated()\` to mean "signed in".`
 				});
+				const foreign = FOREIGN_UID_LITERAL_SQL.exec(e.sql);
+				if (foreign) {
+					const literal = foreign[1];
+					found.push({
+						pattern: "foreign-uid-literal",
+						detail: literal,
+						explanation: `'${literal}' is a ${FOREIGN_CONVENTION_UIDS.get(literal)} convention. Rebase reports an anonymous request as '${ANONYMOUS_USER_ID}', so comparing against '${literal}' passes for every caller. Use \`condition: policy.authenticated()\` to mean "signed in".`
+					});
+				}
 				return;
+			}
 			case "compare": {
 				const literal = [e.left, e.right].find((o) => o.kind === "literal");
 				if (!(e.left.kind === "authUid" || e.right.kind === "authUid") || typeof literal?.value !== "string") return;
-				const platform = FOREIGN_CONVENTION_UIDS[literal.value];
+				const platform = FOREIGN_CONVENTION_UIDS.get(literal.value);
 				if (!platform) return;
 				found.push({
 					pattern: "foreign-uid-literal",
@@ -1110,12 +1298,43 @@ function findAnonymousGrants(expr) {
 	return found;
 }
 function parseOperand(str) {
-	if (/current_setting\s*\(\s*'app\.(uid|user_id)'\s*\)/i.test(str) || /auth\.uid\(\)/i.test(str)) return policy.authUid();
-	const stringMatch = str.match(/^'(.+)'$/);
-	if (stringMatch) return policy.literal(stringMatch[1]);
-	if (/^\w+$/.test(str)) return policy.field(str);
+	if (/^current_setting\s*\(\s*'app\.(uid|user_id)'\s*\)$/i.test(str) || /^rebase\.uid\(\)$/i.test(str)) return policy.authUid();
+	const literal = parseSingleQuoted(str);
+	if (literal !== null) return policy.literal(literal);
+	if (/^-?\d+$/.test(str)) return policy.literal(Number(str));
+	if (/^-?\d*\.\d+$/.test(str)) return policy.literal(Number(str));
+	if (/^true$/i.test(str)) return policy.literal(true);
+	if (/^false$/i.test(str)) return policy.literal(false);
+	if (/^null$/i.test(str)) return policy.literal(null);
+	if (/^\w+$/.test(str) && toSnakeCase(str) !== "") return policy.field(str);
 	return null;
 }
+/**
+* Decode a single-quoted SQL literal, or null when `str` is not exactly one.
+*
+* Rejecting is as important as decoding: `'a' = 'b'` is two literals and an
+* operator, not one literal whose body contains a quote, and a regex anchored
+* on the outer quotes would happily read it as the latter. Every interior quote
+* must therefore be part of a `''` pair.
+*/
+function parseSingleQuoted(str) {
+	if (str.length < 2 || !str.startsWith("'") || !str.endsWith("'")) return null;
+	const body = str.slice(1, -1);
+	let out = "";
+	for (let i = 0; i < body.length; i++) {
+		if (body[i] !== "'") {
+			out += body[i];
+			continue;
+		}
+		if (body[i + 1] === "'") {
+			out += "'";
+			i++;
+			continue;
+		}
+		return null;
+	}
+	return out;
+}
 //#endregion
 //#region src/util/policy/securityRuleToConditions.ts
 /**
@@ -1192,12 +1411,12 @@ function compile(expr, scope) {
 			const rightSql = castForAuthUid(expr.right, operandToSql(expr.right, scope), expr.left);
 			return `${leftSql} ${COMPARE_SQL[expr.op]} ${rightSql}`;
 		}
-		case "rolesOverlap": return `string_to_array(auth.roles(), ',') && ${rolesArraySql(expr.roles)}`;
-		case "rolesContain": return `string_to_array(auth.roles(), ',') @> ${rolesArraySql(expr.roles)}`;
-		case "authenticated": return `auth.uid() IS NOT NULL AND auth.uid() NOT IN (${ANONYMOUS_USER_IDS.map(quoteLiteral).join(", ")})`;
-		case "serverContext": return "auth.uid() IS NULL";
+		case "rolesOverlap": return `string_to_array(${RLS_ROLES_SQL}, ',') && ${rolesArraySql(expr.roles)}`;
+		case "rolesContain": return `string_to_array(${RLS_ROLES_SQL}, ',') @> ${rolesArraySql(expr.roles)}`;
+		case "authenticated": return `${RLS_UID_SQL} IS NOT NULL AND ${RLS_UID_SQL} NOT IN (${ANONYMOUS_USER_IDS.map(quoteLiteral).join(", ")})`;
+		case "serverContext": return `${RLS_UID_SQL} IS NULL`;
 		case "existsIn": return compileExistsIn(expr, scope);
-		case "raw": return expr.sql.replace(/\{(\w+)\}/g, (_, col) => `${outerQualifier(scope)}${resolveColumnName(col, scope.outerCollection)}`);
+		case "raw": return rewriteLegacyRlsFunctions(expr.sql).replace(/\{(\w+)\}/g, (_, col) => `${outerQualifier(scope)}${resolveColumnName(col, scope.outerCollection)}`);
 	}
 }
 /**
@@ -1234,8 +1453,8 @@ function operandToSql(operand, scope) {
 		case "field": return `${scope.fieldPrefix}${resolveColumnName(operand.name, scope.fieldCollection)}`;
 		case "outerField": return `${scope.outerPrefix}${resolveColumnName(operand.name, scope.outerCollection)}`;
 		case "literal": return quoteLiteral(operand.value);
-		case "authUid": return "auth.uid()";
-		case "authRoles": return "string_to_array(auth.roles(), ',')";
+		case "authUid": return RLS_UID_SQL;
+		case "authRoles": return `string_to_array(${RLS_ROLES_SQL}, ',')`;
 	}
 }
 /**
@@ -1340,11 +1559,7 @@ function evaluateCompare(op, left, right, ctx) {
 	if (!l.known || !r.known) return "unknown";
 	const a = l.value;
 	const b = r.value;
-	if (a === null || b === null) {
-		if (op === "eq") return false;
-		if (op === "neq") return true;
-		return "unknown";
-	}
+	if (a === null || b === null) return "unknown";
 	if (op === "eq") return a === b;
 	if (op === "neq") return a !== b;
 	if (typeof a === "string" && typeof b === "string") {
@@ -1391,11 +1606,11 @@ function ruleApplies(rule, targetOperation) {
 * in that case. USING applies to SELECT/UPDATE/DELETE; WITH CHECK to
 * INSERT/UPDATE; both must pass for UPDATE.
 */
-function evaluateRuleForOperation(rule, ctx, targetOperation) {
+function evaluateRuleForOperation(rule, ctx, targetOperation, clauses = "both") {
 	const { usingExpr, withCheckExpr } = securityRuleToConditions(rule);
 	const clause = (expr) => expr === null ? false : evaluatePolicy(expr, ctx);
-	const needsUsing = targetOperation !== "insert";
-	const needsWithCheck = targetOperation === "insert" || targetOperation === "update";
+	const needsUsing = targetOperation !== "insert" && clauses !== "withCheck";
+	const needsWithCheck = (targetOperation === "insert" || targetOperation === "update") && clauses !== "using";
 	const results = [];
 	if (needsUsing) results.push(clause(usingExpr));
 	if (needsWithCheck) results.push(clause(withCheckExpr));
@@ -1411,13 +1626,25 @@ function resolveTriState(value, onUnknown) {
 * the same model compiled to Postgres RLS DDL, so the decision matches database
 * enforcement for every non-raw rule.
 *
+* Engine-independent by design. `securityRules` are a declaration about the
+* data, not about Postgres: the engine decides *who* enforces them (Postgres
+* compiles them to RLS DDL, a document driver applies them in-process), never
+* *whether* they hold. Gating this function on the engine's `supportsRLS`
+* capability is what made every `{ onUnknown: "deny" }` call site in the Mongo
+* driver return `true` before it evaluated anything — and it did so only for
+* collections that spelled their engine out, so declaring `engine: "mongodb"`
+* was what switched authorization off.
+*
 * @param options.onUnknown how to treat rules that cannot be decided
 *   client-side (raw SQL, or row predicates with no row). Defaults to `"allow"`
 *   for optimistic UI gating; enforcement callers should pass `"deny"`.
+* @param options.clauses which half of each rule to evaluate. See
+*   {@link PolicyClauses}; defaults to `"both"`.
 */
 function checkOperation(collection, authContext, entity, targetOperation, options) {
 	const onUnknown = options?.onUnknown ?? "allow";
-	const securityRules = getDataSourceCapabilities(collection.engine).supportsRLS ? collection.securityRules : void 0;
+	const clauses = options?.clauses ?? "both";
+	const securityRules = collection.securityRules;
 	if (!securityRules || securityRules.length === 0) return true;
 	const applicableRules = securityRules.filter((r) => ruleApplies(r, targetOperation));
 	if (applicableRules.length === 0) return false;
@@ -1431,7 +1658,7 @@ function checkOperation(collection, authContext, entity, targetOperation, option
 	let hasPermissive = false;
 	for (const rule of applicableRules) {
 		const mode = rule.mode || "permissive";
-		const passed = resolveTriState(evaluateRuleForOperation(rule, ctx, targetOperation), onUnknown);
+		const passed = resolveTriState(evaluateRuleForOperation(rule, ctx, targetOperation, clauses), onUnknown);
 		if (mode === "restrictive") {
 			if (!passed) {
 				deniedByRestrictive = true;
@@ -1627,8 +1854,14 @@ var buildPropertyCallbacks = (properties) => {
 * Rebase's enforcement model is unified: authenticated (user-context) requests
 * run under the restricted `rebase_user` role, so Postgres RLS binds *every*
 * statement — reads and writes. A collection's `securityRules` are the whole
-* authorization model. The server context (auth flows, migrations,
-* `dataAsAdmin`) runs as the owner and bypasses RLS.
+* authorization model. The server context (auth flows, migrations, raw
+* `rebase.sql`) runs as the owner and bypasses RLS.
+*
+* `rebase.dataAsAdmin` is **not** in that set, despite the name: it is scoped as
+* `{ uid: "service", roles: ["admin"] }`, so it runs as `rebase_user` like any
+* other caller and clears the baseline below through the *admin* arm, not the
+* server arm. Which is why `disableDefaultPolicies` plus a lone
+* `policy.serverContext()` rule locks it out too.
 *
 * Because RLS default-denies, every collection is **locked by default**: with
 * no rules, only the server context and admins can touch it. The generator
@@ -1686,11 +1919,28 @@ function getIdPropertyName$1(collection) {
 *
 * Collections that opt out via `disableDefaultPolicies` are returned unchanged.
 */
+/**
+* The restrictive write gate for an auth collection.
+*
+* Restrictive, so it is ANDed with everything else: whatever an author's
+* permissive rules allow, a write to this table still has to satisfy this too.
+* It is the only thing standing between "users may edit their own row" and
+* "users may grant themselves any role".
+*/
+function adminWriteGate(tableName) {
+	return {
+		name: `${tableName}_require_admin_write`,
+		mode: "restrictive",
+		operations: [...DEFAULT_GUARDED_OPS],
+		condition: SERVER_OR_ADMIN_EXPR$1,
+		check: SERVER_OR_ADMIN_EXPR$1
+	};
+}
 function getEffectiveSecurityRules(collection) {
 	const explicit = [...collection.securityRules ?? []];
-	if (isPostgresCollectionConfig(collection) && collection.disableDefaultPolicies) return explicit;
 	const tableName = getTableName(collection);
 	const injected = [];
+	if (isPostgresCollectionConfig(collection) && collection.disableDefaultPolicies) return isAuthCollection(collection) ? [...explicit, adminWriteGate(tableName)] : explicit;
 	injected.push({
 		name: `${tableName}_default_admin_read`,
 		operations: ["select"],
@@ -1708,13 +1958,7 @@ function getEffectiveSecurityRules(collection) {
 			operations: ["select"],
 			condition: policy.compare(policy.field(getIdPropertyName$1(collection)), "eq", policy.authUid())
 		});
-		injected.push({
-			name: `${tableName}_require_admin_write`,
-			mode: "restrictive",
-			operations: [...DEFAULT_GUARDED_OPS],
-			condition: SERVER_OR_ADMIN_EXPR$1,
-			check: SERVER_OR_ADMIN_EXPR$1
-		});
+		injected.push(adminWriteGate(tableName));
 	}
 	return [...explicit, ...injected];
 }
@@ -1730,7 +1974,7 @@ function getEffectiveSecurityRules(collection) {
 * DDL, which policies are injected and how to take them off.
 */
 function getInjectedSecurityRules(collection) {
-	if (isPostgresCollectionConfig(collection) && collection.disableDefaultPolicies) return [];
+	if (isPostgresCollectionConfig(collection) && collection.disableDefaultPolicies) return isAuthCollection(collection) ? [adminWriteGate(getTableName(collection))] : [];
 	const explicitCount = (collection.securityRules ?? []).length;
 	return getEffectiveSecurityRules(collection).slice(explicitCount);
 }
@@ -1996,9 +2240,14 @@ function registerConditionOperations() {
 	operationsRegistered = true;
 }
 /**
-* Evaluate a JSON Logic rule against the given context.
+* Evaluate a condition against the given context.
+*
+* A condition may be stated as a literal instead of a rule — `hidden: true`
+* rather than `hidden: { "==": [1, 1] }` — and a literal is already its own
+* answer, so it is returned rather than handed to the evaluator.
 */
 function evaluateCondition(rule, context) {
+	if (typeof rule === "boolean") return rule;
 	registerConditionOperations();
 	return jsonLogic.apply(rule, context);
 }
@@ -2216,12 +2465,14 @@ function buildCollectionFromTableMetadata(tableName, metadata) {
 		if (property) {
 			const propRecord = property;
 			Object.keys(propRecord).forEach((key) => propRecord[key] === void 0 && delete propRecord[key]);
-			properties[column.column_name] = property;
-			propertiesOrder.push(column.column_name);
+			const key = firstFreeKey([toWireKey(column.column_name), column.column_name], { has: (candidate) => candidate in properties });
+			if (key !== column.column_name) propRecord.columnName = column.column_name;
+			properties[key] = property;
+			propertiesOrder.push(key);
 		}
 	}
 	if (metadata.foreignKeys) for (const fk of metadata.foreignKeys) {
-		const relName = fk.column_name.endsWith("_id") ? fk.column_name.substring(0, fk.column_name.length - 3) : fk.column_name;
+		const relName = toWireKey(fk.column_name.endsWith("_id") ? fk.column_name.substring(0, fk.column_name.length - 3) : fk.column_name);
 		relations.push({
 			id: fk.column_name,
 			relationName: relName,
@@ -2317,6 +2568,142 @@ function resolveStringColumnLength(prop) {
 	return typeof max === "number" && Number.isInteger(max) && max > 0 ? max : 255;
 }
 //#endregion
+//#region src/util/internal-tables.ts
+/**
+* The tables Rebase creates for its own bookkeeping, and the SQL that keeps the
+* end-user role away from them.
+*
+* ## Why this exists
+*
+* Authenticated requests run as {@link REBASE_USER_ROLE}, and the boot-time role
+* provisioning grants that role `SELECT, INSERT, UPDATE, DELETE` on every table
+* in the schemas a project uses — including `rebase`, because a project's own
+* collections are allowed to live there (the scaffold puts `users` there). It
+* also sets `ALTER DEFAULT PRIVILEGES`, so a table created *later* by the
+* migrating role inherits the same grant.
+*
+* Every framework-internal table is created later: auth's tables come up during
+* `initializeAuth`, `api_keys` during route mounting, `cron_logs` when the first
+* job registers, `idempotency_keys` on the first request that carries a key. So
+* they all inherited full DML for the end-user role — and none of them enables
+* row-level security, because none of them is a collection with
+* `securityRules`. Measured on a freshly provisioned database, `SET ROLE
+* rebase_user` could read `rebase.refresh_tokens` (session token hashes),
+* `rebase.mfa_factors` (`secret_encrypted`), `rebase.recovery_codes`, and
+* `rebase.api_keys` (including its `admin` flag), and insert into
+* `rebase.app_config`.
+*
+* Nothing routes a user-context query at those tables today, so this was not
+* reachable over the API. That is the wrong thing to depend on: the documented
+* model is that RLS is the authorization boundary, and these tables sat outside
+* it. The boundary is now a privilege boundary instead — the role simply cannot
+* address them.
+*
+* ## Why REVOKE rather than ENABLE ROW LEVEL SECURITY
+*
+* RLS with no policy denies every row, which is the same outcome, but it is the
+* *weaker* statement: it leaves the grant in place, so a later policy — or a
+* `FORCE` flag cleared by some future migration — reopens the table. There is no
+* row of `refresh_tokens` any end user should ever reach, so the honest encoding
+* is "this role has no privilege here at all". It also keeps the owner
+* connection (which auth actually runs on) completely unaffected.
+*
+* ## Keeping it true
+*
+* `packages/rls-check` scans the `rebase` schema — it used to skip it as a
+* "platform" schema — and its `rls-disabled` check fires on exactly the
+* condition this module removes: RLS off *and* a DML grant to a reachable role.
+* So a table added here without a revoke is caught by `pnpm rls:check`, not by
+* someone re-reading this file.
+*/
+/**
+* The Postgres role authenticated requests run as.
+*
+* Defined here rather than in the Postgres driver because both the driver (which
+* provisions the role) and this module (which revokes on its behalf) need it,
+* and a second spelling of a role name is a silent no-op waiting to happen.
+*/
+var REBASE_USER_ROLE = "rebase_user";
+/**
+* Framework-internal table names, unqualified.
+*
+* Deliberately NOT including `users`: the auth user table is also a collection,
+* with `securityRules`, RLS enabled and policies applied. Users read their own
+* row through it — revoking there would break sign-in.
+*
+* `atlas_schema_revisions` is Atlas's migration ledger, which lands in `rebase`
+* because `db migrate apply` passes `--revisions-schema rebase`.
+*/
+var REBASE_INTERNAL_TABLES = [
+	"user_identities",
+	"refresh_tokens",
+	"password_reset_tokens",
+	"magic_link_tokens",
+	"mfa_factors",
+	"mfa_challenges",
+	"recovery_codes",
+	"app_config",
+	"schema_meta",
+	"api_keys",
+	"cron_logs",
+	"cron_claims",
+	"idempotency_keys",
+	"entity_history",
+	"branches",
+	"channel_messages",
+	"channel_cursors",
+	"channel_presence",
+	"atlas_schema_revisions"
+];
+/** Postgres identifiers this module is willing to interpolate. */
+var SAFE_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_$]*$/;
+/**
+* A single statement that takes every privilege on `schema.table` away from the
+* end-user role.
+*
+* Wrapped in a `DO` block guarded on `pg_roles` for two reasons, both of which
+* happen in practice:
+*
+*  - the role does not exist when the connection is unprivileged (Rebase then
+*    relies on native RLS rather than a role switch), and a bare `REVOKE` on a
+*    missing role is an error, not a no-op;
+*  - the table may not exist yet — `cron_logs` never appears in a project with
+*    no cron jobs — and `to_regclass` returning NULL has to be tolerated too.
+*
+* One command, so it is safe on handles that speak the extended query protocol
+* and reject multi-statement strings.
+*/
+function revokeInternalTableSql(schema, table) {
+	if (!SAFE_IDENTIFIER.test(schema)) throw new Error(`Refusing to build SQL with an unsafe schema name: ${JSON.stringify(schema)}`);
+	if (!SAFE_IDENTIFIER.test(table)) throw new Error(`Refusing to build SQL with an unsafe table name: ${JSON.stringify(table)}`);
+	const qualified = `"${schema}"."${table}"`;
+	return `
+        DO $rebase_revoke$
+        BEGIN
+            IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = '${REBASE_USER_ROLE}')
+               AND to_regclass('${qualified}') IS NOT NULL THEN
+                EXECUTE 'REVOKE ALL ON ${qualified} FROM ${REBASE_USER_ROLE}';
+            END IF;
+        END
+        $rebase_revoke$;
+    `.trim();
+}
+/**
+* Revoke on every internal table in `schema`, one statement at a time.
+*
+* Best-effort per table: a connection that does not own one of them (a
+* pre-provisioned database, a platform-managed ledger) cannot revoke on it, and
+* that must not take down a boot. The caller decides how loud to be — `onError`
+* exists so the driver can warn without this module importing a logger.
+*/
+async function revokeInternalTableAccess(execute, schema, options) {
+	for (const table of options?.tables ?? REBASE_INTERNAL_TABLES) try {
+		await execute(revokeInternalTableSql(schema, table));
+	} catch (error) {
+		options?.onError?.(table, error);
+	}
+}
+//#endregion
 //#region src/data/resolveDataSource.ts
 /**
 * Build a keyed registry from a list of {@link DataSourceDefinition}s.
@@ -2359,6 +2746,46 @@ function resolveDataSource(collection, registry) {
 		capabilities: getDataSourceCapabilities(engine)
 	};
 }
+/**
+* Does a SQL toolchain own this collection's storage?
+*
+* "Owns the storage" means: something generates a table for it, pushes that
+* table to a database, plans its RLS policies, and reports it as drifted when
+* the two disagree. That is true of a Postgres collection and false of a
+* Firestore or MongoDB one, whose documents live in a store Rebase never
+* migrates — and the two were never told apart. Every stage of the SQL
+* toolchain took "the collections" to mean *all* of them, so a Firestore
+* collection declared next to the Postgres ones got a `pgTable` in the
+* generated schema, a `CREATE TABLE` at boot, RLS policies, and a place in the
+* `db push` include list — where its name shielding a same-named real table
+* from Atlas's exclude list is the one that can lose data.
+*
+* The answer is the resolved engine's {@link DataSourceCapabilities}, not a
+* name check: an engine registered through `registerDataSourceCapabilities`
+* gets the same treatment as the built-in ones.
+*
+* Deliberately answers **true** for an engine nobody has heard of. Build-time
+* tooling (the CLI, the schema generator) has no data-source registry to
+* resolve a `dataSource` key against, so an unknown key resolves to an unknown
+* engine — and the cost of the two mistakes is not symmetric. Wrongly
+* including a collection generates a table nothing writes to; wrongly excluding
+* one silently stops generating a table the app is serving from. Declare
+* `engine` on a collection that is not SQL-backed and this is exact.
+*/
+function isRelationalCollection(collection, registry) {
+	return getDataSourceCapabilities(collection?.engine ?? (collection?.dataSource ? resolveDataSource(collection, registry).engine : void 0)).supportsRelations;
+}
+/**
+* The subset of `collections` a SQL toolchain owns — see
+* {@link isRelationalCollection}.
+*
+* Every stage that generates SQL from collections starts by calling this, so
+* the rule lives in one place rather than being re-decided per generator. It
+* keeps the input order.
+*/
+function relationalCollections(collections, registry) {
+	return collections.filter((collection) => isRelationalCollection(collection, registry));
+}
 //#endregion
 //#region src/collections/CollectionRegistry.ts
 var CollectionRegistry = class {
@@ -2788,8 +3215,24 @@ var QueryBuilder = class {
 	/**
 	* Set a free-text search string if supported by the backend.
 	*/
-	search(searchString) {
+	search(searchString, options) {
 		this.params.searchString = searchString;
+		if (options?.explain !== void 0) this.params.searchExplain = options.explain;
+		return this;
+	}
+	/**
+	* Order rows by nearest-neighbour distance to `vector`, closest first.
+	*
+	* Postgres only, over a property declared as `type: "vector"`. Rows come
+	* back with a `_distance`; `where` filters before the ordering.
+	*/
+	vectorSearch(property, vector, options) {
+		this.params.vectorSearch = {
+			property,
+			vector,
+			...options?.distance !== void 0 && { distance: options.distance },
+			...options?.threshold !== void 0 && { threshold: options.threshold }
+		};
 		return this;
 	}
 	/**
@@ -2861,6 +3304,30 @@ var RebasePaginationError = class RebasePaginationError extends Error {
 		Object.setPrototypeOf(this, RebasePaginationError.prototype);
 	}
 };
+/**
+* Resolve `limit`/`offset`/`page` into the window a read will actually use.
+*
+* Lives here, next to the walk, for the reason at the top of this file: every
+* transport has to mean the same thing by "page two". Four of them did not —
+* the REST layer strode by {@link DEFAULT_LIST_LIMIT}, the local-first
+* evaluator by {@link DEFAULT_PAGE_SIZE}, the in-process accessor by 20, and
+* the published type documented a fourth number. Pages that overlap or skip
+* rows are the mildest of those outcomes.
+*
+* `page` wins over `offset`, as {@link FindParams} documents. `driverOffset`
+* is the value to hand a driver: it stays `undefined` when the caller named no
+* offset, because keyset pagination seeks with a `where` clause and must not
+* look like it is paging by offset.
+*/
+function resolveFindWindow(params) {
+	const limit = params?.limit ?? DEFAULT_LIST_LIMIT;
+	const offset = params?.page != null ? Math.max(0, (params.page - 1) * limit) : params?.offset ?? 0;
+	return {
+		limit,
+		offset,
+		driverOffset: params?.page != null ? offset : params?.offset
+	};
+}
 function normalizePageSize(raw) {
 	if (raw === void 0 || !Number.isFinite(raw)) return 200;
 	return Math.max(1, Math.floor(raw));
@@ -2992,8 +3459,10 @@ function createPaginationHelpers(find, label) {
 * metadata, so type coercion is the responsibility of the server-side data
 * driver which has access to the collection schema.
 *
-* Commas inside list values are backslash-escaped (`\,`), and literal
-* backslashes are escaped as `\\`.
+* Structural characters inside a value are backslash-escaped: `,` → `\,`,
+* `(` → `\(`, `)` → `\)`, and a literal backslash as `\\`. Decoding is
+* deliberately conservative — only those four sequences are decoded, so a
+* backslash that arrives unescaped from an older client survives intact.
 *
 * @module
 */
@@ -3011,22 +3480,55 @@ function stringifyValue(value) {
 	return String(value);
 }
 /**
-* Escape a single list item for the wire format.
-* `\` → `\\`, `,` → `\,`
+* Characters that carry structure in the wire format and must therefore be
+* escaped inside a value: the separator, the group delimiters, and the escape
+* character itself.
+*
+* Parentheses are here because `and(...)`/`or(...)` groups are parsed by
+* tracking paren depth. A value containing one is not merely ambiguous, it
+* moves where the parser thinks the group ends.
+*/
+var WIRE_SPECIALS = /[\\,()]/g;
+/**
+* Escape a value for the wire format: `\` → `\\`, `,` → `\,`, `(` → `\(`,
+* `)` → `\)`.
+*/
+/**
+* The wire spelling of an empty list.
+*
+* A lone backslash: unproducible by {@link escapeWireValue}, which doubles
+* every backslash it emits, so it cannot collide with any real item.
 */
-function escapeListItem(value) {
-	return value.replace(/\\/g, "\\\\").replace(/,/g, "\\,");
+var EMPTY_LIST_TOKEN = "\\";
+function escapeWireValue(value) {
+	return value.replace(WIRE_SPECIALS, (ch) => `\\${ch}`);
 }
 /**
-* Unescape a single list item from the wire format.
-* `\\` → `\`, `\,` → `,`
+* Unescape a wire-format value.
+*
+* **Conservative**, and deliberately so: only the four sequences
+* {@link escapeWireValue} actually produces are decoded. A backslash followed
+* by anything else is left exactly as it is.
+*
+* This used to consume the backslash before *any* character, which is
+* indistinguishable for anything this codec emitted — it only ever emits those
+* four — but not for input arriving from elsewhere. A client on an older
+* release sends a Windows path or a LIKE pattern with a literal `C:\x`
+* unescaped, and greedy unescaping silently turned it into `C:x`, changing
+* which rows matched. Decoding only what the encoder can produce makes the two
+* directions agree across versions.
 */
-function unescapeListItem(value) {
+function unescapeWireValue(value) {
 	let result = "";
-	for (let i = 0; i < value.length; i++) if (value[i] === "\\" && i + 1 < value.length) {
-		result += value[i + 1];
-		i++;
-	} else result += value[i];
+	for (let i = 0; i < value.length; i++) {
+		const next = value[i + 1];
+		if (value[i] === "\\" && (next === "\\" || next === "," || next === "(" || next === ")")) {
+			result += next;
+			i++;
+			continue;
+		}
+		result += value[i];
+	}
 	return result;
 }
 /**
@@ -3044,14 +3546,235 @@ function splitListItems(inner) {
 		current += inner[i] + inner[i + 1];
 		i++;
 	} else if (inner[i] === ",") {
-		items.push(unescapeListItem(current));
+		items.push(unescapeWireValue(current));
 		current = "";
 	} else current += inner[i];
-	items.push(unescapeListItem(current));
+	items.push(unescapeWireValue(current));
 	return items;
 }
-var REST_OP_LOOKUP = REST_TO_CANONICAL;
-var CANONICAL_OP_LOOKUP = CANONICAL_TO_REST;
+/**
+* Split a group body on commas at paren depth 0, honouring escapes.
+*
+* The escape-awareness is the point. The splitter used to track only paren
+* depth, so a comma inside a scalar value ended a condition:
+* `or(name.eq.Doe, John,age.gte.18)` parsed as *three* conditions, the middle
+* one a fabricated `" John" == true`. On an `or` that widens the result set,
+* and nothing anywhere reports an error — the query simply stops meaning what
+* the caller wrote.
+*/
+function splitGroupItems(inner) {
+	const parts = [];
+	let depth = 0;
+	let start = 0;
+	for (let i = 0; i < inner.length; i++) {
+		const ch = inner[i];
+		if (ch === "\\" && i + 1 < inner.length) {
+			i++;
+			continue;
+		}
+		if (ch === "(") depth++;
+		else if (ch === ")") depth--;
+		else if (ch === "," && depth === 0) {
+			parts.push(inner.slice(start, i));
+			start = i + 1;
+		}
+	}
+	parts.push(inner.slice(start));
+	return parts;
+}
+/**
+* Operator tables as `Map`s, because the key comes off the wire.
+*
+* Indexed as plain objects, every `Object.prototype` member answered: a query
+* string of `?f=valueOf.x` found a truthy "operator" — the inherited function —
+* and `deserializeTuple` returned it *as the operator*, so a function object
+* travelled on into the compilers in place of a `WhereFilterOp`. The guard one
+* line below (`if (!canonicalOp)`) reads as though it rejects anything unknown,
+* and does not: `Object.prototype` is not unknown to a plain object.
+*
+* Same shape as the prototype-key defects swept out of `setIn`, `getIn`,
+* `mergeDeep`, `unflattenObject` and `FOREIGN_CONVENTION_UIDS`.
+*/
+var REST_OP_LOOKUP = new Map(Object.entries(REST_TO_CANONICAL));
+var CANONICAL_OP_LOOKUP = new Map(Object.entries(CANONICAL_TO_REST));
+/** The operator spellings a rejection lists back to the caller. */
+var VALID_OPERATOR_LIST = ALL_WHERE_FILTER_OPS.join(", ");
+/**
+* A filter condition named an operator this dialect does not have.
+*
+* ## Why this throws, rather than returning a typed rejection
+*
+* `deserializeFilter` is the *shared* codec: the REST ingress
+* (`packages/server/src/api/rest/query-parser.ts`), the browser SDK and the
+* admin panel (`buildRebaseData.ts`) all decode through it. Two constraints
+* follow.
+*
+* - It cannot throw the server's `ApiError`. `@rebasepro/common` does not
+*   depend on `@rebasepro/server` (the dependency runs the other way), and a
+*   browser client has no error handler to render an `ApiError` with. So the
+*   rejection is this plain `Error` subclass, whose `message` reads correctly
+*   wherever it surfaces — a rejected promise in an app, a 400 body over HTTP.
+* - It cannot be a returned rejection *value*. Every caller assigns the result
+*   straight into a query it is about to run; a sentinel that none of them
+*   check would be ignored, which is exactly the silently-wrong-filter failure
+*   this exists to stop. Throwing is also what this file already does for the
+*   sibling cases — `serializeTuple` on an unknown canonical operator,
+*   `deserializeLogicalCondition` past the nesting bound — and the REST parser
+*   already converts the latter into a 400.
+*
+* `statusCode`, `code` and `details` are carried as fields because the server's
+* Hono error handler duck-types those off any thrown error: a decode path that
+* forgets to convert still answers 400 with the canonical envelope instead of a
+* 500 that says "An unexpected error occurred". `query-parser.ts` converts
+* explicitly all the same — that is the path the contract is stated on, and an
+* incidental 400 is not a contract.
+*/
+var UnknownFilterOperatorError = class extends Error {
+	/** The field the condition was written against. */
+	field;
+	/** The operator string as it arrived, verbatim. */
+	operator;
+	/** Every operator this dialect accepts, in canonical spelling. */
+	validOperators = ALL_WHERE_FILTER_OPS;
+	/** See the class docblock: read by the server's error handler. */
+	statusCode = 400;
+	code = "UNKNOWN_FILTER_OPERATOR";
+	details;
+	constructor(field, operator) {
+		super(`Unknown filter operator '${operator}' on field '${field}'. Valid operators: ${VALID_OPERATOR_LIST}`);
+		this.name = "UnknownFilterOperatorError";
+		this.field = field;
+		this.operator = operator;
+		this.details = {
+			field,
+			operator,
+			validOperators: ALL_WHERE_FILTER_OPS
+		};
+	}
+};
+/**
+* Two to three characters of ASCII punctuation and nothing else — the shape
+* every symbolic operator has (`==`, `>=`, `<>`, `~~`, `!!`, `>>`, `===`), and
+* one a column value effectively never has.
+*
+* Two characters minimum on purpose. A *single* punctuation character is a
+* perfectly ordinary value — `{ grade: ["-", "+"] }` is a two-item list, not a
+* condition — and the only single-character operator anyone actually mistypes
+* is `=`, which is named separately below. `<` and `>` need no special case:
+* they are real operators and resolve.
+*/
+var SYMBOLIC_OPERATOR = /^[^\p{L}\p{N}\s]{2,3}$/u;
+/** Lowercase, strip everything that is not a letter or digit. */
+function normalizeOperatorName(op) {
+	return op.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+/**
+* Every real operator name with its case and separators removed, so a
+* respelling of one — `arrayContains`, `not_in`, `NOT-LIKE`, `isNull` — is
+* recognised as an attempt at an operator rather than read as a value.
+*
+* These are rejected rather than accepted: admitting a second spelling of an
+* operator would leave two wire spellings of one thing, and the rejection
+* message names the one that works.
+*/
+var RESPELLED_OPERATORS = new Set([...ALL_WHERE_FILTER_OPS, ...Object.keys(REST_TO_CANONICAL)].map(normalizeOperatorName));
+/**
+* Operator names *other* query dialects use, which this one does not have.
+*
+* This list is curated, and deliberately so. For a word-shaped string there is
+* no rule that separates "an operator the caller guessed" from "a value that
+* happens to be a word": `{ tags: ["a", "b"] }` has to keep meaning a two-item
+* `in` list, so the codec cannot simply refuse every unrecognised word in
+* position 0. The line is therefore drawn by name, and only around names whose
+* use as an operator is far more likely than their use as one of two sibling
+* values. `contains` is the motivating case — the first thing a developer
+* reaches for, and until now it compiled to `title IN ('contains', 'Hell')`.
+*
+* Genuinely ambiguous single words (`any`, `all`, `exists`, `search`, `not`)
+* are left off: as operators they are rare, and as enum values they are common.
+* Everywhere else the tie goes to *rejecting*, because a 400 naming the
+* supported set costs the caller one round trip, and the alternative — which is
+* what every name on this list used to produce — is a query that runs, returns
+* rows, and is wrong.
+*/
+var NEAR_MISS_OPERATORS = /* @__PURE__ */ new Set([
+	"contains",
+	"notcontains",
+	"doesnotcontain",
+	"doesnotcontains",
+	"includes",
+	"notincludes",
+	"startswith",
+	"notstartswith",
+	"beginswith",
+	"startingwith",
+	"endswith",
+	"notendswith",
+	"matches",
+	"notmatches",
+	"regex",
+	"regexp",
+	"between",
+	"notbetween",
+	"equals",
+	"notequals",
+	"equalto",
+	"isequalto",
+	"isnotequalto",
+	"greaterthan",
+	"greaterthanorequal",
+	"greaterthanorequalto",
+	"lessthan",
+	"lessthanorequal",
+	"lessthanorequalto",
+	"isempty",
+	"isnotempty",
+	"oneof",
+	"noneof",
+	"anyof",
+	"allof",
+	"null",
+	"isnullorempty"
+]);
+/**
+* Was this string *meant* as an operator?
+*
+* Only consulted after {@link toCanonicalOp} has already failed to resolve it,
+* so a `true` here is always a rejection.
+*/
+function isOperatorShaped(op) {
+	if (op === "=") return true;
+	if (SYMBOLIC_OPERATOR.test(op)) return true;
+	const normalized = normalizeOperatorName(op);
+	if (!normalized) return false;
+	return RESPELLED_OPERATORS.has(normalized) || NEAR_MISS_OPERATORS.has(normalized);
+}
+/**
+* Read a `[op, value]` tuple, if that is what this is.
+*
+* Three outcomes, and the middle one is the defect this function exists for:
+*
+* - the operator resolves (canonical *or* REST spelling) → the canonical tuple;
+* - the operator does not resolve but was plainly meant as one → throw;
+* - it does not look like an operator at all → `undefined`, and the caller
+*   falls back to reading the array as a list of values.
+*
+* The old test was `toCanonicalOp(raw[0]) === raw[0]`, i.e. canonical spelling
+* only, with *everything else* — including every REST short-code — dropping
+* through to `["in", raw]`. So the operator string itself became a value in a
+* membership test: `["!!", "Hello"]` compiled to `title IN ('!!','Hello')`,
+* which matches, and the caller got back rows their filter was written to
+* exclude. `["eq", "active"]` had the same shape of failure.
+*/
+function readTuple(field, raw) {
+	if (!Array.isArray(raw) || raw.length !== 2) return void 0;
+	const [op, value] = raw;
+	if (typeof op !== "string") return void 0;
+	const canonical = toCanonicalOp(op);
+	if (canonical) return [canonical, value];
+	if (op.includes(".")) return void 0;
+	if (isOperatorShaped(op)) throw new UnknownFilterOperatorError(field, op);
+}
 /**
 * Serialize a single canonical condition tuple to a PostgREST dot-string.
 *
@@ -3066,9 +3789,13 @@ function serializeTuple(tuple) {
 	if (!Array.isArray(tuple) || tuple.length !== 2) throw new TypeError(`serializeTuple: expected a [WhereFilterOp, value] tuple, got ${JSON.stringify(tuple)}`);
 	const [op, value] = tuple;
 	if (typeof op !== "string") throw new TypeError(`serializeTuple: operator must be a string, got ${typeof op}`);
-	const restOp = CANONICAL_OP_LOOKUP[op];
+	const restOp = CANONICAL_OP_LOOKUP.get(op);
 	if (!restOp) throw new TypeError(`serializeTuple: unknown operator "${op}". Valid operators: ${Object.keys(CANONICAL_TO_REST).join(", ")}`);
-	if (Array.isArray(value)) return `${restOp}.(${value.map((v) => escapeListItem(stringifyValue(v))).join(",")})`;
+	if (value === null && (op === "==" || op === "!=")) return op === "==" ? "isnull.null" : "notnull.null";
+	if (Array.isArray(value)) {
+		if (value.length === 0) return `${restOp}.(${EMPTY_LIST_TOKEN})`;
+		return `${restOp}.(${value.map((v) => escapeWireValue(stringifyValue(v))).join(",")})`;
+	}
 	return `${restOp}.${stringifyValue(value)}`;
 }
 /**
@@ -3120,10 +3847,13 @@ function deserializeSingle(raw) {
 	if (dotIndex === -1) return ["==", raw];
 	const prefix = raw.substring(0, dotIndex);
 	const rest = raw.substring(dotIndex + 1);
-	const canonicalOp = REST_OP_LOOKUP[prefix];
+	const canonicalOp = REST_OP_LOOKUP.get(prefix);
 	if (!canonicalOp) return ["==", raw];
 	if (NULL_OPS.has(canonicalOp)) return [canonicalOp, null];
-	if (rest.startsWith("(") && rest.endsWith(")")) return [canonicalOp, splitListItems(rest.slice(1, -1))];
+	if (rest.startsWith("(") && rest.endsWith(")")) {
+		const inner = rest.slice(1, -1);
+		return [canonicalOp, inner === EMPTY_LIST_TOKEN ? [] : splitListItems(inner)];
+	}
 	return [canonicalOp, rest];
 }
 /**
@@ -3138,20 +3868,27 @@ function deserializeSingle(raw) {
 *
 * deserializeFilter({ age: ["gte.18", "lt.65"] })
 * // → { age: [[">=", "18"], ["<", "65"]] }
+*
+* @throws {UnknownFilterOperatorError} when a condition names an operator this
+* dialect does not have. See that class for why a rejection here is a throw.
 */
 function deserializeFilter(query) {
 	const result = {};
 	for (const [field, raw] of Object.entries(query)) {
 		if (raw === void 0) continue;
-		if (Array.isArray(raw) && raw.length === 2 && typeof raw[0] === "string" && toCanonicalOp(raw[0]) === raw[0]) {
-			result[field] = raw;
+		const tuple = readTuple(field, raw);
+		if (tuple) {
+			result[field] = tuple;
 			continue;
 		}
 		if (Array.isArray(raw)) {
 			if (raw.length === 0) continue;
-			if (Array.isArray(raw[0]) && raw[0].length === 2 && typeof raw[0][0] === "string" && toCanonicalOp(raw[0][0]) === raw[0][0]) {
-				result[field] = raw;
-				continue;
+			if (Array.isArray(raw[0])) {
+				const tuples = raw.map((item) => readTuple(field, item));
+				if (tuples.every((t) => t !== void 0)) {
+					result[field] = tuples;
+					continue;
+				}
 			}
 			if (raw.length === 1) result[field] = typeof raw[0] === "string" ? deserializeSingle(raw[0]) : ["==", raw[0]];
 			else if (typeof raw[0] === "string" && raw[0].includes(".")) result[field] = raw.map((r) => typeof r === "string" ? deserializeSingle(r) : ["==", r]);
@@ -3176,12 +3913,12 @@ function serializeLogicalCondition(cond) {
 		const inner = (cond.conditions ?? []).map(serializeLogicalCondition).join(",");
 		return `${cond.type}(${inner})`;
 	}
-	const restOp = CANONICAL_OP_LOOKUP[cond.operator] ?? "eq";
+	const restOp = CANONICAL_OP_LOOKUP.get(cond.operator) ?? "eq";
 	if (Array.isArray(cond.value)) {
-		const items = cond.value.map((v) => escapeListItem(stringifyValue(v))).join(",");
+		const items = cond.value.map((v) => escapeWireValue(stringifyValue(v))).join(",");
 		return `${cond.column}.${restOp}.(${items})`;
 	}
-	return `${cond.column}.${restOp}.${stringifyValue(cond.value)}`;
+	return `${cond.column}.${restOp}.${escapeWireValue(stringifyValue(cond.value))}`;
 }
 /**
 * Parse a logical condition wire-format string back into a
@@ -3194,24 +3931,29 @@ function serializeLogicalCondition(cond) {
 * deserializeLogicalCondition("or(status.eq.active,age.gte.18)")
 * // → { type: "or", conditions: [...] }
 */
-function deserializeLogicalCondition(str) {
+/**
+* How deeply `or(...)`/`and(...)` groups may nest.
+*
+* This parser recurses once per level, on a value that arrives in a query
+* string. Unbounded, twenty thousand levels reached `RangeError: Maximum call
+* stack size exceeded`, which a caller sees as a 500 about the call stack
+* rather than a 400 about their filter. Node's 16 KB header cap keeps a GET
+* below that in practice, but "the HTTP layer happens to stop it" is not a
+* bound this parser should rely on.
+*
+* Thirty-two is far past anything a real filter expresses; the deepest in this
+* repository's own tests is three.
+*/
+var MAX_LOGICAL_NESTING_DEPTH = 32;
+function deserializeLogicalCondition(str, nesting = 0) {
+	if (nesting > 32) throw new Error(`Filter groups nest more than 32 levels deep. Flatten the condition — \`or(a,or(b,c))\` is \`or(a,b,c)\`.`);
 	const logicalMatch = str.match(/^(and|or)\((.+)\)$/);
 	if (logicalMatch) {
 		const type = logicalMatch[1];
 		const innerStr = logicalMatch[2];
-		const conditions = [];
-		let depth = 0;
-		let start = 0;
-		for (let i = 0; i < innerStr.length; i++) if (innerStr[i] === "(") depth++;
-		else if (innerStr[i] === ")") depth--;
-		else if (innerStr[i] === "," && depth === 0) {
-			conditions.push(deserializeLogicalCondition(innerStr.slice(start, i)));
-			start = i + 1;
-		}
-		conditions.push(deserializeLogicalCondition(innerStr.slice(start)));
 		return {
 			type,
-			conditions
+			conditions: splitGroupItems(innerStr).map((part) => deserializeLogicalCondition(part, nesting + 1))
 		};
 	}
 	const firstDot = str.indexOf(".");
@@ -3226,7 +3968,7 @@ function deserializeLogicalCondition(str) {
 	if (secondDot === -1) return {
 		column,
 		operator: "==",
-		value: rest
+		value: unescapeWireValue(rest)
 	};
 	const opStr = rest.substring(0, secondDot);
 	const valueStr = rest.substring(secondDot + 1);
@@ -3239,7 +3981,7 @@ function deserializeLogicalCondition(str) {
 	return {
 		column,
 		operator,
-		value: valueStr
+		value: unescapeWireValue(valueStr)
 	};
 }
 //#endregion
@@ -3276,10 +4018,12 @@ function createPrimaryKeyResolver(options) {
 * than postgres still serve rows with one, and this keeps them working.
 */
 function rowToEntity(row, slug, primaryKeys = []) {
+	const { _matches, ...values } = row;
 	return {
 		id: primaryKeys.length > 0 ? buildCompositeId(row, primaryKeys) : row.id,
 		path: slug,
-		values: row
+		values,
+		..._matches ? { searchMatches: _matches } : {}
 	};
 }
 /**
@@ -3322,21 +4066,22 @@ function createDriverAccessor(driver, slug, getPks = () => []) {
 	const accessor = {
 		async find(params) {
 			const filter = params?.where ? deserializeFilter(params.where) : void 0;
-			const limit = params?.limit ?? 20;
-			const offset = params?.offset ?? 0;
+			const { limit, offset, driverOffset } = resolveFindWindow(params);
 			const fetchService = driver.restFetchService;
 			const rows = fetchService ? await fetchService.fetchCollectionForRest(slug, {
 				filter,
-				limit: params?.limit,
-				offset: params?.offset,
+				logical: params?.logical,
+				limit,
+				offset: driverOffset,
 				orderBy: params?.orderBy?.[0],
 				order: params?.orderBy?.[1],
 				searchString: params?.searchString
 			}, params?.include) : await driver.fetchCollection({
 				path: slug,
-				limit: params?.limit,
-				offset: params?.offset,
+				limit,
+				offset: driverOffset,
 				filter,
+				logical: params?.logical,
 				orderBy: params?.orderBy?.[0],
 				order: params?.orderBy?.[1],
 				searchString: params?.searchString
@@ -3346,7 +4091,9 @@ function createDriverAccessor(driver, slug, getPks = () => []) {
 			if (driver.count) {
 				total = await driver.count({
 					path: slug,
-					filter
+					filter,
+					logical: params?.logical,
+					searchString: params?.searchString
 				});
 				hasMore = offset + rows.length < total;
 			}
@@ -3398,30 +4145,48 @@ function createDriverAccessor(driver, slug, getPks = () => []) {
 				values: {}
 			} });
 		},
+		updateMany: driver.updateMany ? async (updates) => {
+			return (await driver.updateMany({
+				path: slug,
+				updates: updates.map((u) => ({
+					id: u.id,
+					values: u.data
+				}))
+			})).map((row) => rowToEntity(row, slug, getPks()));
+		} : void 0,
+		deleteMany: driver.deleteMany ? async (ids) => {
+			await driver.deleteMany({
+				path: slug,
+				ids
+			});
+		} : void 0,
 		count: driver.count ? async (params) => {
 			const filter = params?.where ? deserializeFilter(params.where) : void 0;
 			return driver.count({
 				path: slug,
-				filter
+				filter,
+				logical: params?.logical,
+				searchString: params?.searchString
 			});
 		} : void 0,
 		listen: driver.listenCollection ? (params, onUpdate, onError) => {
-			const limit = params?.limit ?? 20;
-			const offset = params?.offset ?? 0;
+			const { limit, offset, driverOffset } = resolveFindWindow(params);
 			const normalize = driver.restFetchService ? inlineRelationRefs : (row) => row;
 			return driver.listenCollection({
 				path: slug,
-				limit: params?.limit,
-				offset: params?.offset,
+				limit,
+				offset: driverOffset,
 				filter: params?.where,
+				logical: params?.logical,
 				orderBy: params?.orderBy?.[0],
 				order: params?.orderBy?.[1],
 				searchString: params?.searchString,
+				searchExplain: params?.searchExplain,
 				onUpdate: (entities) => {
 					onUpdate({
 						data: entities.map((row) => rowToEntity(normalize(row), slug, getPks())),
 						meta: {
-							total: entities.length,
+							total: offset + entities.length,
 							limit,
 							offset,
 							hasMore: entities.length >= limit
@@ -3454,8 +4219,11 @@ function createDriverAccessor(driver, slug, getPks = () => []) {
 		offset(count) {
 			return new QueryBuilder(accessor).offset(count);
 		},
-		search(searchString) {
-			return new QueryBuilder(accessor).search(searchString);
+		search(searchString, options) {
+			return new QueryBuilder(accessor).search(searchString, options);
+		},
+		vectorSearch(property, vector, options) {
+			return new QueryBuilder(accessor).vectorSearch(property, vector, options);
 		},
 		include(...relations) {
 			return new QueryBuilder(accessor).include(...relations);
@@ -3543,8 +4311,18 @@ var SdkQueryBuilder = class {
 		this.params.offset = count;
 		return this;
 	}
-	search(searchString) {
+	search(searchString, options) {
 		this.params.searchString = searchString;
+		if (options?.explain !== void 0) this.params.searchExplain = options.explain;
+		return this;
+	}
+	vectorSearch(property, vector, options) {
+		this.params.vectorSearch = {
+			property,
+			vector,
+			...options?.distance !== void 0 && { distance: options.distance },
+			...options?.threshold !== void 0 && { threshold: options.threshold }
+		};
 		return this;
 	}
 	include(...relations) {
@@ -3598,9 +4376,24 @@ function toSdkCollectionClient(snap, slug = "collection") {
 		async update(id, data) {
 			return entityToRow(await snap.update(id, data));
 		},
+		async updateMany(updates) {
+			if (!Array.isArray(updates)) throw new TypeError("updateMany expects an array of { id, data } entries.");
+			if (updates.length === 0) return [];
+			if (!snap.updateMany) throw new Error("Bulk updates are not supported by this collection's data source. Fall back to update() per record.");
+			return (await snap.updateMany(updates.map((u) => ({
+				id: u.id,
+				data: u.data
+			})))).map(entityToRow);
+		},
 		delete(id) {
 			return snap.delete(id);
 		},
+		async deleteMany(ids) {
+			if (!Array.isArray(ids)) throw new TypeError("deleteMany expects an array of ids.");
+			if (ids.length === 0) return;
+			if (!snap.deleteMany) throw new Error("Bulk deletes are not supported by this collection's data source. Fall back to delete() per record.");
+			await snap.deleteMany(ids);
+		},
 		count: snap.count ? (params) => snap.count(params) : void 0,
 		listen: snap.listen ? (params, onUpdate, onError) => snap.listen(params, (res) => onUpdate({
 			data: res.data.map(entityToRow),
@@ -3616,6 +4409,7 @@ function toSdkCollectionClient(snap, slug = "collection") {
 		limit: (count) => new SdkQueryBuilder(client).limit(count),
 		offset: (count) => new SdkQueryBuilder(client).offset(count),
 		search: (searchString) => new SdkQueryBuilder(client).search(searchString),
+		vectorSearch: (property, vector, options) => new SdkQueryBuilder(client).vectorSearch(property, vector, options),
 		include: (...relations) => new SdkQueryBuilder(client).include(...relations)
 	};
 	return client;
@@ -3623,7 +4417,7 @@ function toSdkCollectionClient(snap, slug = "collection") {
 /**
 * Wrap a flat {@link SDKCollectionClient} into a Entity-shaped
 * {@link CollectionAccessor}. Every returned row is re-wrapped into the
-* `{ id, path, values }` view-model the admin admin renders.
+* `{ id, path, values }` view-model the admin panel renders.
 */
 function toEntityAccessor(sdk, slug, getPks = () => []) {
 	const accessor = {
@@ -3641,6 +4435,9 @@ function toEntityAccessor(sdk, slug, getPks = () => []) {
 		async create(data, id) {
 			return rowToEntity(await sdk.create(data, id), slug, getPks());
 		},
+		createMany: sdk.createMany ? async (data, options) => {
+			return (await sdk.createMany(data, options)).map((row) => rowToEntity(row, slug, getPks()));
+		} : void 0,
 		async update(id, data) {
 			const row = await sdk.update(id, data);
 			if (!row) throw new Error(`Update returned no data for id ${id}`);
@@ -3664,6 +4461,7 @@ function toEntityAccessor(sdk, slug, getPks = () => []) {
 		limit: (count) => new QueryBuilder(accessor).limit(count),
 		offset: (count) => new QueryBuilder(accessor).offset(count),
 		search: (searchString) => new QueryBuilder(accessor).search(searchString),
+		vectorSearch: (property, vector, options) => new QueryBuilder(accessor).vectorSearch(property, vector, options),
 		include: (...relations) => new QueryBuilder(accessor).include(...relations)
 	};
 	return accessor;
@@ -3677,6 +4475,15 @@ function toEntityAccessor(sdk, slug, getPks = () => []) {
 * admin `RebaseDataContext` — without it the admin renders rows with only their
 * `id`.
 */
+/**
+* Only the by-slug accessor is asked for, so only that is required.
+*
+* Taking a whole `RebaseSdkData` meant taking `RebaseSdkData<unknown>`, whose
+* dynamic branch is an index signature — and no `RebaseSdkData<DB>` satisfies
+* it, because its own `collection` method is not a `SDKCollectionClient`. So a
+* caller holding a *typed* client could not pass it to a function that reads
+* one method off it, and that method is identical on every instantiation.
+*/
 function wrapAsEntityData(sdkData, options) {
 	const cache = /* @__PURE__ */ new Map();
 	const primaryKeysFor = createPrimaryKeyResolver(options);
@@ -3779,6 +4586,27 @@ function buildRoutedRebaseData({ defaultData, sources, resolveKey }) {
 	} });
 }
 //#endregion
+//#region src/data/filter-conditions.ts
+/**
+* Read one field's filter as the list of conditions it stands for.
+*
+* Accepts both declared shapes and normalises them to a list:
+*
+* ```ts
+* toFilterTuples(["==", "active"])          // [["==", "active"]]
+* toFilterTuples([[">=", 18], ["<", 65]])   // [[">=", 18], ["<", 65]]
+* ```
+*
+* A falsy, non-array or empty param has no conditions in it — the empty list,
+* so a caller iterating adds nothing rather than compiling a tuple of
+* `undefined`s and logging about an operator nobody sent.
+*/
+function toFilterTuples(filterParam) {
+	if (!filterParam || !Array.isArray(filterParam) || filterParam.length === 0) return [];
+	if (Array.isArray(filterParam[0])) return filterParam;
+	return [filterParam];
+}
+//#endregion
 //#region src/data/sort-dialect.ts
 /**
 * Sort-order wire codec.
@@ -3906,6 +4734,6 @@ async function detectJunctionTables(executeSql) {
 	return junctionTables;
 }
 //#endregion
-export { COLLECTION_PATH_SEPARATOR, COMPOSITE_ID_SEPARATOR, CollectionRegistry, DEFAULT_FIND_ALL_MAX_ROWS, DEFAULT_MAX_PAGES, DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE, DEFAULT_PAGE_SIZE, DEFAULT_STRING_COLUMN_LENGTH, JUNCTION_TABLES_SQL, QueryBuilder, REBASE_INTERNAL_PREFIXES, REBASE_INTERNAL_SCHEMAS, RebasePaginationError, and, buildCollectionFromTableMetadata, buildCompositeId, buildConditionContext, buildPropertyCallbacks, buildRebaseData, buildRoutedRebaseData, buildSdkData, canCreateEntity, canDeleteEntity, canEditEntity, canReadCollection, checkOperation, classifyTable, collectAllPages, cond, createDataSourceRegistry, createPaginationHelpers, createRelationRef, createRelationRefWithData, defaultUsersCollection, defineCollection, deserializeFilter, deserializeLogicalCondition, deserializeOrderBy, detectJunctionTables, embedParentExpression, enumToObjectEntries, evaluateCondition, evaluatePolicy, findAnonymousGrants, findRelation, fullPathToCollectionSegments, getArrayResolvedProperties, getColumnName, getDeclaredPrimaryKeys, getDefaultValueFor, getDefaultValueFortype, getDefaultValuesFor, getEffectiveSecurityRules, getEntityChildViews, getEnumVarName, getGeneratedPolicyNames, getInjectedSecurityRules, getJunctionCollectionConfig, getJunctionSecurityRules, getLabelOrConfigFrom, getPrimaryKeys, getReferenceFrom, getRelationFrom, getSubcollections, getTableName, getTableVarName, isAddressableId, isJunctionBackedRelation, isPropertyBuilder, isRebaseInternalTable, normalizeEmail, normalizeToEntityRelation, or, paginateFind, parseIdValues, policyToPostgres, registerConditionOperations, resolveArrayProperties, resolveCollectionRelations, resolveDataSource, resolveEnumValues, resolveJunctionSpecs, resolvePrimaryKeys, resolveProperties, resolveProperty, resolvePropertyEnum, resolveRelation, resolveRelationProperty, resolveStorageFilenameString, resolveStoragePathString, resolveStorageSource, resolveStringColumnLength, sanitizeData, securityRuleToConditions, segmentsToStrippedPath, serializeFilter, serializeLogicalCondition, serializeOrderBy, sortProperties, sqlToPolicy, stripCollectionPath, traverseValueProperty, traverseValuesProperties, updateDateAutoValues, wrapAsEntityData, wrapAsSdkData };
+export { COLLECTION_PATH_SEPARATOR, COMPOSITE_ID_SEPARATOR, CollectionRegistry, DEFAULT_FIND_ALL_MAX_ROWS, DEFAULT_MAX_PAGES, DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE, DEFAULT_PAGE_SIZE, DEFAULT_STRING_COLUMN_LENGTH, JUNCTION_TABLES_SQL, MAX_LOGICAL_NESTING_DEPTH, QueryBuilder, REBASE_INTERNAL_PREFIXES, REBASE_INTERNAL_SCHEMAS, REBASE_INTERNAL_TABLES, REBASE_USER_ROLE, RebasePaginationError, UnknownFilterOperatorError, and, buildCollectionFromTableMetadata, buildCompositeId, buildConditionContext, buildPropertyCallbacks, buildRebaseData, buildRoutedRebaseData, buildSdkData, canCreateEntity, canDeleteEntity, canEditEntity, canReadCollection, checkOperation, classifyTable, collectAllPages, cond, createDataSourceRegistry, createPaginationHelpers, createRelationRef, createRelationRefWithData, defaultUsersCollection, defineCollection, deserializeFilter, deserializeLogicalCondition, deserializeOrderBy, detectJunctionTables, embedParentExpression, enumToObjectEntries, evaluateCondition, evaluatePolicy, fieldKeyForColumn, findAnonymousGrants, findRelation, fullPathToCollectionSegments, getArrayResolvedProperties, getChildViewDeclaringProperties, getChildViewRelationPropertyKeys, getColumnName, getDeclaredPrimaryKeys, getDefaultValueFor, getDefaultValueFortype, getDefaultValuesFor, getEffectiveSecurityRules, getEntityChildViews, getEnumVarName, getGeneratedPolicyNames, getInjectedSecurityRules, getJunctionCollectionConfig, getJunctionSecurityRules, getLabelOrConfigFrom, getPrimaryKeys, getReferenceFrom, getRelationFrom, getRelationTargetPath, getSubcollections, getTableName, getTableVarName, isAddressableId, isJunctionBackedRelation, isPropertyBuilder, isRebaseInternalTable, isRelationalCollection, normalizeEmail, normalizeToEntityRelation, or, paginateFind, parseIdValues, policyToPostgres, registerConditionOperations, relationalCollections, resolveArrayProperties, resolveCollectionRelations, resolveDataSource, resolveEnumValues, resolveFindWindow, resolveJunctionSpecs, resolvePrimaryKeys, resolveProperties, resolveProperty, resolvePropertyEnum, resolveRelation, resolveRelationProperty, resolveStorageFilenameString, resolveStoragePathString, resolveStorageSource, resolveStringColumnLength, revokeInternalTableAccess, revokeInternalTableSql, sanitizeData, securityRuleToConditions, segmentsToStrippedPath, serializeFilter, serializeLogicalCondition, serializeOrderBy, sortCollectionsBySlug, sortProperties, sqlToPolicy, stripCollectionPath, toFilterTuples, traverseValueProperty, traverseValuesProperties, updateDateAutoValues, wrapAsEntityData, wrapAsSdkData };
 
 //# sourceMappingURL=index.es.js.map