@supalive/core 0.1.4 → 0.1.6

package/dist/src/client/index.js

@@ -1,19 +1,1153 @@
-// ── Query definitions ─────────────────────────────────────────────────────────
-export { defineQuery, _resetGlobalDefs } from "../db/query_definition";
-// ── Core DB ───────────────────────────────────────────────────────────────────
-export { SupaliveDb, sleep } from "../db/realtime_db";
-// ── Context ───────────────────────────────────────────────────────────────────
-export { TxContext, DbReader, DbWriter } from "../db/context";
-export { DbReader as ReadContext, DbWriter as WritableContext } from "../db/context";
-// ── Schema ────────────────────────────────────────────────────────────────────
-export { defineSchema, defineComputedField } from "../db/schema";
-export { matchesPredicate } from "../db/query";
-export * from "../db/types_db";
-export { NO_RETRY, DEFAULT_RETRY, OccConflictError, OccAbortError, } from "../db/types_db";
-// ── Router types (client-safe, no getContextRegistry) ─────────────────────────
-export { createQueryBuilder, createMutationBuilder, createActionBuilder, } from "../router/procedure";
-export { router, } from "../router/router";
-// ── Client ────────────────────────────────────────────────────────────────────
-export { WsClientManager, RPCError, } from "./ws_client_manager";
-export { createClient, } from "./client";
+import { n as createMutationBuilder, r as createQueryBuilder, t as createActionBuilder } from "../../procedure-DX87tyef.js";
+import { n as getContextRegistry, r as router } from "../../router-DlTYWpop.js";
+import { o as matchesPredicate } from "../../query-Bh0RNxDz.js";
+import { n as defineSchema, t as defineComputedField } from "../../schema-Dd7u0A1L.js";
+import { r as supaliveStringify } from "../../helper-wGbzz6zo.js";
+import { C as normalizeIdToBytes, S as bytesFromJson, _ as RawRangeReadSchema, a as DEFAULT_RETRY, b as WriteEntrySchema, c as OccAbortError, d as PointReadSchema, f as PredicateSchema, g as RawPointReadSchema, h as RangeReadSchema, i as CompareOperatorSchema, l as OccConflictError, m as QueryCacheMetadataSchema, n as BigIntSchema, o as LeafPredicateSchema, p as QueryCacheEntrySchema, r as CachedPgMetadataSchema, s as NO_RETRY, t as AndPredicateSchema, u as OrPredicateSchema, v as RawReadEntrySchema, w as normalizeToBytes, x as WriteOpSchema, y as ReadEntrySchema } from "../../types_db-DXj_l9n-.js";
+import { l as ServerMessageSchema } from "../../types_client_rpc-CIsjQQGG.js";
+import { a as TxContext, i as DbWriter, n as sleep, r as DbReader, t as SupaliveDb } from "../../realtime_db-DOCgqbwi.js";
+import { sha1 } from "hash-wasm";
+//#region src/db/query_definition.ts
+const _globalDefs = /* @__PURE__ */ new Map();
+/** For test teardown only — clears the global map between suites. */
+function _resetGlobalDefs() {
+	_globalDefs.clear();
+}
+/**
+* Create a named, typed query definition.
+*
+* The definition is automatically registered in a module-level global so
+* the server can call registry.defineAll() instead of listing every query
+* explicitly. On the client, pass the definition to createClientRpc() to
+* get a fully typed subscribe() call.
+*
+* Usage:
+*   export const projectBoardQuery = defineQuery(
+*     "projectBoard",
+*     async (ctx, params: { projectId: string }) => {
+*       return ctx.query(Tasks)
+*         .select()
+*         .where(f => f.eq("projectId", params.projectId))
+*         .get();
+*     }
+*   );
+*/
+function defineQuery(name, fn) {
+	if (_globalDefs.has(name)) throw new Error(`[defineQuery] "${name}" is already defined. Each query must have a unique name across the whole application.`);
+	const def = {
+		_type: "QueryDefinition",
+		name,
+		fn
+	};
+	_globalDefs.set(name, def);
+	return def;
+}
+//#endregion
+//#region src/client/sub_key.ts
+/**
+* Compute a compact local key for a `(procedure, input)` pair.
+*
+* Output shape: `procedureName#16-hex-chars`.
+*
+* - `procedureName#` prefix keeps DevTools / log output legible.
+* - 16 hex chars = 64 bits of SHA-1. Collision probability over N concurrent
+*   subscriptions is ~ N²/2⁶⁵ — comfortable up to ~10k subs per session.
+*
+* Async because `hash-wasm` lazily inits the wasm module on first call; the
+* cost is paid once per process. Subsequent calls are effectively free.
+*/
+async function computeLocalSubKey(procedure, input) {
+	return `${procedure}#${(await sha1(`${procedure}::${input}`)).slice(0, 16)}`;
+}
+/**
+* Trigger the one-time `hash-wasm` init off the critical path so the first
+* real `subscribe` doesn't pay the ~5–10ms wasm-bootstrap cost. Safe to call
+* any number of times; resolves once the module is ready.
+*/
+function prewarmHasher() {
+	return sha1("");
+}
+//#endregion
+//#region src/client/ws_client_manager.ts
+const WS_OPEN = 1;
+var RPCError = class extends Error {
+	code;
+	constructor(message, code) {
+		super(message);
+		this.name = "RPCError";
+		this.code = code;
+	}
+};
+var WsClientManager = class {
+	ws = null;
+	options;
+	lastSuccessfulConnectionTime = 0;
+	reconnectionTimeout;
+	requestId = 0;
+	pendingRequests = /* @__PURE__ */ new Map();
+	/**
+	* Single source of truth for live subscriptions.
+	*
+	* Keying:
+	*   - In-flight subscribe (no subId yet): `_pending:<requestId>`.
+	*   - Established: the server-returned canonical `subId`.
+	*
+	* Routing `sub:update` / `sub:gone` is O(1) (`get(subId)`). Subscribe-time
+	* dedup scans `values()` for a matching `localKey` (O(N)), which is cheap
+	* since subscribes happen on component mounts, not in the hot path.
+	*/
+	subscriptions = /* @__PURE__ */ new Map();
+	queuedCalls = [];
+	reconnectAttempts = 0;
+	reconnectTimer = null;
+	connectionState = "disconnected";
+	authState = "pending";
+	/**
+	* Authenticated user id from `auth:success`. Distinct from `queryIdentity`
+	* (server-side cache/sub segmentation key); this is just "who am I logged
+	* in as" for app display purposes. Null while unauthenticated / anonymous.
+	*/
+	authUserId = null;
+	explicitlyClosed = false;
+	stateListeners = /* @__PURE__ */ new Set();
+	lastPublicState = "disconnected";
+	serverInactivityMs;
+	lastServerMessageAt = 0;
+	inactivityTimer = null;
+	pendingConnectResolve = null;
+	pendingConnectReject = null;
+	throttleEveryN;
+	throttleDelayMs;
+	throttleCounter = 0;
+	throttling = false;
+	visibilityListener = null;
+	onlineListener = null;
+	constructor(options) {
+		this.options = {
+			reconnectionTimeout: 18e4,
+			reconnect: {
+				enabled: true,
+				maxAttempts: 5,
+				delay: 1e3,
+				backoff: 1.5,
+				...options.reconnect
+			},
+			...options
+		};
+		this.reconnectionTimeout = this.options.reconnectionTimeout;
+		this.serverInactivityMs = options.heartbeat?.serverInactivityMs ?? 6e4;
+		this.throttleEveryN = options.throttle?.everyN ?? 100;
+		this.throttleDelayMs = options.throttle?.delayMs ?? 10;
+		this.installEnvironmentListeners();
+		prewarmHasher().catch(() => {});
+	}
+	/**
+	* Subscribe to client state transitions. Returns an unsubscribe fn.
+	* The listener is called immediately with the current state.
+	*/
+	onState(listener) {
+		this.stateListeners.add(listener);
+		listener(this.computePublicState());
+		return () => {
+			this.stateListeners.delete(listener);
+		};
+	}
+	/** Current public state. */
+	getPublicState() {
+		return this.computePublicState();
+	}
+	/**
+	* Connect to the WebSocket server.
+	* Returns a promise that resolves when connected and authenticated.
+	*/
+	async connect() {
+		this.explicitlyClosed = false;
+		if (this.connectionState == "connected" || this.connectionState == "connecting") return;
+		this.connectionState = "connecting";
+		this.emitState();
+		return new Promise(async (resolve, reject) => {
+			this.pendingConnectResolve = () => {
+				this.pendingConnectResolve = null;
+				this.pendingConnectReject = null;
+				resolve();
+			};
+			this.pendingConnectReject = (err) => {
+				this.pendingConnectResolve = null;
+				this.pendingConnectReject = null;
+				reject(err);
+			};
+			try {
+				const ws = new (await (getWebSocket()))(new URL(this.options.url).toString());
+				this.ws = ws;
+				ws.onopen = () => {
+					this.startInactivityWatchdog();
+				};
+				ws.onmessage = (event) => {
+					const data = typeof event.data === "string" ? event.data : event.data.toString();
+					this.handleMessage(data);
+				};
+				ws.onclose = () => {
+					this.handleClose();
+				};
+				ws.onerror = (err) => {
+					const error = err instanceof Error ? err : new Error(`WebSocket error: `, { cause: err });
+					this.handleError(error);
+					this.pendingConnectReject?.(error);
+				};
+			} catch (err) {
+				this.connectionState = "disconnected";
+				this.emitState();
+				this.pendingConnectReject?.(err);
+			}
+		});
+	}
+	/**
+	* Disconnect from the server.
+	*/
+	disconnect() {
+		this.explicitlyClosed = true;
+		this.cleanup();
+		const oldWs = this.ws;
+		this.ws = null;
+		if (oldWs) {
+			oldWs.onmessage = null;
+			oldWs.onerror = null;
+			oldWs.onopen = null;
+			oldWs.onclose = null;
+			try {
+				oldWs.close();
+			} catch {}
+		}
+		this.removeEnvironmentListeners();
+		this.emitState();
+	}
+	/**
+	* Check if connected and authenticated.
+	*/
+	isReady() {
+		return this.connectionState == "connected" && this.authState != "pending";
+	}
+	/**
+	* Check if authenticated.
+	*/
+	isAuthenticated() {
+		return this.authState == "authenticated";
+	}
+	/**
+	* Check if anonymouse.
+	*/
+	isAnonymouse() {
+		return this.authState == "anonymouse";
+	}
+	/**
+	* The authenticated user's id (from `auth:success`), or null when
+	* unauthenticated / anonymous. Useful for "Logged in as …" display.
+	*
+	* Not to be confused with server-side `queryIdentity`, which is the
+	* cache/subscription segmentation key (resolved entirely on the server).
+	*/
+	getAuthUserId() {
+		return this.authUserId;
+	}
+	/**
+	* Call a procedure (query, mutation, or action).
+	*
+	* If the client is not ready (disconnected or still authenticating), the
+	* call is FIFO-queued and dispatched on the next ready state. The promise
+	* still resolves with the eventual server response.
+	*
+	* Pass `onSend` to be notified when the call actually leaves the queue
+	* (used by `useMutation` to flip `state` from "queued" → "loading").
+	*/
+	async call(procedure, input, options) {
+		if (!this.isReady()) return new Promise((resolve, reject) => {
+			this.queuedCalls.push({
+				procedure,
+				input,
+				resolve,
+				reject,
+				onSend: options?.onSend
+			});
+			if (!this.explicitlyClosed && this.connectionState === "disconnected") this.connect().catch(() => {});
+		});
+		if (this.throttleEveryN <= 0) {
+			options?.onSend?.();
+			return this.dispatchCall(procedure, input);
+		}
+		if (this.throttling) return new Promise((resolve, reject) => {
+			this.queuedCalls.push({
+				procedure,
+				input,
+				resolve,
+				reject,
+				onSend: options?.onSend
+			});
+		});
+		this.throttleCounter++;
+		if (this.throttleCounter >= this.throttleEveryN) {
+			this.throttling = true;
+			await this.runThrottleLoop();
+		}
+		options?.onSend?.();
+		return this.dispatchCall(procedure, input);
+	}
+	/**
+	* Throttle drain loop. Each iteration: sleep `throttleDelayMs`, then
+	* dispatch up to `throttleEveryN` queued items. Exits as soon as the
+	* queue drains inside a single batch (burst over, back to direct
+	* dispatch on the next `call()`) or the connection goes away
+	* (reconnect path will restart us via `flushQueuedCalls`).
+	*/
+	async runThrottleLoop() {
+		while (this.throttling) {
+			await new Promise((r) => setTimeout(r, this.throttleDelayMs));
+			if (!this.isReady()) {
+				this.throttling = false;
+				this.throttleCounter = 0;
+				return;
+			}
+			this.throttleCounter = 0;
+			while (this.throttleCounter < this.throttleEveryN && this.queuedCalls.length > 0) {
+				const item = this.queuedCalls.shift();
+				item.onSend?.();
+				this.dispatchCall(item.procedure, item.input).then(item.resolve, item.reject);
+				this.throttleCounter++;
+			}
+			if (this.queuedCalls.length === 0) {
+				this.throttling = false;
+				this.throttleCounter = 0;
+				return;
+			}
+		}
+	}
+	/**
+	* Issue the call against an established connection. Caller must ensure
+	* `isReady()` before invoking.
+	*/
+	dispatchCall(procedure, input) {
+		const id = this.generateRequestId();
+		return new Promise((resolve, reject) => {
+			this.pendingRequests.set(id, {
+				resolve,
+				reject
+			});
+			this.send({
+				type: "call",
+				id,
+				procedure,
+				input
+			});
+		});
+	}
+	/**
+	* Flush queued calls in FIFO order. Called once `isReady()` becomes
+	* true. With the throttle enabled, dispatch the first batch
+	* synchronously then hand off to the drain loop so a large
+	* post-reconnect flush respects backpressure instead of dumping 10k
+	* frames in one tick.
+	*/
+	flushQueuedCalls() {
+		if (this.queuedCalls.length === 0) return;
+		if (this.throttleEveryN <= 0) {
+			const queue = this.queuedCalls;
+			this.queuedCalls = [];
+			for (const item of queue) {
+				item.onSend?.();
+				this.dispatchCall(item.procedure, item.input).then(item.resolve, item.reject);
+			}
+			return;
+		}
+		this.throttleCounter = 0;
+		while (this.throttleCounter < this.throttleEveryN && this.queuedCalls.length > 0) {
+			const item = this.queuedCalls.shift();
+			item.onSend?.();
+			this.dispatchCall(item.procedure, item.input).then(item.resolve, item.reject);
+			this.throttleCounter++;
+		}
+		if (this.queuedCalls.length > 0) {
+			this.throttling = true;
+			this.runThrottleLoop();
+		}
+	}
+	/**
+	* Re-send `subscribe` for every existing subscription. The subId for each
+	* may legitimately change (e.g. `queryIdentity` was a function of user
+	* identity and the user changed during the disconnect), so we re-key the
+	* unified `subscriptions` Map: snapshot every record, drop them from the
+	* Map, then reinsert under a fresh `_pending:<reqId>` key. Each pending
+	* request's `resolve` rekeys the parked record under the new server-issued
+	* subId so subsequent `sub:update` frames route to the existing
+	* `onUpdate` callback (which the React handle is still holding).
+	*/
+	resubscribeAll() {
+		if (this.subscriptions.size === 0) return;
+		const subs = Array.from(this.subscriptions.values());
+		this.subscriptions.clear();
+		for (const sub of subs) {
+			const id = this.generateRequestId();
+			const pendingKey = `_pending:${id}`;
+			sub.subId = null;
+			this.subscriptions.set(pendingKey, sub);
+			this.pendingRequests.set(id, {
+				subscribeResolve: (subId) => {
+					const parked = this.subscriptions.get(pendingKey);
+					if (!subId || !parked) {
+						this.subscriptions.delete(pendingKey);
+						this.rejectJoiners(parked, new RPCError("Subscribe response missing subId after replay", "PROTOCOL_ERROR"));
+						return;
+					}
+					parked.subId = subId;
+					this.subscriptions.delete(pendingKey);
+					this.subscriptions.set(subId, parked);
+					this.resolveJoiners(parked, subId);
+				},
+				reject: (err) => {
+					if (!(err instanceof RPCError) || err.code !== "DISCONNECTED") {
+						const parked = this.subscriptions.get(pendingKey);
+						this.subscriptions.delete(pendingKey);
+						this.rejectJoiners(parked, err);
+					}
+					console.error(`[WSClient] Failed to re-subscribe ${sub.procedure}:`, err);
+				}
+			});
+			this.send({
+				type: "subscribe",
+				id,
+				procedure: sub.procedure,
+				input: sub.input
+			});
+		}
+	}
+	/**
+	* Subscribe to a live query.
+	*
+	* The client does not compute the subId locally — it sends the
+	* (procedure, input) pair and receives the canonical subId on the
+	* subscribe response. This lets the server's per-procedure
+	* `queryIdentity` override be authoritative without forcing the client
+	* to mirror any of the resolution logic.
+	*
+	* Returns the server-assigned subId and an unsubscribe function.
+	*/
+	async subscribe(procedure, input, serializedInput, onUpdate, onGone) {
+		await this.ensureConnected();
+		const localKey = await computeLocalSubKey(procedure, serializedInput);
+		const existing = this.findSubByLocalKey(localKey);
+		if (existing) {
+			existing.onUpdate = onUpdate;
+			existing.onGone = onGone;
+			if (existing.subId) return {
+				subId: existing.subId,
+				unsubscribe: () => this.unsubscribeByLocalKey(localKey, existing.subId)
+			};
+			return new Promise((resolve, reject) => {
+				const joinerTimeout = setTimeout(() => {
+					existing.pendingJoiners?.delete(joiner);
+					reject(new RPCError(`Subscribe timeout: ${procedure}`, "TIMEOUT"));
+				}, 3e4);
+				const joiner = {
+					resolve: (subId) => {
+						clearTimeout(joinerTimeout);
+						existing.pendingJoiners?.delete(joiner);
+						resolve({
+							subId,
+							unsubscribe: () => this.unsubscribeByLocalKey(localKey, subId)
+						});
+					},
+					reject: (err) => {
+						clearTimeout(joinerTimeout);
+						existing.pendingJoiners?.delete(joiner);
+						reject(err);
+					}
+				};
+				(existing.pendingJoiners ??= /* @__PURE__ */ new Set()).add(joiner);
+			});
+		}
+		const id = this.generateRequestId();
+		const pendingKey = `_pending:${id}`;
+		const record = {
+			subId: null,
+			localKey,
+			procedure,
+			input,
+			onUpdate,
+			onGone
+		};
+		this.subscriptions.set(pendingKey, record);
+		let timeout = null;
+		return new Promise((resolve, reject) => {
+			this.pendingRequests.set(id, {
+				subscribeResolve: (subId) => {
+					if (timeout) {
+						clearTimeout(timeout);
+						timeout = null;
+					}
+					const sub = this.subscriptions.get(pendingKey);
+					if (!subId || !sub) {
+						this.subscriptions.delete(pendingKey);
+						const err = new RPCError("Subscribe response missing subId", "PROTOCOL_ERROR");
+						this.rejectJoiners(sub, err);
+						reject(err);
+						return;
+					}
+					sub.subId = subId;
+					this.subscriptions.delete(pendingKey);
+					this.subscriptions.set(subId, sub);
+					resolve({
+						subId,
+						unsubscribe: () => this.unsubscribeByLocalKey(localKey, subId)
+					});
+					this.resolveJoiners(sub, subId);
+				},
+				reject: (err) => {
+					if (timeout) {
+						clearTimeout(timeout);
+						timeout = null;
+					}
+					if (!(err instanceof RPCError) || err.code !== "DISCONNECTED") {
+						const sub = this.subscriptions.get(pendingKey);
+						this.subscriptions.delete(pendingKey);
+						this.rejectJoiners(sub, err);
+					}
+					reject(err);
+				}
+			});
+			this.send({
+				type: "subscribe",
+				id,
+				procedure,
+				input
+			});
+			timeout = setTimeout(() => {
+				if (this.pendingRequests.has(id)) {
+					this.pendingRequests.delete(id);
+					const sub = this.subscriptions.get(pendingKey);
+					this.subscriptions.delete(pendingKey);
+					const err = new RPCError(`Subscribe timeout: ${procedure}`, "TIMEOUT");
+					this.rejectJoiners(sub, err);
+					reject(err);
+				}
+			}, 3e4);
+		});
+	}
+	findSubByLocalKey(localKey) {
+		for (const sub of this.subscriptions.values()) if (sub.localKey === localKey) return sub;
+	}
+	/** Resolve every joiner waiting on this Subscription with the canonical subId. */
+	resolveJoiners(sub, subId) {
+		if (!sub.pendingJoiners) return;
+		const snapshot = Array.from(sub.pendingJoiners);
+		for (const j of snapshot) j.resolve(subId);
+	}
+	/** Reject every joiner waiting on this Subscription with the given error. */
+	rejectJoiners(sub, err) {
+		if (!sub?.pendingJoiners) return;
+		const snapshot = Array.from(sub.pendingJoiners);
+		for (const j of snapshot) j.reject(err);
+	}
+	unsubscribeByLocalKey(localKey, subId) {
+		const sendUnsubscribe = (subId) => {
+			if (this.connectionState === "connected") this.send({
+				type: "unsubscribe",
+				subId
+			});
+		};
+		if (subId) {
+			this.subscriptions.delete(subId);
+			sendUnsubscribe(subId);
+			return;
+		}
+		for (const [key, sub] of this.subscriptions.entries()) {
+			if (sub.localKey !== localKey) continue;
+			this.subscriptions.delete(key);
+			this.rejectJoiners(sub, new RPCError("Subscription cancelled before response", "CANCELLED"));
+			sendUnsubscribe(sub.subId);
+			return;
+		}
+	}
+	async handleMessage(dataValue) {
+		this.lastServerMessageAt = Date.now();
+		let data = void 0;
+		try {
+			data = JSON.parse(dataValue);
+		} catch {
+			console.error("[WSClient] Failed to parse server message as JSON:", dataValue);
+		}
+		const parsed = ServerMessageSchema.safeParse(data);
+		if (!parsed.success) {
+			console.error("[WSClient] Invalid server message:", parsed.error.issues, data);
+			return;
+		}
+		const message = parsed.data;
+		switch (message.type) {
+			case "connected": {
+				this.connectionState = "connected";
+				this.reconnectAttempts = 0;
+				this.lastSuccessfulConnectionTime = Date.now();
+				const token = await this.options.token?.();
+				if (token) {
+					this.authState = "pending";
+					this.emitState();
+					this.send({
+						type: "auth",
+						data: { token }
+					});
+				} else {
+					this.authState = "anonymouse";
+					this.options.onConnect?.();
+					this.emitState();
+					this.afterReady();
+					this.pendingConnectResolve?.();
+				}
+				break;
+			}
+			case "auth:success":
+				this.authState = "authenticated";
+				this.authUserId = message.userId;
+				this.options.onConnect?.();
+				this.emitState();
+				this.afterReady();
+				this.pendingConnectResolve?.();
+				break;
+			case "auth:failed":
+				this.authState = "unauthenticated";
+				this.authUserId = null;
+				this.options.onConnect?.();
+				this.emitState();
+				this.afterReady();
+				this.pendingConnectResolve?.();
+				break;
+			case "response":
+				this.handleResponse(message);
+				break;
+			case "sub:update":
+				this.handleSubscriptionUpdate(message);
+				break;
+			case "sub:gone":
+				this.handleSubscriptionGone(message);
+				break;
+			case "ping": break;
+			default: console.warn("[WSClient] Unhandled server message type:", message);
+		}
+	}
+	/**
+	* Called once the client transitions to a "ready" state on a fresh
+	* connection. Replays live-query subscriptions and flushes any queued
+	* calls in FIFO order.
+	*/
+	afterReady() {
+		this.resubscribeAll();
+		this.flushQueuedCalls();
+	}
+	handleResponse(message) {
+		const pending = this.pendingRequests.get(message.id);
+		if (!pending) return;
+		this.pendingRequests.delete(message.id);
+		if (message.success) if (pending.subscribeResolve) pending.subscribeResolve(message.subId);
+		else pending.resolve?.(message.data);
+		else pending.reject(new RPCError(message.error ?? "Unknown error", message.code));
+	}
+	handleSubscriptionUpdate(message) {
+		const sub = this.subscriptions.get(message.subId);
+		if (sub) sub.onUpdate(message.data);
+	}
+	/**
+	* Handles a `sub:gone` message: the server no longer tracks this
+	* subscription (e.g. it was fully unregistered while we were disconnected
+	* from the sub-manager). Notify the handle and drop the local entry so a
+	* re-subscribe is required to receive further updates.
+	*/
+	handleSubscriptionGone(message) {
+		const sub = this.subscriptions.get(message.subId);
+		if (!sub) return;
+		this.subscriptions.delete(message.subId);
+		try {
+			sub.onGone?.(message.reason);
+		} catch (e) {
+			console.error("[WSClient] onGone listener threw:", e);
+		}
+	}
+	handleClose() {
+		if (this.connectionState === "disconnected") return;
+		this.connectionState = "disconnected";
+		this.authState = "pending";
+		this.ws = null;
+		this.stopInactivityWatchdog();
+		this.options.onDisconnect?.();
+		this.pendingConnectReject?.(new RPCError("Connection closed before ready", "DISCONNECTED"));
+		for (const pending of this.pendingRequests.values()) pending.reject(new RPCError("Connection closed", "DISCONNECTED"));
+		this.pendingRequests.clear();
+		this.emitState();
+		if (!this.explicitlyClosed && this.options.reconnect?.enabled) this.scheduleReconnect();
+	}
+	handleError(err) {
+		this.options.onError?.(err);
+	}
+	startInactivityWatchdog() {
+		this.stopInactivityWatchdog();
+		this.lastServerMessageAt = Date.now();
+		const tickMs = Math.max(1e3, Math.floor(this.serverInactivityMs / 4));
+		this.inactivityTimer = setInterval(() => {
+			if (Date.now() - this.lastServerMessageAt > this.serverInactivityMs) this.closeAndReconnect("InactiveServer");
+		}, tickMs);
+	}
+	stopInactivityWatchdog() {
+		if (this.inactivityTimer) {
+			clearInterval(this.inactivityTimer);
+			this.inactivityTimer = null;
+		}
+	}
+	/**
+	* Close the current WebSocket and schedule a reconnect via `handleClose`.
+	*
+	* Atomically swaps the old socket's event handlers to no-ops BEFORE
+	* `close()` so a frame in flight at the moment of close cannot fire
+	* `handleMessage` into a half-cleaned state — that was the source of
+	* the "browser says socket is alive but client says disconnected" race.
+	*/
+	closeAndReconnect(reason) {
+		if (this.connectionState === "disconnected") return;
+		console.warn(`[WSClient] closeAndReconnect: ${reason}`);
+		const oldWs = this.ws;
+		if (oldWs) {
+			oldWs.onmessage = null;
+			oldWs.onerror = null;
+			oldWs.onopen = null;
+			oldWs.onclose = null;
+			try {
+				oldWs.close(4e3, reason);
+			} catch {}
+		}
+		this.handleClose();
+	}
+	installEnvironmentListeners() {
+		if (typeof document !== "undefined" && typeof document.addEventListener === "function" && !this.visibilityListener) {
+			this.visibilityListener = () => {
+				if (typeof document === "undefined") return;
+				if (document.visibilityState !== "visible") return;
+				if (this.connectionState !== "connected") return;
+				if (Date.now() - this.lastServerMessageAt > this.serverInactivityMs) this.closeAndReconnect("WokeUpStale");
+			};
+			document.addEventListener("visibilitychange", this.visibilityListener);
+		}
+		if (typeof window !== "undefined" && typeof window.addEventListener === "function" && !this.onlineListener) {
+			this.onlineListener = () => {
+				if (this.connectionState !== "disconnected") return;
+				if (this.explicitlyClosed) return;
+				if (this.reconnectTimer) {
+					clearTimeout(this.reconnectTimer);
+					this.reconnectTimer = null;
+				}
+				this.connect().catch(() => {});
+			};
+			window.addEventListener("online", this.onlineListener);
+		}
+	}
+	removeEnvironmentListeners() {
+		if (this.visibilityListener && typeof document !== "undefined") {
+			document.removeEventListener("visibilitychange", this.visibilityListener);
+			this.visibilityListener = null;
+		}
+		if (this.onlineListener && typeof window !== "undefined") {
+			window.removeEventListener("online", this.onlineListener);
+			this.onlineListener = null;
+		}
+	}
+	scheduleReconnect() {
+		if (this.reconnectAttempts >= (this.options.reconnect?.maxAttempts ?? 5)) {
+			console.error("[WSClient] Max reconnection attempts reached");
+			const giveUp = new RPCError("Max reconnection attempts reached", "DISCONNECTED");
+			for (const q of this.queuedCalls) q.reject(giveUp);
+			this.queuedCalls = [];
+			this.pendingConnectReject?.(giveUp);
+			return;
+		}
+		const base = (this.options.reconnect?.delay ?? 1e3) * Math.pow(this.options.reconnect?.backoff ?? 1.5, this.reconnectAttempts);
+		const delay = base + base * (Math.random() - .5);
+		this.reconnectAttempts++;
+		this.reconnectTimer = setTimeout(() => {
+			this.connect().catch((err) => {
+				console.error("[WSClient] Reconnection failed:", err);
+			});
+		}, delay);
+	}
+	computePublicState() {
+		if (this.connectionState === "disconnected") return "disconnected";
+		if (this.connectionState === "connecting") return "connecting";
+		if (this.authState === "pending") return "authenticating";
+		return "ready";
+	}
+	emitState() {
+		const next = this.computePublicState();
+		if (next === this.lastPublicState) return;
+		this.lastPublicState = next;
+		for (const l of this.stateListeners) try {
+			l(next);
+		} catch (e) {
+			console.error("[WSClient] state listener threw:", e);
+		}
+	}
+	async ensureConnected() {
+		if (this.connectionState != "connected") await this.connect();
+	}
+	send(message) {
+		if (this.ws && this.ws.readyState === WS_OPEN) this.ws.send(supaliveStringify(message));
+	}
+	cleanup() {
+		this.connectionState = "disconnected";
+		this.authState = "pending";
+		this.stopInactivityWatchdog();
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+		const teardown = new RPCError("Client disconnected", "DISCONNECTED");
+		for (const pending of this.pendingRequests.values()) pending.reject(teardown);
+		this.pendingRequests.clear();
+		for (const q of this.queuedCalls) q.reject(teardown);
+		this.queuedCalls = [];
+		this.throttling = false;
+		this.throttleCounter = 0;
+		this.pendingConnectReject?.(teardown);
+	}
+	generateRequestId() {
+		return `${++this.requestId}`;
+	}
+};
+let WebSocketImpl = null;
+if (typeof globalThis !== "undefined" && globalThis.WebSocket) WebSocketImpl = globalThis.WebSocket;
+async function getWebSocket() {
+	if (WebSocketImpl) return WebSocketImpl;
+	return (await import("ws")).WebSocket;
+}
+//#endregion
+//#region src/client/client.ts
+/**
+* Create a fully typed RPC client with WebSocket transport.
+*/
+function createClient(options) {
+	const wsClient = new WsClientManager({
+		url: options.url,
+		token: options.token,
+		reconnectionTimeout: options.reconnectionTimeout,
+		reconnect: options.reconnect,
+		heartbeat: options.heartbeat,
+		throttle: options.throttle,
+		onConnect: options.onConnect,
+		onDisconnect: options.onDisConnect
+	});
+	const liveQueryHandles = /* @__PURE__ */ new Map();
+	function liveQueryDedupKey(procedure, input) {
+		return `${procedure}::${input}`;
+	}
+	const cache = /* @__PURE__ */ new Map();
+	return new Proxy({}, { get(_target, procedureName) {
+		if (typeof procedureName !== "string") return;
+		switch (procedureName) {
+			case "connect": return () => wsClient.connect();
+			case "disconnect": return () => wsClient.disconnect();
+			case "isReady": return () => wsClient.isReady();
+			case "isAuthenticated": return () => wsClient.isAuthenticated();
+			case "isAnonymouse": return () => wsClient.isAnonymouse();
+			case "getAuthUserId": return () => wsClient.getAuthUserId();
+			case "onState": return (listener) => wsClient.onState(listener);
+			case "getPublicState": return () => wsClient.getPublicState();
+		}
+		const cachedProp = cache.get(procedureName);
+		if (cachedProp) return cachedProp;
+		const newProp = {
+			query: async (input) => {
+				return wsClient.call(procedureName, input);
+			},
+			mutate: async (input, opts) => {
+				return wsClient.call(procedureName, input, opts);
+			},
+			action: async (input, opts) => {
+				return wsClient.call(procedureName, input, opts);
+			},
+			liveQuery: (input, serializedInput) => {
+				const dedupKey = liveQueryDedupKey(procedureName, serializedInput);
+				const existing = liveQueryHandles.get(dedupKey);
+				if (existing) return existing;
+				const handle = new LiveQueryHandleImpl(wsClient, procedureName, input, serializedInput, () => liveQueryHandles.delete(dedupKey));
+				liveQueryHandles.set(dedupKey, handle);
+				return handle;
+			}
+		};
+		cache.set(procedureName, newProp);
+		return newProp;
+	} });
+}
+/**
+* Sync external store for one (procedure, input) live query.
+*
+* - Constructor returns immediately; the wasm-hashed server subId is computed
+*   in `kickoffSubscribe()` so callers don't have to await.
+* - `onState` / `onData` ref-count their listeners; the last to leave starts
+*   a 3 s grace timer before unsubscribing on the wire (so transient mounts
+*   in StrictMode don't churn server-side state).
+* - Listens to `wsClient.onState`: any drop flips status to "stale", and the
+*   manager's own `resubscribeAll()` brings us back without our help.
+* - On `sub:gone`, transitions to "error" and auto-retries on next ready.
+*/
+var LiveQueryHandleImpl = class {
+	wsClient;
+	procedure;
+	input;
+	serializedInput;
+	onDispose;
+	state = {
+		data: void 0,
+		status: "connecting",
+		error: null
+	};
+	stateListeners = /* @__PURE__ */ new Set();
+	dataListeners = /* @__PURE__ */ new Set();
+	unsubscribeServer = null;
+	graceTimer = null;
+	subId = null;
+	wsStateOff = null;
+	/** Set once the disposer has fired (after the last unsubscribe). */
+	disposed = false;
+	/**
+	* rAF coalesce buffer for incoming `sub:update` payloads. Bursty
+	* mutations (e.g. 2000 spam transfers) can fire `sub:update` faster than
+	* the screen can repaint; collapsing to one commit per animation frame
+	* caps live-query re-renders at vsync without skipping the latest state.
+	* Tab in a background window naturally throttles down to ~1Hz via the
+	* browser's own rAF policy.
+	*/
+	pendingData = null;
+	rafHandle = null;
+	constructor(wsClient, procedure, input, serializedInput, onDispose) {
+		this.wsClient = wsClient;
+		this.procedure = procedure;
+		this.input = input;
+		this.serializedInput = serializedInput;
+		this.onDispose = onDispose;
+		this.wsStateOff = wsClient.onState((next) => {
+			if (next === "ready" && this.state.status === "stale") {} else if (this.state.status === "success" && (next === "disconnected" || next === "connecting" || next === "authenticating")) this.setState({ status: "stale" });
+		});
+		this.kickoffSubscribe();
+	}
+	get() {
+		return this.state.data;
+	}
+	getState = () => this.state;
+	onState = (listener) => {
+		this.stateListeners.add(listener);
+		this.cancelGrace();
+		return () => {
+			this.stateListeners.delete(listener);
+			this.scheduleGraceUnsubscribe();
+		};
+	};
+	onData(callback) {
+		this.dataListeners.add(callback);
+		this.cancelGrace();
+		if (this.state.data !== void 0) callback(this.state.data);
+		return () => {
+			this.dataListeners.delete(callback);
+			this.scheduleGraceUnsubscribe();
+		};
+	}
+	refetch() {
+		if (this.disposed) return;
+		this.setState({
+			status: "loading",
+			error: null
+		});
+		this.kickoffSubscribe();
+	}
+	unsubscribe() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.cancelGrace();
+		if (this.rafHandle !== null && this.rafHandle !== -1 && typeof cancelAnimationFrame === "function") cancelAnimationFrame(this.rafHandle);
+		this.rafHandle = null;
+		this.pendingData = null;
+		if (this.unsubscribeServer) {
+			try {
+				this.unsubscribeServer();
+			} catch (e) {
+				console.error("[LiveQuery] unsubscribe threw:", e);
+			}
+			this.unsubscribeServer = null;
+		}
+		if (this.wsStateOff) {
+			this.wsStateOff();
+			this.wsStateOff = null;
+		}
+		this.stateListeners.clear();
+		this.dataListeners.clear();
+		this.onDispose();
+	}
+	async kickoffSubscribe() {
+		try {
+			const { subId, unsubscribe } = await this.wsClient.subscribe(this.procedure, this.input, this.serializedInput, (data) => this.handleData(data), (reason) => this.handleGone(reason));
+			if (this.disposed) {
+				try {
+					unsubscribe();
+				} catch {}
+				return;
+			}
+			this.subId = subId;
+			this.unsubscribeServer = unsubscribe;
+		} catch (err) {
+			if (this.disposed) return;
+			const e = err instanceof Error ? err : new Error(String(err));
+			this.setState({
+				status: "error",
+				error: e
+			});
+		}
+	}
+	handleData(data) {
+		if (this.disposed) return;
+		this.pendingData = { value: data };
+		if (this.rafHandle !== null) return;
+		if (typeof requestAnimationFrame !== "function") {
+			this.rafHandle = -1;
+			queueMicrotask(() => {
+				this.rafHandle = null;
+				this.commitPendingData();
+			});
+			return;
+		}
+		this.rafHandle = requestAnimationFrame(() => {
+			this.rafHandle = null;
+			this.commitPendingData();
+		});
+	}
+	commitPendingData() {
+		if (this.disposed) return;
+		const pending = this.pendingData;
+		if (!pending) return;
+		this.pendingData = null;
+		this.setState({
+			data: pending.value,
+			status: "success",
+			error: null
+		});
+		for (const cb of this.dataListeners) try {
+			cb(pending.value);
+		} catch (e) {
+			console.error("[LiveQuery] data listener threw:", e);
+		}
+	}
+	handleGone(reason) {
+		if (this.disposed) return;
+		this.setState({
+			status: "error",
+			error: new RPCError(reason ?? "subscription gone", "SUB_GONE")
+		});
+		this.unsubscribeServer = null;
+		this.subId = null;
+		this.kickoffSubscribe();
+	}
+	setState(patch) {
+		const next = {
+			...this.state,
+			...patch
+		};
+		if (next.data === this.state.data && next.status === this.state.status && next.error === this.state.error) return;
+		this.state = next;
+		for (const l of this.stateListeners) try {
+			l();
+		} catch (e) {
+			console.error("[LiveQuery] state listener threw:", e);
+		}
+	}
+	cancelGrace() {
+		if (this.graceTimer) {
+			clearTimeout(this.graceTimer);
+			this.graceTimer = null;
+		}
+	}
+	scheduleGraceUnsubscribe() {
+		if (this.stateListeners.size > 0 || this.dataListeners.size > 0) return;
+		this.cancelGrace();
+		this.graceTimer = setTimeout(() => {
+			this.graceTimer = null;
+			if (this.stateListeners.size === 0 && this.dataListeners.size === 0) this.unsubscribe();
+		}, 3e3);
+	}
+};
+//#endregion
+//#region src/client/caller_client.ts
+/**
+* Create a server-side caller that bypasses HTTP/WebSocket.
+* 
+* For in-memory calls, input validation is skipped (data is already a JS object).
+* Query procedures also get a liveQuery() method for server-side use.
+*/
+function createCaller(options) {
+	const { isInternal = true, inContext } = options;
+	const registry = getContextRegistry(inContext ?? "default");
+	const cache = /* @__PURE__ */ new Map();
+	let db;
+	return new Proxy({}, { get(_target, procedureName) {
+		if (typeof procedureName !== "string") return;
+		if (procedureName == "init") return async (config) => {
+			db = config.db;
+		};
+		const procedure = registry.getProcedure(procedureName);
+		if (!procedure) throw new Error(`Procedure "${procedureName}" not found`);
+		if (registry.isInternalProcedure(procedureName) && !isInternal) throw new Error(`Procedure "${procedureName}" is internal only`);
+		const validateInput = (input) => {
+			if (typeof input !== "string") return input;
+			return procedure.inputSchema.parse(input);
+		};
+		const cachedProp = cache.get(procedureName);
+		if (cachedProp) return cachedProp;
+		const newProp = {
+			query: async (input, serverCtx) => {
+				if (procedure.type !== "query") throw new Error(`Procedure "${procedureName}" is not a query`);
+				const validatedInput = validateInput(input);
+				return db.query(async (dbCtx) => {
+					const ctx = {
+						db: dbCtx,
+						serverCtx
+					};
+					return procedure.fn(ctx, validatedInput);
+				});
+			},
+			mutate: async (input, serverCtx) => {
+				if (procedure.type !== "mutation") throw new Error(`Procedure "${procedureName}" is not a mutation`);
+				const validatedInput = validateInput(input);
+				return (await db.mutation(async (dbCtx) => {
+					const ctx = {
+						db: dbCtx,
+						serverCtx
+					};
+					return procedure.fn(ctx, validatedInput);
+				})).result;
+			},
+			action: async (input, serverCtx) => {
+				if (procedure.type !== "action") throw new Error(`Procedure "${procedureName}" is not an action`);
+				const validatedInput = validateInput(input);
+				const ctx = {
+					db,
+					serverCtx
+				};
+				return procedure.fn(ctx, validatedInput);
+			},
+			liveQuery: procedure.type === "query" ? async (input, serverCtx) => {
+				const validatedInput = validateInput(input);
+				return db.liveQuery(async (dbCtx) => {
+					const ctx = {
+						db: dbCtx,
+						serverCtx
+					};
+					return procedure.fn(ctx, validatedInput);
+				});
+			} : void 0
+		};
+		cache.set(procedureName, newProp);
+		return newProp;
+	} });
+}
+//#endregion
+export { AndPredicateSchema, BigIntSchema, CachedPgMetadataSchema, CompareOperatorSchema, DEFAULT_RETRY, DbReader, DbReader as ReadContext, DbWriter, DbWriter as WritableContext, LeafPredicateSchema, NO_RETRY, OccAbortError, OccConflictError, OrPredicateSchema, PointReadSchema, PredicateSchema, QueryCacheEntrySchema, QueryCacheMetadataSchema, RPCError, RangeReadSchema, RawPointReadSchema, RawRangeReadSchema, RawReadEntrySchema, ReadEntrySchema, SupaliveDb, TxContext, WriteEntrySchema, WriteOpSchema, WsClientManager, _resetGlobalDefs, bytesFromJson, createActionBuilder, createCaller, createClient, createMutationBuilder, createQueryBuilder, defineComputedField, defineQuery, defineSchema, matchesPredicate, normalizeIdToBytes, normalizeToBytes, router, sleep };
+
 //# sourceMappingURL=index.js.map