@rebasepro/server 0.24.0 → 0.24.1-canary.gcb918fc

package/dist/offline-QNQgsPOq-B2yGeXkn.js

@@ -0,0 +1,3305 @@
+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, t as splitSearchTerms } from "./strings.es-BeZWAodn.js";
+import { D as Vector, E as GeoPoint, S as hasFieldOperation, T as EntityRelation, _ as normalizeOrderBy, c as collectAllPages, l as paginateFind, u as resolveFindWindow, w as EntityReference } from "./filter-dialect-O1HK6Nvr.js";
+import { $ as parseRelationAggregateSort, tt as toCanonicalOp } from "./src-D5Y3N-S4.js";
+import { a as byIdRead, f as rebaseReviver, h as unref, i as buildQueryString, n as MemoryOfflineStore, p as etagOf, r as SDKQueryBuilder, s as createMutationId, t as IndexedDBOfflineStore, u as invalidBulkBody } from "./offline-store-Cm5sAX81-CALiO4Gn.js";
+//#region ../client/dist/offline-QNQgsPOq.js
+/**
+* Lossless round-tripping of rows through the offline store.
+*
+* Both persistence backends move values by structured clone, which keeps
+* `Date` but flattens every class instance to a plain object. For
+* `EntityReference`/`EntityRelation` that is harmless — they carry their own
+* `__type` discriminator, so the JSON reviver can rebuild them — but
+* `GeoPoint` and `Vector` do not, and would come back out of the cache as
+* anonymous `{ latitude, longitude }` / `{ value }` bags. A row read from the
+* cache must be indistinguishable from the same row read from the network, so
+* those two are tagged on the way in and revived on the way out.
+*
+* Type tests here are structural rather than `instanceof`, because a structured
+* clone can arrive from another realm — an iframe, a worker, or the polyfill
+* the tests run against — where the constructor identity differs but the value
+* is the real thing. Only *plain* objects are walked; anything else is passed
+* through whole, so a class instance is never quietly reduced to `{}`.
+*/
+function isDate(value) {
+	return Object.prototype.toString.call(value) === "[object Date]";
+}
+/** An object literal — not a Date, RegExp, Map, or any class instance. */
+function isPlainObject$1(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	if (proto === null || proto === Object.prototype) return true;
+	return proto.constructor?.name === "Object";
+}
+/**
+* `out[key] = value`, as an own property whatever the key. Assigned, a key
+* read from stored data that is literally `__proto__` (which `JSON.parse`
+* creates as an own property) set the new object's prototype instead, and the
+* column was gone from the row.
+*/
+function setOwn(out, key, value) {
+	Object.defineProperty(out, key, {
+		value,
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+}
+function dehydrateValue(value) {
+	if (value === null || value === void 0) return value;
+	if (value instanceof GeoPoint) return {
+		__type: "GeoPoint",
+		latitude: value.latitude,
+		longitude: value.longitude
+	};
+	if (value instanceof Vector) return {
+		__type: "Vector",
+		value: [...value.value]
+	};
+	if (value instanceof EntityReference || value instanceof EntityRelation) return value;
+	if (Array.isArray(value)) return value.map(dehydrateValue);
+	if (isPlainObject$1(value)) {
+		const out = {};
+		for (const [key, inner] of Object.entries(value)) setOwn(out, key, dehydrateValue(inner));
+		return out;
+	}
+	return value;
+}
+function hydrateValue(value) {
+	if (value === null || value === void 0 || isDate(value)) return value;
+	if (Array.isArray(value)) return value.map(hydrateValue);
+	if (typeof value === "object") {
+		const revived = rebaseReviver("", value);
+		if (revived !== value) return revived;
+		if (!isPlainObject$1(value)) return value;
+		const out = {};
+		for (const [key, inner] of Object.entries(value)) setOwn(out, key, hydrateValue(inner));
+		return out;
+	}
+	return value;
+}
+/** Prepare a row for the store. */
+function dehydrateRow(row) {
+	return dehydrateValue(row);
+}
+/** Restore a row read back from the store. */
+function hydrateRow(row) {
+	return hydrateValue(row);
+}
+/**
+* A queued write as the store keeps it, and back. Its payloads are rows, and
+* a row read back from the queue has to be the row that was queued: stored
+* raw, a pending `GeoPoint` came back after a reload as a bare
+* `{ latitude, longitude }`, was overlaid onto the server's rows, and was
+* written back to the cache that way.
+*/
+function mapMutation(op, map) {
+	const rows = (value) => value === void 0 ? value : map(value);
+	return {
+		...op,
+		...op.data !== void 0 ? { data: rows(op.data) } : {},
+		...op.parts ? { parts: op.parts.map((part) => map(part)) } : {},
+		...op.updates ? { updates: op.updates.map((u) => ({
+			id: u.id,
+			data: map(u.data)
+		})) } : {},
+		...op.rollback ? { rollback: { rows: Object.fromEntries(Object.entries(op.rollback.rows).map(([id, row]) => [id, row === null ? null : map(row)])) } } : {},
+		...op.sent?.data !== void 0 ? { sent: {
+			...op.sent,
+			data: rows(op.sent.data)
+		} } : {}
+	};
+}
+/** Prepare a queued write for the store. */
+function dehydrateMutation(op) {
+	return mapMutation(op, dehydrateValue);
+}
+/** Restore a queued write read back from the store. */
+function hydrateMutation(op) {
+	return mapMutation(op, hydrateValue);
+}
+/**
+* Whether the network is worth trying, and when to try again after it wasn't.
+*
+* `navigator.onLine` is necessary but not sufficient: it reports the state of
+* the network interface, so it stays `true` behind a captive portal, on a
+* connection that resolves DNS but reaches nothing, and while the API itself
+* is down. This tracks what actually happened to requests as well, so the
+* first failure is the only one an app pays for — everything after it inside
+* the backoff window skips the doomed round trip and answers from the local
+* store immediately, which is the difference between an app that freezes when
+* the wifi drops and one that does not.
+*/
+/**
+* The request never reached the server, so nothing was decided by it.
+*
+* One question, one answer: `status === 0` is how a transport spells "there
+* was no response at all", and the transport now wraps every `fetch` rejection
+* into a `RebaseApiError` carrying it. This used to also sniff for the shapes
+* a raw `fetch` rejects with — a `TypeError` in a browser, an `AbortError`, a
+* `TimeoutError` — which is a list that has to be kept in step with three
+* runtimes and was wrong in both directions: it missed anything they add, and
+* it claimed a `TypeError` thrown by application code inside a callback was a
+* network failure, which quietly served a cached answer in its place.
+*/
+function isNetworkError(error) {
+	return error instanceof RebaseApiError && error.status === 0;
+}
+/**
+* Statuses that mean "not now" rather than "not ever": a queued write that
+* gets one of these is worth replaying, while a 400 or a 403 never will be.
+* 500 is deliberately absent — an unhandled server error is far more often a
+* bug the same payload will hit again than a blip, and retrying it forever
+* jams every write behind it.
+*/
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([
+	408,
+	425,
+	429,
+	502,
+	503,
+	504
+]);
+/**
+* The server holds this key for a request it has not answered yet.
+*
+* It is a 409 like a duplicate row is a 409, and nothing but the code separates
+* them — one means "your write is already there", the other means "your write
+* may not have happened at all, ask again".
+*/
+var IDEMPOTENCY_IN_PROGRESS = "IDEMPOTENCY_KEY_IN_PROGRESS";
+/**
+* Is the server still answering an earlier attempt of this same write?
+*
+* The only correct response is to ask again — which is exactly what the
+* server's own message says, and exactly what this SDK used not to do.
+*/
+function isIdempotencyInProgressError(error) {
+	return error instanceof RebaseApiError && error.status === 409 && error.code === IDEMPOTENCY_IN_PROGRESS;
+}
+/**
+* Is this key held for a different request than the one just sent with it?
+*
+* For a create the queue already sent once, that is an answer rather than a
+* failure: the key is live only because the first attempt got through and
+* committed, and only its response went missing.
+*/
+function isIdempotencyKeyReusedError(error) {
+	return error instanceof RebaseApiError && error.status === 422 && error.code === "IDEMPOTENCY_KEY_REUSED";
+}
+/** Is this failure worth another attempt later? */
+function isRetryableError(error) {
+	if (isNetworkError(error)) return true;
+	if (!(error instanceof RebaseApiError)) return false;
+	if (isIdempotencyInProgressError(error)) return true;
+	return error.status !== void 0 && RETRYABLE_STATUSES.has(error.status);
+}
+/**
+* Did this write fail because the row is already there?
+*
+* Matched on the SQLSTATE the server passes through (`23505`, unique_violation)
+* and on 409, never on the message — a duplicate-key message names the
+* constraint and the values, so it is neither stable nor safe to parse.
+*
+* The queue uses this to recognise its own earlier attempt. A create whose
+* response was lost is replayed, and for a row carrying an id the SDK generated
+* the server can only be rejecting it because the first attempt actually landed.
+*
+* Which is why the status alone cannot decide it: `IDEMPOTENCY_KEY_IN_PROGRESS`
+* is a 409 that means the opposite — the row may not exist at all. Read as a
+* duplicate, the queue looked for a row that was never written, found nothing,
+* concluded there was nothing left to do and deleted the write from the queue.
+*/
+function isDuplicateKeyError(error) {
+	if (!(error instanceof RebaseApiError)) return false;
+	if (error.code === "23505") return true;
+	return error.status === 409 && !isIdempotencyInProgressError(error);
+}
+/**
+* The longest delay `setTimeout` holds. Past it the delay overflows a signed
+* 32-bit integer and the timer fires after 1 ms — so a `syncIntervalMs` of a
+* month retried continuously instead of almost never.
+*/
+var MAX_TIMER_DELAY_MS = 2147483647;
+var ConnectivityMonitor = class {
+	state = "online";
+	backoffMs;
+	initialBackoffMs;
+	maxBackoffMs;
+	retryAt = 0;
+	timer;
+	listeners = /* @__PURE__ */ new Set();
+	respectBackoff;
+	now;
+	setTimer;
+	clearTimer;
+	/** Called when the backoff window expires, to drive an automatic retry. */
+	onRetryDue;
+	/**
+	* Called when the browser says the connection is back. Its own hook rather
+	* than {@link onRetryDue}: a client with automatic retries off sets no retry
+	* callback, and the `online` event has to wake it all the same.
+	*/
+	onOnline;
+	handleOnline = () => {
+		this.retryAt = 0;
+		this.backoffMs = this.initialBackoffMs;
+		this.clearPendingTimer();
+		this.setState("online");
+		(this.onOnline ?? this.onRetryDue)?.();
+	};
+	handleOffline = () => {
+		this.setState("offline");
+	};
+	constructor(options = {}) {
+		this.initialBackoffMs = options.initialBackoffMs ?? 1e3;
+		this.maxBackoffMs = Math.max(this.initialBackoffMs, options.maxBackoffMs ?? 6e4);
+		this.backoffMs = this.initialBackoffMs;
+		this.respectBackoff = options.respectBackoff ?? true;
+		this.now = options.now ?? (() => Date.now());
+		this.setTimer = options.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+		this.clearTimer = options.clearTimer ?? ((handle) => clearTimeout(handle));
+		if (typeof window !== "undefined" && typeof window.addEventListener === "function") {
+			window.addEventListener("online", this.handleOnline);
+			window.addEventListener("offline", this.handleOffline);
+		}
+		if (typeof navigator !== "undefined" && navigator.onLine === false) this.state = "offline";
+	}
+	/** What the app should be told: are we connected? */
+	isOnline() {
+		if (typeof navigator !== "undefined" && navigator.onLine === false) return false;
+		return this.state === "online";
+	}
+	/**
+	* Should this request even be sent? False means "answer from the local
+	* store instead" — the request would only burn a timeout to reach the same
+	* conclusion the last one already did.
+	*/
+	shouldAttempt() {
+		if (typeof navigator !== "undefined" && navigator.onLine === false) return false;
+		if (this.state === "online" || !this.respectBackoff) return true;
+		return this.now() >= this.retryAt;
+	}
+	/** A request reached the server. */
+	markSuccess() {
+		this.backoffMs = this.initialBackoffMs;
+		this.retryAt = 0;
+		this.clearPendingTimer();
+		this.setState("online");
+	}
+	/** A request did not reach the server: we are offline until proven otherwise. */
+	markFailure() {
+		this.deferRetry();
+		this.setState("offline");
+	}
+	/**
+	* Back off and try again later without claiming the connection is gone.
+	* This is what a 429 or a 503 deserves — the server answered, so the app
+	* is demonstrably online; it just should not hammer.
+	*/
+	deferRetry() {
+		const jitter = .8 + Math.random() * .4;
+		this.retryAt = this.now() + this.backoffMs * jitter;
+		const delay = Math.max(0, this.retryAt - this.now());
+		this.backoffMs = Math.min(this.maxBackoffMs, this.backoffMs * 2);
+		this.scheduleRetry(delay);
+	}
+	/** Milliseconds until the next attempt is allowed; 0 when one is allowed now. */
+	msUntilRetry() {
+		if (this.state === "online") return 0;
+		return Math.max(0, this.retryAt - this.now());
+	}
+	onChange(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	dispose() {
+		if (typeof window !== "undefined" && typeof window.removeEventListener === "function") {
+			window.removeEventListener("online", this.handleOnline);
+			window.removeEventListener("offline", this.handleOffline);
+		}
+		this.clearPendingTimer();
+		this.listeners.clear();
+		this.onRetryDue = void 0;
+		this.onOnline = void 0;
+	}
+	scheduleRetry(delay) {
+		this.clearPendingTimer();
+		if (!this.onRetryDue) return;
+		this.timer = this.setTimer(() => {
+			this.timer = void 0;
+			this.onRetryDue?.();
+		}, Math.min(delay, MAX_TIMER_DELAY_MS));
+		unref(this.timer);
+	}
+	clearPendingTimer() {
+		if (this.timer !== void 0) {
+			this.clearTimer(this.timer);
+			this.timer = void 0;
+		}
+	}
+	setState(next) {
+		if (this.state === next) return;
+		this.state = next;
+		const online = this.isOnline();
+		for (const listener of this.listeners) listener(online);
+	}
+};
+/**
+* A local evaluator for `FindParams`, so cached rows can answer a query the
+* client has never sent to the server — and so a row written offline shows up
+* in every filtered list it belongs to, not just in unfiltered ones.
+*
+* This mirrors the Postgres driver's semantics rather than JavaScript's:
+*
+* - Comparing against NULL is *unknown*, not false-or-true. `status != "done"`
+*   excludes rows where `status` is null, exactly as SQL does — a JS `!==`
+*   would have included them.
+* - `ORDER BY` puts nulls last ascending and first descending, which is the
+*   Postgres default.
+* - A filter value may arrive as a string (off a URL, say), so a string is
+*   compared numerically against a number and as an instant against a date.
+*   `["==", "3"]` matches the number `3`, as it does server-side. Two strings
+*   compare as text: `"01234"` is not `"1234"`.
+*
+* Two things it deliberately approximates, both flagged by
+* {@link isExactlyEvaluable}: `searchString` becomes a case-insensitive
+* substring scan over the row's string fields (the server runs real full-text
+* search over the collection's configured columns), and `include` cannot be
+* evaluated at all, because the related rows live in collections this query
+* knows nothing about.
+*/
+var collator = typeof Intl !== "undefined" && typeof Intl.Collator === "function" ? new Intl.Collator(void 0, {
+	numeric: false,
+	sensitivity: "variant"
+}) : void 0;
+function isNullish(value) {
+	return value === null || value === void 0;
+}
+/**
+* Reduce a value to something comparable. Relations compare by the id they
+* point at — the column holds a foreign key, so that is what the server
+* compares too.
+*/
+function toComparable(value) {
+	if (value instanceof Date) return value.getTime();
+	if (value instanceof EntityRelation) return value.id;
+	if (value && typeof value === "object") {
+		const record = value;
+		if (typeof record.__type === "string" && "id" in record) return record.id;
+	}
+	return value;
+}
+/**
+* Three-way compare with SQL's type coercion but not its collation. Returns
+* `undefined` when the two values are not ordered relative to each other,
+* which is how NULL propagates through a comparison.
+*/
+function compareValues(a, b) {
+	const left = toComparable(a);
+	const right = toComparable(b);
+	if (isNullish(left) || isNullish(right)) return void 0;
+	if (typeof left === "boolean" || typeof right === "boolean") return (left === true || left === "true" || left === 1 ? 1 : 0) - (right === true || right === "true" || right === 1 ? 1 : 0);
+	if (isNumeric(left) || isNumeric(right)) {
+		const leftNum = numericOrNaN(left);
+		const rightNum = numericOrNaN(right);
+		if (!Number.isNaN(leftNum) && !Number.isNaN(rightNum)) return leftNum < rightNum ? -1 : leftNum > rightNum ? 1 : 0;
+	}
+	if (typeof left === "number" || typeof right === "number") {
+		const leftTime = toTime(left);
+		const rightTime = toTime(right);
+		if (leftTime !== void 0 && rightTime !== void 0) return leftTime < rightTime ? -1 : leftTime > rightTime ? 1 : 0;
+	}
+	const leftStr = String(left);
+	const rightStr = String(right);
+	if (collator) return collator.compare(leftStr, rightStr);
+	return leftStr < rightStr ? -1 : leftStr > rightStr ? 1 : 0;
+}
+function isNumeric(value) {
+	return typeof value === "number" || typeof value === "bigint";
+}
+function numericOrNaN(value) {
+	if (typeof value === "number") return value;
+	if (typeof value === "string" && value.trim() !== "") {
+		const n = Number(value);
+		return Number.isNaN(n) ? NaN : n;
+	}
+	if (typeof value === "bigint") return Number(value);
+	return NaN;
+}
+function toTime(value) {
+	if (typeof value === "number") return value;
+	if (typeof value === "string") {
+		const t = Date.parse(value);
+		return Number.isNaN(t) ? void 0 : t;
+	}
+}
+/**
+* Equality with a string filter value allowed to name a number, a boolean or
+* an instant, but never across NULL. Two strings are equal only when they are
+* the same string, as text is in Postgres.
+*/
+function looseEquals(a, b) {
+	const left = toComparable(a);
+	const right = toComparable(b);
+	if (isNullish(left) || isNullish(right)) return isNullish(left) && isNullish(right);
+	if (left === right) return true;
+	if (typeof left === "string" && typeof right === "string") return false;
+	return compareValues(left, right) === 0;
+}
+/**
+* Translate a SQL `LIKE` pattern to an anchored regular expression.
+* `%` matches any run of characters, `_` exactly one, and a backslash escapes
+* either of them.
+*/
+function likeToRegExp(pattern, caseInsensitive) {
+	let source = "^";
+	let lastWasWildcard = false;
+	for (let i = 0; i < pattern.length; i++) {
+		const char = pattern[i];
+		if (char === "\\" && i + 1 < pattern.length) {
+			source += pattern[i + 1].replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+			i++;
+			lastWasWildcard = false;
+		} else if (char === "%") {
+			if (!lastWasWildcard) source += "[\\s\\S]*";
+			lastWasWildcard = true;
+		} else if (char === "_") {
+			source += "[\\s\\S]";
+			lastWasWildcard = false;
+		} else {
+			source += char.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+			lastWasWildcard = false;
+		}
+	}
+	return new RegExp(source + "$", caseInsensitive ? "i" : "");
+}
+function asArray(value) {
+	if (Array.isArray(value)) return value;
+	if (value === void 0) return [];
+	return [value];
+}
+/** Evaluate one canonical operator against one row value. */
+function matchesOperator(rowValue, op, filterValue) {
+	switch (op) {
+		case "is-null": return isNullish(rowValue);
+		case "is-not-null": return !isNullish(rowValue);
+		case "==": return looseEquals(rowValue, filterValue);
+		case "!=":
+			if (isNullish(rowValue)) return false;
+			return !looseEquals(rowValue, filterValue);
+		case "<":
+		case "<=":
+		case ">":
+		case ">=": {
+			const cmp = compareValues(rowValue, filterValue);
+			if (cmp === void 0) return false;
+			if (op === "<") return cmp < 0;
+			if (op === "<=") return cmp <= 0;
+			if (op === ">") return cmp > 0;
+			return cmp >= 0;
+		}
+		case "in":
+			if (isNullish(rowValue)) return false;
+			return asArray(filterValue).some((v) => looseEquals(rowValue, v));
+		case "not-in":
+			if (isNullish(rowValue)) return false;
+			return !asArray(filterValue).some((v) => looseEquals(rowValue, v));
+		case "array-contains":
+			if (!Array.isArray(rowValue)) return false;
+			return rowValue.some((v) => looseEquals(v, filterValue));
+		case "array-contains-any": {
+			if (!Array.isArray(rowValue)) return false;
+			const wanted = asArray(filterValue);
+			return rowValue.some((v) => wanted.some((w) => looseEquals(v, w)));
+		}
+		case "like":
+		case "not-like":
+		case "ilike":
+		case "not-ilike": {
+			if (isNullish(rowValue)) return false;
+			const insensitive = op === "ilike" || op === "not-ilike";
+			const negated = op === "not-like" || op === "not-ilike";
+			const matched = likeToRegExp(String(filterValue), insensitive).test(String(rowValue));
+			return negated ? !matched : matched;
+		}
+		default: return true;
+	}
+}
+function isTuple(value) {
+	return Array.isArray(value) && value.length === 2 && typeof value[0] === "string" && toCanonicalOp(value[0]) !== void 0;
+}
+/**
+* One field's condition, as the tuples this evaluator can read.
+*
+* The single reading of a condition, for {@link matchesWhere} and
+* {@link isExactlyEvaluable} both. Each used to have its own, and only the
+* first was hardened: `{ status: undefined }` (a skipped filter) and the bare
+* wire string `"eq.active"` both reached `.filter` on a non-array in the
+* second and threw.
+*
+* `unreadable` is set when the condition is there but yields nothing this
+* build understands — a wire string, an operator from a newer server. Such a
+* condition filters nothing locally while the server does filter on it, so an
+* answer that ignored it would be wider than the server's.
+*/
+function conditionTuples(condition) {
+	if (condition === void 0) return {
+		tuples: [],
+		unreadable: false
+	};
+	if (isTuple(condition)) return {
+		tuples: [condition],
+		unreadable: false
+	};
+	if (!Array.isArray(condition)) return {
+		tuples: [],
+		unreadable: true
+	};
+	const tuples = condition.filter(isTuple);
+	return {
+		tuples,
+		unreadable: tuples.length !== condition.length || tuples.length === 0
+	};
+}
+/** Evaluate a `where` clause: every field, and every tuple on a field, AND-ed. */
+function matchesWhere(row, where) {
+	if (!where) return true;
+	for (const [field, condition] of Object.entries(where)) {
+		const { tuples } = conditionTuples(condition);
+		for (const [rawOp, value] of tuples) {
+			const op = toCanonicalOp(rawOp) ?? rawOp;
+			if (!matchesOperator(row[field], op, value)) return false;
+		}
+	}
+	return true;
+}
+/** Evaluate a nested and/or tree. */
+function matchesLogical(row, condition) {
+	if (!condition) return true;
+	if ("type" in condition) {
+		const children = condition.conditions ?? [];
+		if (children.length === 0) return true;
+		return condition.type === "or" ? children.some((c) => matchesLogical(row, c)) : children.every((c) => matchesLogical(row, c));
+	}
+	const op = toCanonicalOp(condition.operator) ?? condition.operator;
+	return matchesOperator(row[condition.column], op, condition.value);
+}
+/**
+* Approximate the server's full-text search with a case-insensitive substring
+* scan over the row's own string fields. Narrower than the real thing (no
+* stemming, no configured search columns), and it never matches a field the
+* cached row does not carry — a local list may therefore be missing rows the
+* server would have returned, which is why {@link isExactlyEvaluable} refuses
+* to call a search query exact.
+*
+* Every term has to match, but they may match different fields — the same rule
+* both drivers apply, and the one that finds `sebastian melendez` on a row that
+* keeps the two halves of a name in separate fields. Matching the typed string
+* as a whole found neither that row nor, because the space was part of the
+* needle, anything at all for `sebastian `.
+*/
+function matchesSearch(row, searchString) {
+	if (!searchString) return true;
+	const terms = splitSearchTerms(searchString).map((term) => term.toLowerCase());
+	if (terms.length === 0) return true;
+	const values = Object.values(row);
+	return terms.every((term) => values.some((value) => {
+		if (typeof value === "string") return value.toLowerCase().includes(term);
+		if (typeof value === "number") return String(value).includes(term);
+		return false;
+	}));
+}
+/** Does this row belong in the result set for `params`, ignoring pagination? */
+function matchesParams(row, params) {
+	if (!params) return true;
+	return matchesWhere(row, params.where) && matchesLogical(row, params.logical) && matchesSearch(row, params.searchString);
+}
+/**
+* Sort in place, Postgres-style: nulls last ascending, first descending, with
+* the row id as a tiebreak so paging through an unsorted-but-equal run does
+* not shuffle rows between pages.
+*
+* The tiebreak runs *descending*, which is not a taste: every server-side sort
+* ends on `id DESC` — `FetchService.buildOrderExpressions` appends it to make
+* the ordering total, and the keyset cursor is built to match. This ran
+* ascending, so two rows sharing a sort value came back from the local overlay
+* in the opposite order to the server's, and {@link isLocallySortable} called
+* that page exactly reproducible while it was not.
+*/
+function sortRows(rows, orderBy) {
+	const keys = normalizeOrderBy(orderBy);
+	if (!keys) return rows;
+	return rows.sort((a, b) => {
+		for (const [field, direction = "asc"] of keys) {
+			const cmp = compareOnKey(a, b, field, direction);
+			if (cmp !== 0) return cmp;
+		}
+		return tiebreak(a, b);
+	});
+}
+/** One key's verdict: negative, positive, or 0 for "these two are equal here". */
+function compareOnKey(a, b, field, direction) {
+	const av = a[field];
+	const bv = b[field];
+	const aNull = isNullish(toComparable(av));
+	const bNull = isNullish(toComparable(bv));
+	if (aNull || bNull) {
+		if (aNull && bNull) return 0;
+		return (aNull ? 1 : -1) * (direction === "desc" ? -1 : 1);
+	}
+	const cmp = compareValues(av, bv);
+	if (cmp === void 0 || cmp === 0) return 0;
+	return cmp * (direction === "desc" ? -1 : 1);
+}
+/** The last word, and the server's: `id DESC`. */
+function tiebreak(a, b) {
+	const cmp = compareValues(a.id, b.id);
+	return cmp === void 0 ? 0 : -cmp;
+}
+/**
+* Resolve `page`/`offset`/`limit` the way the server does.
+*
+* It did not: this defaulted an absent limit to 20 while `/api/data` pages by
+* 50, so the same `observe()` answered with 20 rows from the local database and
+* 50 from the network — a list that changed length depending on which side
+* answered, with `page` striding differently on each. Delegated now, so the
+* sentence above is true by construction rather than by agreement.
+*/
+function resolvePagination(params) {
+	const { limit, offset } = resolveFindWindow(params);
+	return {
+		limit,
+		offset
+	};
+}
+/** `<`, `<=`, `>`, `>=` — the operators whose answer depends on a collation. */
+var ORDERING_OPS = /* @__PURE__ */ new Set([
+	"<",
+	"<=",
+	">",
+	">="
+]);
+/**
+* Does any condition in this `where` clause order its operands — or say
+* something this evaluator cannot read at all? Either way the local answer is
+* not the server's.
+*/
+function whereNotExact(where) {
+	if (!where) return false;
+	for (const condition of Object.values(where)) {
+		const { tuples, unreadable } = conditionTuples(condition);
+		if (unreadable) return true;
+		if (tuples.some(([op]) => ORDERING_OPS.has(toCanonicalOp(op) ?? op))) return true;
+	}
+	return false;
+}
+/** The same question, through an `and(...)`/`or(...)` tree. */
+function logicalOrders(condition, depth = 0) {
+	if (!condition || depth > 32) return false;
+	if ("type" in condition) return (condition.conditions ?? []).some((c) => logicalOrders(c, depth + 1));
+	return ORDERING_OPS.has(condition.operator);
+}
+/**
+* Can a locally evaluated answer to `params` be trusted to match the server's,
+* assuming the cache holds every row of the collection?
+*
+* `include` pulls in rows from other collections that this evaluator never
+* sees, and `searchString` is only approximated — both make the local answer a
+* best effort rather than an equivalent one.
+*
+* **Ordering comparisons are refused, and that is the interesting one.**
+* `compareValues` falls back to an `Intl.Collator` for operands it cannot read
+* as numbers or instants. PostgreSQL orders text by the *database's* collation,
+* which is a property of the server this process has never been told: under the
+* C collation `'apple' < 'Banana'` is false, under `en_US.UTF-8` it is true,
+* and the collator says true. So `["<", "Banana"]` selects a different set here
+* than it does there — silently, and in whichever direction the deployment
+* happens to have been created.
+*
+* The refusal covers *every* ordering comparison rather than only the ones with
+* a string operand, because the operand type does not settle it: a numeric
+* bound against a text column (`["<", 10]` on a `varchar`) also reaches the
+* collator, and nothing in `params` says what the column holds. Conservative on
+* purpose — the cost is that a query combining an ordering filter with
+* *unsynced local writes* stops placing those writes optimistically, which is a
+* degraded answer rather than a wrong one. Claiming exactness we do not have is
+* the other way round.
+*
+* This says nothing about ordering *results*; that is a separate claim with a
+* separate answer, because a sort changes which rows come first and not which
+* rows match. See {@link isLocallySortable}.
+*/
+/**
+* Whether an `include` asks for anything, in any of its spellings.
+*
+* `include` is a list of names, a list of dotted paths, or a tree — and only
+* the first two have a `length`. A `.length > 0` test read the tree form as
+* "no relations", which is the answer that makes the local cache claim it can
+* evaluate a relational query exactly.
+*/
+function hasAnyInclude(include) {
+	if (!include) return false;
+	if (Array.isArray(include)) return include.length > 0;
+	return Object.keys(include).length > 0;
+}
+function isExactlyEvaluable(params) {
+	if (!params) return true;
+	if (hasAnyInclude(params.include)) return false;
+	if (params.searchString) return false;
+	if (params.vectorSearch) return false;
+	if (whereNotExact(params.where)) return false;
+	if (logicalOrders(params.logical)) return false;
+	if (whereReachesThroughRelation(params.where)) return false;
+	if (logicalReachesThroughRelation(params.logical)) return false;
+	return true;
+}
+/** Does any filter key reach outside this row — `applications.status`? */
+function whereReachesThroughRelation(where) {
+	return where ? Object.keys(where).some((field) => field.includes(".")) : false;
+}
+/** The same question, through an `and(...)`/`or(...)` tree. */
+function logicalReachesThroughRelation(condition, depth = 0) {
+	if (!condition || depth > 32) return false;
+	if ("type" in condition) return (condition.conditions ?? []).some((c) => logicalReachesThroughRelation(c, depth + 1));
+	return typeof condition.column === "string" && condition.column.includes(".");
+}
+/**
+* Would sorting `rows` locally reproduce the order the server would have sent?
+*
+* Asked of the rows rather than of the query, because unlike a filter this one
+* *is* decidable from the data in hand: {@link compareValues} reaches the
+* collator only when neither operand is a number, and `toComparable` has
+* already turned dates and relations into numbers and ids by then. If every
+* value on the sort column normalises to a number, the collator is unreachable
+* and the local order is the server's order.
+*
+* A text column is therefore refused — see {@link isExactlyEvaluable} for why
+* the two cannot be made to agree — including one holding only digits, which
+* Postgres orders as text ("10", "100", "9").
+*
+* Nulls are fine either way: they are ordered by an explicit rule (last
+* ascending, first descending) that matches Postgres and never reaches the
+* comparator.
+*/
+function isLocallySortable(rows, orderBy) {
+	const keys = normalizeOrderBy(orderBy);
+	if (!keys) return true;
+	if (keys.some(([field]) => parseRelationAggregateSort(field))) return false;
+	return keys.every(([field]) => rows.every((row) => {
+		const value = toComparable(row[field]);
+		if (isNullish(value)) return true;
+		if (typeof value === "number" || typeof value === "boolean") return true;
+		if (typeof value === "bigint") return true;
+		return false;
+	}));
+}
+/** Run a full query — filter, sort, paginate — over a set of rows. */
+function runLocalQuery(rows, params) {
+	const matched = rows.filter((row) => matchesParams(row, params));
+	sortRows(matched, params?.orderBy);
+	const { limit, offset } = resolvePagination(params);
+	const page = matched.slice(offset, offset + limit);
+	return {
+		data: page,
+		meta: {
+			total: matched.length,
+			limit,
+			offset,
+			hasMore: offset + page.length < matched.length
+		}
+	};
+}
+function offlineError(message) {
+	return new RebaseApiError(message, {
+		status: 0,
+		code: "OFFLINE"
+	});
+}
+/**
+* What a write discarded because an earlier write it depends on was refused is
+* reported with. It was never sent; the refusal that doomed it is its `cause`.
+*/
+function dependencyRejected(refused, error) {
+	return new RebaseApiError(`Not sent: an earlier queued write to the same row was refused (${error.message}).`, {
+		status: error instanceof RebaseApiError ? error.status : void 0,
+		code: "DEPENDENCY_REJECTED",
+		details: { rejectedMutationId: refused.mutationId },
+		cause: error
+	});
+}
+/**
+* A refusal about what a write contains — a field the collection no longer
+* has, one the caller may not write, a value a constraint refuses — rather
+* than about the row or the caller as a whole.
+*/
+function isFieldRefusal(error) {
+	if (!(error instanceof RebaseApiError)) return false;
+	return error.status === 400 || error.status === 403 || error.status === 422;
+}
+/**
+* `value` with every occurrence of `from` replaced by `to`, walking plain
+* objects and arrays — and whether anything was replaced.
+*
+* Only ever called with an id the SDK minted for an offline create (a UUID, or
+* a negative number from the clock), which nothing but a reference to that row
+* can equal. That is what makes replacing by value sound without knowing which
+* columns are references.
+*/
+function replaceMintedId(value, from, to) {
+	if (value === from) return {
+		value: to,
+		changed: true
+	};
+	if (Array.isArray(value)) {
+		let changed = false;
+		const out = value.map((item) => {
+			const replaced = replaceMintedId(item, from, to);
+			changed ||= replaced.changed;
+			return replaced.value;
+		});
+		return changed ? {
+			value: out,
+			changed
+		} : {
+			value,
+			changed
+		};
+	}
+	if (isPlainObject(value)) {
+		let changed = false;
+		const out = {};
+		for (const [key, item] of Object.entries(value)) {
+			const replaced = replaceMintedId(item, from, to);
+			changed ||= replaced.changed;
+			setOwn(out, key, replaced.value);
+		}
+		return changed ? {
+			value: out,
+			changed
+		} : {
+			value,
+			changed
+		};
+	}
+	return {
+		value,
+		changed: false
+	};
+}
+/**
+* A plain object from any realm — a queued payload read back from the store is
+* a structured clone, whose `Object.prototype` need not be this one. A class
+* instance (a `GeoPoint`, a `Date`) is not walked.
+*/
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === null || Object.getPrototypeOf(proto) === null;
+}
+/** Whether a queued write's payload mentions `id` anywhere — see {@link replaceMintedId}. */
+function mentionsMintedId(op, id) {
+	return [op.data, ...(op.updates ?? []).map((u) => u.data)].some((payload) => replaceMintedId(payload, id, "").changed);
+}
+/**
+* A page that local rows were added to, cut back to the `limit` it was asked
+* with — as a refetch would return it.
+*
+* Sorted, the page is cut where the order puts it. Unsorted, the rows created
+* here (the last `added`) stand where they were placed, and the server's rows
+* make room from the end of the page.
+*/
+function fitToLimit(rows, limit, added, sorted) {
+	if (!(limit > 0) || rows.length <= limit) return rows;
+	if (sorted || added === 0) return rows.slice(0, limit);
+	const local = rows.slice(rows.length - added);
+	return [...rows.slice(0, rows.length - added).slice(0, Math.max(0, limit - local.length)), ...local].slice(0, limit);
+}
+/**
+* Call the app back without letting it break the engine.
+*
+* A status badge that throws while rendering used to abort a replay half way
+* (and skip every listener registered after it); the replay's own failure
+* handling then had an error that was never about the replay. The app's error
+* is still reported, on the console, where an uncaught one would have gone.
+*/
+function callSafely(callback) {
+	try {
+		callback();
+	} catch (error) {
+		console.error("[rebase offline] A listener threw:", error);
+	}
+}
+/** The server has no such row — deleted by someone else, or never visible to this user. */
+/** A `412`: the row is no longer the version an `If-Match` named. */
+function isPreconditionFailed(error) {
+	return error instanceof RebaseApiError && error.status === 412;
+}
+function isNotFoundError(error) {
+	return error instanceof RebaseApiError && error.status === 404;
+}
+function generateOfflineStringId() {
+	if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
+	return `off-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+/**
+* The last temporary numeric id minted, so the next one is smaller.
+*
+* Module-scoped and strictly decreasing: two temporary ids in the same session
+* must not collide, and neither must one minted a millisecond after another.
+*/
+var lastOfflineNumericId = 0;
+/**
+* A temporary id for a collection whose ids are numbers.
+*
+* **Negative**, which is the convention every local-first engine settles on for
+* the same reason: a real key is a positive integer or an identity sequence, so
+* the sign alone says "this one is not the server's yet" — and it stays a
+* number, which is what matters. A UUID string was minted for every collection,
+* so a `create` while offline handed back `{ id: "526e2faf-…" }` on a row the
+* generated types declare `id: number`. Anything that put that in a URL, a
+* foreign key or an `id.toFixed()` was wrong or threw until the replay
+* reconciled it — and the SDK's own types said it could not happen.
+*/
+function generateOfflineNumericId() {
+	const candidate = -Date.now();
+	lastOfflineNumericId = lastOfflineNumericId === 0 ? candidate : Math.min(candidate, lastOfflineNumericId - 1);
+	return lastOfflineNumericId;
+}
+/**
+* The row an optimistic write puts in the cache before the server has seen it.
+*
+* It is NOT an `M`, and saying so is the point of collecting this in one place.
+* `M` is the row as the database has it — every server default, every generated
+* column, every `afterRead` transform. What an optimistic write has is the
+* fields the caller supplied (plus, on an update, whatever was already cached)
+* and an id, which may itself be a locally-minted placeholder.
+*
+* The two are reconciled when the queued write drains and the server's row
+* replaces this one. Until then the SDK hands the caller this, under `M`,
+* because that is what the offline API's return type promises — and there is
+* nothing in this file that can make that promise true.
+*
+* So: one deliberate assertion, named, rather than five spread across the
+* create / createMany / update / upsert paths, each free to assemble the fields
+* differently. Fixing it properly means the offline surface saying what it
+* actually returns, which is a change to its public types.
+*/
+function optimisticRow(fields, id) {
+	return {
+		...fields,
+		id
+	};
+}
+/**
+* Whether a query answers with something narrower than whole rows: `fields`
+* returns only the columns it names (and the key), and `distinct` collapses
+* rows into their distinct projections. Either way what comes back is not a
+* row of the collection, and must not be stored as one.
+*/
+function isProjection(params) {
+	return (params?.fields?.length ?? 0) > 0 || params?.distinct === true;
+}
+/** `row` narrowed to `keys`: a local row in the shape a projection has. */
+function pick(row, keys) {
+	const out = {};
+	for (const key of keys) if (Object.hasOwn(row, key)) setOwn(out, key, row[key]);
+	return out;
+}
+/** A snapshot as read back from the store, its projected rows revived. */
+function readSnapshot(value) {
+	const snapshot = value;
+	return snapshot.rows ? {
+		...snapshot,
+		rows: snapshot.rows.map((row) => hydrateRow(row))
+	} : snapshot;
+}
+var MISSING = "\0missing";
+/**
+* Replays to spend on a mutation whose idempotency key the server is still
+* holding, when the app has not asked for more.
+*
+* Retries double from a second and cap at the sync interval, so the default
+* budget of five covers about half a minute — less than the lease a server
+* gives a claim nobody came back for. This many outlast it with room for a slow
+* batch, and the count is what stops a server that never releases the key from
+* blocking the queue behind it indefinitely.
+*/
+var IN_PROGRESS_MIN_RETRIES = 12;
+/** The scope of whatever is cached and queued while nobody is signed in. */
+var SIGNED_OUT_SCOPE = "anon";
+/** The most rows one folded replay sends: the server's default bulk limit. */
+var MAX_REPLAY_BATCH = 1e3;
+/**
+* Where {@link OfflineConfig.keepLastUser} keeps the last signed-in user's id.
+* In the cache area but under no user's scope, so clearing one user's data
+* leaves it alone.
+*/
+var LAST_USER_KEY = "rebase-offline:last-user";
+var OfflineManager = class {
+	store;
+	maxCachedQueries;
+	maxCachedRows;
+	maxRetries;
+	onSyncError;
+	onConflict;
+	createInner;
+	inners = /* @__PURE__ */ new Map();
+	connectivity;
+	keepLastUser;
+	replayBatchSize;
+	scope = SIGNED_OUT_SCOPE;
+	/**
+	* The scope is the last signed-in user's, taken without a confirmed
+	* session ({@link resumeLastUser}). Nothing replays while it is set: the
+	* queue is sent under the credentials of whoever is signed in, and nobody
+	* is yet.
+	*/
+	unverified = false;
+	/**
+	* Set while the manager does not know whose data it holds: from
+	* {@link holdScope} until the next {@link setScope}. `scope` is not
+	* consulted meanwhile — no operation gets a {@link ScopeTicket}, and
+	* nothing reads or writes the store.
+	*/
+	scopeHold;
+	/**
+	* Bumped by every change of user, and by `clear()`.
+	*
+	* The load paths always re-checked the scope after their awaits; the write
+	* paths did not. A `find` sent for user A that answered after B had signed
+	* in wrote A's RLS-filtered rows into B's local database, under B's keys,
+	* and showed them to B's observers; a replay acknowledged after the switch
+	* dequeued a key under B's scope that did not exist, so A's write stayed
+	* queued and was sent again when A came back. Every write now carries the
+	* {@link ScopeTicket} its operation started under, and one that is stale
+	* touches nothing that belongs to the new user.
+	*/
+	scopeEpoch = 0;
+	/** The local database: normalized rows and query snapshots per collection. */
+	collections = /* @__PURE__ */ new Map();
+	/** In-memory mirror of the current scope's queue, in replay order. */
+	queueEntries = [];
+	get queue() {
+		return this.queueEntries;
+	}
+	set queue(next) {
+		this.queueEntries = next;
+		this.pendingIndex = void 0;
+	}
+	/**
+	* Per collection, the row ids the queue writes to and the ones it creates
+	* — {@link hasPending} and {@link isLocallyCreated}, which answering a
+	* page asks once or twice per row. Each used to scan the whole queue: a
+	* 500-row page against 200 queued writes read 80,000 queue entries, on
+	* every emit. Built on first use after the queue changes; whatever changes
+	* it in place calls {@link queueChangedInPlace}.
+	*/
+	pendingIndex;
+	/**
+	* The mutations currently on the wire: one, or the members of a folded
+	* run (`replayBatchSize`).
+	*
+	* `flush` awaits `replay(op)` with `op` still at the head of `queue`, so for
+	* the whole duration of that request the in-flight op is also the queue's
+	* *tail* whenever it is the only entry. Both shortcuts in `enqueue` reach
+	* for the tail, and neither may touch an op the server is already reading:
+	*
+	* - Coalescing an update into it mutates a payload that has already been
+	*   serialized and sent, and `drop` then removes the whole entry on ACK —
+	*   so the second edit is neither sent nor kept. A silently lost write.
+	* - Cancelling it out against a delete assumes the server never saw the
+	*   create. It is seeing it right now, so the row would be created and the
+	*   delete never queued — an orphan row nothing will ever remove.
+	*
+	* Guarding on ids rather than on a boolean is what keeps this correct
+	* when a folded run sends several at once, its last member the tail.
+	*/
+	inFlight = /* @__PURE__ */ new Set();
+	queueLoad;
+	/** Serializes enqueues so concurrent writes keep the order the app made them. */
+	enqueueChain = Promise.resolve();
+	flushPromise;
+	queueListeners = /* @__PURE__ */ new Set();
+	statusListeners = /* @__PURE__ */ new Set();
+	observers = /* @__PURE__ */ new Map();
+	refreshPending = /* @__PURE__ */ new Set();
+	revCounter = 0;
+	disposed = false;
+	/** Whether {@link requestPersistence} has asked. */
+	persistenceRequested = false;
+	currentStatus = {
+		online: true,
+		syncing: false,
+		pending: 0
+	};
+	channel;
+	tabId = createMutationId();
+	api;
+	constructor(config, createInner) {
+		this.store = config.store ?? (typeof indexedDB !== "undefined" ? new IndexedDBOfflineStore() : new MemoryOfflineStore());
+		this.maxCachedQueries = config.maxCachedQueriesPerCollection ?? 50;
+		this.maxCachedRows = config.maxCachedRowsPerCollection ?? 5e3;
+		this.maxRetries = config.maxRetries ?? 5;
+		this.onSyncError = config.onSyncError;
+		this.onConflict = config.onConflict;
+		this.keepLastUser = config.keepLastUser === true;
+		const batch = Math.floor(config.replayBatchSize ?? 1);
+		this.replayBatchSize = Number.isFinite(batch) ? Math.min(Math.max(batch, 1), MAX_REPLAY_BATCH) : 1;
+		this.createInner = createInner;
+		const maxBackoffMs = config.syncIntervalMs ?? 6e4;
+		this.connectivity = new ConnectivityMonitor({
+			maxBackoffMs: Math.max(1e3, maxBackoffMs),
+			respectBackoff: maxBackoffMs > 0
+		});
+		if (maxBackoffMs > 0) this.connectivity.onRetryDue = () => {
+			this.sync().catch(() => void 0);
+		};
+		this.connectivity.onOnline = () => {
+			this.sync().catch(() => void 0);
+		};
+		this.connectivity.onChange((online) => {
+			this.patchStatus({ online });
+			if (online) this.revalidateAll();
+		});
+		this.currentStatus.online = this.connectivity.isOnline();
+		if ((config.crossTab ?? this.store instanceof IndexedDBOfflineStore) && typeof BroadcastChannel !== "undefined") try {
+			this.channel = new BroadcastChannel("rebase-offline");
+			this.channel.onmessage = (event) => this.onBroadcast(event.data);
+			unref(this.channel);
+		} catch {}
+		this.api = {
+			sync: () => this.sync(),
+			pending: async (options) => {
+				if (options?.orphaned) {
+					await this.scopeKnown();
+					if (this.scope === SIGNED_OUT_SCOPE) return [];
+					return await this.readQueue(`${SIGNED_OUT_SCOPE}|`);
+				}
+				await this.ensureQueueLoaded();
+				return this.queue.map((m) => hydrateMutation(structuredClone(dehydrateMutation(m))));
+			},
+			status: () => ({ ...this.currentStatus }),
+			onStatusChange: (listener) => {
+				this.statusListeners.add(listener);
+				return () => this.statusListeners.delete(listener);
+			},
+			clear: async (options) => {
+				await this.scopeKnown();
+				if (options?.orphaned) {
+					if (this.scope === SIGNED_OUT_SCOPE) return;
+					await this.store.clear(`${SIGNED_OUT_SCOPE}|`);
+					this.broadcast({ type: "queue" }, SIGNED_OUT_SCOPE);
+					return;
+				}
+				this.scopeEpoch++;
+				await this.store.clear(`${this.scope}|`);
+				this.queue = [];
+				this.resetCollections();
+				this.patchStatus({
+					pending: 0,
+					lastError: void 0
+				});
+				this.notifyQueue();
+				for (const slug of this.observers.keys()) this.notifyCollection(slug, false);
+			},
+			onQueueChange: (listener) => {
+				this.queueListeners.add(listener);
+				return () => this.queueListeners.delete(listener);
+			}
+		};
+	}
+	/**
+	* Cache and queue are partitioned per signed-in user: cached rows are
+	* RLS-filtered for the user who fetched them, and queued writes must
+	* replay under the credentials that made them — so neither may ever leak
+	* across a sign-out/sign-in on a shared browser.
+	*/
+	setScope(uid, options) {
+		const next = uid || SIGNED_OUT_SCOPE;
+		const unverified = next !== SIGNED_OUT_SCOPE && options?.unverified === true;
+		if (!unverified) this.rememberUser(uid);
+		const hold = this.scopeHold;
+		if (!hold && next === this.scope) {
+			if (this.unverified && !unverified) {
+				this.unverified = false;
+				this.patchStatus({ unverifiedUser: void 0 });
+				this.sync().catch(() => void 0);
+			}
+			return;
+		}
+		this.scope = next;
+		this.unverified = unverified;
+		this.scopeHold = void 0;
+		this.leaveScope();
+		this.patchStatus({ unverifiedUser: unverified || void 0 });
+		hold?.release();
+		this.revalidateAll();
+		this.sync().catch(() => void 0);
+	}
+	/** Whether the manager was created with {@link OfflineConfig.keepLastUser}. */
+	get keepsLastUser() {
+		return this.keepLastUser;
+	}
+	/**
+	* Take the scope of the last user who signed in on this device, without a
+	* session — for a load whose session restore could not reach the server.
+	* See {@link OfflineConfig.keepLastUser}. With no user remembered (or the
+	* option off) this is the signed-out scope, as it would have been anyway.
+	*
+	* Only while the scope is still held: an auth event that settled it while
+	* the id was being read is newer news.
+	*/
+	async resumeLastUser() {
+		let uid;
+		if (this.keepLastUser) try {
+			const entry = await this.store.getCache(LAST_USER_KEY);
+			if (typeof entry?.value === "string" && entry.value) uid = entry.value;
+		} catch {}
+		if (!this.scopeHold) return;
+		this.setScope(uid, { unverified: uid !== void 0 });
+	}
+	/**
+	* Keep the signed-in user's id for {@link resumeLastUser}, or forget it at
+	* sign-out. Forgetting does not depend on the option, so turning it off
+	* does not leave the last id behind for good.
+	*/
+	rememberUser(uid) {
+		(uid ? this.keepLastUser ? this.store.setCache(LAST_USER_KEY, {
+			value: uid,
+			cachedAt: Date.now()
+		}) : void 0 : this.store.deleteCache([LAST_USER_KEY]))?.catch(() => void 0);
+	}
+	/**
+	* Forget whose data this is until the next {@link setScope}.
+	*
+	* For the time before the client knows who is signed in — a session being
+	* restored on load. Taking that time for "signed out" would put the user's
+	* own writes in the signed-out queue, which no sign-in replays, and show
+	* them the signed-out local database instead of theirs.
+	*
+	* Meanwhile the manager has no scope at all. Every operation — a read, a
+	* write, a replay, `pending()`, `clear()` — waits for one and then runs
+	* for whoever it turns out to be, and nothing reads or writes the store.
+	* A realtime frame arriving in between is handed on as the server sent it
+	* and kept nowhere.
+	*/
+	holdScope() {
+		if (this.scopeHold) return;
+		let release;
+		const known = new Promise((resolve) => {
+			release = resolve;
+		});
+		this.scopeHold = {
+			known,
+			release
+		};
+		this.leaveScope();
+	}
+	/** Let go of the current user's rows and queue: in memory, and on screen. */
+	leaveScope() {
+		this.scopeEpoch++;
+		this.queueLoad = void 0;
+		this.queue = [];
+		this.resetCollections();
+		this.patchStatus({
+			pending: 0,
+			lastError: void 0
+		});
+		this.notifyQueue();
+		for (const slug of this.observers.keys()) this.notifyCollection(slug, false);
+	}
+	/** Settles once the manager knows whose data it holds — see {@link holdScope}. */
+	async scopeKnown() {
+		while (this.scopeHold) await this.scopeHold.known;
+	}
+	/**
+	* The user an operation is running for — see {@link scopeEpoch} — or
+	* nothing while that is not known ({@link holdScope}). An operation takes
+	* it as `this.ticket() ?? await this.nextTicket()`, before its first await.
+	*/
+	ticket() {
+		if (this.scopeHold) return void 0;
+		return {
+			scope: this.scope,
+			epoch: this.scopeEpoch
+		};
+	}
+	/** The ticket of whoever the held scope turns out to be. */
+	async nextTicket() {
+		await this.scopeKnown();
+		return {
+			scope: this.scope,
+			epoch: this.scopeEpoch
+		};
+	}
+	/** Whether an operation's user is still the signed-in one. */
+	isCurrent(ticket) {
+		return ticket.epoch === this.scopeEpoch;
+	}
+	/**
+	* Throw away every local row, for a scope change or an explicit clear.
+	*
+	* The state objects are replaced rather than emptied, so a load still in
+	* flight for the previous user fails its identity check and discards what
+	* it read instead of grafting it onto the new one. The replacements are
+	* marked ready: nothing needs loading until something asks, and observers
+	* have to be told *now* that the rows they are showing are gone.
+	*/
+	resetCollections() {
+		const slugs = [...this.collections.keys()];
+		this.collections = /* @__PURE__ */ new Map();
+		for (const slug of slugs) this.collections.set(slug, {
+			rows: /* @__PURE__ */ new Map(),
+			snapshots: /* @__PURE__ */ new Map(),
+			fresh: /* @__PURE__ */ new Set(),
+			freshRows: /* @__PURE__ */ new Set(),
+			absent: /* @__PURE__ */ new Set(),
+			ready: true
+		});
+	}
+	/** Release listeners, timers and the cross-tab channel (client.close()). */
+	dispose() {
+		this.disposed = true;
+		this.connectivity.dispose();
+		try {
+			this.channel?.close();
+		} catch {}
+		this.observers.clear();
+		this.queueListeners.clear();
+		this.statusListeners.clear();
+	}
+	wrap(slug, inner) {
+		this.inners.set(slug, inner);
+		/**
+		* `find`, and the page reader of `iterate()` / `findAll()` when `walk`
+		* is set.
+		*
+		* A walk reads `meta.hasMore` as the server's word on whether to go
+		* on. A page the server never answered here is evaluated over whatever
+		* rows happen to be cached, and its `hasMore` is about those rows — so
+		* offline, `findAll()` stopped at the first such page and returned a
+		* fraction of the collection as the whole of it, with nothing to tell
+		* the two apart. A walk refuses that page instead.
+		*/
+		const findPage = async (params, walk) => {
+			const ticket = this.ticket() ?? await this.nextTicket();
+			const state = await this.ensureCollection(slug);
+			if (this.connectivity.shouldAttempt()) try {
+				const res = await inner.find(params);
+				this.connectivity.markSuccess();
+				if (!this.isCurrent(ticket)) return res;
+				await this.ingest(slug, res.data ?? [], ticket, isProjection(params));
+				if (!this.isCurrent(ticket)) return res;
+				const snapshot = this.recordSnapshot(slug, params, res, ticket);
+				const answer = this.answer(slug, params, snapshot);
+				this.notifyCollection(slug, false);
+				return {
+					data: answer.data,
+					meta: answer.meta
+				};
+			} catch (error) {
+				if (!isNetworkError(error)) {
+					if (isRetryableError(error) && this.hasLocalAnswer(state, slug, params) && !(walk && !this.snapshotFor(slug, params))) {
+						const answer = this.answer(slug, params, this.snapshotFor(slug, params));
+						return {
+							data: answer.data,
+							meta: answer.meta
+						};
+					}
+					throw error;
+				}
+				this.connectivity.markFailure();
+			}
+			if (walk && !this.snapshotFor(slug, params)) throw unwalkable();
+			const answer = this.localFind(slug, params);
+			this.notifyCollection(slug, false);
+			return {
+				data: answer.data,
+				meta: answer.meta
+			};
+		};
+		const unwalkable = () => offlineError(`Offline: a page of "${slug}" the server has not answered on this device is needed to read the collection to the end, and the local database cannot say what is on it.`);
+		const wrapped = {
+			find: (params) => findPage(params, false),
+			iterate: (params) => paginateFind((p) => findPage(p, true), params, slug),
+			findAll: (params) => collectAllPages((p) => findPage(p, true), params, slug),
+			findById: async (id, options) => {
+				const ticket = this.ticket() ?? await this.nextTicket();
+				await this.ensureCollection(slug);
+				if (this.connectivity.shouldAttempt()) try {
+					const row = await inner.findById(id, options);
+					this.connectivity.markSuccess();
+					if (!this.isCurrent(ticket)) return row;
+					if (row !== void 0) await this.ingest(slug, [row], ticket);
+					else if (!this.hasPending(slug, id)) this.removeLocalRow(slug, id, ticket, true);
+					this.notifyCollection(slug, false);
+					return this.localRow(slug, id);
+				} catch (error) {
+					if (!isNetworkError(error)) throw error;
+					this.connectivity.markFailure();
+				}
+				const local = this.localRow(slug, id);
+				if (local !== void 0 || this.hasPending(slug, id)) return local;
+				if (this.collections.get(slug)?.absent.has(String(id))) return void 0;
+				throw offlineError(`Offline: "${slug}" row ${String(id)} is not in the local database.`);
+			},
+			get: async (id) => {
+				const row = await wrapped.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;
+			},
+			create: async (data, id, options) => {
+				const ticket = this.ticket() ?? await this.nextTicket();
+				await this.ensureCollection(slug);
+				const idempotencyKey = options?.idempotencyKey ?? createMutationId();
+				let sent = false;
+				if (this.connectivity.shouldAttempt()) try {
+					const row = await inner.create(data, id, {
+						...options,
+						idempotencyKey
+					});
+					this.connectivity.markSuccess();
+					await this.ingest(slug, [row], ticket);
+					this.notifyCollection(slug);
+					this.scheduleRefresh(slug);
+					return row;
+				} catch (error) {
+					if (!isNetworkError(error)) throw error;
+					this.connectivity.markFailure();
+					sent = true;
+				}
+				const providedId = id ?? data.id;
+				const rowId = providedId ?? this.mintOfflineId(slug);
+				const row = optimisticRow(data, rowId);
+				await this.enqueue({
+					collection: slug,
+					type: "create",
+					id: rowId,
+					data: row,
+					generatedId: providedId === void 0,
+					...sent ? { sent: {
+						idempotencyKey,
+						data: { ...data },
+						id
+					} } : {},
+					rollback: { rows: { [String(rowId)]: this.rawLocalRow(slug, rowId) ?? null } }
+				}, ticket);
+				this.setLocalRow(slug, rowId, row, ticket);
+				this.notifyCollection(slug);
+				return row;
+			},
+			createMany: async (data, options) => {
+				const ticket = this.ticket() ?? await this.nextTicket();
+				await this.ensureCollection(slug);
+				if (!Array.isArray(data)) throw invalidBulkBody("createMany expects an array of records.");
+				if (data.length === 0) return [];
+				const idempotencyKey = options?.idempotencyKey ?? createMutationId();
+				let sent = false;
+				if (this.connectivity.shouldAttempt()) try {
+					const rows = await inner.createMany(data, {
+						...options,
+						idempotencyKey
+					});
+					this.connectivity.markSuccess();
+					await this.ingest(slug, rows, ticket);
+					this.notifyCollection(slug);
+					this.scheduleRefresh(slug);
+					return rows;
+				} catch (error) {
+					if (!isNetworkError(error)) throw error;
+					this.connectivity.markFailure();
+					sent = true;
+				}
+				if (!sent && options?.onConflict?.length) throw new RebaseClientError(`Cannot upsert into "${slug}" while offline: the rows it would replace can only be found by the server. Upserting on the primary key, with the key in each row, is queued; upserting on a natural key is not.`, { code: "OFFLINE_UPSERT_UNSUPPORTED" });
+				const rows = data.map((r) => optimisticRow(r, r.id ?? this.mintOfflineId(slug)));
+				const rollback = {};
+				for (const row of rows) {
+					const key = String(row.id);
+					rollback[key] = this.rawLocalRow(slug, row.id) ?? null;
+				}
+				await this.enqueue({
+					collection: slug,
+					type: "createMany",
+					data: rows,
+					upsert: options?.upsert,
+					...sent ? { sent: {
+						idempotencyKey,
+						data: data.map((r) => ({ ...r })),
+						...options?.onConflict?.length ? { onConflict: [...options.onConflict] } : {}
+					} } : {},
+					rollback: { rows: rollback }
+				}, ticket);
+				for (const row of rows) this.setLocalRow(slug, row.id, row, ticket);
+				this.notifyCollection(slug);
+				return rows;
+			},
+			/**
+			* Upsert, with the one case that cannot be resolved without the
+			* server refused rather than guessed.
+			*
+			* On the primary key an upsert is create-or-replace, which the
+			* local store can do and the queue already carries (`createMany`
+			* with `upsert`). On a natural key it is not: deciding whether a
+			* row with that email exists means an index this store does not
+			* keep, and inventing an id would insert a duplicate the moment the
+			* queue drains — the exact outcome upsert exists to prevent.
+			*/
+			upsert: async (data, options) => {
+				const ticket = this.ticket() ?? await this.nextTicket();
+				await this.ensureCollection(slug);
+				if (this.connectivity.shouldAttempt()) try {
+					const row = await inner.upsert(data, options);
+					this.connectivity.markSuccess();
+					await this.ingest(slug, [row], ticket);
+					this.notifyCollection(slug);
+					this.scheduleRefresh(slug);
+					return row;
+				} catch (error) {
+					if (!isNetworkError(error)) throw error;
+					this.connectivity.markFailure();
+				}
+				const rowId = data.id;
+				if (options?.onConflict?.length || rowId === void 0) throw new RebaseClientError(`Cannot upsert into "${slug}" while offline: the row it would replace can only be found by the server. Upserting on the primary key, with the key in the row, is queued; upserting on a natural key is not.`, { code: "OFFLINE_UPSERT_UNSUPPORTED" });
+				const row = optimisticRow(data, rowId);
+				await this.enqueue({
+					collection: slug,
+					type: "createMany",
+					data: [row],
+					upsert: true,
+					rollback: { rows: { [String(rowId)]: this.rawLocalRow(slug, rowId) ?? null } }
+				}, ticket);
+				this.setLocalRow(slug, rowId, row, ticket);
+				this.notifyCollection(slug);
+				return row;
+			},
+			updateMany: async (updates, options) => {
+				const ticket = this.ticket() ?? await this.nextTicket();
+				await this.ensureCollection(slug);
+				if (!Array.isArray(updates)) throw invalidBulkBody("updateMany expects an array of { id, data } entries.");
+				if (updates.length === 0) return [];
+				const anyPending = updates.some((u) => this.hasPending(slug, u.id));
+				if (this.connectivity.shouldAttempt() && !anyPending) try {
+					const rows = await inner.updateMany(updates, options);
+					this.connectivity.markSuccess();
+					await this.ingest(slug, rows, ticket);
+					this.notifyCollection(slug);
+					return rows;
+				} catch (error) {
+					if (!isNetworkError(error)) throw error;
+					this.connectivity.markFailure();
+				}
+				const rollback = {};
+				const optimistic = [];
+				for (const { id, data } of updates) {
+					const base = this.rawLocalRow(slug, id);
+					rollback[String(id)] = base ?? null;
+					optimistic.push(optimisticRow({
+						...base ?? {},
+						...data
+					}, id));
+				}
+				await this.enqueue({
+					collection: slug,
+					type: "updateMany",
+					updates: updates.map((u) => ({
+						id: u.id,
+						data: u.data
+					})),
+					rollback: { rows: rollback }
+				}, ticket);
+				for (const row of optimistic) this.setLocalRow(slug, row.id, row, ticket);
+				this.notifyCollection(slug);
+				return optimistic;
+			},
+			deleteMany: async (ids, options) => {
+				const ticket = this.ticket() ?? await this.nextTicket();
+				await this.ensureCollection(slug);
+				if (!Array.isArray(ids)) throw invalidBulkBody("deleteMany expects an array of ids.");
+				if (ids.length === 0) return;
+				const anyPending = ids.some((id) => this.hasPending(slug, id));
+				if (this.connectivity.shouldAttempt() && !anyPending) try {
+					await inner.deleteMany(ids, options);
+					this.connectivity.markSuccess();
+					for (const id of ids) this.removeLocalRow(slug, id, ticket, true);
+					this.notifyCollection(slug);
+					this.scheduleRefresh(slug);
+					return;
+				} catch (error) {
+					if (!isNetworkError(error)) throw error;
+					this.connectivity.markFailure();
+				}
+				const rollback = {};
+				for (const id of ids) rollback[String(id)] = this.rawLocalRow(slug, id) ?? null;
+				await this.enqueue({
+					collection: slug,
+					type: "deleteMany",
+					ids,
+					rollback: { rows: rollback }
+				}, ticket);
+				for (const id of ids) this.removeLocalRow(slug, id, ticket, false);
+				this.notifyCollection(slug);
+			},
+			update: async (id, data, options) => {
+				const ticket = this.ticket() ?? await this.nextTicket();
+				await this.ensureCollection(slug);
+				const idempotencyKey = options?.idempotencyKey ?? createMutationId();
+				let sent = false;
+				let sendFailure;
+				if (this.connectivity.shouldAttempt() && !this.hasPending(slug, id)) try {
+					const row = await inner.update(id, data, {
+						...options,
+						idempotencyKey
+					});
+					this.connectivity.markSuccess();
+					await this.ingest(slug, [row], ticket);
+					this.notifyCollection(slug);
+					return row;
+				} catch (error) {
+					if (!isNetworkError(error)) throw error;
+					this.connectivity.markFailure();
+					sent = true;
+					sendFailure = error;
+				}
+				if (hasFieldOperation(data)) {
+					if (sent) throw new RebaseApiError(`The connection failed after a field operation on "${slug}" was sent, so it may or may not have been applied. Retry it with the idempotencyKey in \`details\` to apply it at most once.`, {
+						status: 0,
+						code: "NETWORK_ERROR",
+						details: { idempotencyKey },
+						cause: sendFailure
+					});
+					throw new RebaseClientError(`Cannot apply a field operation to "${slug}" while offline: it is evaluated against the stored value, which this device does not have a current copy of. Send the value itself, or retry when the connection is back.`, { code: "OFFLINE_FIELD_OP_UNSUPPORTED" });
+				}
+				const base = this.rawLocalRow(slug, id);
+				const ifMatch = this.onConflict ? options?.ifMatch ?? (this.hasPending(slug, id) ? void 0 : this.etagFor(slug, id)) : void 0;
+				await this.enqueue({
+					collection: slug,
+					type: "update",
+					id,
+					data,
+					...sent ? { sent: { idempotencyKey } } : {},
+					...ifMatch ? { ifMatch } : {},
+					rollback: { rows: { [String(id)]: base ?? null } }
+				}, ticket);
+				const optimistic = optimisticRow({
+					...base ?? {},
+					...data
+				}, id);
+				this.setLocalRow(slug, id, optimistic, ticket);
+				this.notifyCollection(slug);
+				return optimistic;
+			},
+			delete: async (id, options) => {
+				const ticket = this.ticket() ?? await this.nextTicket();
+				await this.ensureCollection(slug);
+				const idempotencyKey = options?.idempotencyKey ?? createMutationId();
+				let sent = false;
+				if (this.connectivity.shouldAttempt() && !this.hasPending(slug, id)) try {
+					await inner.delete(id, {
+						...options,
+						idempotencyKey
+					});
+					this.connectivity.markSuccess();
+					this.removeLocalRow(slug, id, ticket, true);
+					this.notifyCollection(slug);
+					this.scheduleRefresh(slug);
+					return;
+				} catch (error) {
+					if (!isNetworkError(error)) throw error;
+					this.connectivity.markFailure();
+					sent = true;
+				}
+				await this.enqueue({
+					collection: slug,
+					type: "delete",
+					id,
+					...sent ? { sent: { idempotencyKey } } : {},
+					rollback: { rows: { [String(id)]: this.rawLocalRow(slug, id) ?? null } }
+				}, ticket);
+				this.removeLocalRow(slug, id, ticket);
+				this.notifyCollection(slug);
+			},
+			count: async (params) => {
+				const ticket = this.ticket() ?? await this.nextTicket();
+				await this.ensureCollection(slug);
+				if (this.connectivity.shouldAttempt()) try {
+					const n = await inner.count(params);
+					this.connectivity.markSuccess();
+					if (!this.isCurrent(ticket)) return n;
+					this.writeCache(this.countKey(slug, params), n);
+					return Math.max(0, n + this.pendingDelta(slug, params));
+				} catch (error) {
+					if (!isNetworkError(error)) throw error;
+					this.connectivity.markFailure();
+				}
+				const cached = await this.readCache(this.countKey(slug, params));
+				if (cached !== void 0) return Math.max(0, cached + this.pendingDelta(slug, params));
+				throw offlineError(`Offline: no cached count for "${slug}".`);
+			},
+			observe: (params, onResult, onError, options) => this.observe(slug, wrapped, inner, params, onResult, onError, options),
+			observeById: (id, onResult, onError, options) => this.observeById(slug, wrapped, inner, id, onResult, onError, options),
+			where(columnOrCondition, operator, value) {
+				const builder = new SDKQueryBuilder(wrapped);
+				if (typeof columnOrCondition === "object") return builder.where(columnOrCondition);
+				return builder.where(columnOrCondition, operator, value);
+			},
+			orderBy: (column, direction, nulls) => new SDKQueryBuilder(wrapped).orderBy(column, direction, nulls),
+			limit: (count) => new SDKQueryBuilder(wrapped).limit(count),
+			offset: (count) => new SDKQueryBuilder(wrapped).offset(count),
+			search: (searchString, options) => new SDKQueryBuilder(wrapped).search(searchString, options),
+			vectorSearch: (property, vector, options) => new SDKQueryBuilder(wrapped).vectorSearch(property, vector, options),
+			include: (...relations) => new SDKQueryBuilder(wrapped).include(...relations),
+			fields: (...columns) => new SDKQueryBuilder(wrapped).fields(...columns),
+			distinct: (enabled) => new SDKQueryBuilder(wrapped).distinct(enabled),
+			after: (cursor) => new SDKQueryBuilder(wrapped).after(cursor),
+			trash: this.wrapTrash(slug, inner),
+			aggregate: inner.aggregate,
+			listen: inner.listen,
+			listenById: inner.listenById,
+			listenCount: inner.listenCount
+		};
+		if (!isUnsupported(inner.listen)) wrapped.listen = (params, onUpdate, onError) => inner.listen(params, (response) => {
+			const ticket = this.ticket();
+			if (!ticket) {
+				onUpdate(response);
+				return;
+			}
+			this.ingest(slug, response.data ?? [], ticket, isProjection(params)).then(() => {
+				if (!this.isCurrent(ticket)) return;
+				const snapshot = this.recordSnapshot(slug, params, response, ticket);
+				const answer = this.answer(slug, params, snapshot);
+				this.notifyCollection(slug, false);
+				onUpdate({
+					...response,
+					data: answer.data,
+					meta: answer.meta
+				});
+			});
+		}, onError);
+		if (!isUnsupported(inner.listenById)) wrapped.listenById = (id, onUpdate, onError, options) => inner.listenById(id, (row) => {
+			const ticket = this.ticket();
+			if (!ticket) {
+				onUpdate(row);
+				return;
+			}
+			if (!row) {
+				if (!this.hasPending(slug, id)) this.removeLocalRow(slug, id, ticket, true);
+				this.notifyCollection(slug, false);
+				onUpdate(row);
+				return;
+			}
+			this.ingest(slug, [row], ticket).then(() => {
+				if (!this.isCurrent(ticket)) return;
+				this.notifyCollection(slug, false);
+				onUpdate(this.localRow(slug, id) ?? row);
+			});
+		}, onError, options);
+		return wrapped;
+	}
+	/**
+	* `client.data.<slug>.trash` on an offline client: every call goes to the
+	* server, and none is cached or queued.
+	*
+	* The local database holds live rows only — a trashed row read into it
+	* would show up in every live query that matches it — so it cannot answer
+	* a trash read, and a restore or a purge queued offline would act on a row
+	* this device has never seen. Each of them rejects with `OFFLINE` instead.
+	*
+	* What the server answers does reach the local database: a restored row
+	* is live again and joins it, and a purged row leaves it. A row with a
+	* write still queued is synced first, so a purge never overtakes the
+	* queued delete it follows; if the queue cannot drain, the call is refused.
+	*/
+	wrapTrash(slug, inner) {
+		const online = async (what, call) => {
+			const message = `Offline: ${what} on the trash of "${slug}" needs the server; the trash is never cached on this device.`;
+			if (!this.connectivity.shouldAttempt()) throw offlineError(message);
+			try {
+				const result = await call();
+				this.connectivity.markSuccess();
+				return result;
+			} catch (error) {
+				if (!isNetworkError(error)) throw error;
+				this.connectivity.markFailure();
+				throw new RebaseApiError(message, {
+					status: 0,
+					code: "OFFLINE",
+					cause: error
+				});
+			}
+		};
+		const settleQueued = async (what, ids) => {
+			if (!ids.some((id) => this.hasPending(slug, id))) return;
+			await this.sync().catch(() => void 0);
+			const stuck = ids.find((id) => this.hasPending(slug, id));
+			if (stuck === void 0) return;
+			throw new RebaseClientError(`Cannot ${what} "${slug}" row ${String(stuck)} yet: a write to it is still queued, and the trash acts on the server's copy. Retry once \`client.offline.sync()\` has sent it.`, {
+				code: "TRASH_PENDING_WRITE",
+				details: { id: stuck }
+			});
+		};
+		const restored = async (rows, ticket) => {
+			await this.ingest(slug, rows.filter((row) => row && typeof row === "object"), ticket);
+			this.notifyCollection(slug);
+			this.scheduleRefresh(slug);
+		};
+		const purged = (ids, ticket) => {
+			for (const id of ids) this.removeLocalRow(slug, id, ticket, true);
+			this.notifyCollection(slug);
+			this.scheduleRefresh(slug);
+		};
+		return {
+			find: (params) => online("find()", () => inner.trash.find(params)),
+			count: (params) => online("count()", () => inner.trash.count(params)),
+			restore: async (id, options) => {
+				const ticket = this.ticket() ?? await this.nextTicket();
+				await this.ensureCollection(slug);
+				await settleQueued("restore", [id]);
+				const row = await online("restore()", () => inner.trash.restore(id, options));
+				await restored(row ? [row] : [], ticket);
+				return row;
+			},
+			restoreMany: async (ids, options) => {
+				const ticket = this.ticket() ?? await this.nextTicket();
+				await this.ensureCollection(slug);
+				if (!Array.isArray(ids)) throw invalidBulkBody("trash.restoreMany expects an array of ids.");
+				await settleQueued("restore", ids);
+				const rows = await online("restoreMany()", () => inner.trash.restoreMany(ids, options));
+				await restored(rows, ticket);
+				return rows;
+			},
+			purge: async (id, options) => {
+				const ticket = this.ticket() ?? await this.nextTicket();
+				await this.ensureCollection(slug);
+				await settleQueued("purge", [id]);
+				await online("purge()", () => inner.trash.purge(id, options));
+				purged([id], ticket);
+			},
+			purgeMany: async (ids, options) => {
+				const ticket = this.ticket() ?? await this.nextTicket();
+				await this.ensureCollection(slug);
+				if (!Array.isArray(ids)) throw invalidBulkBody("trash.purgeMany expects an array of ids.");
+				if (ids.length === 0) return;
+				await settleQueued("purge", ids);
+				await online("purgeMany()", () => inner.trash.purgeMany(ids, options));
+				purged(ids, ticket);
+			}
+		};
+	}
+	observe(slug, wrapped, inner, params, onResult, onError, options) {
+		let closed = false;
+		let unlisten;
+		const observer = {
+			slug,
+			params,
+			settled: false,
+			refresh: () => wrapped.find(params).catch(() => void 0),
+			emit: () => {
+				if (closed || !this.collections.get(slug)?.ready) return;
+				const result = this.answer(slug, params, this.snapshotFor(slug, params));
+				const signature = `${result.fromCache ? "c" : "s"}${result.hasPendingWrites ? "p" : "-"}` + this.signature(slug, result.data, result.meta.total);
+				if (observer.settled && signature === observer.signature) return;
+				observer.signature = signature;
+				observer.settled = true;
+				onResult(observer.error ? {
+					...result,
+					error: observer.error
+				} : result);
+			}
+		};
+		this.observersFor(slug).add(observer);
+		(async () => {
+			await this.ensureCollection(slug);
+			if (closed) return;
+			if (this.hasLocalAnswer(this.collections.get(slug), slug, params)) observer.emit();
+			try {
+				await wrapped.find(params);
+				observer.error = void 0;
+			} catch (error) {
+				observer.error = error;
+				if (closed) return;
+				if (!observer.settled) {
+					onError?.(error);
+					return;
+				}
+			}
+			if (!closed) observer.emit();
+		})();
+		if (options?.realtime !== false && !isUnsupported(inner.listen)) unlisten = inner.listen(params, (response) => {
+			const ticket = this.ticket();
+			if (!ticket) return;
+			this.ingest(slug, response.data ?? [], ticket, isProjection(params)).then(() => {
+				this.recordSnapshot(slug, params, response, ticket);
+				this.notifyCollection(slug, false);
+			});
+		}, onError);
+		return () => {
+			closed = true;
+			this.observersFor(slug).delete(observer);
+			unlisten?.();
+		};
+	}
+	observeById(slug, wrapped, inner, id, onResult, onError, options) {
+		const read = byIdRead(options);
+		let closed = false;
+		let unlisten;
+		const observer = {
+			slug,
+			id,
+			settled: false,
+			refresh: () => wrapped.findById(id, read).catch(() => void 0),
+			emit: () => {
+				if (closed || !this.collections.get(slug)?.ready) return;
+				const row = this.localRow(slug, id);
+				const entry = this.collections.get(slug)?.rows.get(String(id));
+				const fromCache = !this.collections.get(slug)?.freshRows.has(String(id));
+				const hasPendingWrites = this.hasPending(slug, id);
+				const signature = `${fromCache ? "c" : "s"}${hasPendingWrites ? "p" : "-"}|` + (row === void 0 ? MISSING : `${String(id)}:${entry?.rev ?? 0}`);
+				if (observer.settled && signature === observer.signature) return;
+				observer.signature = signature;
+				observer.settled = true;
+				onResult(row, {
+					fromCache,
+					hasPendingWrites
+				});
+			}
+		};
+		this.observersFor(slug).add(observer);
+		(async () => {
+			await this.ensureCollection(slug);
+			if (closed) return;
+			if (this.localRow(slug, id) !== void 0) observer.emit();
+			try {
+				await wrapped.findById(id, read);
+			} catch (error) {
+				if (closed) return;
+				if (!observer.settled) {
+					onError?.(error);
+					return;
+				}
+			}
+			if (!closed) observer.emit();
+		})();
+		if (options?.realtime !== false && !isUnsupported(inner.listenById)) unlisten = inner.listenById(id, (row) => {
+			const ticket = this.ticket();
+			if (!ticket) return;
+			if (!row) {
+				if (!this.hasPending(slug, id)) this.removeLocalRow(slug, id, ticket, true);
+				this.notifyCollection(slug, false);
+				return;
+			}
+			this.ingest(slug, [row], ticket).then(() => this.notifyCollection(slug, false));
+		}, onError, read);
+		return () => {
+			closed = true;
+			this.observersFor(slug).delete(observer);
+			unlisten?.();
+		};
+	}
+	observersFor(slug) {
+		let set = this.observers.get(slug);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.observers.set(slug, set);
+		}
+		return set;
+	}
+	/** Cheap change detection: which rows, in what order, at which revision. */
+	signature(slug, rows, total) {
+		const state = this.collections.get(slug);
+		return `${total}|${rows.map((row) => {
+			const key = String(row.id);
+			const entry = state?.rows.get(key);
+			return entry?.row === row ? `${key}:${entry.rev}` : `${key}=${JSON.stringify(row)}`;
+		}).join(",")}`;
+	}
+	notifyCollection(slug, broadcast = true) {
+		const set = this.observers.get(slug);
+		if (set) for (const observer of [...set]) callSafely(() => observer.emit());
+		if (broadcast) this.broadcast({
+			type: "rows",
+			slugs: [slug]
+		});
+	}
+	/** Connectivity came back (or the user changed): re-read everything live. */
+	revalidateAll() {
+		for (const slug of this.observers.keys()) {
+			this.notifyCollection(slug, false);
+			this.scheduleRefresh(slug);
+		}
+	}
+	collectionState(slug) {
+		let state = this.collections.get(slug);
+		if (!state) {
+			state = {
+				rows: /* @__PURE__ */ new Map(),
+				snapshots: /* @__PURE__ */ new Map(),
+				fresh: /* @__PURE__ */ new Set(),
+				freshRows: /* @__PURE__ */ new Set(),
+				absent: /* @__PURE__ */ new Set(),
+				ready: false
+			};
+			this.collections.set(slug, state);
+		}
+		return state;
+	}
+	ensureCollection(slug) {
+		if (this.scopeHold) return this.scopeKnown().then(() => this.ensureCollection(slug));
+		const state = this.collectionState(slug);
+		if (!state.loaded) {
+			const scope = this.scope;
+			state.loaded = (async () => {
+				await this.ensureQueueLoaded();
+				const [rows, snapshots, absent] = await Promise.all([
+					this.store.listCacheEntries(`${scope}|row|${slug}|`).catch(() => []),
+					this.store.listCacheEntries(`${scope}|q|${slug}|`).catch(() => []),
+					this.store.listCache(`${scope}|abs|${slug}|`).catch(() => [])
+				]);
+				if (this.scope !== scope || this.collections.get(slug) !== state) return;
+				for (const entry of rows) {
+					const row = entry.value;
+					if (!row || row.id === void 0 || row.id === null) continue;
+					state.rows.set(String(row.id), {
+						row: hydrateRow(row),
+						cachedAt: entry.cachedAt,
+						rev: ++this.revCounter
+					});
+				}
+				for (const entry of snapshots) {
+					const key = entry.key.slice(`${scope}|q|${slug}|`.length);
+					if (entry.value) state.snapshots.set(key, readSnapshot(entry.value));
+				}
+				for (const entry of absent) state.absent.add(entry.key.slice(`${scope}|abs|${slug}|`.length));
+			})().catch(() => void 0).finally(() => {
+				state.ready = true;
+			});
+		}
+		return state.loaded.then(() => state);
+	}
+	snapshotFor(slug, params) {
+		return this.collections.get(slug)?.snapshots.get(buildQueryString(params));
+	}
+	hasLocalAnswer(state, slug, params) {
+		if (!state) return false;
+		return state.snapshots.has(buildQueryString(params)) || state.rows.size > 0;
+	}
+	/**
+	* Answer a query from the local database.
+	*
+	* With a snapshot, the server's own page — its ids, order and total — is
+	* the skeleton, and the local rows fill it in: rows deleted locally drop
+	* out, rows edited locally show the edit, and rows *created* locally join
+	* the first page if they match. Without one, the query is evaluated
+	* outright over every cached row, which is the best that can be done for a
+	* query the server has never answered here.
+	*/
+	answer(slug, params, snapshot) {
+		const state = this.collections.get(slug);
+		const exact = isExactlyEvaluable(params);
+		const fromCache = !state?.fresh.has(buildQueryString(params));
+		if (!state) return {
+			data: [],
+			meta: {
+				...resolvePagination(params),
+				total: 0,
+				hasMore: false
+			},
+			fromCache: true,
+			hasPendingWrites: false,
+			partial: true
+		};
+		if (!snapshot) {
+			const local = runLocalQuery([...state.rows.values()].map((e) => e.row), params);
+			return {
+				...local,
+				fromCache,
+				hasPendingWrites: local.data.some((row) => this.hasPending(slug, row.id)),
+				partial: true
+			};
+		}
+		if (snapshot.rows) return this.projectedAnswer(slug, params, snapshot, snapshot.rows, fromCache);
+		const rows = [];
+		const seen = /* @__PURE__ */ new Set();
+		/** Rows the server counted that we know are no longer in the result. */
+		let removed = 0;
+		for (const id of snapshot.ids) {
+			const key = String(id);
+			const entry = state.rows.get(key);
+			if (!entry) {
+				if (state.absent.has(key) || this.hasPending(slug, key)) removed++;
+				continue;
+			}
+			if (exact && this.hasPending(slug, key) && !matchesParams(entry.row, params)) {
+				removed++;
+				continue;
+			}
+			rows.push(entry.row);
+			seen.add(key);
+		}
+		let added = 0;
+		const offset = snapshot.offset ?? 0;
+		if (exact && offset === 0) for (const [key, entry] of state.rows) {
+			if (seen.has(key) || !this.hasPending(slug, key)) continue;
+			if (!this.isLocallyCreated(slug, key) && !this.movedIntoFilter(slug, key, params)) continue;
+			if (!matchesParams(entry.row, params)) continue;
+			rows.push(entry.row);
+			added++;
+		}
+		const orderIsLocal = isLocallySortable(rows, params?.orderBy);
+		const sorted = Boolean(params?.orderBy && orderIsLocal);
+		if (sorted) sortRows(rows, params.orderBy);
+		const total = Math.max(rows.length, snapshot.total - removed + added);
+		const page = fitToLimit(rows, snapshot.limit, added, sorted);
+		return {
+			data: page,
+			meta: {
+				total,
+				limit: snapshot.limit,
+				offset,
+				hasMore: snapshot.hasMore || page.length < rows.length
+			},
+			fromCache,
+			hasPendingWrites: rows.some((row) => this.hasPending(slug, row.id)),
+			partial: !exact || !orderIsLocal
+		};
+	}
+	/**
+	* Answer a projected query (`fields`, `distinct`) from the server's own
+	* answer to it.
+	*
+	* The server's rows are the answer. The local database contributes only
+	* what it knows better: a row with unsynced writes shows them, narrowed to
+	* the columns the server sent, or drops out if it was deleted here or
+	* edited out of a filter this side can evaluate; and rows created here
+	* join the first page when there is somewhere to put them. A distinct
+	* query, or an order on a column the projection does not carry, leaves
+	* them out, and the result says it is partial.
+	*/
+	projectedAnswer(slug, params, snapshot, served, fromCache) {
+		const state = this.collectionState(slug);
+		const exact = isExactlyEvaluable(params);
+		const rows = [];
+		const seen = /* @__PURE__ */ new Set();
+		let removed = 0;
+		for (const row of served) {
+			const key = row.id === void 0 || row.id === null ? void 0 : String(row.id);
+			if (key !== void 0) seen.add(key);
+			if (key === void 0 || !this.hasPending(slug, key)) {
+				rows.push(row);
+				continue;
+			}
+			const local = state.rows.get(key)?.row;
+			if (!local || exact && !matchesParams(local, params)) {
+				removed++;
+				continue;
+			}
+			rows.push(pick(local, Object.keys(row)));
+		}
+		let added = 0;
+		let unplaced = false;
+		const offset = snapshot.offset ?? 0;
+		if (exact && offset === 0) {
+			const shape = served.length > 0 ? Object.keys(served[0]) : ["id", ...params?.fields ?? []];
+			const placeable = !params?.distinct && (normalizeOrderBy(params?.orderBy) ?? []).every(([field]) => shape.includes(field));
+			for (const [key, entry] of state.rows) {
+				if (seen.has(key) || !this.hasPending(slug, key)) continue;
+				if (!this.isLocallyCreated(slug, key) && !this.movedIntoFilter(slug, key, params)) continue;
+				if (!matchesParams(entry.row, params)) continue;
+				if (!placeable) {
+					unplaced = true;
+					continue;
+				}
+				rows.push(pick(entry.row, shape));
+				added++;
+			}
+		}
+		const orderIsLocal = added === 0 || isLocallySortable(rows, params?.orderBy);
+		const sorted = Boolean(added > 0 && params?.orderBy && orderIsLocal);
+		if (sorted) sortRows(rows, params.orderBy);
+		const page = fitToLimit(rows, snapshot.limit, added, sorted);
+		return {
+			data: page,
+			meta: {
+				total: Math.max(rows.length, snapshot.total - removed + added),
+				limit: snapshot.limit,
+				offset,
+				hasMore: snapshot.hasMore || page.length < rows.length
+			},
+			fromCache,
+			hasPendingWrites: rows.some((row) => row.id !== void 0 && row.id !== null && this.hasPending(slug, row.id)),
+			partial: !exact || !orderIsLocal || unplaced
+		};
+	}
+	localFind(slug, params) {
+		const state = this.collections.get(slug);
+		const snapshot = this.snapshotFor(slug, params);
+		state?.fresh.delete(buildQueryString(params));
+		if (!snapshot && (!state || state.rows.size === 0)) throw offlineError(`Offline: no cached data for "${slug}".`);
+		const answer = this.answer(slug, params, snapshot);
+		return snapshot ? answer : {
+			...answer,
+			partial: true
+		};
+	}
+	/**
+	* A temporary id of the type this collection's ids actually have.
+	*
+	* There is no schema here to read it off — the generated `Database` types
+	* are erased at compile time, and the whole point of this path is that the
+	* server is unreachable. So it is read off the rows the local database
+	* already holds: a collection whose cached ids are numbers gets a negative
+	* number, and everything else gets a UUID.
+	*
+	* A collection with nothing cached falls back to a UUID, which is the same
+	* guess as before — but that is a first write on a device that has never
+	* read the collection, which is also the case where nothing local can tell
+	* the difference. Reading one row first is enough to fix it.
+	*/
+	mintOfflineId(slug) {
+		for (const entry of this.collections.get(slug)?.rows.values() ?? []) {
+			const id = entry.row.id;
+			if (typeof id === "number") return generateOfflineNumericId();
+			if (typeof id === "string") break;
+		}
+		return generateOfflineStringId();
+	}
+	/**
+	* Keep the version a server row came with, or forget the one held when it
+	* came with none: a row from a list carries no version, and may be newer
+	* than the one held. Only with `onConflict`, the one reader of it.
+	*/
+	noteETag(state, key, row) {
+		if (!this.onConflict) return;
+		const etag = etagOf(row);
+		if (etag) (state.etags ??= /* @__PURE__ */ new Map()).set(key, etag);
+		else state.etags?.delete(key);
+	}
+	etagFor(slug, id) {
+		return this.collections.get(slug)?.etags?.get(String(id));
+	}
+	rawLocalRow(slug, id) {
+		const entry = this.collections.get(slug)?.rows.get(String(id));
+		return entry ? { ...entry.row } : void 0;
+	}
+	localRow(slug, id) {
+		return this.collections.get(slug)?.rows.get(String(id))?.row;
+	}
+	setLocalRow(slug, id, row, ticket) {
+		if (!this.isCurrent(ticket)) return;
+		const state = this.collectionState(slug);
+		const key = String(id);
+		const cachedAt = Date.now();
+		state.rows.set(key, {
+			row: { ...row },
+			cachedAt,
+			rev: ++this.revCounter
+		});
+		state.freshRows.delete(key);
+		this.forgetTombstone(slug, key);
+		this.writeCache(this.rowKey(slug, key), dehydrateRow(row), cachedAt);
+		this.evictRows(slug);
+	}
+	/**
+	* Drop a row and, when the server is the one saying it is gone, remember
+	* that. "I looked it up and it does not exist" is real knowledge: without
+	* it, opening a deleted row while offline would report a missing local
+	* database instead of a missing row.
+	*/
+	removeLocalRow(slug, id, ticket, known = false) {
+		if (!this.isCurrent(ticket)) return;
+		const state = this.collectionState(slug);
+		const key = String(id);
+		const existed = state.rows.delete(key);
+		state.etags?.delete(key);
+		if (known) {
+			state.absent.add(key);
+			state.freshRows.add(key);
+			this.writeCache(this.absentKey(slug, key), true);
+			this.capTombstones(slug);
+		} else state.freshRows.delete(key);
+		if (existed) this.deleteCache([this.rowKey(slug, key)]);
+	}
+	forgetTombstone(slug, key) {
+		if (!this.collectionState(slug).absent.delete(key)) return;
+		this.deleteCache([this.absentKey(slug, key)]);
+	}
+	/**
+	* Merge server rows into the local database. A row with unsynced local
+	* writes keeps them: the server's copy is the base the queued mutations
+	* are re-applied to, not a replacement for what the user did.
+	*
+	* Rows that came back unchanged keep their identity and revision, so a
+	* refetch that changed nothing does not re-render every live query that
+	* touches them — or rewrite them all to disk.
+	*
+	* A `projection` (see {@link isProjection}) only refreshes the columns it
+	* carries on rows already held, and never creates one. It is not a row:
+	* stored as one, it replaced the full row every other query reads and
+	* wrote the narrowed copy to disk, so a list lost its columns because a
+	* dropdown elsewhere asked for titles.
+	*/
+	async ingest(slug, rows, ticket, projection = false) {
+		if (rows.length === 0 || !this.isCurrent(ticket)) return;
+		const state = await this.ensureCollection(slug);
+		if (!this.isCurrent(ticket)) return;
+		const cachedAt = Date.now();
+		const writes = [];
+		const deletes = [];
+		for (const raw of rows) {
+			if (!raw || raw.id === void 0 || raw.id === null) continue;
+			const key = String(raw.id);
+			this.noteETag(state, key, raw);
+			const existing = state.rows.get(key);
+			if (projection && !existing) continue;
+			const base = projection && existing ? {
+				...existing.row,
+				...raw
+			} : { ...raw };
+			const merged = this.hasPending(slug, key) ? this.applyPendingToRow(slug, key, base) : base;
+			if (merged === void 0) {
+				state.rows.delete(key);
+				deletes.push(this.rowKey(slug, key));
+				continue;
+			}
+			this.forgetTombstone(slug, key);
+			if (!projection) state.freshRows.add(key);
+			if (existing && JSON.stringify(existing.row) === JSON.stringify(merged)) {
+				existing.cachedAt = cachedAt;
+				continue;
+			}
+			state.rows.set(key, {
+				row: merged,
+				cachedAt,
+				rev: ++this.revCounter
+			});
+			writes.push({
+				key: this.rowKey(slug, key),
+				entry: {
+					value: dehydrateRow(merged),
+					cachedAt
+				}
+			});
+		}
+		if (writes.length > 0) this.store.setCacheMany(writes).catch(() => void 0);
+		if (deletes.length > 0) this.deleteCache(deletes);
+		this.evictRows(slug);
+	}
+	/**
+	* Fold the queued mutations for one row over a base, newest last.
+	* `afterMutationId` skips everything up to and including that mutation,
+	* which is how a just-replayed write avoids being applied on top of the
+	* server's response to it.
+	*/
+	applyPendingToRow(slug, idKey, base, afterMutationId) {
+		let row = base;
+		let skipping = afterMutationId !== void 0;
+		for (const op of this.queue) {
+			if (skipping) {
+				if (op.mutationId === afterMutationId) skipping = false;
+				continue;
+			}
+			if (op.collection !== slug) continue;
+			if (op.type === "createMany") {
+				const match = op.data?.find((r) => String(r.id) === idKey);
+				if (match) row = { ...match };
+				continue;
+			}
+			if (op.type === "updateMany") {
+				const update = op.updates?.find((u) => String(u.id) === idKey);
+				if (update) row = {
+					...row ?? {},
+					...update.data,
+					id: update.id
+				};
+				continue;
+			}
+			if (op.type === "deleteMany") {
+				if (op.ids?.some((id) => String(id) === idKey)) row = void 0;
+				continue;
+			}
+			if (op.id === void 0 || String(op.id) !== idKey) continue;
+			if (op.type === "create") row = { ...op.data };
+			else if (op.type === "update") row = {
+				...row ?? {},
+				...op.data,
+				id: op.id
+			};
+			else if (op.type === "delete") row = void 0;
+		}
+		return row;
+	}
+	recordSnapshot(slug, params, result, ticket) {
+		const window = resolvePagination(params);
+		const meta = result.meta ?? {
+			total: result.data?.length ?? 0,
+			...window,
+			hasMore: false
+		};
+		const snapshot = {
+			ids: (result.data ?? []).map((row) => row.id).filter((id) => id !== void 0),
+			total: meta.total ?? result.data?.length ?? 0,
+			limit: meta.limit ?? window.limit,
+			offset: meta.offset ?? window.offset,
+			hasMore: meta.hasMore ?? false,
+			...isProjection(params) ? { rows: (result.data ?? []).map((row) => ({ ...row })) } : {}
+		};
+		if (!this.isCurrent(ticket)) return snapshot;
+		const state = this.collectionState(slug);
+		const key = buildQueryString(params);
+		state.snapshots.set(key, snapshot);
+		state.fresh.add(key);
+		this.writeCache(`${this.scope}|q|${slug}|${key}`, snapshot.rows ? {
+			...snapshot,
+			rows: snapshot.rows.map((row) => dehydrateRow(row))
+		} : snapshot);
+		this.evictSnapshots(slug);
+		return snapshot;
+	}
+	/**
+	* A write changed which rows belong in a list, and only the server can say
+	* how — a row it generated is in no cached page, and the totals moved.
+	* Re-run every live query on the collection; queries nobody is watching
+	* are corrected by their next `find`.
+	*
+	* Coalesced per microtask so a burst of writes costs one round trip, and
+	* skipped entirely while offline, where the local database is already the
+	* best answer available.
+	*/
+	scheduleRefresh(slug) {
+		if (this.refreshPending.has(slug)) return;
+		const observers = this.observers.get(slug);
+		if (!observers || observers.size === 0) return;
+		this.refreshPending.add(slug);
+		Promise.resolve().then(() => {
+			this.refreshPending.delete(slug);
+			if (this.disposed || !this.connectivity.shouldAttempt()) return;
+			for (const observer of [...this.observers.get(slug) ?? []]) observer.refresh();
+		});
+	}
+	evictRows(slug) {
+		const state = this.collections.get(slug);
+		if (!state || state.rows.size <= this.maxCachedRows) return;
+		const evictable = [...state.rows.entries()].filter(([key]) => !this.hasPending(slug, key)).sort((a, b) => a[1].cachedAt - b[1].cachedAt);
+		const excess = state.rows.size - this.maxCachedRows;
+		const doomed = evictable.slice(0, excess);
+		for (const [key] of doomed) {
+			state.rows.delete(key);
+			state.etags?.delete(key);
+		}
+		if (doomed.length > 0) this.deleteCache(doomed.map(([key]) => this.rowKey(slug, key)));
+	}
+	/**
+	* Tombstones are tiny but unbounded — every row the app ever asked for and
+	* did not find leaves one. Capped against the row budget, oldest first,
+	* whenever one is added: the cap used to sit behind the row cache's own
+	* early return, so it only applied once the rows were over theirs, and
+	* looking up missing ids grew the set without limit.
+	*/
+	capTombstones(slug) {
+		const state = this.collections.get(slug);
+		if (!state || state.absent.size <= this.maxCachedRows) return;
+		const stale = [...state.absent].slice(0, state.absent.size - this.maxCachedRows);
+		for (const key of stale) state.absent.delete(key);
+		this.deleteCache(stale.map((key) => this.absentKey(slug, key)));
+	}
+	evictSnapshots(slug) {
+		const state = this.collections.get(slug);
+		if (!state || state.snapshots.size <= this.maxCachedQueries) return;
+		const excess = state.snapshots.size - this.maxCachedQueries;
+		const doomed = [...state.snapshots.keys()].slice(0, excess);
+		for (const key of doomed) {
+			state.snapshots.delete(key);
+			state.fresh.delete(key);
+		}
+		this.deleteCache(doomed.map((key) => `${this.scope}|q|${slug}|${key}`));
+	}
+	ensureQueueLoaded() {
+		if (this.scopeHold) return this.scopeKnown().then(() => this.ensureQueueLoaded());
+		if (!this.queueLoad) {
+			const scope = this.scope;
+			this.queueLoad = this.readQueue(`${scope}|`).then((queue) => {
+				if (this.scope !== scope) return;
+				this.queue = queue;
+				this.patchStatus({ pending: queue.length });
+				this.notifyQueue();
+			}).catch(() => void 0);
+		}
+		return this.queueLoad;
+	}
+	enqueue(mutation, ticket) {
+		const result = this.enqueueChain.then(async () => {
+			await this.ensureQueueLoaded();
+			if (!this.isCurrent(ticket)) {
+				const orphan = {
+					...mutation,
+					mutationId: createMutationId(),
+					queuedAt: Date.now(),
+					schemaVersion: 1
+				};
+				await this.persistMutation(`${ticket.scope}|${orphan.mutationId}`, orphan);
+				return;
+			}
+			if (mutation.type === "update") {
+				const tail = this.queue[this.queue.length - 1];
+				if (tail && !this.inFlight.has(tail.mutationId) && tail.sent === void 0 && (tail.schemaVersion ?? 1) <= 1 && tail.collection === mutation.collection && (tail.type === "create" || tail.type === "update") && tail.id === mutation.id) {
+					if (tail.type === "update") tail.parts = [...tail.parts ?? [{ ...tail.data }], { ...mutation.data }];
+					tail.data = {
+						...tail.data,
+						...mutation.data,
+						id: tail.id
+					};
+					await this.persistMutation(this.queueKey(tail), tail);
+					return;
+				}
+			}
+			if (mutation.type === "delete") {
+				if (this.queue.some((m) => m.collection === mutation.collection && m.type === "create" && m.id === mutation.id && m.generatedId === true && m.sent === void 0 && !this.inFlight.has(m.mutationId))) {
+					const doomed = this.queue.filter((m) => m.collection === mutation.collection && m.id === mutation.id && (m.type === "create" || m.type === "update") && !this.inFlight.has(m.mutationId));
+					for (const op of doomed) await this.store.dequeue(this.queueKey(op));
+					this.queue = this.queue.filter((m) => !doomed.includes(m));
+					this.afterQueueChange();
+					return;
+				}
+			}
+			const full = {
+				...mutation,
+				mutationId: createMutationId(),
+				queuedAt: Date.now(),
+				schemaVersion: 1
+			};
+			await this.persistMutation(this.queueKey(full), full);
+			this.queue.push(full);
+			this.queueChangedInPlace();
+			this.afterQueueChange();
+			this.requestPersistence();
+		});
+		this.enqueueChain = result.catch(() => void 0);
+		return result;
+	}
+	/**
+	* Ask the browser to keep the offline database, once, when there is first
+	* something in it worth keeping. Without it IndexedDB is best-effort
+	* storage, evicted under pressure (and by Safari after seven days without
+	* a visit) with the unsent writes in it.
+	*/
+	requestPersistence() {
+		if (this.persistenceRequested || !(this.store instanceof IndexedDBOfflineStore)) return;
+		this.persistenceRequested = true;
+		const storage = globalThis.navigator?.storage;
+		if (typeof storage?.persist !== "function") return;
+		storage.persist().then((persisted) => this.patchStatus({ persisted }), () => void 0);
+	}
+	/** The queue's row ids for one collection — see {@link pendingIndex}. */
+	pendingIds(slug) {
+		if (!this.pendingIndex) {
+			const index = /* @__PURE__ */ new Map();
+			const note = (entry, key, op) => {
+				entry.writes.add(key);
+				if (!entry.first.has(key)) entry.first.set(key, op);
+			};
+			for (const op of this.queue) {
+				let entry = index.get(op.collection);
+				if (!entry) index.set(op.collection, entry = {
+					writes: /* @__PURE__ */ new Set(),
+					creates: /* @__PURE__ */ new Set(),
+					first: /* @__PURE__ */ new Map()
+				});
+				if (op.type === "createMany") for (const row of op.data ?? []) {
+					note(entry, String(row.id), op);
+					entry.creates.add(String(row.id));
+				}
+				else if (op.type === "updateMany") for (const update of op.updates ?? []) note(entry, String(update.id), op);
+				else if (op.type === "deleteMany") for (const id of op.ids ?? []) note(entry, String(id), op);
+				else if (op.id !== void 0) {
+					note(entry, String(op.id), op);
+					if (op.type === "create") entry.creates.add(String(op.id));
+				}
+			}
+			this.pendingIndex = index;
+		}
+		return this.pendingIndex.get(slug);
+	}
+	/**
+	* Did the queued writes to this row bring it into the query's filter? The
+	* row as it was before the first of them is that write's rollback; one
+	* that did not match then is in no server page of the query, so only
+	* this side can put it on screen.
+	*/
+	movedIntoFilter(slug, idKey, params) {
+		const before = this.pendingIds(slug)?.first.get(idKey)?.rollback?.rows?.[idKey];
+		return before !== void 0 && before !== null && !matchesParams(before, params);
+	}
+	/** The queue's entries were changed without replacing the array. */
+	queueChangedInPlace() {
+		this.pendingIndex = void 0;
+	}
+	hasPending(slug, id) {
+		return this.pendingIds(slug)?.writes.has(String(id)) ?? false;
+	}
+	/** Is this row one the server has never been told about? */
+	isLocallyCreated(slug, idKey) {
+		return this.pendingIds(slug)?.creates.has(idKey) ?? false;
+	}
+	/** How many rows the queue adds to (or removes from) a server-side count. */
+	pendingDelta(slug, params) {
+		if (!isExactlyEvaluable(params)) return 0;
+		const counts = (row) => row && matchesParams(row, params) ? 1 : 0;
+		const before = (op, id) => id === void 0 ? void 0 : op.rollback?.rows?.[String(id)];
+		let delta = 0;
+		for (const op of this.queue) {
+			if (op.collection !== slug) continue;
+			if (op.type === "create" || op.type === "createMany") {
+				const rows = op.type === "create" ? [op.data] : op.data ?? [];
+				for (const row of rows) delta += counts(row) - counts(before(op, row?.id));
+			} else if (op.type === "update") {
+				const was = before(op, op.id);
+				if (was) delta += counts({
+					...was,
+					...op.data
+				}) - counts(was);
+			} else if (op.type === "updateMany") for (const update of op.updates ?? []) {
+				const was = before(op, update.id);
+				if (was) delta += counts({
+					...was,
+					...update.data
+				}) - counts(was);
+			}
+			else if (op.type === "delete") delta -= counts(before(op, op.id));
+			else if (op.type === "deleteMany") for (const id of op.ids ?? []) delta -= counts(before(op, id));
+		}
+		return delta;
+	}
+	sync() {
+		if (this.flushPromise) return this.flushPromise;
+		const run = () => this.withLock(() => this.flush());
+		this.flushPromise = (this.scopeHold ? this.scopeKnown().then(run) : run()).finally(() => {
+			this.flushPromise = void 0;
+		});
+		return this.flushPromise;
+	}
+	async flush() {
+		const ticket = this.ticket() ?? await this.nextTicket();
+		await this.ensureQueueLoaded();
+		await this.reloadQueue();
+		if (this.queue.length === 0) return {
+			flushed: 0,
+			remaining: 0
+		};
+		if (this.unverified) return {
+			flushed: 0,
+			remaining: this.queue.length
+		};
+		this.patchStatus({ syncing: true });
+		const touched = /* @__PURE__ */ new Set();
+		const queuedAtStart = this.queue.length;
+		let flushed = 0;
+		const unbatched = /* @__PURE__ */ new Set();
+		try {
+			while (this.queue.length > 0 && !this.disposed && this.isCurrent(ticket)) {
+				const op = this.queue[0];
+				if ((op.schemaVersion ?? 1) > 1) {
+					this.patchStatus({ lastError: `A queued write was saved by a newer version of the SDK (layout ${String(op.schemaVersion)}); it is kept, and replays once this page runs that version.` });
+					break;
+				}
+				touched.add(op.collection);
+				const run = this.foldableRun(unbatched);
+				if (run.length > 1) {
+					const outcome = await this.replayRun(run, ticket);
+					if (outcome === "offline") break;
+					if (outcome === "unbatch") {
+						for (const member of run) unbatched.add(member.mutationId);
+						continue;
+					}
+					flushed += run.length;
+					continue;
+				}
+				this.inFlight.add(op.mutationId);
+				try {
+					try {
+						await this.replay(op, ticket);
+					} catch (error) {
+						if (isNetworkError(error)) {
+							this.connectivity.markFailure();
+							break;
+						}
+						if (op.type === "update" && op.ifMatch && isPreconditionFailed(error)) {
+							this.connectivity.markSuccess();
+							await this.resolveConflict(op, error, ticket);
+							continue;
+						}
+						op.attempts = (op.attempts ?? 0) + 1;
+						op.lastError = error?.message ?? String(error);
+						const limit = isIdempotencyInProgressError(error) ? Math.max(this.maxRetries, IN_PROGRESS_MIN_RETRIES) : this.maxRetries;
+						if (isRetryableError(error) && op.attempts < limit) {
+							await this.persistMutation(`${ticket.scope}|${op.mutationId}`, op).catch(() => void 0);
+							this.connectivity.deferRetry();
+							this.patchStatus({ lastError: op.lastError });
+							break;
+						}
+						if (op.type === "delete" && isNotFoundError(error)) {
+							this.connectivity.markSuccess();
+							this.removeLocalRow(op.collection, op.id, ticket, true);
+							await this.drop(op, ticket);
+							flushed++;
+							continue;
+						}
+						if (isFieldRefusal(error) && (op.parts?.length ?? 0) > 1) {
+							await this.splitCoalesced(op, ticket);
+							continue;
+						}
+						await this.rejectMutation(op, error, ticket);
+						continue;
+					}
+					this.connectivity.markSuccess();
+					await this.drop(op, ticket);
+					flushed++;
+				} finally {
+					this.inFlight.delete(op.mutationId);
+				}
+			}
+		} finally {
+			this.patchStatus({ syncing: false });
+		}
+		if (!this.isCurrent(ticket)) return {
+			flushed,
+			remaining: this.queue.length
+		};
+		if (this.queue.length !== queuedAtStart) {
+			for (const slug of touched) {
+				this.notifyCollection(slug);
+				this.scheduleRefresh(slug);
+			}
+			this.broadcast({ type: "queue" });
+		}
+		if (this.queue.length === 0) this.patchStatus({ lastSyncedAt: Date.now() });
+		return {
+			flushed,
+			remaining: this.queue.length
+		};
+	}
+	/**
+	* The creates at the head of the queue that may replay as one request —
+	* see {@link OfflineConfig.replayBatchSize}. Fewer than two means the head
+	* replays on its own.
+	*
+	* Consecutive, so the queue's order holds; one collection, since a bulk
+	* write is one collection's. Each is a create never sent (so its request
+	* is still its own to choose) with an id the SDK minted as a string — a
+	* lost answer then cannot duplicate it, because the server refuses that
+	* id the second time and the single replay recognises the row as its
+	* own. A create whose values name another member's minted id waits: the
+	* server may give that row a different id, which only a replay one at a
+	* time can carry over.
+	*/
+	foldableRun(unbatched) {
+		if (this.replayBatchSize < 2) return [];
+		const foldable = (op, collection) => op !== void 0 && op.type === "create" && op.generatedId === true && typeof op.id === "string" && op.sent === void 0 && !op.upsert && (op.schemaVersion ?? 1) <= 1 && !unbatched.has(op.mutationId) && (collection === void 0 || op.collection === collection);
+		const head = this.queue[0];
+		if (!foldable(head)) return [];
+		const run = [head];
+		for (let i = 1; i < this.queue.length && run.length < this.replayBatchSize; i++) {
+			const next = this.queue[i];
+			if (!foldable(next, head.collection)) break;
+			if (run.some((member) => mentionsMintedId(next, member.id))) break;
+			run.push(next);
+		}
+		return run;
+	}
+	/**
+	* Replay a {@link foldableRun} as one `createMany`.
+	*
+	* - `"done"`: every member is acknowledged, adopted and dropped.
+	* - `"offline"`: the connection failed; the members stay queued, as one
+	*   write would.
+	* - `"unbatch"`: anything else — a refusal, a busy server. Nothing was
+	*   written (a bulk write is one transaction), and the caller replays the
+	*   members one at a time, where each refusal, retry budget and recovery
+	*   applies to its own write.
+	*
+	* The key names the run by its first and last member and its length,
+	* which fixes its composition: a run re-sent after a lost answer is the
+	* same request under the same key, and is answered from the server's
+	* record of it.
+	*/
+	async replayRun(run, ticket) {
+		const inner = this.innerFor(run[0].collection);
+		const idempotencyKey = `${run[0].mutationId}..${run[run.length - 1].mutationId}:${run.length}`;
+		for (const member of run) this.inFlight.add(member.mutationId);
+		try {
+			let rows;
+			try {
+				rows = await inner.createMany(run.map((member) => member.data), { idempotencyKey });
+			} catch (error) {
+				if (!isNetworkError(error)) return "unbatch";
+				this.connectivity.markFailure();
+				return "offline";
+			}
+			this.connectivity.markSuccess();
+			for (let i = 0; i < run.length; i++) {
+				await this.adoptServerRow(run[i], run[i].id, rows[i], ticket);
+				await this.drop(run[i], ticket);
+			}
+			return "done";
+		} finally {
+			for (const member of run) this.inFlight.delete(member.mutationId);
+		}
+	}
+	async replay(op, ticket) {
+		const inner = this.innerFor(op.collection);
+		if (op.type === "create") {
+			let row;
+			try {
+				row = await this.sendQueuedWrite(op, (idempotencyKey) => inner.create(op.data, void 0, { idempotencyKey }), (sent) => inner.create(sent.data, sent.id, { idempotencyKey: sent.idempotencyKey }));
+			} catch (error) {
+				if (!(op.generatedId === true && isDuplicateKeyError(error))) throw error;
+				row = await inner.findById(op.id);
+				if (!row) throw error;
+			}
+			await this.adoptServerRow(op, op.id, row, ticket);
+		} else if (op.type === "createMany") {
+			const queued = op.data ?? [];
+			const asSent = (sent) => inner.createMany(sent.data, {
+				...op.upsert ? { upsert: true } : {},
+				...sent.onConflict?.length ? { onConflict: sent.onConflict } : {},
+				idempotencyKey: sent.idempotencyKey
+			});
+			const rows = op.sent?.onConflict?.length ? await asSent(op.sent) : await this.sendQueuedWrite(op, (idempotencyKey) => inner.createMany(queued, {
+				...op.upsert ? { upsert: true } : {},
+				idempotencyKey
+			}), asSent);
+			for (let i = 0; i < rows.length; i++) await this.adoptServerRow(op, queued[i]?.id, rows[i], ticket);
+		} else if (op.type === "updateMany") {
+			const queued = op.updates ?? [];
+			const rows = await inner.updateMany(queued.map((u) => ({
+				id: u.id,
+				data: u.data
+			})), { idempotencyKey: op.mutationId });
+			for (let i = 0; i < rows.length; i++) await this.ingestReplaced(op, queued[i].id, rows[i], ticket);
+		} else if (op.type === "update") {
+			if (!op.sent) {
+				op.sent = { idempotencyKey: op.mutationId };
+				await this.persistMutation(`${ticket.scope}|${op.mutationId}`, op).catch(() => void 0);
+			}
+			const row = await inner.update(op.id, op.data, {
+				idempotencyKey: op.sent.idempotencyKey,
+				...op.ifMatch ? { ifMatch: op.ifMatch } : {}
+			});
+			await this.ingestReplaced(op, op.id, row, ticket);
+		} else if (op.type === "deleteMany") {
+			const ids = op.ids ?? [];
+			try {
+				await inner.deleteMany(ids, { idempotencyKey: op.mutationId });
+			} catch (error) {
+				if (!isNotFoundError(error)) throw error;
+				for (const id of ids) try {
+					await inner.delete(id, { idempotencyKey: `${op.mutationId}:${String(id)}` });
+				} catch (rowError) {
+					if (!isNotFoundError(rowError)) throw rowError;
+				}
+			}
+			for (const id of ids) this.removeLocalRow(op.collection, id, ticket, true);
+		} else if (op.type === "delete") {
+			await inner.delete(op.id, { idempotencyKey: op.sent?.idempotencyKey ?? op.mutationId });
+			this.removeLocalRow(op.collection, op.id, ticket, true);
+		}
+	}
+	/**
+	* Send a queued write under its key.
+	*
+	* A write the queue sent once already, before it was queued, carries that
+	* attempt's key and is sent under it again, as queued. If the server holds
+	* the key for a different request, the difference is the ids minted here
+	* — so the first attempt committed and only its answer was lost, and
+	* sending that request again returns the stored answer instead of a
+	* second copy of the rows.
+	*/
+	async sendQueuedWrite(op, asQueued, asSent) {
+		try {
+			return await asQueued(op.sent?.idempotencyKey ?? op.mutationId);
+		} catch (error) {
+			if (!op.sent || !isIdempotencyKeyReusedError(error)) throw error;
+			return asSent(op.sent);
+		}
+	}
+	/**
+	* Take the server's version of a row the client created offline.
+	*
+	* The server may have assigned a different id — a serial column ignores
+	* the id we invented — in which case every local trace of the temporary id
+	* has to move with it, including queued writes that were made against it
+	* before it was ever sent.
+	*/
+	async adoptServerRow(op, localId, row, ticket) {
+		if (!row) return;
+		const slug = op.collection;
+		const serverId = row.id;
+		if (localId !== void 0 && serverId !== void 0 && String(serverId) !== String(localId)) {
+			const oldKey = String(localId);
+			this.removeLocalRow(slug, localId, ticket);
+			const queue = this.isCurrent(ticket) ? this.queue : await this.readQueue(`${ticket.scope}|`).catch(() => []);
+			const minted = op.type === "create" && op.generatedId === true;
+			for (const queued of queue) {
+				let dirty = false;
+				if (minted && queued !== op) {
+					const data = replaceMintedId(queued.data, localId, serverId);
+					if (data.changed) {
+						queued.data = data.value;
+						dirty = true;
+					}
+					if (queued.updates) {
+						const updates = replaceMintedId(queued.updates.map((u) => u.data), localId, serverId);
+						if (updates.changed) {
+							const values = updates.value;
+							queued.updates = queued.updates.map((u, i) => ({
+								id: u.id,
+								data: values[i]
+							}));
+							dirty = true;
+						}
+					}
+				}
+				if (queued.collection !== slug) {
+					if (dirty) await this.persistMutation(`${ticket.scope}|${queued.mutationId}`, queued).catch(() => void 0);
+					continue;
+				}
+				if (queued.id !== void 0 && String(queued.id) === oldKey) {
+					queued.id = serverId;
+					this.queueChangedInPlace();
+					if (queued.data && !Array.isArray(queued.data)) queued.data.id = serverId;
+					dirty = true;
+				}
+				const rollbackRows = queued.rollback?.rows;
+				if (rollbackRows && oldKey in rollbackRows) {
+					rollbackRows[String(serverId)] = rollbackRows[oldKey];
+					delete rollbackRows[oldKey];
+					dirty = true;
+				}
+				if (dirty) await this.persistMutation(`${ticket.scope}|${queued.mutationId}`, queued).catch(() => void 0);
+			}
+		}
+		await this.ingestReplaced(op, serverId ?? localId, row, ticket);
+	}
+	/**
+	* Write a server row over the local one, ignoring the mutation that just
+	* produced it — re-applying that would put the pre-server values back on
+	* top of the server's answer — but keeping every write queued *after* it.
+	* Those are still unsent, and dropping them here would make the row snap
+	* back to the server's version in front of the user, only to change again
+	* when they replay a moment later.
+	*/
+	async ingestReplaced(op, id, row, ticket) {
+		if (!this.isCurrent(ticket)) return;
+		const slug = op.collection;
+		const state = await this.ensureCollection(slug);
+		if (!this.isCurrent(ticket)) return;
+		const key = String(id);
+		this.noteETag(state, key, row);
+		const merged = this.applyPendingToRow(slug, key, { ...row }, op.mutationId);
+		if (merged === void 0) {
+			this.removeLocalRow(slug, key, ticket);
+			return;
+		}
+		const cachedAt = Date.now();
+		state.rows.set(key, {
+			row: merged,
+			cachedAt,
+			rev: ++this.revCounter
+		});
+		if (this.applyPendingToRow(slug, key, void 0, op.mutationId) === void 0) state.freshRows.add(key);
+		this.writeCache(this.rowKey(slug, key), dehydrateRow(merged), cachedAt);
+	}
+	/**
+	* The server refused a mutation. Put back what it changed, and discard the
+	* queued writes that were built on top of it: an edit to a row whose
+	* creation was rejected can only fail the same way, and applying it would
+	* leave the local database claiming a row the server does not have.
+	*
+	* The cascade stops the moment a later write stops *depending* on the
+	* rejected one. An `update` reads the row it edits, so it is doomed with
+	* it; a `create` overwrites the row outright and a `delete` needs nothing
+	* of it, so both stand on their own and are kept — dropping them would
+	* silently lose writes the server would have accepted.
+	*/
+	async rejectMutation(op, error, ticket, report = true) {
+		if (!this.isCurrent(ticket)) return;
+		const ids = new Set(Object.keys(op.rollback?.rows ?? {}));
+		if (op.id !== void 0) ids.add(String(op.id));
+		const doomed = [op];
+		const orphaned = new Set(ids);
+		const neverCreated = op.type === "create" && op.generatedId === true && op.id !== void 0 ? [op.id] : [];
+		const position = this.queue.indexOf(op);
+		for (const later of this.queue.slice(position + 1)) {
+			if (neverCreated.some((id) => mentionsMintedId(later, id))) {
+				doomed.push(later);
+				if (later.type === "create" && later.generatedId === true && later.id !== void 0) neverCreated.push(later.id);
+				continue;
+			}
+			if (later.collection !== op.collection) continue;
+			const hit = this.idsOf(later).filter((id) => orphaned.has(id));
+			if (hit.length === 0) continue;
+			if (later.type === "update") doomed.push(later);
+			else for (const id of hit) orphaned.delete(id);
+		}
+		for (const dropped of doomed) await this.drop(dropped, ticket);
+		if (!this.isCurrent(ticket)) return;
+		const touched = /* @__PURE__ */ new Set([op.collection]);
+		for (const dropped of doomed) {
+			if (dropped === op || !neverCreated.length || dropped.collection === op.collection && dropped.type === "update") continue;
+			touched.add(dropped.collection);
+			for (const [idKey, previous] of Object.entries(dropped.rollback?.rows ?? {})) {
+				const restored = this.applyPendingToRow(dropped.collection, idKey, previous ?? void 0);
+				if (restored === void 0) this.removeLocalRow(dropped.collection, idKey, ticket);
+				else this.setLocalRow(dropped.collection, idKey, restored, ticket);
+			}
+		}
+		const goneKey = op.type === "update" && isNotFoundError(error) ? String(op.id) : void 0;
+		for (const [idKey, previous] of Object.entries(op.rollback?.rows ?? {})) {
+			const gone = idKey === goneKey;
+			const restored = this.applyPendingToRow(op.collection, idKey, gone ? void 0 : previous ?? void 0);
+			if (restored === void 0) this.removeLocalRow(op.collection, idKey, ticket, gone);
+			else this.setLocalRow(op.collection, idKey, restored, ticket);
+		}
+		this.patchStatus({ lastError: error.message });
+		for (const slug of touched) {
+			this.notifyCollection(slug);
+			this.scheduleRefresh(slug);
+		}
+		for (const dropped of doomed) {
+			if (dropped === op && !report) continue;
+			callSafely(() => this.onSyncError?.(dropped === op ? error : dependencyRejected(op, error), dropped));
+		}
+	}
+	/**
+	* An edit replayed with `If-Match` and refused with a 412: ask
+	* {@link OfflineConfig.onConflict}, and do what it says. A callback that
+	* throws, or none, is "overwrite" — what replay did before it knew of
+	* conflicts.
+	*/
+	async resolveConflict(op, error, ticket) {
+		let resolution = "overwrite";
+		if (this.onConflict) try {
+			resolution = await this.onConflict(error, op) === "discard" ? "discard" : "overwrite";
+		} catch (callbackError) {
+			console.error("Error in offline onConflict:", callbackError);
+		}
+		if (resolution === "overwrite") {
+			delete op.ifMatch;
+			await this.persistMutation(`${ticket.scope}|${op.mutationId}`, op).catch(() => void 0);
+			return resolution;
+		}
+		await this.rejectMutation(op, error, ticket, false);
+		const slug = op.collection;
+		const id = op.id;
+		try {
+			const row = await this.innerFor(slug).findById(id);
+			if (this.isCurrent(ticket)) {
+				if (row) await this.ingest(slug, [row], ticket);
+				else if (!this.hasPending(slug, id)) this.removeLocalRow(slug, id, ticket, true);
+				this.notifyCollection(slug);
+			}
+		} catch {}
+		return resolution;
+	}
+	/**
+	* Put the separate edits a coalesced `update` was made of back in the
+	* queue, in its place and in their order, each with the row as it stood
+	* before it as its rollback — so a refusal undoes that edit alone.
+	*
+	* Their ids extend the merged op's, which sorts them after it and before
+	* whatever was queued next, so the queue's order survives a reload.
+	*/
+	async splitCoalesced(op, ticket) {
+		const parts = op.parts ?? [];
+		const idKey = String(op.id);
+		let before = op.rollback?.rows?.[idKey] ?? null;
+		const pieces = parts.map((part, index) => {
+			const piece = {
+				mutationId: `${op.mutationId}:${index}`,
+				collection: op.collection,
+				type: "update",
+				id: op.id,
+				data: { ...part },
+				queuedAt: op.queuedAt,
+				...index === 0 && op.ifMatch ? { ifMatch: op.ifMatch } : {},
+				rollback: { rows: { [idKey]: before === null ? null : { ...before } } }
+			};
+			if (before !== null) before = {
+				...before,
+				...part
+			};
+			return piece;
+		});
+		for (const piece of pieces) await this.persistMutation(`${ticket.scope}|${piece.mutationId}`, piece).catch(() => void 0);
+		await this.store.dequeue(`${ticket.scope}|${op.mutationId}`).catch(() => void 0);
+		if (!this.isCurrent(ticket)) return;
+		const position = this.queue.indexOf(op);
+		this.queue.splice(position < 0 ? 0 : position, position < 0 ? 0 : 1, ...pieces);
+		this.queueChangedInPlace();
+		this.afterQueueChange(false);
+	}
+	/** Every row id a mutation writes to. */
+	idsOf(op) {
+		if (op.type === "createMany") return (op.data ?? []).map((r) => String(r.id));
+		if (op.type === "updateMany") return (op.updates ?? []).map((u) => String(u.id));
+		if (op.type === "deleteMany") return (op.ids ?? []).map((id) => String(id));
+		return op.id === void 0 ? [] : [String(op.id)];
+	}
+	async drop(op, ticket) {
+		await this.store.dequeue(`${ticket.scope}|${op.mutationId}`).catch(() => void 0);
+		if (!this.isCurrent(ticket)) return;
+		this.queue = this.queue.filter((m) => m.mutationId !== op.mutationId);
+		this.afterQueueChange(false);
+	}
+	/** Replay uses unwrapped clients: a failure must never re-enqueue itself. */
+	innerFor(slug) {
+		let inner = this.inners.get(slug);
+		if (!inner) {
+			inner = this.createInner(slug);
+			this.inners.set(slug, inner);
+		}
+		return inner;
+	}
+	async withLock(fn) {
+		const locks = globalThis.navigator?.locks;
+		if (!locks?.request) return fn();
+		let started = false;
+		try {
+			return await locks.request(`rebase-offline-sync:${this.scope}`, () => {
+				started = true;
+				return fn();
+			});
+		} catch (error) {
+			if (started) throw error;
+			return fn();
+		}
+	}
+	broadcast(message, scope = this.scope) {
+		if (!this.channel) return;
+		try {
+			this.channel.postMessage({
+				...message,
+				scope,
+				sender: this.tabId
+			});
+		} catch {}
+	}
+	onBroadcast(message) {
+		if (this.disposed || !message || typeof message !== "object") return;
+		const msg = message;
+		if (this.scopeHold || msg.sender === this.tabId || msg.scope !== this.scope) return;
+		if (msg.type === "rows") for (const slug of msg.slugs ?? []) this.reloadCollection(slug);
+		else if (msg.type === "queue") this.reloadQueue();
+	}
+	/** Re-read one collection from the store, replacing what is in memory. */
+	async reloadCollection(slug) {
+		const state = this.collections.get(slug);
+		if (!state?.loaded || this.scopeHold) return;
+		await this.reloadQueue();
+		const scope = this.scope;
+		const [rows, snapshots, absent] = await Promise.all([
+			this.store.listCacheEntries(`${scope}|row|${slug}|`).catch(() => []),
+			this.store.listCacheEntries(`${scope}|q|${slug}|`).catch(() => []),
+			this.store.listCache(`${scope}|abs|${slug}|`).catch(() => [])
+		]);
+		if (this.scope !== scope || this.collections.get(slug) !== state) return;
+		const next = /* @__PURE__ */ new Map();
+		for (const entry of rows) {
+			const row = entry.value;
+			if (!row || row.id === void 0 || row.id === null) continue;
+			const key = String(row.id);
+			const existing = state.rows.get(key);
+			const hydrated = hydrateRow(row);
+			const unchanged = existing && JSON.stringify(existing.row) === JSON.stringify(hydrated);
+			next.set(key, {
+				row: hydrated,
+				cachedAt: entry.cachedAt,
+				rev: unchanged ? existing.rev : ++this.revCounter
+			});
+		}
+		state.rows = next;
+		state.snapshots = /* @__PURE__ */ new Map();
+		for (const entry of snapshots) {
+			const key = entry.key.slice(`${scope}|q|${slug}|`.length);
+			if (entry.value) state.snapshots.set(key, readSnapshot(entry.value));
+		}
+		state.absent = new Set(absent.map((entry) => entry.key.slice(`${scope}|abs|${slug}|`.length)));
+		this.notifyCollection(slug, false);
+	}
+	async reloadQueue() {
+		if (this.scopeHold) return;
+		const scope = this.scope;
+		const queue = await this.readQueue(`${scope}|`).catch(() => void 0);
+		if (!queue || this.scope !== scope) return;
+		this.queue = queue;
+		this.afterQueueChange(false);
+	}
+	afterQueueChange(broadcast = true) {
+		this.patchStatus({ pending: this.queue.length });
+		this.notifyQueue();
+		if (broadcast) this.broadcast({ type: "queue" });
+	}
+	notifyQueue() {
+		for (const listener of this.queueListeners) callSafely(() => listener(this.queue.length));
+	}
+	patchStatus(patch) {
+		let changed = false;
+		for (const [key, value] of Object.entries(patch)) if (this.currentStatus[key] !== value) {
+			this.currentStatus[key] = value;
+			changed = true;
+		}
+		if (!changed) return;
+		const snapshot = { ...this.currentStatus };
+		for (const listener of this.statusListeners) callSafely(() => listener(snapshot));
+	}
+	countKey(slug, params) {
+		return `${this.scope}|count|${slug}|${buildQueryString(params)}`;
+	}
+	rowKey(slug, id) {
+		return `${this.scope}|row|${slug}|${String(id)}`;
+	}
+	absentKey(slug, id) {
+		return `${this.scope}|abs|${slug}|${String(id)}`;
+	}
+	queueKey(mutation) {
+		return `${this.scope}|${mutation.mutationId}`;
+	}
+	/** Queue a write in the store, its rows encoded as the cache's are. */
+	persistMutation(key, op) {
+		return this.store.enqueue(key, dehydrateMutation(op));
+	}
+	/** The store's queue under `prefix`, its rows revived. */
+	async readQueue(prefix) {
+		return (await this.store.listQueue(prefix)).map(hydrateMutation);
+	}
+	async readCache(key) {
+		try {
+			return (await this.store.getCache(key))?.value;
+		} catch {
+			return;
+		}
+	}
+	async writeCache(key, value, cachedAt = Date.now()) {
+		try {
+			await this.store.setCache(key, {
+				value,
+				cachedAt
+			});
+		} catch {}
+	}
+	async deleteCache(keys) {
+		try {
+			await this.store.deleteCache(keys);
+		} catch {}
+	}
+};
+//#endregion
+export { OfflineManager };
+
+//# sourceMappingURL=offline-QNQgsPOq-B2yGeXkn.js.map