@rebasepro/server 0.24.0 → 0.24.1-canary.gcb918fc

package/dist/filter-dialect-O1HK6Nvr.js

@@ -0,0 +1,1628 @@
+import { createRequire as __rebaseCreateRequire } from "module";
+import __rebaseProcess from "process";
+globalThis.process ??= __rebaseProcess;
+__rebaseCreateRequire(import.meta.url);
+import { c as RebaseClientError } from "./strings.es-BeZWAodn.js";
+import { J as CANONICAL_TO_REST, Q as isRelationAggregateSort, X as NULL_OPS, Y as LIST_OPS, Z as REST_TO_CANONICAL, et as sortKeyToString, q as ALL_WHERE_FILTER_OPS, tt as toCanonicalOp } from "./src-D5Y3N-S4.js";
+//#region ../types/src/types/entities.ts
+/**
+* Class used to create a reference to a entity in a different path.
+*
+* @example
+* // Simple reference (most common case - single driver, single db)
+* new EntityReference({ id: "123", path: "users" })
+*
+* // Reference to a different driver (e.g., Firestore)
+* new EntityReference({ id: "123", path: "analytics", driver: "firestore" })
+*
+* // Reference to a specific database within a driver
+* new EntityReference({ id: "123", path: "orders", driver: "postgres", databaseId: "orders_db" })
+*/
+var EntityReference = class {
+	__type = "reference";
+	/**
+	* ID of the entity
+	*/
+	id;
+	/**
+	* A string representing the path of the referenced document (relative
+	* to the root of the database).
+	*/
+	path;
+	/**
+	* Which driver (e.g., 'postgres', 'firestore').
+	* Defaults to "(default)" if not specified.
+	*/
+	driver;
+	/**
+	* Which database within the driver.
+	* Defaults to "(default)" if not specified.
+	*/
+	databaseId;
+	/**
+	* Create a reference to a entity.
+	*
+	* @example
+	* // Simple reference (most common case)
+	* new EntityReference({ id: "123", path: "users" })
+	*
+	* // With driver
+	* new EntityReference({ id: "123", path: "analytics", driver: "firestore" })
+	*/
+	constructor(props) {
+		this.id = props.id;
+		this.path = props.path;
+		this.driver = props.driver;
+		this.databaseId = props.databaseId;
+	}
+	get pathWithId() {
+		return `${this.path}/${this.id}`;
+	}
+	/**
+	* Get the full path including driver and database prefixes if specified.
+	* For the common case (single driver, single db), this just returns pathWithId.
+	*/
+	get fullPath() {
+		const parts = [];
+		if (this.driver && this.driver !== "(default)") parts.push(this.driver);
+		if (this.databaseId && this.databaseId !== "(default)") parts.push(this.databaseId);
+		if (parts.length > 0) return `${parts.join(":")}:::${this.path}/${this.id}`;
+		return this.pathWithId;
+	}
+	isEntityReference() {
+		return true;
+	}
+};
+/**
+* Class used to create a reference to a entity in a different path
+*/
+var EntityRelation = class {
+	__type = "relation";
+	/**
+	* ID of the entity
+	*/
+	id;
+	/**
+	* A string representing the path of the referenced document (relative
+	* to the root of the database).
+	*/
+	path;
+	/**
+	* Pre-fetched data payload to eliminate N+1 queries.
+	* When present, clients can use this directly instead of fetching.
+	*/
+	data;
+	constructor(id, path, data) {
+		this.id = id;
+		this.path = path;
+		this.data = data;
+	}
+	get pathWithId() {
+		return `${this.path}/${this.id}`;
+	}
+	isEntityReference() {
+		return false;
+	}
+	isEntityRelation() {
+		return true;
+	}
+};
+var GeoPoint = class {
+	/**
+	* The latitude of this GeoPoint instance.
+	*/
+	latitude;
+	/**
+	* The longitude of this GeoPoint instance.
+	*/
+	longitude;
+	constructor(latitude, longitude) {
+		this.latitude = latitude;
+		this.longitude = longitude;
+	}
+};
+var Vector = class {
+	value;
+	constructor(value) {
+		this.value = value;
+	}
+};
+//#endregion
+//#region ../types/src/controllers/data.ts
+/**
+* SDK collection client — returns flat rows, no Entity wrapper.
+*
+* This is the public API surface for app developers using
+* `createRebaseClient()`. admin internals use `CollectionAccessor` instead.
+*
+* Type parameters:
+* - `M` — the **Row** shape returned by reads (`find`, `findById`, `listen`).
+* - `I` — the **Insert** shape accepted by {@link create}. Defaults to
+*   `Partial<M>`; the generated SDK supplies a dedicated `Insert` type where
+*   required columns are required and auto-generated / read-only columns are
+*   omitted, so `create({})` on a table with required fields is a compile error.
+* - `U` — the **Update** shape accepted by {@link update}. Defaults to
+*   `Partial<M>`; the generated SDK supplies a dedicated `Update` type.
+*
+* @example
+* const { data: posts } = await rebase.data.posts.find();
+* console.log(posts[0].title);       // flat access
+* console.log(posts[0].id);          // id at top level
+*
+* const post = await rebase.data.posts.findById(1);
+* console.log(post?.title);          // no .values needed
+*
+* @group Data
+*/
+/**
+* A change expressed as an operation on the column's current value, rather than
+* as the value to store.
+*
+* `{ views: 5 }` says what the number becomes; `{ views: { $inc: 1 } }` says
+* what happens to it. The difference is the read the caller no longer has to
+* make — and the race that read opens. Two requests that each read `4`, add one
+* and write `5` lose an increment between them; `SET views = views + 1` cannot,
+* because the arithmetic happens inside the statement holding the row lock.
+*
+* Exactly one operator per field. `{ views: { $inc: 1, $push: "x" } }` is
+* refused rather than applied in an order the caller cannot see.
+*
+* @group Data
+*/
+/**
+* The operator names, as a value.
+*
+* A runtime list beside the type because three layers have to *recognise* an
+* operation, not just accept one: the REST validator, the driver that compiles
+* it, and the offline queue that must refuse to apply one locally. Three copies
+* of four strings is three chances for one of them to miss an operator added to
+* the other two, and the failure is silent in the worst direction — an
+* unrecognised marker is written to the column as a JSON document.
+*
+* @group Data
+*/
+var FIELD_OPERATORS = [
+	"$inc",
+	"$push",
+	"$pull",
+	"$merge"
+];
+/**
+* The key of a {@link BatchRef}. Declared here, beside the field operators,
+* because the two share one namespace: a `$`-prefixed key in a write payload is
+* a marker, and every reader of that namespace has to know all of it.
+*
+* @group Data
+*/
+var BATCH_REF_KEY = "$ref";
+/**
+* Whether a value is *trying* to be a field operation — including a misspelled
+* one, which is the case worth catching.
+*
+* Any `$`-prefixed key counts, because `{ $increment: 1 }` written to a number
+* column as a JSON document is the failure this exists to prevent.
+*
+* Except on a `map` (pass `propertyType`): a map's value is a JSON document,
+* and one may legitimately carry `$` keys — a JSON Schema's `$schema`, a
+* MongoDB-style export. There, only a single-key object whose key is one of
+* {@link FIELD_OPERATORS} is an operation, and anything else is data. A caller
+* that does not know the property type gets the strict reading.
+*
+* The one exception is `{ $ref: … }`, the batch's backward reference. It stands
+* where a *value* goes and is resolved to one before the row is written, so it
+* is not an operation on a column — reading it as a misspelled operator refused
+* every `$ref` in a batch with "unknown field operator '$ref'".
+*
+* @group Data
+*/
+function isFieldOperation(value, propertyType) {
+	if (typeof value !== "object" || value === null || Array.isArray(value) || value instanceof Date) return false;
+	const keys = Object.keys(value);
+	if (keys.length === 1 && keys[0] === "$ref") return false;
+	if (propertyType === "map") return keys.length === 1 && FIELD_OPERATORS.includes(keys[0]);
+	return keys.some((key) => key.startsWith("$"));
+}
+/** True when any value in a write payload is (or is attempting to be) one. @group Data */
+function hasFieldOperation(values) {
+	return !!values && Object.values(values).some((value) => isFieldOperation(value));
+}
+//#endregion
+//#region ../common/src/util/entities.ts
+/**
+* Normalize a value into a proper EntityRelation instance.
+* Handles EntityRelation class instances, and plain objects
+* with `__type === "relation"` or an `isEntityRelation()` method.
+*
+* When `propertyType` is `"relation"`, also accepts plain objects that
+* 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, 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;
+	return new EntityRelation(obj.id, obj.path, obj.data);
+}
+/**
+* A row snapshot with every relation in it reduced to its reference — target
+* path and id, `__type` kept — and the related row's values dropped.
+*
+* What a history entry stores and serves. The history route is gated on
+* reading the row, not the rows it points at, so a snapshot that embedded the
+* admin's `{ __type: "relation", data: { values } }` envelope handed whoever
+* may read `posts` history the `authors` columns too. Entries are written as
+* the stored row now, which holds no envelope; this keeps it that way for any
+* path that hands one in, and reads entries recorded before.
+*
+* Walks maps and arrays, since a relation can sit inside either. Anything that
+* is not an envelope comes back as it was.
+*/
+function withRelationReferencesOnly(value) {
+	if (Array.isArray(value)) return value.map((item) => withRelationReferencesOnly(item));
+	if (value === null || typeof value !== "object" || value instanceof Date) return value;
+	const obj = value;
+	if (obj.__type === "relation" || obj.__type === "reference") {
+		const { data: _related, ...reference } = obj;
+		return reference;
+	}
+	if (Object.getPrototypeOf(obj) !== Object.prototype && Object.getPrototypeOf(obj) !== null) return value;
+	return Object.fromEntries(Object.entries(obj).map(([key, item]) => [key, withRelationReferencesOnly(item)]));
+}
+//#endregion
+//#region ../common/src/data/sort-dialect.ts
+/**
+* Sort-order wire codec.
+*
+* This is the ONLY module that knows about the colon-delimited wire format
+* (`"field:direction"`) used in HTTP query parameters, and about the JSON-array
+* form that carries a multi-column sort over the same parameter.
+* Everything else speaks {@link OrderByTuple} exclusively.
+*
+* Mirrors the filter architecture in `filter-dialect.ts`.
+*
+* @module
+*/
+/**
+* Collapse the one-key and many-key spellings of a sort into the list form.
+*
+* `["a", "desc"]` and `[["a", "desc"]]` mean the same thing and normalize to
+* the same value; the two are told apart by whether the first element is
+* itself an array, which no field name ever is.
+*
+* This is also where a {@link RelationAggregateSort} object stops being an
+* object. Above this function a sort key may be either spelling; below it,
+* every key is a string — which is what `OrderByTuple`, the REST parameter, the
+* driver contract and the cursor all already were. Doing it here means the one
+* place that already collapses the two *shapes* of a sort also collapses the
+* two *spellings* of a key, rather than every consumer learning about both.
+*
+* @returns The keys in order of significance, or `undefined` for no sort. An
+*   empty list also returns `undefined` — "sort by nothing" is no sort, and
+*   letting `[]` through would have every layer below re-deciding what it meant.
+*/
+function normalizeOrderBy(orderBy) {
+	if (!orderBy || orderBy.length === 0) return void 0;
+	const list = Array.isArray(orderBy[0]) ? orderBy : [orderBy];
+	if (list.length === 0) return void 0;
+	return list.map((entry, index) => toStrictTuple(entry, index));
+}
+/** A sort whose *shape* is unusable, as opposed to one naming a field that does not exist. */
+var OrderBySpecError = class extends Error {
+	code = "INVALID_ORDER_BY";
+	constructor(detail) {
+		super(`Invalid \`orderBy\`: ${detail}. Expected a field name, or a list of [field, direction] pairs like [["roles","asc"],["created_at","desc"]]`);
+		this.name = "OrderBySpecError";
+	}
+};
+/** `first`/`last`, or a refusal naming the entry — see {@link NullsPlacement}. */
+function toStrictNulls(raw, index) {
+	if (raw === void 0 || raw === null) return void 0;
+	if (raw !== "first" && raw !== "last") throw new OrderBySpecError(`entry ${index} has nulls '${String(raw)}' — expected "first" or "last"`);
+	return raw;
+}
+function toStrictTuple(raw, index) {
+	if (!Array.isArray(raw)) throw new OrderBySpecError(`entry ${index} has no field name`);
+	const key = isRelationAggregateSort(raw[0]) ? sortKeyToString(raw[0]) : raw[0];
+	if (typeof key !== "string" || key.trim() === "") throw new OrderBySpecError(`entry ${index} has no field name`);
+	const direction = raw[1];
+	if (direction !== void 0 && direction !== "asc" && direction !== "desc") throw new OrderBySpecError(`entry ${index} has direction '${String(direction)}'`);
+	const nulls = toStrictNulls(raw[2], index);
+	return nulls ? [
+		key,
+		direction ?? "asc",
+		nulls
+	] : [key, direction ?? "asc"];
+}
+/**
+* Serialize a sort to the wire.
+*
+* A single key keeps the `"field:direction"` shorthand it has always used —
+* short, readable in a URL, and what every existing client and test expects.
+* Several keys are emitted as the canonical JSON array the server already
+* accepts, because the shorthand has no separator to spare: a comma-joined
+* `"a:asc,b:desc"` parses as one field named `a` with the direction
+* `"asc,b:desc"`, which the server refuses.
+*
+* **Runtime tolerance:** if the input is already a well-formed wire string
+* (from an untyped JS caller), it is returned unchanged.
+* This is undocumented tolerance, not public API — don't rely on it.
+*
+* @param orderBy - A canonical tuple or list of tuples, or at runtime
+*   possibly a pre-serialized string (undocumented tolerance).
+* @returns The wire-format string, or `undefined` if the input is falsy.
+*
+* @remarks
+* Field names containing `:` are representable in the tuple form but
+* **not** in the single-key wire encoding — this is an inherent limitation of
+* the colon-delimited shorthand and is not resolved here.
+*/
+function serializeOrderBy(orderBy) {
+	if (!orderBy) return void 0;
+	if (typeof orderBy === "string") return orderBy;
+	const list = normalizeOrderBy(orderBy);
+	if (!list) return void 0;
+	if (list.length === 1) {
+		const [field, direction, nulls] = list[0];
+		return nulls ? `${field}:${direction}:${nulls}` : `${field}:${direction}`;
+	}
+	return JSON.stringify(list.map(([field, direction, nulls]) => nulls ? {
+		field,
+		direction,
+		nulls
+	} : {
+		field,
+		direction
+	}));
+}
+/**
+* Deserialize a wire-format `"field:direction"` string into an {@link OrderByTuple}.
+*
+* Lenient parsing:
+* - Bare field name (no colon): `"name"` → `["name", "asc"]`
+* - Unknown direction: `"name:foo"` → `["name", "asc"]`
+* - Empty / falsy input, or a blank field name: → `undefined`
+*
+* The leniency is this end's alone; the *server* refuses the same value. This
+* used to say "matches existing server behaviour", and it stopped being true
+* when `parseOrderByParam` grew a strict direction check: `?orderBy=name:foo`
+* now answers `400 INVALID_ORDER_BY` ("entry 0 has direction 'foo'"). The split
+* is deliberate — see {@link parseOrderBySpecStrict} — because a value this
+* function is handed was produced by {@link serializeOrderBy} a moment earlier,
+* and one that reaches the server came from a stranger.
+*
+* A blank field is `undefined` rather than `[" ", "asc"]`: whitespace is not a
+* field name, and the tuple it used to produce could not be re-encoded — the
+* only value in this codec that survived a decode and failed the next encode.
+*
+* Reads the single-key shorthand only. For a value that may carry several keys,
+* use {@link deserializeOrderByList} — handed a JSON array this returns the
+* whole array as one nonsensical field name.
+*
+* @param raw - The wire-format string from an HTTP query parameter.
+* @returns The canonical tuple, or `undefined` if the input names no field.
+*/
+function deserializeOrderBy(raw) {
+	if (!raw) return void 0;
+	const idx = raw.indexOf(":");
+	if (idx === -1) return raw.trim() === "" ? void 0 : [raw, "asc"];
+	const field = raw.slice(0, idx);
+	if (field.trim() === "") return void 0;
+	const rest = raw.slice(idx + 1);
+	const nullsIdx = rest.indexOf(":");
+	const dir = nullsIdx === -1 ? rest : rest.slice(0, nullsIdx);
+	const nulls = nullsIdx === -1 ? void 0 : rest.slice(nullsIdx + 1);
+	const direction = dir === "desc" ? "desc" : "asc";
+	return nulls === "first" || nulls === "last" ? [
+		field,
+		direction,
+		nulls
+	] : [field, direction];
+}
+/**
+* Deserialize either wire spelling — the single-key shorthand or the JSON
+* array — into the list form.
+*
+* Lenient in the same way {@link deserializeOrderBy} is: this is the client end
+* of the codec, where the value was produced by {@link serializeOrderBy} a
+* moment earlier. The *server* end parses the same shapes strictly, in
+* `parseOrderByParam`, because there the value came from a stranger and a
+* direction it cannot read has to be refused rather than quietly turned into
+* `"asc"`.
+*/
+function deserializeOrderByList(raw) {
+	if (!raw) return void 0;
+	const trimmed = raw.trim();
+	if (trimmed.startsWith("[")) try {
+		const parsed = JSON.parse(trimmed);
+		if (Array.isArray(parsed)) {
+			const list = parsed.map((entry) => {
+				if (typeof entry === "string") return deserializeOrderBy(entry);
+				if (entry && typeof entry === "object" && typeof entry.field === "string") {
+					const direction = entry.direction === "desc" ? "desc" : "asc";
+					return entry.nulls === "first" || entry.nulls === "last" ? [
+						entry.field,
+						direction,
+						entry.nulls
+					] : [entry.field, direction];
+				}
+			}).filter((entry) => entry !== void 0);
+			return list.length > 0 ? list : void 0;
+		}
+	} catch {}
+	const single = deserializeOrderBy(trimmed);
+	return single ? [single] : void 0;
+}
+//#endregion
+//#region ../common/src/data/include-spec.ts
+/** An `include` that cannot be read, as opposed to one naming a relation that does not exist. */
+var IncludeSpecError = class IncludeSpecError extends Error {
+	code;
+	constructor(detail, code = "INVALID_INCLUDE") {
+		super(`Invalid \`include\`: ${detail}`);
+		this.name = "IncludeSpecError";
+		this.code = code;
+		Object.setPrototypeOf(this, IncludeSpecError.prototype);
+	}
+};
+var emptyNode = () => ({ children: {} });
+function ensureNode(tree, key) {
+	return tree[key] ??= emptyNode();
+}
+/**
+* Merge one dotted path (`"comments.author"`) into a tree.
+*
+* Merging rather than assigning is what makes `include=comments,comments.author`
+* mean the same thing as `include=comments.author`: the second path deepens the
+* node the first created instead of replacing it and losing its options.
+*/
+function addPath(tree, path) {
+	const segments = path.split(".").map((s) => s.trim()).filter(Boolean);
+	if (segments.length === 0) return;
+	if (segments.length > 3) throw new IncludeSpecError(`"${path}" nests ${segments.length} relations deep; the limit is 3. Each hop is another query, and an unbounded one walks a self-referencing relation forever.`, "INCLUDE_TOO_DEEP");
+	let level = tree;
+	for (const segment of segments) level = ensureNode(level, segment).children;
+}
+function normalizeOptions(key, options, depth) {
+	if (depth > 3) throw new IncludeSpecError(`"${key}" nests more than 3 relations deep.`, "INCLUDE_TOO_DEEP");
+	if (options.limit !== void 0 && (!Number.isInteger(options.limit) || options.limit < 1)) throw new IncludeSpecError(`"${key}" has limit ${JSON.stringify(options.limit)} — expected a whole number of 1 or more.`);
+	if (options.count !== void 0 && typeof options.count !== "boolean") throw new IncludeSpecError(`"${key}" has count ${JSON.stringify(options.count)} — expected \`true\` or \`false\`.`);
+	const node = { children: {} };
+	if (options.limit !== void 0) node.limit = options.limit;
+	if (options.count) node.count = true;
+	if (options.where) node.where = options.where;
+	if (options.logical) node.logical = options.logical;
+	if (options.fields && options.fields.length > 0) node.fields = [...options.fields];
+	const orderBy = typeof options.orderBy === "string" ? deserializeOrderByList(options.orderBy) : normalizeOrderBy(options.orderBy);
+	if (orderBy) node.orderBy = orderBy;
+	if (options.include) {
+		const nested = normalizeIncludeAt(options.include, depth + 1);
+		if (nested.wildcard) throw new IncludeSpecError(`"${key}" asks for \`*\` inside a nested include. Name the relations you need.`);
+		node.children = nested.tree;
+	}
+	return node;
+}
+function normalizeIncludeAt(spec, depth) {
+	if (Array.isArray(spec)) {
+		const tree = {};
+		let wildcard = false;
+		for (const raw of spec) {
+			if (typeof raw !== "string") throw new IncludeSpecError(`${typeof raw} is not a relation name`);
+			const name = raw.trim();
+			if (!name) continue;
+			if (name === "*") {
+				wildcard = true;
+				continue;
+			}
+			addPath(tree, name);
+		}
+		return {
+			wildcard,
+			tree
+		};
+	}
+	if (typeof spec !== "object" || spec === null) throw new IncludeSpecError(`${typeof spec} is not a list of relations or an include tree`);
+	const tree = {};
+	let wildcard = false;
+	for (const [key, value] of Object.entries(spec)) {
+		if (key === "*") {
+			if (value) wildcard = true;
+			continue;
+		}
+		if (value === true) {
+			ensureNode(tree, key);
+			continue;
+		}
+		if (value === false || value === void 0 || value === null) continue;
+		if (typeof value !== "object" || Array.isArray(value)) throw new IncludeSpecError(`"${key}" must be \`true\` or an options object`);
+		tree[key] = normalizeOptions(key, value, depth);
+	}
+	return {
+		wildcard,
+		tree
+	};
+}
+/**
+* Collapse any {@link IncludeSpec} spelling into one tree.
+*
+* `["author", "comments.author"]` and
+* `{ author: true, comments: { include: { author: true } } }` normalize to the
+* same value — which is the whole point: the REST parameter can only carry the
+* flat spelling, the SDK prefers the tree, and the driver should never learn
+* about either.
+*
+* @throws {IncludeSpecError} for a shape that is not an include at all, or one
+*   that nests past {@link MAX_INCLUDE_DEPTH}.
+*/
+function normalizeInclude(spec) {
+	if (spec === void 0 || spec === null) return void 0;
+	const normalized = normalizeIncludeAt(spec, 1);
+	if (!normalized.wildcard && Object.keys(normalized.tree).length === 0) return void 0;
+	return normalized;
+}
+/**
+* Every relation name a tree names, as dotted paths — `["comments",
+* "comments.author"]`.
+*
+* Used to report which names an `include` asked for when one of them is not a
+* relation, and to serialize a tree that carries no per-relation options back
+* to the flat wire spelling.
+*/
+function includePaths(tree, prefix = "") {
+	const out = [];
+	for (const [key, node] of Object.entries(tree)) {
+		const path = prefix ? `${prefix}.${key}` : key;
+		out.push(path);
+		out.push(...includePaths(node.children, path));
+	}
+	return out;
+}
+/** Whether any node in the tree carries per-relation options. */
+function hasOptions(tree) {
+	return Object.values(tree).some((node) => node.limit !== void 0 || node.where !== void 0 || node.logical !== void 0 || node.orderBy !== void 0 || node.fields !== void 0 || node.count !== void 0 || hasOptions(node.children));
+}
+/**
+* Serialize an {@link IncludeSpec} for the REST `?include=` parameter.
+*
+* Two spellings, and which one is used is decided by the request rather than
+* chosen:
+*
+* - **Comma-separated dotted paths** — `include=author,comments.author`. What a
+*   plain include is, what a human types, and what every existing client sends.
+* - **JSON**, when any relation carries options — `include={"comments":{"limit":5,
+*   "include":{"author":true}}}`. The flat spelling has nowhere to put a
+*   `limit`, and inventing a punctuation for it (`comments(limit:5)`) would be a
+*   third grammar to learn beside the two this API already has.
+*
+* The server accepts both on every list and get route, and tells them apart the
+* same way this does: a value starting with `{` is JSON.
+*/
+function serializeInclude(spec) {
+	const normalized = normalizeInclude(spec);
+	if (!normalized) return void 0;
+	if (normalized.wildcard && Object.keys(normalized.tree).length === 0) return "*";
+	if (!hasOptions(normalized.tree)) {
+		const paths = includePaths(normalized.tree);
+		const leaves = paths.filter((path) => !paths.some((other) => other.startsWith(`${path}.`)));
+		const all = normalized.wildcard ? ["*", ...leaves] : leaves;
+		return all.length > 0 ? all.join(",") : void 0;
+	}
+	return JSON.stringify(toWireTree(normalized));
+}
+/**
+* A normalized tree, back in the {@link IncludeSpec} spelling a caller writes.
+*
+* The round trip is what lets a builder accumulate `include` calls: normalize
+* each, merge, and hand the result back as a spec the next layer can normalize
+* again. Idempotent, so doing it twice changes nothing.
+*/
+function denormalizeInclude(normalized) {
+	return toWireTree(normalized);
+}
+function mergeTrees(into, from) {
+	for (const [key, node] of Object.entries(from)) {
+		const existing = into[key];
+		if (!existing) {
+			into[key] = node;
+			continue;
+		}
+		if (node.limit !== void 0) existing.limit = node.limit;
+		if (node.where !== void 0) existing.where = node.where;
+		if (node.logical !== void 0) existing.logical = node.logical;
+		if (node.orderBy !== void 0) existing.orderBy = node.orderBy;
+		if (node.fields !== void 0) existing.fields = node.fields;
+		if (node.count !== void 0) existing.count = node.count;
+		existing.children = mergeTrees(existing.children, node.children);
+	}
+	return into;
+}
+/**
+* Combine several `include` requests into one.
+*
+* Repeated `.include(...)` calls on a query builder are additive: each names
+* more of the graph to load, and a later one must not discard what an earlier
+* one asked for. Assigning instead of merging is why `.include("author")
+* .include("tags")` used to load only tags.
+*/
+function mergeIncludeSpecs(existing, additions) {
+	const merged = {
+		wildcard: false,
+		tree: {}
+	};
+	const absorb = (spec) => {
+		const normalized = normalizeInclude(spec);
+		if (!normalized) return;
+		merged.wildcard ||= normalized.wildcard;
+		mergeTrees(merged.tree, normalized.tree);
+	};
+	absorb(existing);
+	const names = additions.filter((a) => typeof a === "string");
+	if (names.length > 0) absorb(names);
+	for (const addition of additions) if (typeof addition !== "string") absorb(addition);
+	if (!merged.wildcard && Object.keys(merged.tree).length === 0) return void 0;
+	return denormalizeInclude(merged);
+}
+function toWireTree(normalized) {
+	const emit = (tree) => {
+		const out = {};
+		for (const [key, node] of Object.entries(tree)) {
+			const options = {};
+			if (node.limit !== void 0) options.limit = node.limit;
+			if (node.where) options.where = node.where;
+			if (node.logical) options.logical = node.logical;
+			if (node.orderBy) options.orderBy = node.orderBy;
+			if (node.fields) options.fields = node.fields;
+			if (node.count) options.count = true;
+			const children = emit(node.children);
+			if (Object.keys(children).length > 0) options.include = children;
+			out[key] = Object.keys(options).length > 0 ? options : true;
+		}
+		return out;
+	};
+	const tree = emit(normalized.tree);
+	if (normalized.wildcard) tree["*"] = true;
+	return tree;
+}
+/**
+* Read the REST `?include=` parameter, in either spelling.
+*
+* @throws {IncludeSpecError} for malformed JSON or a tree that nests too deep.
+*/
+function deserializeInclude(raw) {
+	if (raw === void 0 || raw === null) return void 0;
+	const text = raw.trim();
+	if (!text) return void 0;
+	if (text.startsWith("{")) {
+		let parsed;
+		try {
+			parsed = JSON.parse(text);
+		} catch {
+			throw new IncludeSpecError("the parametrised form must be a JSON object, e.g. {\"comments\":{\"limit\":5,\"include\":{\"author\":true}}}");
+		}
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new IncludeSpecError("the parametrised form must be a JSON object");
+		return parsed;
+	}
+	return text.split(",").map((s) => s.trim()).filter(Boolean);
+}
+/** Rows `findAll()` will materialise before it refuses to continue. */
+var DEFAULT_FIND_ALL_MAX_ROWS = 1e4;
+/**
+* Requests one walk may make before it gives up on the server ever saying
+* `hasMore: false`. At the default page size that is two million rows — far
+* past any legitimate walk, and short of running forever.
+*/
+var DEFAULT_MAX_PAGES = 1e4;
+/**
+* Thrown when a walk stops for a reason the caller needs to know about.
+*
+* Every one of these is a case where the alternative would be silent: a
+* truncated array that looks complete, or a loop that never returns. Check
+* {@link code} to tell them apart.
+*/
+var RebasePaginationError = class RebasePaginationError extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "RebasePaginationError";
+		this.code = code;
+		Object.setPrototypeOf(this, RebasePaginationError.prototype);
+	}
+};
+/**
+* What a read naming both `page` and `offset` is refused with — by the server
+* (400 `PAGE_WITH_OFFSET`) and, before any request, by every client.
+*/
+var PAGE_WITH_OFFSET_MESSAGE = "`page` and `offset` describe the same window; send one.";
+/**
+* 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` and `offset` together are refused with `PAGE_WITH_OFFSET`, as the
+* server refuses them: they name one window twice, and `page` used to win
+* silently over an `offset` the caller then never saw applied. `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) {
+	if (params?.page != null && params.offset != null) throw new RebaseClientError(PAGE_WITH_OFFSET_MESSAGE, { code: "PAGE_WITH_OFFSET" });
+	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));
+}
+function normalizeMaxPages(raw) {
+	if (raw === void 0) return DEFAULT_MAX_PAGES;
+	if (raw === Number.POSITIVE_INFINITY) return raw;
+	if (!Number.isFinite(raw)) return DEFAULT_MAX_PAGES;
+	return Math.max(1, Math.floor(raw));
+}
+function normalizeMaxRows(raw) {
+	if (raw === void 0) return DEFAULT_FIND_ALL_MAX_ROWS;
+	if (raw === Number.POSITIVE_INFINITY) return raw;
+	if (!Number.isFinite(raw)) return DEFAULT_FIND_ALL_MAX_ROWS;
+	return Math.max(0, Math.floor(raw));
+}
+/**
+* Walk every row a query matches, yielding one row at a time and fetching the
+* next page only when the consumer asks for it.
+*
+* See {@link SDKCollectionClient.iterate} for the caller-facing contract,
+* including the offset-drift caveat and the `cursor` alternative.
+*
+* @param find   the transport's single-page read
+* @param params `find()` parameters minus the window, plus the walk options
+* @param label  the collection name, so an error says which walk failed
+*/
+async function* paginateFind(find, params, label = "collection") {
+	const { pageSize, cursor, maxPages, after: startAfter, offset: startOffset, page: startPage, ...rest } = params ?? {};
+	const findParams = {
+		...rest,
+		count: "none"
+	};
+	const size = normalizePageSize(pageSize);
+	const pageCap = normalizeMaxPages(maxPages);
+	const seekRequested = cursor !== void 0 && cursor !== null || !!startAfter;
+	if (cursor !== void 0 && cursor !== null) {
+		const field = typeof cursor === "string" ? cursor : cursor.field;
+		const requested = typeof cursor === "object" && cursor !== null ? cursor.direction : void 0;
+		if (!normalizeOrderBy(findParams.orderBy)) findParams.orderBy = [field, requested ?? "asc"];
+	}
+	let offset = resolveFindWindow({
+		limit: size,
+		offset: startOffset,
+		page: startPage
+	}).offset;
+	let pages = 0;
+	let after = startAfter || void 0;
+	let seekingByServerCursor = false;
+	for (;;) {
+		if (pages >= pageCap) throw new RebasePaginationError("max-pages", `Iterating "${label}" made ${pages} requests without the server reporting the end of the collection. Stopping rather than looping forever — raise \`maxPages\` if the walk is genuinely this long, or check that the backend sets \`meta.hasMore\`.`);
+		const pageParams = {
+			...findParams,
+			limit: size
+		};
+		if (seekRequested) {
+			if (after) pageParams.after = after;
+		} else if (seekingByServerCursor && after) pageParams.after = after;
+		else pageParams.offset = offset;
+		const page = await find(pageParams);
+		pages += 1;
+		const rows = page?.data ?? [];
+		if (rows.length === 0) return;
+		for (const row of rows) yield row;
+		if (page?.meta?.hasMore !== true) return;
+		if (seekRequested) {
+			const next = page.meta.nextCursor;
+			if (!next) throw new RebasePaginationError("cursor-missing", `Cannot seek past the last row of "${label}": the server reported another page but issued no cursor for it. An ordering with no stored value to compare against — relevance (\`_score\`) — cannot key a cursor. Drop \`cursor\` to page by offset.`);
+			if (next === after) throw new RebasePaginationError("cursor-stalled", `Iterating "${label}" is stuck: two pages in a row ended on the same cursor, so the walk cannot advance. Continuing would loop forever. Page by offset instead, or report this — a cursor that does not move is a server-side bug.`);
+			after = next;
+		} else {
+			offset += rows.length;
+			const next = page.meta.nextCursor;
+			seekingByServerCursor = !!next && next !== after;
+			after = seekingByServerCursor ? next : void 0;
+		}
+	}
+}
+/**
+* {@link paginateFind}, collected into an array under a ceiling.
+*
+* See {@link SDKCollectionClient.findAll}.
+*/
+async function collectAllPages(find, params, label = "collection") {
+	const { maxRows, ...rest } = params ?? {};
+	const cap = normalizeMaxRows(maxRows);
+	const out = [];
+	for await (const row of paginateFind(find, rest, label)) {
+		out.push(row);
+		if (out.length > cap) throw new RebasePaginationError("max-rows", `findAll("${label}") matched more than ${cap} rows. Returning the first ${cap} would look like the whole answer and quietly not be one, so this throws instead. Raise \`maxRows\` if you meant to load them all, or stream with \`iterate()\`.`);
+	}
+	return out;
+}
+//#endregion
+//#region ../common/src/data/filter-dialect.ts
+/**
+* REST wire-format adapter for the unified filter system.
+*
+* This module is the ONLY code in the entire codebase that knows about
+* PostgREST-style dot-syntax strings (`eq.active`, `gt.18`, `in.(a,b)`).
+* Everything else speaks `FilterValues` exclusively.
+*
+* Wire-format values are always strings — the wire format carries no type
+* metadata, so type coercion is the responsibility of the server-side data
+* driver which has access to the collection schema.
+*
+* 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
+*/
+/**
+* Serialize a JS value to its querystring representation.
+* `null` is serialized as the literal string `"null"`.
+* Relation values (`EntityRelation` instances or `{ __type: "relation", id, path }`
+* objects) are serialized as their raw id — the wire format only carries the
+* value to compare against the FK column.
+*
+* A `Date` is its ISO 8601 instant — what JSON makes of it on the socket and
+* in-process, so one filter names one instant through every door. `String()`
+* gave the viewer's local zone, no milliseconds and a parenthesised zone name
+* Postgres cannot parse. An invalid date keeps its "Invalid Date" spelling for
+* the server to refuse, rather than throwing a `RangeError` from here.
+*/
+function stringifyValue(value) {
+	if (value === null) return "null";
+	if (value instanceof Date && !Number.isNaN(value.getTime())) return value.toISOString();
+	const relation = normalizeToEntityRelation(value);
+	if (relation) return String(relation.id);
+	return String(value);
+}
+/**
+* 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.
+*/
+var EMPTY_LIST_TOKEN = "\\";
+function escapeWireValue(value) {
+	return value.replace(WIRE_SPECIALS, (ch) => `\\${ch}`);
+}
+/**
+* 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 unescapeWireValue(value) {
+	let result = "";
+	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;
+}
+/**
+* Whether a scalar, sent raw as a query parameter's operand, would be read
+* back as something other than itself.
+*
+* A query parameter owns its whole value, so its scalar goes out unescaped —
+* `eq.a,b`, `eq.C:\x` — and the decoder returns it verbatim. Two shapes break
+* that. A parenthesised operand is a list for every operator (so that
+* `["==", ["a","b"]]` on an array column stays a list), so raw, the scalar
+* `"(deleted)"` would arrive as `["deleted"]`: an `==` matching nothing, a
+* `!=` returning the very rows it excludes. Such a scalar is sent escaped,
+* `eq.\(deleted\)`. And that spelling has to be told apart from a raw value
+* that looks the same, so a scalar of *that* shape is escaped in turn.
+*
+* Everything else stays raw, so a value an older client sends decodes as it
+* always has — unless it is exactly the escaped spelling of such a scalar,
+* which decodes to the scalar it spells.
+*/
+function scalarNeedsEscape(value) {
+	if (value.startsWith("(") && value.endsWith(")")) return true;
+	return decodeEscapedScalar(value) !== void 0;
+}
+/**
+* The scalar an operand is the escaped spelling of, when it is one.
+*
+* Exact on purpose: only an operand that {@link escapeWireValue} produces from
+* a scalar that {@link scalarNeedsEscape} is decoded. Any other operand —
+* including a raw backslash an older client sent, like `\\server\share` — is
+* left verbatim. Terminates because an operand that matches contains an
+* escape pair, so the value is strictly shorter than it.
+*/
+function decodeEscapedScalar(operand) {
+	if (!operand.startsWith("\\")) return void 0;
+	const value = unescapeWireValue(operand);
+	return escapeWireValue(value) === operand && scalarNeedsEscape(value) ? value : void 0;
+}
+/**
+* Split a parenthesized list string on unescaped commas.
+* Input is the content between `(` and `)`.
+*
+* @example
+* splitListItems("admin,editor")          // ["admin", "editor"]
+* splitListItems("hello\\, world,foo")    // ["hello, world", "foo"]
+*/
+function splitListItems(inner) {
+	const items = [];
+	let current = "";
+	for (let i = 0; i < inner.length; i++) if (inner[i] === "\\" && i + 1 < inner.length) {
+		current += inner[i] + inner[i + 1];
+		i++;
+	} else if (inner[i] === ",") {
+		items.push(unescapeWireValue(current));
+		current = "";
+	} else current += inner[i];
+	items.push(unescapeWireValue(current));
+	return items;
+}
+/**
+* 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);
+}
+/**
+* The query-parameter names a REST listing reads as something other than a
+* field filter: pagination and whether to count, sorting, includes,
+* projection, search, the logical groups, the JSON `where` dialect, an
+* aggregate's `select`/`groupBy`, and the soft-delete switches.
+*
+* One list for both ends. The server skips these names when it collects
+* `?<field>=<op>.<value>` filters, and the SDK sends a filter on a column with
+* one of these names inside `?where=` instead — a collection is free to have a
+* `page`, `select` or `hard` column, and a filter on it sent as its own
+* parameter was read as the parameter and never applied.
+*/
+var RESERVED_QUERY_KEYS = /* @__PURE__ */ new Set([
+	"limit",
+	"offset",
+	"page",
+	"after",
+	"orderBy",
+	"include",
+	"fields",
+	"distinct",
+	"count",
+	"searchString",
+	"searchExplain",
+	"vector_search",
+	"vector",
+	"vector_distance",
+	"vector_threshold",
+	"or",
+	"and",
+	"not",
+	"where",
+	"select",
+	"groupBy",
+	"deleted",
+	"hard"
+]);
+/**
+* Encode the `<op>.<value>` half of a wire condition.
+*
+* This is the single leaf encoder. Both wire positions that carry a condition
+* — a top-level query parameter (`?status=eq.active`) and a leaf inside an
+* `and(...)`/`or(...)` group (`or(status.eq.active,…)`) — go through it, so a
+* rule expressed here holds in both. The group serializer used to carry its
+* own copy, and the copy had drifted on every rule that matters: `null` went
+* out as the four-character string, the empty list as `()`, and an operator
+* this dialect does not have was silently rewritten to `eq` — a filter that
+* ran, returned rows, and answered a different question than the one asked.
+*
+* `escapeScalar` is the one thing the two positions legitimately disagree
+* about. A scalar in a query parameter owns the whole value and needs no
+* escaping; a scalar inside a group sits between the same commas a list item
+* does, so a comma in it would end the condition early.
+*/
+function serializeOperatorAndValue(op, value, { escapeScalar, where }) {
+	if (typeof op !== "string") throw new TypeError(`${where}: operator must be a string, got ${typeof op}`);
+	const restOp = CANONICAL_OP_LOOKUP.get(op);
+	if (!restOp) throw new TypeError(`${where}: unknown operator "${op}". Valid operators: ${Object.keys(CANONICAL_TO_REST).join(", ")}`);
+	if (value === null && (op === "==" || op === "!=")) return op === "==" ? "isnull.null" : "notnull.null";
+	if (NULL_OPS.has(op)) return `${restOp}.null`;
+	if (Array.isArray(value)) {
+		if (value.length === 0) return `${restOp}.(${EMPTY_LIST_TOKEN})`;
+		return `${restOp}.(${value.map((v) => escapeWireValue(stringifyValue(v))).join(",")})`;
+	}
+	const scalar = stringifyValue(value);
+	return `${restOp}.${escapeScalar || !LIST_OPS.has(op) && scalarNeedsEscape(scalar) ? escapeWireValue(scalar) : scalar}`;
+}
+/**
+* Serialize a single canonical condition tuple to a PostgREST dot-string.
+*
+* Throws `TypeError` if the input is not a valid `[WhereFilterOp, unknown]` tuple.
+*
+* @example
+* serializeTuple(["==", "active"])           // "eq.active"
+* serializeTuple(["in", ["admin","editor"]]) // "in.(admin,editor)"
+* serializeTuple([">=", 18])                 // "gte.18"
+*/
+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;
+	return serializeOperatorAndValue(op, value, {
+		escapeScalar: false,
+		where: "serializeTuple"
+	});
+}
+/**
+* Convert `FilterValues` (or `WireFilterValues`) to a PostgREST-style
+* querystring record.
+*
+* - Canonical `[WhereFilterOp, value]` tuples are serialized strictly.
+* - Pre-serialized PostgREST strings (e.g. `"eq.published"`) are passed through.
+* - Single conditions produce a string value.
+* - Multiple conditions on the same field produce a string array (repeated params).
+*
+* @example
+* serializeFilter({ status: ["==", "active"] })
+* // → { status: "eq.active" }
+*
+* serializeFilter({ age: [[">=", 18], ["<", 65]] })
+* // → { age: ["gte.18", "lt.65"] }
+*
+* // Pre-serialized strings pass through unchanged:
+* serializeFilter({ status: "eq.published" })
+* // → { status: "eq.published" }
+*/
+function serializeFilter(filter) {
+	const result = {};
+	for (const [field, condition] of Object.entries(filter)) {
+		if (condition === void 0) continue;
+		if (typeof condition === "string") {
+			result[field] = condition;
+			continue;
+		}
+		if (Array.isArray(condition) && condition.length > 0 && Array.isArray(condition[0])) result[field] = condition.map(serializeTuple);
+		else result[field] = serializeTuple(condition);
+	}
+	return result;
+}
+/**
+* The spellings a null-testing operator's operand may take.
+*
+* The serializer writes `isnull.null`; a hand-written `isnull.true` means the
+* same thing and has always been accepted. Anything else after the operator is
+* not an operand it has — `notnull.reason` is a *value* — see
+* {@link deserializeSingle}.
+*/
+var NULL_OPERANDS = /* @__PURE__ */ new Set([
+	"null",
+	"true",
+	"false",
+	""
+]);
+/**
+* Parse a single PostgREST dot-string into a `[WhereFilterOp, unknown]` tuple.
+*
+* All values are returned as strings — the wire format carries no type
+* metadata, so coercion is the data driver's responsibility.
+*
+* ## When a leading segment is an operator, and when it is part of the value
+*
+* `?status=in.progress` and `?status=in.(a,b)` differ by one character and mean
+* entirely different things, and the reading here decides which. The rule, in
+* full:
+*
+* > A dot-string is read as `operator.operand` **only** when its first segment
+* > names a known REST operator **and** what follows is a well-formed operand
+* > *for that operator's arity*. Otherwise the whole string is the value.
+*
+* Arity, per operator family:
+*
+* - **List** operators (`in`, `nin`, `csa` — `LIST_OPS`) take a parenthesised
+*   list and nothing else. `in.(draft,review)` is the operator; `in.progress`
+*   is the *value* `"in.progress"`, because there is no list there and so no
+*   `in` filter that could have been written. That case used to compile to
+*   `status IN ('progress')` — a filter the caller never wrote, quietly
+*   matching the wrong rows and, on a status field, hiding every row they were
+*   looking for.
+* - **Null** operators (`isnull`, `notnull` — {@link NULL_OPS}) take no
+*   operand: only {@link NULL_OPERANDS}. `notnull.reason` is the value
+*   `"notnull.reason"`, not "reason is not null".
+* - **Everything else** takes one scalar, and any remainder is one — including
+*   the empty string, so `eq.` really is "equals the empty string". A
+*   parenthesised remainder is a list for these too (`eq.(a,b)` is array
+*   equality); a scalar that is itself parenthesised arrives escaped,
+*   `eq.\(none\)`, and is decoded here — see {@link scalarNeedsEscape}.
+*
+* ### The one ambiguity that remains, and how to write past it
+*
+* A scalar operator's operand is unconstrained, so `?status=like.that` is a
+* `LIKE 'that'` and no rule at this layer can tell it from the literal value
+* `"like.that"` — both are well-formed encodings, and picking either by guess
+* would break the other. Two spellings say "value" unambiguously, and both
+* round-trip:
+*
+* - `?status=eq.like.that` — name the operator. The *first* segment is consumed
+*   as the operator and everything after it is the value, dots and all. This is
+*   what `serializeFilter` emits, which is why the SDK never meets the
+*   ambiguity at all.
+* - `?where={"status":["==","like.that"]}` — the JSON dialect's tuple form.
+*
+* Values that merely *contain* dots (`user@host.com`, `1.2.3`) were never
+* ambiguous: their first segment names no operator to begin with.
+*/
+function deserializeSingle(raw) {
+	const dotIndex = raw.indexOf(".");
+	if (dotIndex === -1) return ["==", raw];
+	const prefix = raw.substring(0, dotIndex);
+	const rest = raw.substring(dotIndex + 1);
+	const canonicalOp = REST_OP_LOOKUP.get(prefix);
+	if (!canonicalOp) return ["==", raw];
+	if (NULL_OPS.has(canonicalOp)) {
+		if (!NULL_OPERANDS.has(rest)) return ["==", raw];
+		return [canonicalOp, null];
+	}
+	if (rest.startsWith("(") && rest.endsWith(")")) {
+		const inner = rest.slice(1, -1);
+		return [canonicalOp, inner === EMPTY_LIST_TOKEN ? [] : splitListItems(inner)];
+	}
+	if (LIST_OPS.has(canonicalOp)) return ["==", raw];
+	return [canonicalOp, decodeEscapedScalar(rest) ?? rest];
+}
+/**
+* Convert a PostgREST-style querystring record to `FilterValues`.
+*
+* - String values are parsed as single conditions.
+* - String arrays (repeated query params) become multiple conditions on the same field.
+*
+* @example
+* deserializeFilter({ status: "eq.active" })
+* // → { status: ["==", "active"] }
+*
+* 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;
+		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])) {
+				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]);
+			else result[field] = ["in", raw];
+		} else if (typeof raw === "string") result[field] = deserializeSingle(raw);
+		else result[field] = ["==", raw];
+	}
+	return result;
+}
+/**
+* Serialize a `LogicalCondition` or `FilterCondition` to its wire-format string.
+*
+* Leaf encoding is {@link serializeOperatorAndValue}, the same function
+* `serializeTuple` uses, so `null`, the empty list and an unknown operator
+* behave identically inside a group and in a query parameter.
+*
+* @throws {TypeError} when a leaf names an operator this dialect does not have.
+* It used to fall back to `eq`, which turned `age >= 18` into `age = 18` with
+* no diagnostic anywhere.
+*
+* @example
+* serializeLogicalCondition({ column: "status", operator: "==", value: "active" })
+* // → "status.eq.active"
+*
+* serializeLogicalCondition({ column: "deleted_at", operator: "==", value: null })
+* // → "deleted_at.isnull.null"
+*
+* serializeLogicalCondition({ type: "or", conditions: [...] })
+* // → "or(status.eq.active,status.eq.pending)"
+*/
+function serializeLogicalCondition(cond) {
+	if ("type" in cond) {
+		const inner = (cond.conditions ?? []).map(serializeLogicalCondition).join(",");
+		return `${cond.type}(${inner})`;
+	}
+	return `${escapeWireValue(cond.column)}.${serializeOperatorAndValue(cond.operator, cond.value, {
+		escapeScalar: true,
+		where: "serializeLogicalCondition"
+	})}`;
+}
+/**
+* The positions of the dots that can separate a leaf's segments.
+*
+* Dots inside a list value (`in.(1.5,2.5)`) are not separators. The value
+* always follows the operator, so the search only needs the region before the
+* first unescaped paren.
+*/
+function leafSeparators(str) {
+	let limit = str.length;
+	for (let i = 0; i < str.length; i++) {
+		if (str[i] === "\\") {
+			i++;
+			continue;
+		}
+		if (str[i] === "(") {
+			limit = i;
+			break;
+		}
+	}
+	const dots = [];
+	for (let i = 0; i < limit; i++) {
+		if (str[i] === "\\") {
+			i++;
+			continue;
+		}
+		if (str[i] === ".") dots.push(i);
+	}
+	return dots;
+}
+/**
+* Split a leaf condition into `column`, operator token and value.
+*
+* The naive reading — column is everything before the first dot, operator is
+* everything up to the second — cannot express a relation path. A filter on
+* `author.name` serializes to `author.name.eq.bob` and came back as the column
+* `author` with the operator `name`, which resolves to nothing, so the
+* fallback made it `author == "eq.bob"`: a condition that runs and matches
+* nothing, on a column the caller never named.
+*
+* So the operator is found rather than assumed: it is the first dot-separated
+* segment after the column that resolves to a real operator. Everything before
+* it is the column, everything after is the value. `version.eq.1.2.3` reads as
+* `version == "1.2.3"` because the scan stops at the first match — the `eq` at
+* offset 1, not a later segment — and `metadata->>x.eq.5` never had dots in the
+* column to begin with.
+*
+* Returns `undefined` when no segment resolves — `status.active`, an equality
+* written without an operator, which the caller handles.
+*/
+function splitLeafCondition(str) {
+	const dots = leafSeparators(str);
+	for (let i = 1; i < dots.length; i++) {
+		const operator = toCanonicalOp(str.substring(dots[i - 1] + 1, dots[i]));
+		if (!operator) continue;
+		return {
+			column: unescapeWireValue(str.substring(0, dots[i - 1])),
+			operator,
+			value: str.substring(dots[i] + 1)
+		};
+	}
+}
+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|not)\((.+)\)$/);
+	if (logicalMatch) {
+		const type = logicalMatch[1];
+		const innerStr = logicalMatch[2];
+		return {
+			type,
+			conditions: splitGroupItems(innerStr).map((part) => deserializeLogicalCondition(part, nesting + 1))
+		};
+	}
+	const leaf = splitLeafCondition(str);
+	if (!leaf) {
+		const firstDot = str.indexOf(".");
+		if (firstDot === -1) return {
+			column: unescapeWireValue(str),
+			operator: "==",
+			value: true
+		};
+		const dots = leafSeparators(str);
+		for (let i = 1; i < dots.length; i++) {
+			const segment = str.substring(dots[i - 1] + 1, dots[i]);
+			if (isOperatorShaped(segment)) throw new UnknownFilterOperatorError(unescapeWireValue(str.substring(0, dots[i - 1])), segment);
+		}
+		return {
+			column: unescapeWireValue(str.substring(0, firstDot)),
+			operator: "==",
+			value: unescapeWireValue(str.substring(firstDot + 1))
+		};
+	}
+	const { column, operator, value: valueStr } = leaf;
+	if (NULL_OPS.has(operator)) return {
+		column,
+		operator,
+		value: null
+	};
+	if (valueStr.startsWith("(") && valueStr.endsWith(")")) {
+		const inner = valueStr.slice(1, -1);
+		return {
+			column,
+			operator,
+			value: inner === EMPTY_LIST_TOKEN ? [] : splitListItems(inner)
+		};
+	}
+	return {
+		column,
+		operator,
+		value: unescapeWireValue(valueStr)
+	};
+}
+//#endregion
+export { isFieldOperation as C, Vector as D, GeoPoint as E, hasFieldOperation as S, EntityRelation as T, normalizeOrderBy as _, serializeFilter as a, BATCH_REF_KEY as b, collectAllPages as c, IncludeSpecError as d, deserializeInclude as f, OrderBySpecError as g, serializeInclude as h, deserializeLogicalCondition as i, paginateFind as l, normalizeInclude as m, UnknownFilterOperatorError as n, serializeLogicalCondition as o, mergeIncludeSpecs as p, deserializeFilter as r, PAGE_WITH_OFFSET_MESSAGE as s, RESERVED_QUERY_KEYS as t, resolveFindWindow as u, serializeOrderBy as v, EntityReference as w, FIELD_OPERATORS as x, withRelationReferencesOnly as y };
+
+//# sourceMappingURL=filter-dialect-O1HK6Nvr.js.map