@rebasepro/server 0.24.0 → 0.24.1-canary.g19596ef

package/dist/offline-store-Cm5sAX81-CALiO4Gn.js

@@ -0,0 +1,1915 @@
+import { createRequire as __rebaseCreateRequire } from "module";
+import __rebaseProcess from "process";
+globalThis.process ??= __rebaseProcess;
+__rebaseCreateRequire(import.meta.url);
+import { c as RebaseClientError, l as isUnsupported, s as RebaseApiError, u as unsupportedMethod } from "./strings.es-BeZWAodn.js";
+import { D as Vector, E as GeoPoint, T as EntityRelation, _ as normalizeOrderBy, a as serializeFilter, c as collectAllPages, h as serializeInclude, l as paginateFind, o as serializeLogicalCondition, p as mergeIncludeSpecs, t as RESERVED_QUERY_KEYS, u as resolveFindWindow, v as serializeOrderBy, w as EntityReference } from "./filter-dialect-O1HK6Nvr.js";
+import { et as sortKeyToString } from "./src-D5Y3N-S4.js";
+import { t as IMPERSONATE_HEADER } from "./auth_adapter-CIItCTc8.js";
+import { t as SCHEMA_VERSION_HEADER } from "./project_manifest-R6y_KHms.js";
+//#region ../utils/dist/unref.es.js
+/**
+* Release a Node handle's hold on the event loop, where the runtime has one.
+*
+* `unref` is Node's, not the web platform's. Node ref-counts the handles that
+* can keep a process alive — timers, `BroadcastChannel`, sockets — and gives
+* each an `unref()` that says "you are still live, but do not be the reason
+* this process refuses to exit". The browser's equivalents have no such method:
+* `setTimeout` there returns a plain number, and nothing is holding a page open
+* in the first place.
+*
+* So the call is genuinely conditional at runtime, in every package that runs
+* in both places. Spelled out at the call site it came to
+* `(handle as unknown as { unref?: () => void }).unref?.()` — a double cast,
+* because where the DOM declaration of `setTimeout` wins the handle is a
+* `number`, and `number` does not overlap an object type, so a single `as` is
+* refused. The `unknown` in the middle was there to make the refusal go away,
+* and it also discarded the check on the member's name and signature. There
+* were seven copies, which is seven chances to get one of those wrong.
+*
+* Takes `unknown` on purpose: the argument's type is exactly what is not known
+* here, and narrowing it to a timer would be a claim this cannot make about a
+* `BroadcastChannel`. A no-op on a browser handle, on `null`/`undefined`, and
+* on a Node timer that has already fired.
+*/
+function unref(handle) {
+	if (handle === null || typeof handle !== "object") return;
+	const fn = handle.unref;
+	if (typeof fn === "function") fn.call(handle);
+}
+//#endregion
+//#region ../common/src/data/row-etag.ts
+/**
+* A row's version — the `ETag` the read that produced it reported — kept on
+* the row without being part of it.
+*
+* @module
+*/
+/**
+* Where a fetched row's version is kept.
+*
+* Non-enumerable, so it does not appear in `Object.keys`, in `JSON.stringify`,
+* in a spread into an update body, or in the generated `Row` type — a row's
+* version is a fact about the *response*, not a column, and putting it in the
+* row proper would mean the server having to strip it back off every write.
+*
+* A string key rather than a symbol so it survives the structured clone an
+* offline store or a worker boundary does… which it does not, and that is the
+* honest position: an etag is per-read, and a row that has been through a cache
+* has not been read from the server. `etagOf` answers `undefined` there, and a
+* conditional write without a tag is an unconditional one.
+*/
+var ETAG_KEY = "__etag";
+/**
+* The version of a row, when it came straight from a read that reported one.
+*
+* ```ts
+* const post = await client.data.posts.get(1);
+* await client.data.posts.update(1, { title: "New" }, { ifMatch: etagOf(post) });
+* ```
+*
+* Set on a row from `findById()`/`get()`, from `update()`, and on every row
+* `listenById()` delivers (the SDK asks the server to tag each frame).
+* `undefined` for a row from `find()` (a list response carries one ETag at
+* most, and it would not be this row's), from the offline cache, or from a
+* server that does not send them. Passing `undefined` as `ifMatch` sends no
+* precondition, so the call above degrades to an ordinary update rather than
+* failing — which is the right default, and the reason to read this at the call
+* site where the choice is visible.
+*/
+function etagOf(row) {
+	if (!row || typeof row !== "object") return void 0;
+	const value = row[ETAG_KEY];
+	return typeof value === "string" ? value : void 0;
+}
+/**
+* Attach a version to a row without making it part of the row: a
+* non-enumerable `__etag`, so it stays out of `Object.keys`, a spread and
+* `JSON.stringify`, and a row copied through any of them has no tag — which
+* is right, since the copy was not read from the server.
+*/
+function withETag(row, etag) {
+	if (!etag || !row || typeof row !== "object") return row;
+	Object.defineProperty(row, ETAG_KEY, {
+		value: etag,
+		enumerable: false,
+		configurable: true,
+		writable: true
+	});
+	return row;
+}
+//#endregion
+//#region ../client/dist/offline-store-Cm5sAX81.js
+function rebaseReviver(_key, value) {
+	if (value && typeof value === "object" && "__type" in value) {
+		const record = value;
+		switch (record.__type) {
+			case "date":
+			case "Date": {
+				if (typeof record.value !== "string") return value;
+				const date = new Date(record.value);
+				return isNaN(date.getTime()) ? null : date;
+			}
+			case "reference":
+			case "EntityReference": return new EntityReference({
+				id: String(record.id),
+				path: record.path,
+				driver: record.driver,
+				databaseId: record.databaseId
+			});
+			case "relation":
+			case "EntityRelation": return new EntityRelation(record.id, record.path, record.data);
+			case "GeoPoint": return new GeoPoint(record.latitude, record.longitude);
+			case "Vector": return new Vector(record.value);
+			default: return value;
+		}
+	}
+	return value;
+}
+/**
+* Could `text` hold an object with a `__type` key — the only values
+* {@link rebaseReviver} changes?
+*
+* A key is spelled either literally or with `\u` escapes, so a body with
+* neither cannot contain one. The check is two substring scans, which run at
+* memory speed; a false positive only costs the walk below.
+*/
+function mayHoldTypedValues(text) {
+	return text.includes("\"__type\"") || text.includes("\\u");
+}
+/**
+* Set a property the way `JSON.parse`'s reviver does: as an own data property.
+* A plain assignment to a key named `__proto__` would call the setter and swap
+* the object's prototype instead.
+*/
+function setRevived(target, key, value) {
+	if (key === "__proto__") Object.defineProperty(target, key, {
+		value,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
+	else target[key] = value;
+}
+/**
+* {@link rebaseReviver}, applied bottom-up to an already parsed value, in
+* place: every child is revived before its parent, so a relation's `data` holds
+* its own revived values by the time the relation is built from it — the order
+* `JSON.parse` calls a reviver in. Primitives are never visited; the reviver
+* hands every one of them back unchanged.
+*/
+function reviveTree(value) {
+	if (value === null || typeof value !== "object") return value;
+	if (Array.isArray(value)) {
+		for (let i = 0; i < value.length; i++) {
+			const item = value[i];
+			if (item !== null && typeof item === "object") {
+				const revived = reviveTree(item);
+				if (revived !== item) value[i] = revived;
+			}
+		}
+		return value;
+	}
+	const record = value;
+	for (const key of Object.keys(record)) {
+		const item = record[key];
+		if (item !== null && typeof item === "object") {
+			const revived = reviveTree(item);
+			if (revived !== item) setRevived(record, key, revived);
+		}
+	}
+	return rebaseReviver("", record);
+}
+/**
+* `JSON.parse(text, rebaseReviver)`, without the reviver's cost where it has
+* nothing to do.
+*
+* Handing `JSON.parse` a reviver takes V8 off its fast path and calls back for
+* every key and every value, primitives included: about 7× a plain parse on a
+* 1,000-row page, 10 ms of main thread per 600 KB. The reviver only ever
+* changes objects carrying `__type`, and a REST page of flat rows has none. So
+* this parses plainly and walks the result only when the text can hold one —
+* and the walk visits objects, never primitives.
+*
+* Same result, instance for instance: the same values revived, bottom-up, as
+* own data properties, and nothing deleted (the reviver never answers
+* `undefined`).
+*
+* @throws SyntaxError exactly where `JSON.parse` does.
+*/
+function parseRebaseJson(text) {
+	const parsed = JSON.parse(text);
+	if (!mayHoldTypedValues(text)) return parsed;
+	return reviveTree(parsed);
+}
+/**
+* True when there is no browser to have signed a user in — a Node script, a
+* cron job, an edge worker.
+*
+* Anonymous is an ordinary, correct state in a browser: before sign-in, on a
+* marketing page, for public reads. Warning there would be noise that teaches
+* people to ignore warnings, so the guard is off entirely. This uses the same
+* `typeof window` test as {@link resolveBaseUrl}, and additionally treats a
+* defined `document` as a browser so an SSR shim or test harness that installs
+* only one of the two is still excluded.
+*/
+function isServerLikeEnvironment() {
+	return typeof window === "undefined" && typeof document === "undefined";
+}
+/**
+* Emitted once per client. Kept as a constant so the wording is testable and
+* greppable — this is the string a user will paste into a search.
+*/
+var ANONYMOUS_SERVER_CLIENT_WARNING = "[rebase] This client was created outside a browser with no credential — no `token`, no auth token getter, and no cookie auth flow — so every request runs as an anonymous caller. Row-level security will return only publicly readable rows, which is usually nothing and occasionally the wrong thing. Inside a cron or function handler, use the `rebase` you were handed instead of building a new one: its data plane is already admin-scoped. In a standalone script or job, pass the service key as `token`. If you really do want anonymous access, pass `anonymous: true` to silence this.";
+/**
+* Refuse a filter whose *value* is missing.
+*
+* `where: { status: ["==", undefined] }` used to serialize to the literal
+* string, so `status=eq.undefined` went out on the wire and the server dutifully
+* looked for rows whose status is the four-letter word "undefined". The caller
+* saw an empty page, not an error — the classic shape of a variable that was
+* never set.
+*
+* Dropping the condition instead would be worse than sending it: the query
+* would come back *unfiltered*, which for an ownership or tenant filter means
+* returning rows the caller never asked to see. So this is a hard error, and
+* both correct spellings are named in the message: omit the key to skip the
+* filter, or use `["is-null", null]` to match SQL NULL (which still
+* serializes — `null` is a value, `undefined` is the absence of one).
+*/
+function assertNoUndefinedFilterValues(where) {
+	const reject = (field, op) => {
+		throw new RebaseClientError(`Filter on "${field}" has an undefined value (["${String(op)}", undefined]). Omit "${field}" from \`where\` to skip the filter, or use ["is-null", null] to match SQL NULL.`, {
+			code: "INVALID_FILTER",
+			details: {
+				field,
+				operator: String(op)
+			}
+		});
+	};
+	for (const [field, condition] of Object.entries(where)) {
+		if (condition === void 0) continue;
+		if (!Array.isArray(condition)) continue;
+		const tuples = Array.isArray(condition[0]) ? condition : [condition];
+		for (const tuple of tuples) {
+			if (!Array.isArray(tuple) || tuple.length !== 2) continue;
+			const [op, value] = tuple;
+			if (value === void 0) reject(field, op);
+			if (Array.isArray(value) && value.some((v) => v === void 0)) reject(field, op);
+		}
+	}
+}
+/**
+* A find's parameters as `[name, value]` pairs, in the order the URL carries
+* them, values not yet URL-encoded.
+*
+* One list for both spellings of a listing: {@link buildQueryString} encodes it
+* into the `GET`'s URL, and {@link buildQueryBody} gathers it into the body of
+* `POST …/query`, which the server turns back into exactly these parameters.
+* Two serializers would be two chances to send a query one way and not the
+* other.
+*/
+function findParamPairs(params, deleted) {
+	const pairs = [];
+	if (deleted) pairs.push(["deleted", deleted]);
+	if (!params) return pairs;
+	resolveFindWindow(params);
+	if (params.limit != null) pairs.push(["limit", String(params.limit)]);
+	if (params.offset != null) pairs.push(["offset", String(params.offset)]);
+	if (params.page != null) pairs.push(["page", String(params.page)]);
+	if (params.after) pairs.push(["after", params.after]);
+	if (params.count === "none") pairs.push(["count", "none"]);
+	if (params.orderBy) {
+		const wire = serializeOrderBy(params.orderBy);
+		if (wire) pairs.push(["orderBy", wire]);
+	}
+	if (params.searchString) {
+		pairs.push(["searchString", params.searchString]);
+		if (params.searchExplain) pairs.push(["searchExplain", "true"]);
+	}
+	if (params.vectorSearch) {
+		const vs = params.vectorSearch;
+		pairs.push(["vector_search", vs.property]);
+		pairs.push(["vector", JSON.stringify(vs.vector)]);
+		if (vs.distance) pairs.push(["vector_distance", vs.distance]);
+		if (vs.threshold !== void 0) pairs.push(["vector_threshold", String(vs.threshold)]);
+	}
+	const include = serializeInclude(params.include);
+	if (include) pairs.push(["include", include]);
+	if (params.fields && params.fields.length > 0) pairs.push(["fields", params.fields.join(",")]);
+	if (params.distinct) pairs.push(["distinct", "true"]);
+	if (params.logical) {
+		const root = params.logical;
+		const serialized = (root.conditions ?? []).map(serializeLogicalCondition).join(",");
+		pairs.push([root.type, `(${serialized})`]);
+	}
+	if (params.where) appendWhere(pairs, params.where);
+	return pairs;
+}
+var encodePairs = (pairs) => pairs.length > 0 ? "?" + pairs.map(([name, value]) => `${encodeURIComponent(name)}=${encodeURIComponent(value)}`).join("&") : "";
+function buildQueryString(params, deleted) {
+	return encodePairs(findParamPairs(params, deleted));
+}
+/**
+* The body of `POST /data/<collection>/query`: the parameters
+* {@link buildQueryString} puts in the URL, spelled as the URL spells them —
+* each value a string, and a parameter the URL repeats (a filter with two
+* conditions on one field) a list of them. The server reads it back into the
+* same parameters and runs the same listing.
+*/
+function buildQueryBody(params, deleted) {
+	const body = {};
+	for (const [name, value] of findParamPairs(params, deleted)) {
+		const held = body[name];
+		body[name] = held === void 0 ? value : [...Array.isArray(held) ? held : [held], value];
+	}
+	return body;
+}
+/**
+* Append a `where` to a query string, one `?<field>=<op>.<value>` parameter per
+* condition.
+*
+* Except on a column whose name the server reads as a parameter of its own —
+* `page`, `select`, `hard`, `where` ({@link RESERVED_QUERY_KEYS}). A filter on
+* such a column sent as its own parameter is read as that parameter, and the
+* filter is never applied. Those conditions go inside `?where=` instead, in the
+* same dot-string spelling, which the server decodes through the same codec and
+* merges in. A collection with no such column sends exactly what it did before.
+*/
+function appendWhere(pairs, where) {
+	assertNoUndefinedFilterValues(where);
+	const serialized = serializeFilter(where);
+	const reserved = {};
+	for (const [field, value] of Object.entries(serialized)) {
+		if (RESERVED_QUERY_KEYS.has(field)) {
+			reserved[field] = value;
+			continue;
+		}
+		for (const v of Array.isArray(value) ? value : [value]) pairs.push([field, v]);
+	}
+	if (Object.keys(reserved).length > 0) pairs.push(["where", JSON.stringify(reserved)]);
+}
+/**
+* The query string for `GET /<collection>/aggregate`.
+*
+* `?select=sum(total),count()` is SQL's spelling, because whoever writes an
+* aggregate is thinking in SQL and any other spelling has to be learned first —
+* and because it is what the route already parses. The filters are serialised
+* by exactly the same code a `find()` uses, so "revenue by status, this month"
+* narrows the same rows whichever call is asking.
+*
+* `include` and a cursor are deliberately not here: an aggregate has no
+* relations to load and no row to continue after. `limit`, `offset` and
+* `orderBy` are, and page and sort the *groups* — `orderBy` by a group column or
+* an aggregate's alias, in the spelling a `find()` sends.
+*/
+function buildAggregateQueryString(params) {
+	const pairs = [];
+	const select = params.select.map((entry) => `${entry.fn}(${entry.field ?? ""})`).join(",");
+	pairs.push(["select", select]);
+	if (params.groupBy && params.groupBy.length > 0) pairs.push(["groupBy", params.groupBy.join(",")]);
+	if (params.limit != null) pairs.push(["limit", String(params.limit)]);
+	if (params.offset != null) pairs.push(["offset", String(params.offset)]);
+	if (params.orderBy) {
+		const wire = serializeOrderBy(params.orderBy);
+		if (wire) pairs.push(["orderBy", wire]);
+	}
+	if (params.searchString) pairs.push(["searchString", params.searchString]);
+	if (params.logical) {
+		const root = params.logical;
+		const serialized = (root.conditions ?? []).map(serializeLogicalCondition).join(",");
+		pairs.push([root.type, `(${serialized})`]);
+	}
+	if (params.where) appendWhere(pairs, params.where);
+	return encodePairs(pairs);
+}
+/**
+* The 401 codes that mean "the credential on this request is no good", which a
+* refreshed token can fix.
+*
+* The rest of the 401s are answers about something the caller *sent*: a wrong
+* current password (`INVALID_CREDENTIALS`), a mistyped MFA code (`INVALID_CODE`,
+* `CHALLENGE_EXHAUSTED`), a sign-in that needs a second factor
+* (`MFA_REQUIRED`). Refreshing and resending one of those rotated the session
+* for nothing, sent the same wrong answer twice — and an MFA challenge claims
+* an attempt before it judges the code, so every typo cost two of its five.
+*/
+var TOKEN_REFUSAL_CODES = /* @__PURE__ */ new Set([
+	"UNAUTHORIZED",
+	"INVALID_TOKEN",
+	"TOKEN_EXPIRED",
+	"SESSION_REVOKED"
+]);
+/**
+* Whether a 401's body says the token was the problem.
+*
+* A 401 with no code at all counts: it is what an older server, a proxy or
+* anything not speaking the envelope sends, and there the token is the
+* likeliest cause — refreshing is what this client always did with it.
+*/
+function isTokenRefusal(body) {
+	const error = body?.error;
+	const code = error && typeof error === "object" ? error.code : void 0;
+	return typeof code !== "string" || code === "" || TOKEN_REFUSAL_CODES.has(code);
+}
+/**
+* The base every request and every caller-built URL resolves against.
+*
+* `baseUrl` is optional because the common production shape is a Rebase
+* backend serving its own SPA, where the API is simply the page's origin.
+* Leaving it unset is therefore the *correct* configuration there — and the
+* one that keeps working when a second hostname (a custom domain) points at
+* the same app.
+*
+* When unset in a browser this resolves to the page origin rather than "".
+* Requests behave identically either way, but the empty string is a trap for
+* anything that builds a URL from `client.baseUrl`: `new URL("" + path)`
+* throws, so apps "fixed" it by baking an absolute host into their bundle —
+* which is exactly what breaks the day a custom domain is added, and which no
+* amount of CORS configuration repairs, because a SameSite=Lax auth cookie is
+* not sent cross-site either.
+*/
+/**
+* The code an error carries when the response did not name one: a proxy's 413,
+* a load balancer's 502, a crash page's 500 — anything without the server's
+* envelope. Without it `e.code` was `undefined` and the documented
+* `switch (e.code)` fell through to `default` on exactly the failures that are
+* not Rebase's own. Only codes the backend itself answers with, so a switch
+* written against the error reference catches both.
+*
+* @internal
+*/
+function defaultCodeForStatus(status) {
+	switch (status) {
+		case 400: return "BAD_REQUEST";
+		case 401: return "UNAUTHORIZED";
+		case 403: return "FORBIDDEN";
+		case 404: return "NOT_FOUND";
+		case 409: return "CONFLICT";
+		case 412: return "PRECONDITION_FAILED";
+		case 413: return "PAYLOAD_TOO_LARGE";
+		case 415: return "UNSUPPORTED_MEDIA_TYPE";
+		case 429: return "RATE_LIMITED";
+		case 502:
+		case 503:
+		case 504: return "SERVICE_UNAVAILABLE";
+		default: return status >= 500 && status < 600 ? "INTERNAL_ERROR" : void 0;
+	}
+}
+function resolveBaseUrl(configured) {
+	if (configured) return configured.replace(/\/$/, "");
+	if (typeof window !== "undefined" && window.location?.origin) return window.location.origin;
+	return "";
+}
+function createTransport(config, environment) {
+	const rawFetch = config.fetch || globalThis.fetch;
+	/**
+	* `fetch`, but its rejection is a `RebaseApiError` like everything else
+	* this client throws.
+	*
+	* A transport failure — DNS, a refused connection, CORS, an aborted
+	* request — rejects with whatever the runtime's `fetch` felt like: a
+	* `TypeError` reading "Failed to fetch" in a browser, a `TypeError` with a
+	* `cause` in undici, a `DOMException` on abort. So the one class the SDK
+	* documents as "a `catch` block only ever needs to check for this" did not
+	* cover the most common failure of all, and `e.status` / `e.code` were
+	* undefined on the error every app hits first: the server being down.
+	*
+	* `status: 0` rather than a made-up 5xx. There was no response, and 0 is
+	* how `XMLHttpRequest` has always spelled that; a fabricated 503 would be
+	* indistinguishable from one the server actually sent. The original error
+	* is on `cause`, so nothing is hidden.
+	*
+	* Wrapped once, at construction, because the request path reads `fetchFn`
+	* twice — the first attempt and the post-refresh retry — and a wrapper
+	* applied at one call site is a wrapper missing from the other.
+	*/
+	const fetchFn = async (input, init) => {
+		try {
+			return await rawFetch(input, init);
+		} catch (e) {
+			if (e instanceof RebaseApiError) throw e;
+			const url = typeof input === "string" ? input : String(input.url ?? input);
+			if (!/^[a-z][a-z0-9+.-]*:/i.test(url) && typeof window === "undefined") throw new RebaseClientError(`This client has no \`baseUrl\`, and outside a browser the relative URL ${url} cannot be fetched. Pass \`baseUrl\` (e.g. "http://localhost:3001") to createRebaseClient().`, {
+				code: "BASE_URL_REQUIRED",
+				cause: e
+			});
+			throw new RebaseApiError(`Could not reach the server at ${url}: ${e instanceof Error ? e.message : String(e)}`, {
+				status: 0,
+				code: "NETWORK_ERROR",
+				cause: e
+			});
+		}
+	};
+	const apiPath = config.apiPath || "/api";
+	for (const field of ["baseUrl", "storageUrlOrigin"]) {
+		const value = config[field];
+		if (!value || !apiPath) continue;
+		const trimmed = value.replace(/\/+$/, "");
+		if (!trimmed.endsWith(apiPath)) continue;
+		console.warn(`[Rebase] ${field} ${JSON.stringify(value)} already ends with the API path ${JSON.stringify(apiPath)}, which is appended to it — requests will go to ${trimmed}${apiPath}/… and 404. Pass the origin only (${JSON.stringify(trimmed.slice(0, trimmed.length - apiPath.length) || "/")}), or set \`apiPath\` if the server really does mount the API one level deeper.`);
+	}
+	/**
+	* The token `setToken` last set — the auth module sets it on every sign-in,
+	* refresh and sign-out — or, until anything has, `config.token`.
+	*
+	* `config.token` is read each time a token is needed rather than copied
+	* here once, so a config that declares `token` as a getter hands over what
+	* its source holds at that moment: the Rebase console lends its own,
+	* background-refreshed session to a tenant client that way. The realtime
+	* socket resolves its token through this transport, so the two read it
+	* alike.
+	*/
+	let setTokenValue;
+	const heldToken = () => setTokenValue ? setTokenValue.token : config.token;
+	let tokenGetter;
+	let tokenRefresher;
+	let onUnauthorizedHandler = config.onUnauthorized;
+	/** Once per client, never per request — log spam is its own bug. */
+	let anonymousWarningIssued = false;
+	/**
+	* Warn a server-side caller that it built a client that can only ever be
+	* anonymous. Deliberately checked at the *first request* rather than at
+	* construction: `setToken()` / `setAuthTokenGetter()` and a server-side
+	* `auth.signIn…()` (which calls `transport.setToken`) all land after the
+	* constructor, and warning at construction would fire on every one of them.
+	*/
+	function warnIfAnonymousServerClient(activeToken) {
+		if (anonymousWarningIssued) return;
+		if (activeToken) return;
+		if (tokenGetter) return;
+		if (config.anonymous) return;
+		if (environment?.credentialOutOfBand) return;
+		if (!isServerLikeEnvironment()) return;
+		anonymousWarningIssued = true;
+		console.warn(ANONYMOUS_SERVER_CLIENT_WARNING);
+	}
+	const defaultHeaders = {
+		...config.headers ?? {},
+		...config.schemaVersion ? { [SCHEMA_VERSION_HEADER]: config.schemaVersion } : {},
+		...config.impersonate !== void 0 ? { [IMPERSONATE_HEADER]: config.impersonate } : {}
+	};
+	function getHeaders(activeToken, init) {
+		const headers = {
+			"Content-Type": "application/json",
+			...defaultHeaders,
+			...activeToken ? { Authorization: `Bearer ${activeToken}` } : {},
+			...init?.headers || {}
+		};
+		if (init?.body instanceof FormData) delete headers["Content-Type"];
+		return headers;
+	}
+	/**
+	* The refusal for a success status carrying a body this client cannot read.
+	*
+	* The first 120 characters go in the message because they identify the
+	* sender at a glance: `<!doctype html>` says "you are talking to a web
+	* server, not to this API" faster than any wording here could.
+	*
+	* One function for both the first attempt and the post-refresh retry — the
+	* retry is a second copy of this whole response-reading path, and copies
+	* are how one of them ends up fixed and the other not.
+	*/
+	function unreadableResponse(status, text, contentType) {
+		const type = contentType?.split(";")[0].trim().toLowerCase() || "";
+		return new RebaseApiError(`The server answered ${status} with a body that is not JSON, so there is nothing to return. ${type !== "" && type !== "text/html" && !type.includes("json") ? `The body is ${type}. If this is a custom function that answers text or a file, ask for it with \`functions.invoke(name, payload, { responseType: "text" | "blob" | "response" })\`.` : "This usually means the request reached something other than the Rebase API — a single-page-app fallback serving index.html, or a proxy error page — so check the API URL configuration (e.g. VITE_API_URL)."} The body began: ${JSON.stringify(text.slice(0, 120))}`, {
+			status,
+			code: "INVALID_JSON_RESPONSE",
+			...type ? { details: { contentType: type } } : {}
+		});
+	}
+	/**
+	* The server always emits the canonical
+	* `{ error: { message, code, details?, requestId? } }` envelope (formatted
+	* by the central `errorHandler`), so a field is read strictly from
+	* `body.error.*` and never from the top level.
+	*/
+	function getErrorField(obj, field) {
+		const err = obj?.error;
+		if (err && typeof err === "object" && err !== null) return err[field];
+	}
+	/**
+	* `Retry-After` as whole seconds, or `undefined`.
+	*
+	* The header is either a number of seconds or an HTTP date; both spellings
+	* are legal and servers use both, so both are read. A date in the past —
+	* which happens on a clock skew — is clamped to 0 rather than negative.
+	*/
+	function parseRetryAfter(header) {
+		if (!header) return void 0;
+		const seconds = Number(header.trim());
+		if (Number.isFinite(seconds)) return Math.max(0, Math.floor(seconds));
+		const at = Date.parse(header);
+		if (Number.isNaN(at)) return void 0;
+		return Math.max(0, Math.round((at - Date.now()) / 1e3));
+	}
+	/**
+	* Everything a failed response says about itself, in one place.
+	*
+	* The request path reads a response twice — the first attempt and the
+	* post-refresh retry — and the two used to build their error separately.
+	* Which is how they came to disagree: both dropped `requestId` and
+	* `Retry-After`, and a fix applied to one would have missed the other.
+	*/
+	function errorFrom(res, body, fallbackMessage) {
+		const requestId = getErrorField(body, "requestId") ?? res.headers?.get("X-Request-ID") ?? void 0;
+		return new RebaseApiError(String(getErrorField(body, "message") || fallbackMessage || `Request failed with status ${res.status}`), {
+			status: res.status,
+			code: getErrorField(body, "code") || defaultCodeForStatus(res.status),
+			details: getErrorField(body, "details"),
+			...typeof requestId === "string" && requestId ? { requestId } : {},
+			...(() => {
+				const retryAfter = parseRetryAfter(res.headers?.get("Retry-After") ?? null);
+				return retryAfter === void 0 ? {} : { retryAfterSeconds: retryAfter };
+			})()
+		});
+	}
+	/**
+	* The token a request should carry: the getter's when one is installed,
+	* otherwise the one held — or, when the token refresher says the held one
+	* is spent, the one it hands back once its refresh lands.
+	*/
+	async function tokenForRequest() {
+		if (tokenGetter) {
+			try {
+				const fetched = await tokenGetter();
+				if (fetched !== null && fetched !== void 0) return fetched;
+			} catch (e) {}
+			return heldToken();
+		}
+		const pending = tokenRefresher?.();
+		if (pending) try {
+			const fresh = await pending;
+			if (fresh) return fresh;
+		} catch (e) {}
+		return heldToken();
+	}
+	/** The body as JSON, `{}` for none, `undefined` when it is there and is not JSON. */
+	function parseBody(text) {
+		if (!text) return {};
+		try {
+			return parseRebaseJson(text);
+		} catch (e) {
+			return;
+		}
+	}
+	/**
+	* Send a request and hand back the response that answers it: the token
+	* attached, a token refusal answered by one refresh and resend, and an
+	* error status thrown as a {@link RebaseApiError}. The body of a success is
+	* left unread, for the caller to read in whatever form it expects.
+	*
+	* One path for the first attempt and the post-refresh retry: the two used
+	* to be separate copies of this whole sequence, and copies are how one of
+	* them ends up fixed and the other not.
+	*/
+	async function requestRaw(path, init, meta) {
+		const url = resolveBaseUrl(config.baseUrl) + apiPath + path;
+		const activeToken = await tokenForRequest();
+		warnIfAnonymousServerClient(activeToken);
+		let res = await fetchFn(url, {
+			...init,
+			headers: getHeaders(activeToken, init)
+		});
+		let readText;
+		if (res.status === 401 && onUnauthorizedHandler) {
+			readText = await res.text().catch(() => "");
+			if (isTokenRefusal(parseBody(readText) ?? {})) {
+				if (await onUnauthorizedHandler()) {
+					let retryToken = heldToken();
+					if (tokenGetter) try {
+						const fetched = await tokenGetter();
+						if (fetched !== null && fetched !== void 0) retryToken = fetched;
+					} catch (e) {}
+					res = await fetchFn(url, {
+						...init,
+						headers: getHeaders(retryToken, init)
+					});
+					readText = void 0;
+				}
+			}
+		}
+		if (meta) {
+			meta.status = res.status;
+			meta.etag = res.headers?.get?.("ETag") ?? void 0;
+			meta.headers = res.headers;
+		}
+		if (!res.ok) {
+			const text = readText ?? await res.text().catch(() => "");
+			let fallbackMessage = res.statusText;
+			if (res.status === 404 && !fallbackMessage) fallbackMessage = `Endpoint not found (${init?.method || "GET"} ${path}). This usually means the collection is not registered on the backend, or the frontend API URL configuration (e.g. VITE_API_URL) is missing or pointing to the wrong host.`;
+			throw errorFrom(res, parseBody(text) ?? {}, fallbackMessage);
+		}
+		return res;
+	}
+	async function request(path, init, meta) {
+		const res = await requestRaw(path, init, meta);
+		if (res.status === 204) return void 0;
+		const text = await res.text().catch(() => "");
+		/**
+		* `undefined` when the body was there and could not be read as JSON.
+		*
+		* On a *success* status that is the whole answer, and `{}` was being
+		* returned as though the server had sent it: `find()` answered `{}`
+		* instead of an array, `getOne()` an empty object, with nothing thrown.
+		*
+		* The case that produces it is not exotic. Point `VITE_API_URL` at the
+		* frontend's own host and `/api/data/posts` lands on the SPA fallback,
+		* which answers `200` with `index.html` — so the misconfiguration the
+		* 404 message spends four lines explaining reaches the caller, in its
+		* most common form, as an empty success.
+		*/
+		const body = parseBody(text);
+		if (body === void 0) throw unreadableResponse(res.status, text, res.headers?.get?.("Content-Type") ?? null);
+		return body;
+	}
+	return {
+		request,
+		requestRaw,
+		setToken(newToken) {
+			setTokenValue = { token: newToken || void 0 };
+		},
+		setAuthTokenGetter(getter) {
+			tokenGetter = getter;
+		},
+		setOnUnauthorized(handler) {
+			onUnauthorizedHandler = handler;
+		},
+		setTokenRefresher(refresher) {
+			tokenRefresher = refresher ?? void 0;
+		},
+		get baseUrl() {
+			return resolveBaseUrl(config.baseUrl);
+		},
+		get apiPath() {
+			return apiPath;
+		},
+		get storageUrlOrigin() {
+			return config.storageUrlOrigin?.replace(/\/$/, "") || void 0;
+		},
+		get fetchFn() {
+			return fetchFn;
+		},
+		getHeaders: (init) => getHeaders(heldToken(), init),
+		resolveToken: async () => await tokenForRequest() || null
+	};
+}
+/**
+* SDK Query Builder — returns flat rows (`FindResult<M>`) instead of
+* Entity-wrapped results (`FindResponse<M>`).
+*
+* @example
+* const { data } = await rebase.data.posts
+*     .where("status", "==", "published")
+*     .orderBy("created_at", "desc")
+*     .limit(10)
+*     .find();
+*
+* console.log(data[0].title); // flat access
+*/
+var SDKQueryBuilder = class {
+	collection;
+	params = { where: {} };
+	constructor(collection) {
+		this.collection = collection;
+	}
+	where(columnOrCondition, operator, value) {
+		if (typeof columnOrCondition === "object" && columnOrCondition !== null && "type" in columnOrCondition) {
+			const next = columnOrCondition;
+			this.params.logical = this.params.logical ? {
+				type: "and",
+				conditions: [this.params.logical, next]
+			} : next;
+			return this;
+		}
+		if (!this.params.where) this.params.where = {};
+		const column = columnOrCondition;
+		const condition = [operator, value];
+		const existing = this.params.where[column];
+		if (existing === void 0) this.params.where[column] = condition;
+		else if (Array.isArray(existing) && existing.length > 0 && Array.isArray(existing[0])) this.params.where[column].push(condition);
+		else {
+			let firstCondition;
+			if (Array.isArray(existing) && existing.length === 2 && typeof existing[0] === "string") firstCondition = existing;
+			else firstCondition = ["==", existing];
+			this.params.where[column] = [firstCondition, condition];
+		}
+		return this;
+	}
+	/**
+	* Order the results by a specific column.
+	*
+	* Call it again to add a tie-breaker rather than replace the sort: keys
+	* apply in the order they were added, so
+	* `.orderBy("roles").orderBy("created_at", "desc")` sorts by role and
+	* shows the newest first within each one.
+	*/
+	orderBy(column, direction = "asc", nulls) {
+		const existing = normalizeOrderBy(this.params.orderBy) ?? [];
+		const key = sortKeyToString(column);
+		this.params.orderBy = [...existing, nulls ? [
+			key,
+			direction,
+			nulls
+		] : [key, direction]];
+		return this;
+	}
+	/**
+	* Limit the number of results returned.
+	*/
+	limit(count) {
+		this.params.limit = count;
+		return this;
+	}
+	/**
+	* Skip the first N results.
+	*/
+	offset(count) {
+		this.params.offset = count;
+		return this;
+	}
+	/**
+	* Set a free-text search string if supported by the backend.
+	*
+	* By default this is a substring match across the collection's top-level
+	* string properties. A Postgres collection that declares a `search` block
+	* gets ranked full-text matching over the fields it named instead, and each
+	* row comes back with a `_score` you can sort on:
+	*
+	* ```ts
+	* client.data.talents.search("auditor iso 14001").orderBy("_score", "desc").find()
+	* ```
+	*
+	* Pass `{ explain: true }` to have each row report which of the declared
+	* fields matched, with a highlighted snippet, on `_matches`:
+	*
+	* ```ts
+	* const { data } = await client.data.talents.search("iso 14001", { explain: true }).find();
+	* data[0]._matches
+	* // [{ field: "questionnaire.certifications", snippet: "<mark>ISO</mark> <mark>14001</mark> Lead Auditor" }]
+	* ```
+	*/
+	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`.
+	*
+	* The server has supported this from the REST layer since vectors landed;
+	* this is the SDK reaching it. Results come back closest-first with a
+	* `_distance` on each row, and any `where` / `orderBy` on the same query is
+	* a filter applied before the ordering — distance decides the order.
+	*
+	* You supply the query vector. Rebase stores and searches embeddings; it
+	* does not produce them, so this is where whatever model you already use
+	* for the stored vectors gets called.
+	*
+	* @param property - Name of the `vector` property to compare against.
+	* @param vector - The query embedding. Its length must match the property's
+	*                 declared `dimensions`, or the server answers 400.
+	* @example
+	* client.data.docs.vectorSearch("embedding", queryVector, { threshold: 0.35 }).limit(10).find()
+	*/
+	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;
+	}
+	/**
+	* Load related rows into the response, in place of their foreign keys.
+	*
+	* Three spellings, all the same request:
+	*
+	* ```ts
+	* client.data.posts.include("tags", "author")            // names
+	* client.data.posts.include("comments.author")           // a dotted path
+	* client.data.posts.include({                            // parametrised
+	*     comments: {
+	*         limit: 5,
+	*         where: { published: ["==", true] },
+	*         orderBy: ["created_at", "desc"],
+	*         include: { author: true }
+	*     }
+	* })
+	* ```
+	*
+	* Up to three hops deep, and `"*"` still loads every relation one hop
+	* deep. A name that is not a relation of the collection is a 400
+	* `UNKNOWN_RELATION` — it used to be ignored, which answers 200 with the
+	* field missing and reads exactly like a row that has no related row.
+	*
+	* Repeated calls **merge**: `.include("author").include("tags")` asks for
+	* both. Assigning here — which is what it used to do — meant the second
+	* call silently discarded the first.
+	*/
+	include(...relations) {
+		this.params.include = mergeIncludeSpecs(this.params.include, relations);
+		return this;
+	}
+	/**
+	* Return only these columns.
+	*
+	* A projection at the database, not a trim of the response: a query that
+	* needs two fields of a wide row reads two columns. The primary key always
+	* comes back regardless — a row that cannot be addressed cannot be
+	* updated, deleted or paged past — and `excludeFromApi` columns stay
+	* hidden whether or not they are named.
+	*/
+	fields(...columns) {
+		this.params.fields = [...this.params.fields ?? [], ...columns];
+		return this;
+	}
+	/**
+	* Collapse rows that are identical over the columns being returned.
+	*
+	* Only meaningful alongside {@link fields}: the primary key is always in
+	* the projection, so without narrowing it every row is already distinct.
+	*
+	* ```ts
+	* client.data.posts.fields("status").distinct().find()   // the statuses in use
+	* ```
+	*/
+	distinct(enabled = true) {
+		this.params.distinct = enabled;
+		return this;
+	}
+	/**
+	* Continue after a previous page's `meta.nextCursor` — keyset paging.
+	*
+	* Unlike `offset`, a row inserted or deleted before the cursor cannot
+	* shift the window, so a walk neither repeats nor skips rows. Keep
+	* `orderBy` identical across pages: a cursor only continues the listing it
+	* came from, and one used against a different sort is refused rather than
+	* seeked in an order nobody asked for.
+	*/
+	after(cursor) {
+		this.params.after = cursor;
+		return this;
+	}
+	/**
+	* Execute the find query and return the results as flat rows.
+	*/
+	async find() {
+		return this.collection.find(this.params);
+	}
+	/**
+	* Aggregate the rows this query matches instead of returning them.
+	*
+	* The builder's `where`/`logical`/`search` narrow which rows are
+	* aggregated; its `orderBy`, `include` and window do not apply — an
+	* aggregate has no rows to sort, no relations to load and no page to
+	* continue.
+	*
+	* ```ts
+	* await client.data.orders
+	*     .where("created_at", ">=", startOfMonth)
+	*     .aggregate({ select: [{ fn: "sum", field: "total" }], groupBy: ["status"] });
+	* // [{ status: "paid", sum_total: 41822.5 }, …]
+	* ```
+	*/
+	async aggregate(params) {
+		return this.collection.aggregate({
+			...params,
+			where: this.params.where,
+			logical: this.params.logical,
+			searchString: this.params.searchString
+		});
+	}
+	/**
+	* Page through everything this query matches, one row at a time.
+	*
+	* `.limit()` on the builder becomes the page size, so the ceiling on a
+	* single `find()` is not a ceiling on what the query can read.
+	*/
+	iterate(options) {
+		return this.collection.iterate({
+			...this.params,
+			...this.params.limit !== void 0 && { pageSize: this.params.limit },
+			...options
+		});
+	}
+	/** Collect everything this query matches into one array. */
+	findAll(options) {
+		return this.collection.findAll({
+			...this.params,
+			...this.params.limit !== void 0 && { pageSize: this.params.limit },
+			...options
+		});
+	}
+	/**
+	* Count the records matching this query.
+	*/
+	async count() {
+		return this.collection.count(this.params);
+	}
+	/**
+	* Listen to realtime updates matching this query.
+	*
+	* The guard that used to stand here — `if (!this.collection.listen) throw`
+	* — has moved onto the client itself, which is where the same failure had
+	* to be diagnosed anyway: `client.data.posts.listen(…)`, one call short of
+	* this builder, answered `undefined is not a function`. The message is now
+	* the same either way.
+	*/
+	listen(onUpdate, onError) {
+		return this.collection.listen(this.params, onUpdate, onError);
+	}
+};
+/**
+* What `listen`/`listenById` say on a client that has no socket.
+*
+* One sentence, in one place: it used to live in `SDKQueryBuilder.listen` only,
+* so the same failure reached callers of `client.data.posts.listen` as
+* `undefined is not a function`.
+*/
+var NO_SOCKET = "Listen is only available when RebaseClient is configured with a websocketUrl, and not when it was created with realtime: false.";
+/**
+* Why a live query cannot be opened for these parameters, or `undefined` when
+* it can.
+*
+* A `listen()` is the same query as the `find()` beside it, so what `find()`
+* refuses it refuses too. The socket would not: a frame is JSON, where an
+* `undefined` filter value becomes `null`, so `["!=", uid]` with `uid` unset
+* subscribed to every row whose column is NOT NULL — an ownership filter
+* widened instead of refused. And `after` names a place in one run of the
+* query, which a subscription re-runs on every write; the server keeps no
+* cursor for one, so it was dropped, and page one streamed to a caller who had
+* asked for page two.
+*/
+function listenRefusal(params) {
+	if (params?.where) try {
+		assertNoUndefinedFilterValues(params.where);
+	} catch (error) {
+		if (error instanceof RebaseClientError) return error;
+		throw error;
+	}
+	if (params?.after) return new RebaseClientError("listen() cannot continue from a cursor: a subscription re-runs its query on every write, and `after` names a place in one run of it. Use `offset` or `page` for a live window, or `find({ after })` to read the page once.", { code: "CURSOR_NOT_LIVE" });
+}
+/**
+* Counts currently in flight, **per client**, keyed by the exact request they
+* issue. Entries live only for the duration of the request — see `count()` for
+* why they exist at all.
+*
+* The map used to be module-level, shared by every client in the process. A
+* request key is a path and a query string: it says nothing about *who* is
+* asking. So two clients holding different credentials — an admin panel beside
+* a signed-in user's client, a per-request server client in a Node process, a
+* test asserting one client's calls — counting the same collection would share
+* one request, and whichever arrived second was answered with the first one's
+* total. Row-level security makes those genuinely different numbers.
+*
+* Keyed on the transport instead, which is the object a credential lives on.
+* A `WeakMap`, so a closed client's entry goes with it.
+*/
+var inflightCounts = /* @__PURE__ */ new WeakMap();
+/** The in-flight map for one transport, created on first use. */
+function inflightCountsFor(transport) {
+	let map = inflightCounts.get(transport);
+	if (!map) {
+		map = /* @__PURE__ */ new Map();
+		inflightCounts.set(transport, map);
+	}
+	return map;
+}
+/**
+* Transports whose server reads `?count=none` as a filter on a column named
+* `count`.
+*
+* Every server released before the parameter existed does, and answers a 400
+* `UNKNOWN_FILTER_FIELD` naming `count`. Skipping the count only ever saves
+* the server work, so a read refused for it is sent again without it, and
+* later reads through the same transport (one per client, so one server) stop
+* sending it. Membership is never cleared: a server does not lose the
+* parameter, and one that gains it in an upgrade gets it again on the next
+* page load.
+*/
+var serversWithoutCountParam = /* @__PURE__ */ new WeakSet();
+/**
+* The longest URL a `find()` sends as a `GET`. Past it the parameters go in
+* the body of `POST /data/<collection>/query` instead.
+*
+* Not the server's own ceiling but the one in front of it: nginx refuses a
+* request line over 8 KB by default (414), and a proxy or CDN is in front of
+* most deployments. 6 KB leaves the rest of the request line, and the headers
+* some proxies count against the same buffer, room.
+*/
+var MAX_FIND_URL_LENGTH = 6 * 1024;
+/**
+* Transports whose server has no `POST …/query` — every server before 0.24.
+*
+* Such a server answers the POST 404 (or a proxy 405), and the read is sent
+* again as the `GET` it has always been, which may well be refused for its
+* length: that refusal is the old server's answer, and the caller sees it.
+* Membership is never cleared, as for {@link serversWithoutCountParam}.
+*/
+var serversWithoutQueryRoute = /* @__PURE__ */ new WeakSet();
+/** {@link serversWithoutQueryRoute}, for `POST …/count`. */
+var serversWithoutCountRoute = /* @__PURE__ */ new WeakSet();
+/**
+* Whether a read goes as its `POST` twin rather than `GET`: always for a
+* vector search, whose embedding is a JSON array in the URL (768 dimensions
+* are 17 KB of it, past Node's 16 KB and nginx's 8 KB), and for anything else
+* whose URL would not fit through a proxy.
+*/
+function sendsQueryBody(transport, path, queryString, params, serversWithoutRoute) {
+	if (serversWithoutRoute.has(transport)) return false;
+	if (params?.vectorSearch) return true;
+	return `${transport.baseUrl ?? ""}${transport.apiPath ?? ""}${path}${queryString}`.length > MAX_FIND_URL_LENGTH;
+}
+/**
+* A read whose parameters go in the URL of `GET <path>`, or — where
+* {@link sendsQueryBody} says so — in the JSON body of its `POST` twin:
+* `POST …/query` for a listing, `POST …/count` for a count.
+*
+* Against a server without the twin (404, or a proxy's 405) the `GET` is sent
+* instead, and the transport remembers — unless the `GET` 404s as well, which
+* is the collection's answer, not the route's.
+*/
+/**
+* A success whose body is not the shape the method reads: no body at all (a
+* `204`, or a `200` with nothing in it), or JSON without the page's `data`
+* list. Usually a proxy or a route that is not the Rebase API answering. It
+* used to resolve as an empty page, or the row `{}`, or throw a bare
+* `TypeError` — none of which `switch (e.code)` could tell from a real answer.
+*/
+function unexpectedResponse(slug, method, status, expected) {
+	return new RebaseApiError(`${method} on "${slug}" got ${status === 204 ? "a 204 with no body" : `a ${status} without ${expected}`} from the server. This usually means something other than the Rebase API answered — a proxy, or a route outside the API — so check the API URL configuration.`, {
+		status,
+		code: "UNEXPECTED_RESPONSE"
+	});
+}
+/**
+* A bulk call given something other than an array. A `RebaseClientError` with
+* the code the server uses for the same mistake in a request body, so one
+* `case "INVALID_BULK_BODY"` covers both.
+*/
+function invalidBulkBody(message) {
+	return new RebaseClientError(message, { code: "INVALID_BULK_BODY" });
+}
+async function readWithParams(transport, path, postPath, params, serversWithoutRoute, deleted) {
+	const queryString = buildQueryString(params, deleted);
+	const get = () => transport.request(path + queryString, { method: "GET" });
+	if (!sendsQueryBody(transport, path, queryString, params, serversWithoutRoute)) return get();
+	try {
+		return await transport.request(postPath, {
+			method: "POST",
+			body: JSON.stringify(buildQueryBody(params, deleted))
+		});
+	} catch (error) {
+		if (!(error instanceof RebaseApiError) || error.status !== 404 && error.status !== 405) throw error;
+		try {
+			const answer = await get();
+			serversWithoutRoute.add(transport);
+			return answer;
+		} catch (getError) {
+			if (!(getError instanceof RebaseApiError && getError.status === 404)) serversWithoutRoute.add(transport);
+			throw getError;
+		}
+	}
+}
+function isCountReadAsFilter(error) {
+	if (!(error instanceof RebaseApiError) || error.status !== 400 || error.code !== "UNKNOWN_FILTER_FIELD") return false;
+	const details = error.details;
+	return typeof details === "object" && details !== null && "field" in details && details.field === "count";
+}
+/**
+* The headers a write's options ask for.
+*
+* One function rather than a spread at each call site: the three headers are
+* easy to add to one method and forget on the next, which is exactly how single
+* `PATCH` and `DELETE` came to send an `Idempotency-Key` the server never read
+* and `delete()` came to have no options at all.
+*/
+function writeHeaders(options) {
+	const headers = {};
+	if (options?.idempotencyKey) headers["Idempotency-Key"] = options.idempotencyKey;
+	if (options?.ifMatch) headers["If-Match"] = options.ifMatch;
+	if (options?.returning === false) headers["Prefer"] = "return=minimal";
+	return Object.keys(headers).length > 0 ? { headers } : void 0;
+}
+/** What `softDelete: true` names the field a delete stamps. */
+var DEFAULT_SOFT_DELETE_FIELD = "deletedAt";
+/**
+* The part of {@link ObserveByIdOptions} that is a read option: `include`, and
+* nothing else, so `realtime` never travels as a query parameter.
+*/
+function byIdRead(options) {
+	return options?.include !== void 0 ? { include: options.include } : void 0;
+}
+/**
+* The bulk route names the row a failure came from — "Row 0 of 1 (id 7)
+* failed: …" — which is what a caller needs from a 10,000-row import and noise
+* from `upsert()`, which the caller wrote as one row and which only travels as
+* a one-row batch. Drops that prefix and nothing else: the error keeps its
+* class, status, code, details and cause. `createMany` does not call this.
+*/
+var ONE_ROW_BULK_PREFIX = /^Row 0 of 1 \(.*?\) failed: /;
+function withoutBulkRowPrefix(error) {
+	if (error instanceof Error && ONE_ROW_BULK_PREFIX.test(error.message)) error.message = error.message.replace(ONE_ROW_BULK_PREFIX, "");
+	return error;
+}
+function createCollectionClient(transport, slug, ws) {
+	const basePath = `/data/${slug}`;
+	/**
+	* A listing — the live rows, or with `deleted` the trash's. One reader for
+	* both, so the trash takes every parameter, and every fallback for an
+	* older server, that `find()` does.
+	*/
+	async function findRows(params, deleted) {
+		const method = deleted ? "trash.find()" : "find()";
+		const read = async (p) => {
+			const page = await readWithParams(transport, basePath, `${basePath}/query`, p, serversWithoutQueryRoute, deleted);
+			if (!page || !Array.isArray(page.data)) throw unexpectedResponse(slug, method, page ? 200 : 204, "a page with a `data` list");
+			return page;
+		};
+		const counted = {
+			...params,
+			count: void 0
+		};
+		let raw;
+		if (params?.count !== "none") raw = await read(params);
+		else if (serversWithoutCountParam.has(transport)) raw = await read(counted);
+		else try {
+			raw = await read(params);
+		} catch (error) {
+			if (!isCountReadAsFilter(error)) throw error;
+			serversWithoutCountParam.add(transport);
+			raw = await read(counted);
+		}
+		return {
+			data: raw.data,
+			meta: raw.meta
+		};
+	}
+	/** A count — of the live rows, or with `deleted` of the trash's. */
+	async function countRows(params, deleted) {
+		const countParams = {
+			...params,
+			limit: void 0,
+			offset: void 0,
+			include: void 0,
+			count: void 0
+		};
+		const qs = buildQueryString(countParams, deleted);
+		const key = basePath + "/count" + qs;
+		const inflight = inflightCountsFor(transport);
+		const existing = inflight.get(key);
+		if (existing) return existing;
+		const request = readWithParams(transport, `${basePath}/count`, `${basePath}/count`, countParams, serversWithoutCountRoute, deleted).then((raw) => raw.count ?? 0);
+		inflight.set(key, request);
+		try {
+			return await request;
+		} finally {
+			inflight.delete(key);
+		}
+	}
+	const restoreField = (options) => options?.field ?? DEFAULT_SOFT_DELETE_FIELD;
+	const client = {
+		find(params) {
+			return findRows(params);
+		},
+		trash: {
+			find: (params) => findRows(params, "only"),
+			count: (params) => countRows(params, "only"),
+			restore: (id, options) => client.update(id, { [restoreField(options)]: null }, options),
+			restoreMany: (ids, options) => {
+				if (!Array.isArray(ids)) return Promise.reject(invalidBulkBody("trash.restoreMany expects an array of ids."));
+				const data = { [restoreField(options)]: null };
+				return client.updateMany(ids.map((id) => ({
+					id,
+					data
+				})), options);
+			},
+			async purge(id, options) {
+				await transport.request(`${basePath}/${encodeURIComponent(String(id))}?hard=true`, {
+					method: "DELETE",
+					...writeHeaders(options)
+				});
+			},
+			async purgeMany(ids, options) {
+				if (!Array.isArray(ids)) throw invalidBulkBody("trash.purgeMany expects an array of ids.");
+				if (ids.length === 0) return;
+				await transport.request(`${basePath}/bulk/delete?hard=true`, {
+					method: "POST",
+					body: JSON.stringify({ ids }),
+					...writeHeaders(options)
+				});
+			}
+		},
+		iterate(params) {
+			return paginateFind((p) => client.find(p), params, slug);
+		},
+		findAll(params) {
+			return collectAllPages((p) => client.find(p), params, slug);
+		},
+		async findById(id, options) {
+			try {
+				const meta = {};
+				const raw = await transport.request(`${basePath}/${encodeURIComponent(String(id))}${buildQueryString({ include: options?.include })}`, { method: "GET" }, meta);
+				if (!raw) return void 0;
+				if (Object.keys(raw).length === 0) throw unexpectedResponse(slug, "findById()", meta.status ?? 200, "a row");
+				return withETag(raw, meta.etag);
+			} catch (err) {
+				if (err instanceof RebaseApiError && err.status === 404) return;
+				throw err;
+			}
+		},
+		async get(id) {
+			const row = await client.findById(id);
+			if (row === void 0) throw new RebaseApiError(`No record with id ${JSON.stringify(String(id))} in "${slug}".`, {
+				status: 404,
+				code: "NOT_FOUND"
+			});
+			return row;
+		},
+		async create(data, id, options) {
+			const body = { ...data };
+			if (id !== void 0) body.id = id;
+			return await transport.request(basePath, {
+				method: "POST",
+				body: JSON.stringify(body),
+				...writeHeaders(options)
+			});
+		},
+		/**
+		* Insert, or replace the row already occupying the conflict target.
+		*
+		* One statement server-side (`INSERT ... ON CONFLICT DO UPDATE`), so
+		* unlike a `findById` followed by `create`-or-`update` it cannot lose
+		* the race between the two.
+		*
+		* Sent as a one-row bulk write with `upsert: true`, which is what the
+		* in-process accessor and the offline queue already send. It used to be
+		* `POST /data/<slug>` with `?on_conflict=` only when a target was
+		* named — and the route reads that POST without the parameter as the
+		* plain insert a `create` is, so the documented default ("on the
+		* primary key") never happened online: re-upserting an existing row
+		* answered 409, while the same call succeeded offline and in a
+		* function.
+		*/
+		async upsert(data, options) {
+			const raw = await transport.request(`${basePath}/bulk`, {
+				method: "POST",
+				body: JSON.stringify({
+					rows: [data],
+					upsert: true,
+					...options?.onConflict?.length ? { onConflict: options.onConflict } : {}
+				}),
+				...writeHeaders(options)
+			}).catch((error) => {
+				throw withoutBulkRowPrefix(error);
+			});
+			return options?.returning === false ? void 0 : raw?.data?.[0];
+		},
+		async createMany(data, options) {
+			if (!Array.isArray(data)) throw invalidBulkBody("createMany expects an array of records.");
+			if (data.length === 0) return [];
+			const raw = await transport.request(`${basePath}/bulk`, {
+				method: "POST",
+				body: JSON.stringify({
+					rows: data,
+					...options?.upsert ? { upsert: true } : {},
+					...options?.onConflict?.length ? { onConflict: options.onConflict } : {}
+				}),
+				...writeHeaders(options)
+			});
+			if (options?.returning === false) return [];
+			return raw.data || [];
+		},
+		/**
+		* `PATCH`, the verb for a merge — `update(id, data: Partial<M>)` sends
+		* only the keys the caller named and the server merges the rest.
+		*
+		* `PATCH` is the verb the OpenAPI spec names, so a spec-validating
+		* gateway in front of the API sees the operation this sends. The
+		* server also answers `PUT` on the same route, as a deprecated alias
+		* marked `Deprecation: true` and left out of the spec; this client
+		* never sends it.
+		*/
+		async update(id, data, options) {
+			const meta = {};
+			return withETag(await transport.request(`${basePath}/${encodeURIComponent(String(id))}`, {
+				method: "PATCH",
+				body: JSON.stringify(data),
+				...writeHeaders(options)
+			}, meta), meta.etag);
+		},
+		async updateMany(updates, options) {
+			if (!Array.isArray(updates)) throw invalidBulkBody("updateMany expects an array of { id, data } entries.");
+			if (updates.length === 0) return [];
+			const raw = await transport.request(`${basePath}/bulk`, {
+				method: "PATCH",
+				body: JSON.stringify({ updates }),
+				...writeHeaders(options)
+			});
+			if (options?.returning === false) return [];
+			return raw.data || [];
+		},
+		async delete(id, options) {
+			await transport.request(`${basePath}/${encodeURIComponent(String(id))}`, {
+				method: "DELETE",
+				...writeHeaders(options)
+			});
+		},
+		/**
+		* `POST .../bulk/delete`, not `DELETE .../bulk`.
+		*
+		* The honest verb would take the ids in a DELETE body, and that is the
+		* one request shape the HTTP ecosystem handles unreliably: bodies on
+		* DELETE are permitted but widely dropped by proxies and CDNs, and
+		* several OpenAPI generators ignore `requestBody` on a DELETE
+		* operation, so a generated client would send the request without its
+		* ids. A backend deployed behind arbitrary ingress cannot take that
+		* bet. Same reason `:batchDelete` exists in Google's API guidelines.
+		*/
+		async deleteMany(ids, options) {
+			if (!Array.isArray(ids)) throw invalidBulkBody("deleteMany expects an array of ids.");
+			if (ids.length === 0) return;
+			await transport.request(`${basePath}/bulk/delete`, {
+				method: "POST",
+				body: JSON.stringify({ ids }),
+				...writeHeaders(options)
+			});
+		},
+		count(params) {
+			return countRows(params);
+		},
+		observe(params, onResult, onError, options) {
+			let closed = false;
+			let liveDelivered = false;
+			let signature;
+			const deliver = (result, fromLive) => {
+				if (closed) return;
+				if (fromLive) liveDelivered = true;
+				else if (liveDelivered) return;
+				const next = `${result.meta?.total ?? ""}|${JSON.stringify(result.data)}`;
+				if (signature !== void 0 && next === signature) return;
+				signature = next;
+				onResult({
+					...result,
+					fromCache: false,
+					hasPendingWrites: false,
+					partial: false
+				});
+			};
+			const wantsLive = options?.realtime !== false && !isUnsupported(client.listen);
+			const refusal = wantsLive ? listenRefusal(params) : void 0;
+			if (refusal) {
+				queueMicrotask(() => {
+					if (!closed) onError?.(refusal);
+				});
+				return () => {
+					closed = true;
+				};
+			}
+			const live = wantsLive ? client.listen(params, (result) => deliver(result, true), onError) : void 0;
+			if (!liveDelivered) client.find(params).then((result) => deliver(result, false)).catch((error) => {
+				if (!closed) onError?.(error);
+			});
+			return () => {
+				closed = true;
+				live?.();
+			};
+		},
+		observeById(id, onResult, onError, options) {
+			let closed = false;
+			let liveDelivered = false;
+			let signature;
+			const deliver = (row, fromLive) => {
+				if (closed) return;
+				if (fromLive) liveDelivered = true;
+				else if (liveDelivered) return;
+				const next = row === void 0 ? "\0missing" : JSON.stringify(row);
+				if (signature !== void 0 && next === signature) return;
+				signature = next;
+				onResult(row, {
+					fromCache: false,
+					hasPendingWrites: false
+				});
+			};
+			const live = options?.realtime !== false && !isUnsupported(client.listenById) ? client.listenById(id, (row) => deliver(row, true), onError, byIdRead(options)) : void 0;
+			if (!liveDelivered) client.findById(id, byIdRead(options)).then((row) => deliver(row, false)).catch((error) => {
+				if (!closed) onError?.(error);
+			});
+			return () => {
+				closed = true;
+				live?.();
+			};
+		},
+		where(columnOrCondition, operator, value) {
+			const builder = new SDKQueryBuilder(client);
+			if (typeof columnOrCondition === "object") return builder.where(columnOrCondition);
+			return builder.where(columnOrCondition, operator, value);
+		},
+		orderBy(column, direction, nulls) {
+			return new SDKQueryBuilder(client).orderBy(column, direction, nulls);
+		},
+		limit(count) {
+			return new SDKQueryBuilder(client).limit(count);
+		},
+		offset(count) {
+			return new SDKQueryBuilder(client).offset(count);
+		},
+		search(searchString, options) {
+			return new SDKQueryBuilder(client).search(searchString, options);
+		},
+		vectorSearch(property, vector, options) {
+			return new SDKQueryBuilder(client).vectorSearch(property, vector, options);
+		},
+		include(...relations) {
+			return new SDKQueryBuilder(client).include(...relations);
+		},
+		fields(...columns) {
+			return new SDKQueryBuilder(client).fields(...columns);
+		},
+		distinct(enabled) {
+			return new SDKQueryBuilder(client).distinct(enabled);
+		},
+		after(cursor) {
+			return new SDKQueryBuilder(client).after(cursor);
+		},
+		/**
+		* `count`/`sum`/`avg`/`min`/`max` over the matching rows, optionally
+		* grouped — `GET /<collection>/aggregate`.
+		*
+		* The REST route has served this since aggregates landed and the SDK
+		* had no method for it, so the only way to reach it from a typed client
+		* was to hand-build the URL. `findAll()` and a reduce is the thing this
+		* exists to replace: wrong under a `limit`, unaffordable without one.
+		*/
+		async aggregate(params) {
+			const qs = buildAggregateQueryString(params);
+			const raw = await transport.request(`${basePath}/aggregate${qs}`, { method: "GET" });
+			const rows = raw.data || [];
+			if (raw.meta) Object.defineProperty(rows, "meta", {
+				value: raw.meta,
+				enumerable: false
+			});
+			return rows;
+		},
+		listen: unsupportedMethod(NO_SOCKET),
+		listenById: unsupportedMethod(NO_SOCKET),
+		listenCount: unsupportedMethod(NO_SOCKET)
+	};
+	if (ws) {
+		client.listen = (params, onUpdate, onError) => {
+			let active = true;
+			const refusal = listenRefusal(params);
+			if (refusal) {
+				queueMicrotask(() => {
+					if (active) onError?.(refusal);
+				});
+				return () => {
+					active = false;
+				};
+			}
+			let lastUpdateId = 0;
+			let lastKnownTotal;
+			const window = resolveFindWindow(params);
+			const unsub = ws.listenCollection({
+				path: slug,
+				filter: params?.where,
+				logical: params?.logical,
+				limit: params?.limit,
+				offset: window.driverOffset,
+				page: params?.page,
+				include: params?.include,
+				fields: params?.fields,
+				distinct: params?.distinct,
+				orderBy: normalizeOrderBy(params?.orderBy),
+				searchString: params?.searchString,
+				searchExplain: params?.searchExplain,
+				vectorSearch: params?.vectorSearch
+			}, (incomingRows, frameMeta) => {
+				const currentUpdateId = ++lastUpdateId;
+				const requestedLimit = window.limit;
+				const offset = window.offset;
+				const rows = incomingRows;
+				const emit = (total, hasMore, nextCursor) => {
+					if (!active || currentUpdateId !== lastUpdateId) return;
+					onUpdate({
+						data: rows,
+						meta: {
+							total,
+							limit: frameMeta?.limit ?? requestedLimit,
+							offset: frameMeta?.offset ?? offset,
+							hasMore,
+							...nextCursor && { nextCursor }
+						}
+					});
+				};
+				if (frameMeta && frameMeta.total !== void 0) {
+					lastKnownTotal = frameMeta.total;
+					emit(frameMeta.total, frameMeta.hasMore, frameMeta.nextCursor);
+					return;
+				}
+				if (lastKnownTotal !== void 0) {
+					emit(lastKnownTotal, offset + rows.length < lastKnownTotal, frameMeta?.nextCursor);
+					return;
+				}
+				client.count(params).then((total) => {
+					lastKnownTotal = total;
+					emit(total, offset + rows.length < total, frameMeta?.nextCursor);
+				}).catch(() => {
+					emit(offset + rows.length, rows.length >= requestedLimit, frameMeta?.nextCursor);
+				});
+			}, onError);
+			return () => {
+				active = false;
+				unsub();
+			};
+		};
+		/**
+		* The count as a subscription of its own: `countOnly` asks the server
+		* to read no rows. One that predates it reads the single row
+		* `limit: 1` asks for and counts as usual, and the frame's `meta`
+		* answers either way. One that sends no `meta` at all is asked with
+		* `count()` on each frame instead.
+		*/
+		client.listenCount = (params, onCount, onError) => {
+			let active = true;
+			let last;
+			const emit = (total) => {
+				if (!active || total === last) return;
+				last = total;
+				onCount(total);
+			};
+			const unsub = ws.listenCollection({
+				path: slug,
+				filter: params?.where,
+				logical: params?.logical,
+				searchString: params?.searchString,
+				limit: 1,
+				countOnly: true
+			}, (_rows, meta) => {
+				if (typeof meta?.total === "number") emit(meta.total);
+				else if (!meta) client.count(params).then(emit).catch((error) => {
+					if (active) onError?.(error instanceof Error ? error : new Error(String(error)));
+				});
+			}, onError);
+			return () => {
+				active = false;
+				unsub();
+			};
+		};
+		client.listenById = (id, onUpdate, onError, options) => {
+			return ws.listenOne({
+				path: slug,
+				id: String(id),
+				...options?.include !== void 0 ? { include: options.include } : {}
+			}, (row) => {
+				if (row) onUpdate(row);
+				else onUpdate(void 0);
+			}, onError);
+		};
+	}
+	return client;
+}
+/**
+* Monotonic within a tab, unique across tabs, and sortable as a plain string:
+* `<ms base36, padded>-<counter>-<random>`. The padding is what keeps
+* lexicographic order equal to chronological order, and the random suffix is
+* what stops two tabs from writing the same queue key in the same millisecond
+* — which would silently drop one of the two writes.
+*/
+var mutationCounter = 0;
+function createMutationId(now = Date.now()) {
+	return `${now.toString(36).padStart(10, "0")}-${(mutationCounter = (mutationCounter + 1) % 1679616).toString(36).padStart(4, "0")}-${Math.random().toString(36).slice(2, 10).padStart(8, "0")}`;
+}
+/**
+* In-memory store: the default outside the browser and the workhorse of the
+* test suite. Values are deep-copied on the way in and out so a caller
+* mutating a returned row cannot silently edit the "persisted" copy — the
+* IndexedDB implementation gets the same guarantee for free from structured
+* cloning, and the two must not differ in aliasing behaviour.
+*/
+var MemoryOfflineStore = class {
+	cache = /* @__PURE__ */ new Map();
+	queue = /* @__PURE__ */ new Map();
+	async getCache(key) {
+		const entry = this.cache.get(key);
+		return entry ? structuredClone(entry) : void 0;
+	}
+	async setCache(key, entry) {
+		this.cache.set(key, structuredClone(entry));
+	}
+	async setCacheMany(entries) {
+		for (const { key, entry } of entries) this.cache.set(key, structuredClone(entry));
+	}
+	async deleteCache(keys) {
+		for (const key of keys) this.cache.delete(key);
+	}
+	async listCache(prefix) {
+		const out = [];
+		for (const [key, entry] of this.cache) if (key.startsWith(prefix)) out.push({
+			key,
+			cachedAt: entry.cachedAt
+		});
+		return out;
+	}
+	async listCacheEntries(prefix) {
+		const out = [];
+		for (const [key, entry] of this.cache) if (key.startsWith(prefix)) out.push({
+			key,
+			...structuredClone(entry)
+		});
+		out.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+		return out;
+	}
+	async enqueue(key, mutation) {
+		this.queue.set(key, structuredClone(mutation));
+	}
+	async dequeue(key) {
+		this.queue.delete(key);
+	}
+	async listQueue(prefix) {
+		return [...this.queue.entries()].filter(([key]) => key.startsWith(prefix)).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([, mutation]) => structuredClone(mutation));
+	}
+	async clear(prefix) {
+		for (const key of [...this.cache.keys()]) if (key.startsWith(prefix)) this.cache.delete(key);
+		for (const key of [...this.queue.keys()]) if (key.startsWith(prefix)) this.queue.delete(key);
+	}
+};
+var IDB_NAME = "rebase-offline";
+/**
+* v2 introduced the normalized row cache and string mutation ids. A v1
+* database holds whole-response blobs under keys this version cannot read and
+* queue entries ordered by a numeric `seq` this version no longer writes, so
+* the upgrade drops both stores rather than trying to translate them. Offline
+* support had not shipped in a release when v2 landed, so nothing in the wild
+* loses a queued write to this.
+*/
+var IDB_VERSION = 2;
+var CACHE_STORE = "cache";
+var QUEUE_STORE = "queue";
+/** The exclusive upper bound of an IDBKeyRange covering every key under `prefix`. */
+function prefixRange(prefix) {
+	return IDBKeyRange.bound(prefix, prefix + "￿", false, false);
+}
+function requestToPromise(request) {
+	return new Promise((resolve, reject) => {
+		request.onsuccess = () => resolve(request.result);
+		request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("IndexedDB request failed"));
+	});
+}
+/** Resolve when the whole transaction commits, not just when the last request returns. */
+function transactionDone(tx) {
+	return new Promise((resolve, reject) => {
+		tx.oncomplete = () => resolve();
+		tx.onabort = tx.onerror = () => reject(tx.error ?? /* @__PURE__ */ new Error("IndexedDB transaction failed"));
+	});
+}
+/**
+* IndexedDB-backed store — the browser default, so cached rows and queued
+* writes survive a reload or a browser restart. Everything lives in one
+* database with two object stores; keys are the manager's full prefixed
+* strings, so multiple users (scopes) share the database without ever
+* sharing entries.
+*/
+var IndexedDBOfflineStore = class {
+	dbPromise;
+	/**
+	* Where everything goes once the database turns out to belong to a newer
+	* version of the SDK — see {@link backend}.
+	*/
+	fallback;
+	/**
+	* The database, or the in-memory stand-in when it cannot be opened at
+	* this version.
+	*
+	* A tab still running an older build (a stale tab, a rolled-back deploy)
+	* that opens a database a newer build upgraded gets a `VersionError` —
+	* and every read and every write after it failed with an opaque
+	* IndexedDB rejection, so the app went down instead of degrading. It now
+	* works in memory for the life of the page, says so once, and leaves the
+	* newer build's data alone.
+	*/
+	async backend() {
+		if (this.fallback) return this.fallback;
+		try {
+			return await this.open();
+		} catch (error) {
+			if (error?.name !== "VersionError") throw error;
+			if (!this.fallback) {
+				console.warn("[rebase offline] The offline database on this device was written by a newer version of the SDK. This page keeps its offline data in memory only, and leaves that database untouched; reload to pick up the newer version.");
+				this.fallback = new MemoryOfflineStore();
+			}
+			return this.fallback;
+		}
+	}
+	open() {
+		if (!this.dbPromise) this.dbPromise = new Promise((resolve, reject) => {
+			const request = indexedDB.open(IDB_NAME, IDB_VERSION);
+			request.onupgradeneeded = (event) => {
+				const db = request.result;
+				if (event.oldVersion > 0 && event.oldVersion < 2) {
+					if (db.objectStoreNames.contains(CACHE_STORE)) db.deleteObjectStore(CACHE_STORE);
+					if (db.objectStoreNames.contains(QUEUE_STORE)) db.deleteObjectStore(QUEUE_STORE);
+				}
+				if (!db.objectStoreNames.contains(CACHE_STORE)) db.createObjectStore(CACHE_STORE);
+				if (!db.objectStoreNames.contains(QUEUE_STORE)) db.createObjectStore(QUEUE_STORE);
+			};
+			request.onsuccess = () => {
+				const db = request.result;
+				db.onversionchange = () => {
+					db.close();
+					this.dbPromise = void 0;
+				};
+				resolve(db);
+			};
+			request.onerror = () => {
+				this.dbPromise = void 0;
+				reject(request.error ?? /* @__PURE__ */ new Error("Failed to open IndexedDB"));
+			};
+			request.onblocked = () => {
+				this.dbPromise = void 0;
+				reject(/* @__PURE__ */ new Error("IndexedDB upgrade blocked by another tab"));
+			};
+		});
+		return this.dbPromise;
+	}
+	async store(db, name, mode) {
+		return db.transaction(name, mode).objectStore(name);
+	}
+	async getCache(key) {
+		const db = await this.backend();
+		if (db instanceof MemoryOfflineStore) return db.getCache(key);
+		return await requestToPromise((await this.store(db, CACHE_STORE, "readonly")).get(key));
+	}
+	async setCache(key, entry) {
+		const db = await this.backend();
+		if (db instanceof MemoryOfflineStore) return db.setCache(key, entry);
+		await requestToPromise((await this.store(db, CACHE_STORE, "readwrite")).put(entry, key));
+	}
+	async setCacheMany(entries) {
+		if (entries.length === 0) return;
+		const db = await this.backend();
+		if (db instanceof MemoryOfflineStore) return db.setCacheMany(entries);
+		const store = await this.store(db, CACHE_STORE, "readwrite");
+		for (const { key, entry } of entries) store.put(entry, key);
+		await transactionDone(store.transaction);
+	}
+	async deleteCache(keys) {
+		if (keys.length === 0) return;
+		const db = await this.backend();
+		if (db instanceof MemoryOfflineStore) return db.deleteCache(keys);
+		const store = await this.store(db, CACHE_STORE, "readwrite");
+		for (const key of keys) store.delete(key);
+		await transactionDone(store.transaction);
+	}
+	async listCache(prefix) {
+		const db = await this.backend();
+		if (db instanceof MemoryOfflineStore) return db.listCache(prefix);
+		const store = await this.store(db, CACHE_STORE, "readonly");
+		const [keys, entries] = await Promise.all([requestToPromise(store.getAllKeys(prefixRange(prefix))), requestToPromise(store.getAll(prefixRange(prefix)))]);
+		return keys.map((key, i) => ({
+			key: String(key),
+			cachedAt: entries[i]?.cachedAt ?? 0
+		}));
+	}
+	async listCacheEntries(prefix) {
+		const db = await this.backend();
+		if (db instanceof MemoryOfflineStore) return db.listCacheEntries(prefix);
+		const store = await this.store(db, CACHE_STORE, "readonly");
+		const [keys, entries] = await Promise.all([requestToPromise(store.getAllKeys(prefixRange(prefix))), requestToPromise(store.getAll(prefixRange(prefix)))]);
+		return keys.map((key, i) => {
+			const entry = entries[i];
+			return {
+				key: String(key),
+				value: entry?.value,
+				cachedAt: entry?.cachedAt ?? 0
+			};
+		});
+	}
+	async enqueue(key, mutation) {
+		const db = await this.backend();
+		if (db instanceof MemoryOfflineStore) return db.enqueue(key, mutation);
+		await requestToPromise((await this.store(db, QUEUE_STORE, "readwrite")).put(mutation, key));
+	}
+	async dequeue(key) {
+		const db = await this.backend();
+		if (db instanceof MemoryOfflineStore) return db.dequeue(key);
+		await requestToPromise((await this.store(db, QUEUE_STORE, "readwrite")).delete(key));
+	}
+	async listQueue(prefix) {
+		const db = await this.backend();
+		if (db instanceof MemoryOfflineStore) return db.listQueue(prefix);
+		return await requestToPromise((await this.store(db, QUEUE_STORE, "readonly")).getAll(prefixRange(prefix)));
+	}
+	async clear(prefix) {
+		const db = await this.backend();
+		if (db instanceof MemoryOfflineStore) return db.clear(prefix);
+		await requestToPromise((await this.store(db, CACHE_STORE, "readwrite")).delete(prefixRange(prefix)));
+		await requestToPromise((await this.store(db, QUEUE_STORE, "readwrite")).delete(prefixRange(prefix)));
+	}
+};
+//#endregion
+export { byIdRead as a, createTransport as c, parseRebaseJson as d, rebaseReviver as f, unref as h, buildQueryString as i, defaultCodeForStatus as l, withETag as m, MemoryOfflineStore as n, createCollectionClient as o, etagOf as p, SDKQueryBuilder as r, createMutationId as s, IndexedDBOfflineStore as t, invalidBulkBody as u };
+
+//# sourceMappingURL=offline-store-Cm5sAX81-CALiO4Gn.js.map