@rebasepro/server 0.13.0 → 0.13.1-canary.g1822133

package/dist/{src-Cum9kox5.js → src-C7rkDGxA.js}

@@ -2,7 +2,64 @@ import { createRequire as __createRequire } from "module";
 import "process";
 __createRequire(import.meta.url);
 import { r as __require, t as __commonJSMin } from "./rolldown-runtime-DSJWtz9O.js";
-import { c as NULL_OPS, i as isRelationalCollectionConfig, l as REST_TO_CANONICAL, n as getDeclaredSubcollections, o as getDataSourceCapabilities, r as isPostgresCollectionConfig, s as CANONICAL_TO_REST, u as toCanonicalOp } from "./src-_qQ3RNCK.js";
+import { a as getDeclaredSubcollections, d as CANONICAL_TO_REST, f as NULL_OPS, l as getDataSourceCapabilities, m as toCanonicalOp, o as isPostgresCollectionConfig, p as REST_TO_CANONICAL, s as isRelationalCollectionConfig, u as ALL_WHERE_FILTER_OPS } from "./src-Cz9nMgUR.js";
+//#region ../types/src/errors.ts
+/**
+* The single error type thrown across the entire Rebase client surface —
+* HTTP data/control-plane calls, realtime/WebSocket operations, and
+* client-side logic errors (e.g. an unknown collection accessor). A `catch`
+* block only ever needs to check for this one class:
+*
+* ```ts
+* import { RebaseApiError } from "@rebasepro/client"; // re-exported
+*
+* try {
+*   await client.data.products.update(id, { price: 9 });
+* } catch (e) {
+*   if (e instanceof RebaseApiError) {
+*     if (e.status === 404) { ... }   // HTTP failures carry a status
+*     console.error(e.code, e.details);
+*   }
+* }
+* ```
+*
+* `status` is present for HTTP failures and `undefined` otherwise, so its
+* presence distinguishes transport-level errors from realtime/logic errors.
+*
+* @group Errors
+*/
+var RebaseApiError = class extends Error {
+	/** HTTP status code, or `undefined` for non-HTTP errors. */
+	status;
+	/** Stable machine-readable error code, when the server supplied one. See {@link RebaseErrorCode}. */
+	code;
+	/** Structured error payload from the server, when present. */
+	details;
+	constructor(message, init = {}) {
+		super(message);
+		this.name = "RebaseApiError";
+		this.status = init.status;
+		this.code = init.code;
+		this.details = init.details;
+		if (init.cause !== void 0) this.cause = init.cause;
+	}
+};
+/**
+* Client-side logic error — raised before any request is made (e.g. accessing
+* an unknown collection accessor when a typed dictionary is configured).
+*
+* A subclass of {@link RebaseApiError} (with no `status`), so a single
+* `catch (e) { if (e instanceof RebaseApiError) ... }` handles it too.
+*
+* @group Errors
+*/
+var RebaseClientError = class extends RebaseApiError {
+	constructor(message) {
+		super(message);
+		this.name = "RebaseClientError";
+	}
+};
+//#endregion
 //#region ../types/src/types/entities.ts
 /**
 * Class used to create a reference to a entity in a different path.
@@ -129,7 +186,7 @@ var Vector = class {
 //#endregion
 //#region ../types/src/types/policy.ts
 /**
-* The id a request without a logged-in user reports as `auth.uid()`.
+* The id a request without a logged-in user reports as `rebase.uid()`.
 *
 * A user-context request always sets `app.uid`: blank would read back as
 * `NULL`, and `NULL` is how the trusted server context is recognised, so an
@@ -137,7 +194,7 @@ var Vector = class {
 * therefore substitutes this sentinel at the single chokepoint where the GUC
 * is set.
 *
-* The consequence for policy authors is that **`auth.uid() IS NOT NULL` is a
+* The consequence for policy authors is that **`rebase.uid() IS NOT NULL` is a
 * tautology on the user path** — it is true for anonymous visitors too. Use
 * {@link policy.authenticated} to mean "signed in", and
 * {@link policy.serverContext} to mean "the trusted server context". Do not
@@ -154,7 +211,7 @@ var ANONYMOUS_USER_ID = "anonymous";
 * JavaScript evaluator and the linter were all built on
 * {@link ANONYMOUS_USER_ID}, while the request path scoped unauthenticated
 * callers as `'anon'` — so `policy.authenticated()`, which compiled to
-* `auth.uid() <> 'anonymous'`, was *true* for an anonymous visitor. The
+* `rebase.uid() <> 'anonymous'`, was *true* for an anonymous visitor. The
 * sanctioned way to write "signed in" granted to everyone, and the linter
 * flagged the spelling that actually worked as a foreign convention.
 *
@@ -235,6 +292,54 @@ var policy = {
 	authUid: () => ({ kind: "authUid" }),
 	authRoles: () => ({ kind: "authRoles" })
 };
+/** Largest `limit` a client may ask for on any surface. Above it, the read is refused. */
+var MAX_LIST_LIMIT = 1e3;
+/**
+* Thrown by {@link resolveClientListLimit} for a `limit` the platform will not
+* serve. Carries an HTTP status so an ingress that speaks HTTP can forward it
+* verbatim, and `maxLimit` so one can be built without re-deriving the ceiling.
+*
+* @group Errors
+*/
+var ListLimitError = class ListLimitError extends RebaseApiError {
+	/** The ceiling that was exceeded — what the caller should page by instead. */
+	maxLimit;
+	constructor(message, maxLimit) {
+		super(message, {
+			status: 400,
+			code: "INVALID_LIMIT"
+		});
+		this.name = "ListLimitError";
+		this.maxLimit = maxLimit;
+		Object.setPrototypeOf(this, ListLimitError.prototype);
+	}
+};
+/**
+* Resolve a client-supplied list `limit` into a safe, always-defined value.
+*
+* - An absent / blank limit falls back to the mode default:
+*   `vectorDefaultLimit` for a vector search, otherwise `defaultLimit`.
+* - A limit that is present must be an integer in `[1, maxLimit]`. Anything
+*   else — `0`, a negative, `1.5`, `abc`, `100000000` — throws
+*   {@link ListLimitError} rather than being coerced into range, because every
+*   coercion answers a question the caller did not ask with a page it cannot
+*   tell apart from the whole collection.
+*
+* The return is never `undefined` — no ingress that routes its client limit
+* through this can produce an unbounded read.
+*
+* @throws {ListLimitError} when a present `limit` is not an integer in range.
+*/
+function resolveClientListLimit(rawLimit, opts = {}) {
+	const maxLimit = opts.maxLimit ?? 1e3;
+	if (rawLimit != null && String(rawLimit).trim() !== "") {
+		const parsed = typeof rawLimit === "number" ? rawLimit : Number(String(rawLimit).trim());
+		if (!Number.isInteger(parsed) || parsed < 1) throw new ListLimitError(`Invalid \`limit\`: ${String(rawLimit)}. Expected a whole number between 1 and ${maxLimit}.`, maxLimit);
+		if (parsed > maxLimit) throw new ListLimitError(`\`limit\` ${parsed} is above the maximum of ${maxLimit}. Ask for at most ${maxLimit} rows per read and page through the rest with \`offset\` — answering with a smaller page would be indistinguishable from there being no more rows.`, maxLimit);
+		return parsed;
+	}
+	return opts.vectorSearch ? opts.vectorDefaultLimit ?? 10 : opts.defaultLimit ?? 50;
+}
 (/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	(function(e) {
 		var t;
@@ -1371,6 +1476,47 @@ function singularizeForKey(name) {
 	const result = singular(name);
 	return result.length > 0 ? result : name;
 }
+/**
+* The API name a database column is served under.
+*
+* The wire name of a field is its property key, and Rebase's property keys are
+* camelCase — `displayName`, `createdAt`, `photoURL`. Columns are snake_case,
+* because an unquoted Postgres identifier folds to lower case and a camelCase
+* column is therefore reachable only as `"authorId"` forever: in hand-written
+* SQL, in psql, in an RLS policy body, in a dump, and in every third-party tool
+* that ever touches the database. So the two conventions are both right, and
+* this is the function that crosses between them.
+*
+* It exists because two sources of field names never crossed: a foreign key
+* derived from a relation (`author_id`) and a column read back by introspection
+* (`user_id`) both landed on the wire under their column name, while every
+* hand-authored collection next to them used camelCase. One API, two
+* conventions, and no rule a caller could infer from outside — those names are
+* also the `where` and `orderBy` keys, so it was not a matter of taste.
+*
+* Rules, in the order they matter:
+*
+*  - **A name with no separator is returned unchanged.** `photoURL` stays
+*    `photoURL` and `id` stays `id`. Lower-casing a single token is what makes
+*    a "camelCase" helper destructive — `camelCase("photoURL")` is `photourl` —
+*    and this function is applied to names that are *already* keys.
+*  - **Each following segment keeps its own casing** apart from an upper-cased
+*    first letter, so `photo_URL` → `photoURL` rather than `photoUrl`.
+*  - **The result may still not be a JavaScript identifier.** `2fa_enabled`
+*    becomes `2faEnabled`, which is a perfectly good object key and still needs
+*    quoting where one is written into generated source.
+*
+* Not the inverse of {@link toSnakeCase}: `toSnakeCase` tokenises on case
+* boundaries and would turn `photoURL` into `photo_url`. Round-tripping is not
+* a property either function promises, which is why a column name that a
+* property maps explicitly is always read off `columnName` rather than derived.
+*/
+function toWireKey(columnName) {
+	if (!columnName) return columnName;
+	const segments = columnName.split(/[-_ ]+/).filter(Boolean);
+	if (segments.length <= 1) return columnName;
+	return segments.map((segment, index) => index === 0 ? segment.charAt(0).toLowerCase() + segment.slice(1) : segment.charAt(0).toUpperCase() + segment.slice(1)).join("");
+}
 //#endregion
 //#region ../common/src/util/entities.ts
 /**
@@ -1382,10 +1528,21 @@ function singularizeForKey(name) {
 * 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;
@@ -1657,6 +1814,48 @@ function getTableName(collection) {
 	return toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
 }
 /**
+* 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
@@ -1749,6 +1948,37 @@ function getSubcollections(collection) {
 	return getEntityChildViews(collection).map((view) => view.collection);
 }
 //#endregion
+//#region ../common/src/util/policy/sqlToPolicy.ts
+/**
+* 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.
+*/
+/**
+* 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"]
+]);
+new RegExp(String.raw`rebase\.uid\(\)\s*=\s*'(${[...FOREIGN_CONVENTION_UIDS.keys()].join("|")})'`, "i");
+//#endregion
 //#region ../common/src/util/auth-default-policies.ts
 /**
 * Default RLS policies injected by the schema generator.
@@ -1756,8 +1986,14 @@ function getSubcollections(collection) {
 * 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
@@ -1815,11 +2051,28 @@ function getIdPropertyName(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"],
@@ -1837,13 +2090,7 @@ function getEffectiveSecurityRules(collection) {
 			operations: ["select"],
 			condition: policy.compare(policy.field(getIdPropertyName(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];
 }
@@ -2883,8 +3130,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;
 	}
 	/**
@@ -2941,6 +3204,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 ?? 50;
+	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));
@@ -3060,8 +3347,10 @@ async function collectAllPages(find, params, label = "collection") {
 * 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
 */
@@ -3079,22 +3368,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: `\` → `\\`, `,` → `\,`, `(` → `\(`,
+* `)` → `\)`.
 */
-function escapeListItem(value) {
-	return value.replace(/\\/g, "\\\\").replace(/,/g, "\\,");
+/**
+* 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.
+*/
+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;
 }
 /**
@@ -3112,14 +3434,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.
 *
@@ -3134,9 +3677,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)}`;
 }
 /**
@@ -3188,10 +3735,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];
 }
 /**
@@ -3206,20 +3756,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]);
@@ -3244,42 +3801,22 @@ 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
-* `LogicalCondition` or `FilterCondition`.
-*
-* @example
-* deserializeLogicalCondition("status.eq.active")
-* // → { column: "status", operator: "==", value: "active" }
-*
-* deserializeLogicalCondition("or(status.eq.active,age.gte.18)")
-* // → { type: "or", conditions: [...] }
-*/
-function deserializeLogicalCondition(str) {
+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(".");
@@ -3294,7 +3831,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);
@@ -3307,7 +3844,7 @@ function deserializeLogicalCondition(str) {
 	return {
 		column,
 		operator,
-		value: valueStr
+		value: unescapeWireValue(valueStr)
 	};
 }
 //#endregion
@@ -3344,10 +3881,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 } : {}
 	};
 }
 /**
@@ -3390,21 +3929,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
@@ -3414,7 +3954,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;
 			}
@@ -3466,30 +4008,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
@@ -3522,8 +4082,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);
@@ -3611,8 +4174,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) {
@@ -3666,9 +4239,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),
@@ -3684,6 +4272,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;
@@ -3772,6 +4361,6 @@ function buildRoutedRebaseData({ defaultData, sources, resolveKey }) {
 	} });
 }
 //#endregion
-export { Vector as S, ANONYMOUS_USER_ID as _, serializeFilter as a, EntityRelation as b, paginateFind as c, resolveDataSource as d, getEffectiveSecurityRules as f, toSnakeCase as g, buildCompositeId as h, deserializeLogicalCondition as i, CollectionRegistry as l, resolveCollectionRelations as m, buildSdkData as n, serializeLogicalCondition as o, findRelation as p, deserializeFilter as r, collectAllPages as s, buildRoutedRebaseData as t, createDataSourceRegistry as u, isAnonymousUid as v, GeoPoint as x, EntityReference as y };
+export { RebaseApiError as A, resolveClientListLimit as C, EntityRelation as D, EntityReference as E, GeoPoint as O, MAX_LIST_LIMIT as S, isAnonymousUid as T, resolveCollectionRelations as _, deserializeLogicalCondition as a, toSnakeCase as b, collectAllPages as c, CollectionRegistry as d, createDataSourceRegistry as f, findRelation as g, fieldKeyForColumn as h, deserializeFilter as i, RebaseClientError as j, Vector as k, paginateFind as l, getEffectiveSecurityRules as m, buildSdkData as n, serializeFilter as o, resolveDataSource as p, UnknownFilterOperatorError as r, serializeLogicalCondition as s, buildRoutedRebaseData as t, resolveFindWindow as u, buildCompositeId as v, ANONYMOUS_USER_ID as w, ListLimitError as x, resolvePrimaryKeys as y };
 
-//# sourceMappingURL=src-Cum9kox5.js.map
+//# sourceMappingURL=src-C7rkDGxA.js.map