@supalive/core 0.1.4 → 0.1.5

package/dist/src/exports/server.js

@@ -1,3 +1,1347 @@
-export * from "../server/index";
-export { SubscriptionManager } from "../server/subscription-manager";
+import { n as getContextRegistry } from "../../router-DlTYWpop.js";
+import { n as stableStringify, r as supaliveStringify, t as groupByToMap } from "../../helper-zdJT5FUc.js";
+import { i as AuthenticationError, o as ClientMessageSchema } from "../../types_client_rpc-CIsjQQGG.js";
+import { n as RemoteSubscriptionMessageSchema } from "../../types_server-Dk6o_B7N.js";
+import { n as sleep } from "../../realtime_db-D9p2X2PH.js";
+import { C as UpdateSubscriptionReadSetParamsSchema, S as UnregisterSubscriptionsResultSchema, _ as RegisterSubscriptionParamsSchema, a as initCacheLayer, b as UnregisterSubscriptionResultSchema, c as appInstanceId, d as logger, f as serializeMapValue, g as RegisterSubscriptionBatchResultSchema, i as createDatabase, l as isProduction, m as InvalidateWritesetResultSchema, n as DB_QUERY_TIMEOUT_MS, o as initDatabase, p as InvalidateWritesetParamsSchema, r as bootstrapDbTypes, s as CacheLayer, u as logLevelOf, v as RegisterSubscriptionResultSchema, w as UpdateSubscriptionReadSetResultSchema, y as UnregisterSubscriptionParamsSchema } from "../../subscription-worker-BurdPO8d.js";
+import { createServer } from "http";
+import { WebSocket, WebSocketServer } from "ws";
+import { v4 } from "uuid";
+import { ExponentialBackoff, handleAll, retry } from "cockatiel";
+import { sha1 } from "hash-wasm";
+import { Client, Server } from "rpc-websockets";
+import { Worker } from "node:worker_threads";
+import { fileURLToPath } from "node:url";
+//#region src/server/sub_hash.ts
+/** Compute stable hash using json-stable-stringify and SHA1. */
+async function getHashOf(input) {
+	return sha1((typeof input === "string" ? input : stableStringify(input)) ?? "");
+}
+/**
+* Default identity literal used when neither a procedure-level
+* `queryIdentity` override nor a per-session user is available.
+*/
+const ANONYMOUS_IDENTITY = "anonymous";
+/**
+* Compute a subscription id from hash of procedure + input + queryIdentity.
+*
+* `queryIdentity` is the segmentation key for cache/subscriptions. By default
+* it is the authenticated user's id (so two users get distinct subscriptions
+* for the same query), but a procedure may override it to share cache/subs
+* across users (e.g. for a public, user-independent query).
+*/
+async function generateSubscriptionId(procedure, input, queryIdentity) {
+	return `sub_${await getHashOf(`${procedure}_${typeof input === "string" ? input : stableStringify(input)}_${queryIdentity}`)}`;
+}
+/**
+* Compute cache key from query name + args + queryIdentity. The identity
+* participates so that user-specific results don't poison each other's
+* cache when a procedure does authorize per-user.
+*/
+async function generateCacheKey(queryName, input, queryIdentity) {
+	return `ck_${await getHashOf(`${queryName}_${typeof input === "string" ? input : stableStringify(input)}_${queryIdentity}`)}`;
+}
+//#endregion
+//#region src/server/subscription-manager-client.ts
+const logger$3 = logger.child({ name: "SUBS_MGR_CLIENT" }, { level: logLevelOf("SUB_MANAGER_CLIENT_LOG_LEVEL") });
+const subscriptionManagerDataPack = {
+	encode: (data) => supaliveStringify(data),
+	decode: (data) => JSON.parse(data)
+};
+/**
+* RPC client for the (single) sub-manager process.
+*
+* Design (Convex-inspired):
+*   • The sub-manager is in-memory and ephemeral. There is no version
+*     protocol, no client-side registration registry, no OUT_OF_SYNC
+*     replay logic. All recovery is driven from the app server using
+*     state it already has (`serverSubscriptions`) plus registration
+*     records persisted to Redis at `sl:reg:<subId>`.
+*
+*   • Out-of-order `updateSubscriptionReadSet` calls are filtered server
+*     side using `lastSnapshotTs` (monotonic DB commit timestamp).
+*
+*   • On rpc-websockets reconnect, the client:
+*       1. Transitions to `busy` (any in-flight `invalidateWriteset`
+*          buffers its writeSet).
+*       2. Invokes the app server's `recoveryDriver` to re-register all
+*          known subs.
+*       3. Flushes the buffer as one batched `invalidateWriteset` RPC and
+*          hands the resulting `affected[]` to `affectedHandler`.
+*       4. Transitions to `ready`.
+*
+*   • During an extended outage, the buffer is bounded; if exceeded, it
+*     is dropped and we rely on the commit-log replay built into
+*     `SubscriptionWorker.register()` to catch each sub up on the next
+*     re-register.
+*/
+var SubManagerClient = class {
+	client;
+	state = "busy";
+	hasConnectedOnce = false;
+	/** Resolves whenever state transitions to 'ready'. Replaced on each busy→ready cycle. */
+	readyPromise;
+	resolveReady;
+	/** Writeset entries accumulated while state === 'busy'. Flushed as one RPC after recovery. */
+	bufferedWriteSets = [];
+	bufferLimit;
+	bufferDroppedDuringOutage = false;
+	recoveryDriver;
+	affectedHandler;
+	constructor(urlOrOptions) {
+		const opts = typeof urlOrOptions === "string" ? { url: urlOrOptions } : urlOrOptions;
+		this.bufferLimit = opts.invalidateBufferLimit ?? 5e4;
+		this.readyPromise = new Promise((r) => {
+			this.resolveReady = r;
+		});
+		this.client = new Client(opts.url, { dataPack: subscriptionManagerDataPack });
+		this.client.setAutoReconnect(true);
+		this.client.setMaxReconnects(0);
+		this.client.dataPack = subscriptionManagerDataPack;
+		this.client.on("open", this.handleOpen.bind(this));
+		this.client.on("close", this.handleClose.bind(this));
+		this.client.on("error", (err) => logger$3.warn(err, "sub-manager client socket error"));
+	}
+	/**
+	* Wire up the app-server-driven recovery. Must be called before any
+	* disconnect/reconnect cycle for buffered writeSets to be flushed and
+	* subscriptions re-registered.
+	*/
+	setRecoveryDriver(driver) {
+		this.recoveryDriver = driver;
+	}
+	/**
+	* Wire up the handler invoked when batched invalidate results land
+	* after recovery. The handler is expected to drive
+	* `reexecuteAffectedQuery` for each entry.
+	*/
+	setAffectedHandler(handler) {
+		this.affectedHandler = handler;
+	}
+	async registerSubscription(params) {
+		return this.call("registerSubscription", params, RegisterSubscriptionResultSchema);
+	}
+	async registerSubscriptionBatch(params) {
+		return this.call("registerSubscriptionBatch", params, RegisterSubscriptionBatchResultSchema);
+	}
+	async updateSubscriptionReadSet(params) {
+		return this.call("updateSubscriptionReadSet", params, UpdateSubscriptionReadSetResultSchema);
+	}
+	async unregisterSubscription(params) {
+		return this.call("unregisterSubscription", params, UnregisterSubscriptionResultSchema);
+	}
+	async unregisterSubscriptions(params) {
+		return this.call("unregisterSubscriptions", params, UnregisterSubscriptionsResultSchema);
+	}
+	/**
+	* Sends the writeSet to the sub-manager for invalidation, OR buffers it
+	* if the client is currently disconnected / recovering. Returns
+	* `{ affected: [] }` while buffering — the actual `affected` from the
+	* buffered batch is delivered via the registered `affectedHandler`
+	* after recovery completes.
+	*/
+	async invalidateWriteset(params) {
+		if (this.state === "busy") {
+			this.appendToBuffer(params.writeSet);
+			return { affected: [] };
+		}
+		return this.call("invalidateWriteset", params, InvalidateWritesetResultSchema);
+	}
+	/**
+	* Single point through which RPCs go. Throws on transport / server error.
+	* `registerSubscription`, `updateSubscriptionReadSet`, and
+	* `unregisterSubscription` are NOT gated on the ready state: during a
+	* disconnect they will fail at the socket layer, and during recovery
+	* (which itself uses these methods) gating would deadlock.
+	*/
+	async call(procName, params, resType) {
+		const result = await this.client.call(procName, params);
+		return resType.parse(result);
+	}
+	appendToBuffer(writeSet) {
+		if (this.bufferedWriteSets.length + writeSet.length > this.bufferLimit) {
+			if (!this.bufferDroppedDuringOutage) {
+				logger$3.warn(`Invalidate buffer would exceed ${this.bufferLimit}; dropping buffered entries. Subscriptions will be caught up via commit-log replay on re-register.`);
+				this.bufferDroppedDuringOutage = true;
+			}
+			this.bufferedWriteSets = [];
+			return;
+		}
+		this.bufferedWriteSets.push(...writeSet);
+	}
+	async flushBuffer() {
+		if (this.bufferedWriteSets.length === 0) return;
+		const writeSet = this.bufferedWriteSets;
+		this.bufferedWriteSets = [];
+		this.bufferDroppedDuringOutage = false;
+		try {
+			const result = await this.call("invalidateWriteset", { writeSet }, InvalidateWritesetResultSchema);
+			if (this.affectedHandler && result.affected.length > 0) await this.affectedHandler(result.affected);
+		} catch (err) {
+			logger$3.error(err, "Failed to flush invalidate buffer after recovery");
+		}
+	}
+	markBusy() {
+		if (this.state === "busy") return;
+		this.state = "busy";
+		this.readyPromise = new Promise((r) => {
+			this.resolveReady = r;
+		});
+	}
+	markReady() {
+		if (this.state === "ready") return;
+		this.state = "ready";
+		this.resolveReady();
+	}
+	handleClose() {
+		logger$3.info("sub-manager client: socket closed");
+		this.markBusy();
+	}
+	handleOpen() {
+		if (!this.hasConnectedOnce) {
+			this.hasConnectedOnce = true;
+			logger$3.info("sub-manager client: initial connect");
+			this.markReady();
+			return;
+		}
+		logger$3.info("sub-manager client: reconnected — starting recovery");
+		this.runRecovery();
+	}
+	async runRecovery() {
+		try {
+			if (this.recoveryDriver) await this.recoveryDriver();
+			else logger$3.warn("sub-manager client: no recoveryDriver configured — skipping recovery step");
+			await this.flushBuffer();
+		} catch (err) {
+			logger$3.error(err, "Recovery failed; state will be marked ready anyway");
+		} finally {
+			logger$3.info("sub-manager client: recovery complete");
+			this.markReady();
+		}
+	}
+	/**
+	* Test/inspection helpers.
+	*/
+	/** @internal */
+	isReady() {
+		return this.state === "ready";
+	}
+	/** @internal */
+	bufferSize() {
+		return this.bufferedWriteSets.length;
+	}
+};
+//#endregion
+//#region src/server/supalive-server.ts
+const redisRetryPolicy = retry(handleAll, {
+	maxAttempts: 3,
+	backoff: new ExponentialBackoff({
+		initialDelay: 100,
+		maxDelay: 5e3,
+		exponent: 2
+	})
+});
+/**
+* Global broadcast channel used to signal column-type cache invalidation
+* across every running server instance. Publishers (migration tooling,
+* the publishSchemaReload helper below) send a JSON message of shape
+* `{ type: "schema:reload"; tables?: string[]; originInstance?: string }`.
+* Subscribers re-bootstrap from PG (or Redis) so the next batched write
+* sees up-to-date column metadata without a process restart.
+*/
+const SCHEMA_RELOAD_CHANNEL = "supalive:schema:reload";
+/**
+* Per-socket cap on pending mutations. The Nth+1 mutation from a single
+* client gets rejected with TOO_MANY_CONCURRENT_MUTATIONS rather than
+* being enqueued — this is rate-limit pressure on a misbehaving client,
+* not a hard system limit.
+*
+* Mirrors Convex's OPERATION_QUEUE_BUFFER_SIZE (1000). Mutations drain
+* one-at-a-time per socket, so a healthy client never approaches this.
+*/
+const MAX_MUTATION_QUEUE_BUFFER = 1e3;
+/**
+* Per-socket cap on in-flight actions. Actions run in parallel (unlike
+* mutations) because they may do long external work (HTTP, queue calls);
+* the cap exists so one socket can't open thousands of outbound
+* connections from inside the server.
+*/
+const MAX_ACTION_CONCURRENCY = 1e3;
+const HEARTBEAT_INTERVAL_MS = Number(process.env.SUPALIVE_HEARTBEAT_INTERVAL_MS ?? 15e3);
+const CLIENT_TIMEOUT_MS = 12e4;
+/**
+* TTL on the Redis lock that elects the recompute winner when the writer
+* doesn't hold the sub locally. Each (subId, commitTs) gets its own lock
+* key, so this only needs to bound the worst-case recompute duration —
+* if the winner crashes mid-recompute, the lock expires and the next
+* mutation triggers a new race.
+*/
+const RECOMPUTE_LOCK_TTL_SECONDS = Number(process.env.SUPALIVE_RECOMPUTE_LOCK_TTL_SECONDS ?? 10);
+const logger$2 = logger.child({ "name": "SUPALIVE" }, { level: logLevelOf("SERVER_LOG_LEVEL") });
+/**
+* Supalive WebSocket Server
+*/
+var SupaliveWebSocketServer = class {
+	config;
+	instanceId;
+	httpServer;
+	wss;
+	cache;
+	redisSub;
+	db;
+	contextRegistry;
+	router;
+	sessions = /* @__PURE__ */ new Map();
+	serverSubscriptions = /* @__PURE__ */ new Map();
+	subManagerClient;
+	stats = {
+		activeConnections: 0,
+		totalConnections: 0,
+		activeSubscriptions: 0
+	};
+	constructor(config) {
+		this.config = {
+			port: 3e3,
+			host: "0.0.0.0",
+			contextName: "default",
+			sessionTtlSeconds: 3600,
+			...config
+		};
+		this.instanceId = appInstanceId;
+		if (!config.subManagerUrl) throw new Error("subManagerUrl config is required (WebSocket URL of the sub-manager process)");
+		this.subManagerClient = new SubManagerClient(config.subManagerUrl);
+		this.cache = config.cacheLayer;
+		this.redisSub = config.redisSubClient;
+		this.db = config.database;
+		this.subManagerClient.setRecoveryDriver(this.runSubManagerRecovery.bind(this));
+		this.subManagerClient.setAffectedHandler(this.runAffectedHandler.bind(this));
+		this.httpServer = createServer();
+		this.wss = new WebSocketServer({
+			server: this.httpServer,
+			autoPong: true,
+			maxPayload: 100 * 1024 * 1024
+		});
+		this.setupWebSocketHandlers();
+		this.subscribeToInstanceChannel();
+	}
+	/**
+	* Per-session heartbeat. Fires every `HEARTBEAT_INTERVAL_MS` and does
+	* both jobs on the same tick:
+	*
+	*   1. Inactivity check + ws-protocol ping (dead-TCP detection).
+	*   2. App-level `{type:"ping"}` if the channel has been idle for at
+	*      least one heartbeat interval (client-watchdog refresh).
+	*
+	* The `lastSentAt` gate on (2) preserves the original "only ping when
+	* idle" semantics: a session producing sub:updates faster than the
+	* heartbeat interval never emits a redundant app-ping.
+	*/
+	startSessionHeartbeat(session) {
+		session.heartbeatTimer = setInterval(() => {
+			if (Date.now() - session.lastReceivedAt > CLIENT_TIMEOUT_MS) {
+				logger$2.info(`ws inactivity → terminate session ${session.id}`);
+				try {
+					session.ws.terminate();
+				} catch {}
+				return;
+			}
+			try {
+				session.ws.ping();
+			} catch {}
+			if (Date.now() - session.lastSentAt >= HEARTBEAT_INTERVAL_MS) this.sendMessage(session, { type: "ping" });
+		}, HEARTBEAT_INTERVAL_MS);
+	}
+	clearSessionTimers(session) {
+		if (session.heartbeatTimer) {
+			clearInterval(session.heartbeatTimer);
+			session.heartbeatTimer = null;
+		}
+	}
+	registerRouter(router) {
+		this.router = router;
+		this.contextRegistry = getContextRegistry(router.contextName);
+	}
+	async start() {
+		return new Promise((resolve) => {
+			this.httpServer.listen(this.config.port, this.config.host, () => {
+				logger$2.info(`Server: ${this.instanceId} listening on ${this.config.host}:${this.config.port}`);
+				resolve();
+			});
+		});
+	}
+	async stop() {
+		this.wss.close();
+		for (const [ws] of this.sessions) ws.close(1001, "Server shutting down");
+		this.httpServer.close();
+		logger$2.info("Server stopped");
+	}
+	getStats() {
+		return {
+			instanceId: this.instanceId,
+			activeConnections: this.stats.activeConnections,
+			totalConnections: this.stats.totalConnections,
+			activeSubscriptions: this.stats.activeSubscriptions
+		};
+	}
+	getInstanceId() {
+		return this.instanceId;
+	}
+	setupWebSocketHandlers() {
+		this.wss.on("connection", (ws, req) => {
+			this.handleConnection(ws, req).catch((err) => {
+				logger$2.error(err, "Connection handler error");
+			});
+		});
+	}
+	async handleConnection(ws, req) {
+		this.stats.totalConnections++;
+		this.stats.activeConnections++;
+		const session = {
+			id: v4(),
+			ws,
+			serverCtx: {},
+			subIds: /* @__PURE__ */ new Set(),
+			mutationQueue: [],
+			mutationInFlight: false,
+			actionInFlight: 0,
+			lastReceivedAt: Date.now(),
+			lastSentAt: Date.now(),
+			heartbeatTimer: null
+		};
+		logger$2.info(`New session: ${session.id}`);
+		this.sessions.set(ws, session);
+		this.sendMessage(session, {
+			type: "connected",
+			sessionId: session.id
+		});
+		ws.on("message", (data) => {
+			session.lastReceivedAt = Date.now();
+			this.handleMessage(session, data.toString()).catch((err) => {
+				logger$2.error(err, "Message handler error");
+			});
+		});
+		ws.on("ping", () => {
+			session.lastReceivedAt = Date.now();
+		});
+		ws.on("pong", () => {
+			session.lastReceivedAt = Date.now();
+		});
+		this.startSessionHeartbeat(session);
+		ws.on("close", (code) => {
+			logger$2.info(`Connection closed: ${session.id}, code: ${code}`);
+			this.clearSessionTimers(session);
+			this.handleDisconnect(session);
+			this.sessions.delete(ws);
+			this.stats.activeConnections--;
+		});
+		ws.on("error", (err) => {
+			logger$2.error(err, "Websocket error");
+		});
+	}
+	async handleMessage(session, message) {
+		try {
+			const rawMsg = JSON.parse(message);
+			const parseResult = ClientMessageSchema.safeParse(rawMsg);
+			if (!parseResult.success) {
+				this.sendError(session, "", "Invalid message format", "INVALID_MESSAGE");
+				return;
+			}
+			await this.processMessage(session, parseResult.data);
+		} catch (err) {
+			logger$2.error(err, "Message handling error");
+			this.sendError(session, "", "Parse error", "PARSE_ERROR");
+		}
+	}
+	async processMessage(session, msg) {
+		switch (msg.type) {
+			case "auth":
+				await this.handleAuth(session, msg.data);
+				break;
+			case "call":
+				await this.handleCall(session, msg.id, msg.procedure, msg.input);
+				break;
+			case "subscribe":
+				await this.handleSubscribe(session, msg.id, msg.procedure, msg.input);
+				break;
+			case "unsubscribe":
+				await this.handleUnsubscribe(session, msg.subId);
+				break;
+		}
+	}
+	async handleAuth(session, data) {
+		if (!this.config.verifyAuth || !data) {
+			this.sendMessage(session, {
+				type: "auth:success",
+				userId: "anonymous"
+			});
+			return;
+		}
+		try {
+			const authResult = await this.config.verifyAuth(data, session.id);
+			if (!authResult) {
+				this.sendMessage(session, {
+					type: "auth:failed",
+					message: "Invalid authentication"
+				});
+				return;
+			}
+			session.serverCtx = authResult;
+			this.sendMessage(session, {
+				type: "auth:success",
+				userId: authResult.user.userId
+			});
+		} catch (e) {
+			if (e instanceof AuthenticationError) this.sendMessage(session, {
+				type: "auth:failed",
+				message: "Invalid authentication: " + e.message,
+				extra: e.extra
+			});
+			else this.sendMessage(session, {
+				type: "auth:failed",
+				message: "Invalid authentication"
+			});
+		}
+	}
+	/**
+	* Park a mutation on this session's FIFO queue and resolve when it
+	* eventually drains. The drainer is fire-and-forget: it picks up any
+	* newly enqueued op as long as one drain loop is running on this
+	* session. Callers (handleCall) own the response/error for their own
+	* op via the returned promise.
+	*/
+	enqueueMutation(session, procedure, validatedInput) {
+		return new Promise((resolve, reject) => {
+			const pending = {
+				procedure,
+				validatedInput,
+				resolve,
+				reject
+			};
+			session.mutationQueue.push(pending);
+			this.drainMutationQueue(session).catch((err) => logger$2.error(err, "drainMutationQueue crashed"));
+		});
+	}
+	/**
+	* Drain the per-session mutation queue serially. Only one drain loop
+	* runs at a time per session — re-entrant calls bail immediately, the
+	* loop already in progress will pick up the new op before exiting.
+	*/
+	async drainMutationQueue(session) {
+		if (session.mutationInFlight) return;
+		session.mutationInFlight = true;
+		try {
+			while (session.mutationQueue.length > 0) {
+				const op = session.mutationQueue.shift();
+				try {
+					const fn = op.procedure.fn;
+					const result = await this.db.mutation(async (ctx) => {
+						return fn({
+							db: ctx,
+							serverCtx: session.serverCtx
+						}, op.validatedInput);
+					});
+					op.resolve(result);
+				} catch (err) {
+					op.reject(err);
+				}
+			}
+		} finally {
+			session.mutationInFlight = false;
+		}
+	}
+	async handleCall(session, id, procedureName, input) {
+		if (!this.router) {
+			this.sendError(session, id, "Router not registered", "SERVER_ERROR");
+			return;
+		}
+		const procedure = this.contextRegistry.getProcedure(procedureName);
+		if (!procedure) {
+			this.sendError(session, id, `Procedure "${procedureName}" not found`, "NOT_FOUND");
+			return;
+		}
+		try {
+			const validatedInput = procedure.inputSchema.parse(input);
+			if (procedure.type === "query") {
+				const result = await this.db.query(async (ctx) => {
+					const fn = procedure.fn;
+					return fn({
+						db: ctx,
+						serverCtx: session.serverCtx
+					}, validatedInput);
+				});
+				this.sendMessage(session, {
+					type: "response",
+					id,
+					success: true,
+					data: result
+				});
+			} else if (procedure.type === "mutation") {
+				if (session.mutationQueue.length >= MAX_MUTATION_QUEUE_BUFFER) {
+					this.sendError(session, id, `Too many concurrent mutations on this connection (max ${MAX_MUTATION_QUEUE_BUFFER})`, "TOO_MANY_CONCURRENT_MUTATIONS");
+					return;
+				}
+				const mutationResult = await this.enqueueMutation(session, procedure, validatedInput);
+				this.sendMessage(session, {
+					type: "response",
+					id,
+					success: true
+				});
+				await this.handleMutationCommit(mutationResult.writeSet, mutationResult.commitTs);
+			} else if (procedure.type === "action") {
+				if (session.actionInFlight >= MAX_ACTION_CONCURRENCY) {
+					this.sendError(session, id, `Too many concurrent actions on this connection (max ${MAX_ACTION_CONCURRENCY})`, "TOO_MANY_CONCURRENT_ACTIONS");
+					return;
+				}
+				session.actionInFlight++;
+				let result;
+				try {
+					const fn = procedure.fn;
+					result = await fn({
+						db: this.db,
+						serverCtx: session.serverCtx
+					}, validatedInput);
+				} finally {
+					session.actionInFlight--;
+				}
+				this.sendMessage(session, {
+					type: "response",
+					id,
+					success: true,
+					data: result
+				});
+			}
+		} catch (err) {
+			logger$2.error(err, `Error executing "${procedureName}"`);
+			this.sendError(session, id, err instanceof Error ? err.message : "Execution failed", "EXECUTION_ERROR");
+		}
+	}
+	async handleSubscribe(session, id, procedureName, input) {
+		if (!this.router) {
+			this.sendError(session, id, "Router not registered", "SERVER_ERROR");
+			return;
+		}
+		const procedure = this.contextRegistry.getProcedure(procedureName);
+		if (!procedure || procedure.type !== "query") {
+			this.sendError(session, id, `Procedure "${procedureName}" not found or not a query`, "NOT_FOUND");
+			return;
+		}
+		try {
+			const validatedInput = procedure.inputSchema.parse(input);
+			const queryIdentity = this.resolveQueryIdentity(procedure, session, validatedInput);
+			const inputJsonStable = stableStringify(validatedInput);
+			const subId = await generateSubscriptionId(procedureName, inputJsonStable, queryIdentity);
+			const cacheKey = await generateCacheKey(procedureName, inputJsonStable, queryIdentity);
+			const existingServerSub = this.serverSubscriptions.get(subId);
+			let data;
+			let dataHash;
+			let liveResult = null;
+			session.subIds.add(subId);
+			if (existingServerSub) {
+				existingServerSub.subscribedTimes += 1;
+				const cached = await this.cache.getQueryCacheFor(existingServerSub.cacheKey);
+				if (cached) data = cached.data;
+				else {
+					liveResult = await this.executeLiveQuery(procedureName, validatedInput, session.serverCtx);
+					data = liveResult.data;
+				}
+			} else {
+				const lastSnapshotTs = await this.db.impl.getLatestSnapshotTimestamp();
+				const subManagerResult = await this.subManagerClient.registerSubscription({
+					subId,
+					cacheKey,
+					queryName: procedureName,
+					args: validatedInput,
+					queryIdentity,
+					instanceName: this.instanceId,
+					lastSnapshotTs
+				});
+				const cached = await this.cache.getQueryCacheFor(subManagerResult.cacheKey);
+				if (cached && !subManagerResult.recompute) data = cached.data;
+				else {
+					liveResult = await this.executeLiveQuery(procedureName, validatedInput, session.serverCtx);
+					data = liveResult.data;
+				}
+				this.serverSubscriptions.set(subId, {
+					subId,
+					cacheKey,
+					subscribedTimes: 1
+				});
+				this.stats.activeSubscriptions++;
+			}
+			if (liveResult) {
+				const [updateResult] = await Promise.all([this.subManagerClient.updateSubscriptionReadSet({
+					cacheKey,
+					subId,
+					lastSnapshotTs: liveResult.ts,
+					readSet: liveResult.readSet,
+					instanceName: this.instanceId
+				}), this.cache.setQueryCacheFor(cacheKey, data)]);
+				if (!updateResult.tracked) logger$2.warn(`updateSubscriptionReadSet returned tracked:false immediately after register for ${subId} — possible sub-manager restart mid-subscribe`);
+			}
+			dataHash = await getHashOf(data);
+			this.sendMessage(session, {
+				type: "response",
+				id,
+				success: true,
+				subId
+			});
+			this.sendMessage(session, {
+				type: "sub:update",
+				subId,
+				data,
+				dataHash
+			});
+			logger$2.info(`Subscribed: ${subId} for session ${session.id}`);
+		} catch (err) {
+			logger$2.error(err, `Error subscribing to "${procedureName}"`);
+			this.sendMessage(session, {
+				type: "response",
+				id,
+				success: false
+			});
+			this.sendError(session, id, err instanceof Error ? err.message : "Subscribe failed", "SUBSCRIBE_ERROR");
+		}
+	}
+	async handleUnsubscribe(session, subId) {
+		const serverSub = this.serverSubscriptions.get(subId);
+		if (!serverSub) {
+			session.subIds.delete(subId);
+			return;
+		}
+		serverSub.subscribedTimes -= 1;
+		if (serverSub.subscribedTimes <= 0) {
+			session.subIds.delete(subId);
+			this.serverSubscriptions.delete(subId);
+			this.stats.activeSubscriptions--;
+			try {
+				await this.subManagerClient.unregisterSubscription({
+					subId,
+					instanceName: this.instanceId
+				});
+			} catch (err) {
+				logger$2.error(err, "Failed to unregister from sub-manager:");
+			}
+		}
+		logger$2.info(`Unsubscribed: ${subId} for session ${session.id}, remaining server subs: ${serverSub.subscribedTimes}`);
+	}
+	async handleDisconnect(session) {
+		logger$2.info(`Session disconnected: ${session.id}`);
+		let unregisterSubs = void 0;
+		for (const subId of session.subIds) {
+			const sub = this.serverSubscriptions.get(subId);
+			if (!sub) continue;
+			sub.subscribedTimes -= 1;
+			if (sub.subscribedTimes <= 0) {
+				if (!unregisterSubs) unregisterSubs = [];
+				unregisterSubs.push(sub);
+			}
+		}
+		if (!unregisterSubs || unregisterSubs.length === 0) return;
+		try {
+			await this.subManagerClient.unregisterSubscriptions(unregisterSubs.map((sub) => ({
+				subId: sub.subId,
+				instanceName: this.instanceId
+			})));
+		} catch (err) {
+			logger$2.error(err, "Failed to unregister from sub-manager:");
+		}
+		for (const sub of unregisterSubs) if (sub.subscribedTimes <= 0) {
+			this.serverSubscriptions.delete(sub.subId);
+			this.stats.activeSubscriptions--;
+		}
+		logger$2.info(`All Subscription sessions is disconnected: ${session.id}, subs: ${unregisterSubs.length}`);
+	}
+	/**
+	* Drives recovery on a sub-manager reconnect. Iterates this app server's
+	* `serverSubscriptions`, reads each subId's registration record from
+	* Redis (`sl:reg:<subId>`), and re-registers it with the sub-manager.
+	*
+	* • If the Redis record is missing, another app-server instance fully
+	*   unregistered the sub during our disconnect. We drop it locally and
+	*   send `sub:gone` to every session that was holding it.
+	* • If the sub-manager reports `recompute: true` (cache-metadata + commit
+	*   log replay detected staleness), we kick a reexec for that sub.
+	*
+	* Returns after all subs have been processed. Only then does the
+	* SubManagerClient flush its buffered invalidate writeSets.
+	*/
+	async runSubManagerRecovery() {
+		const snapshot = Array.from(this.serverSubscriptions.values());
+		if (snapshot.length === 0) {
+			logger$2.info("Sub-manager recovery: no subscriptions to restore");
+			return;
+		}
+		logger$2.info(`Sub-manager recovery: restoring ${snapshot.length} subscription(s)`);
+		const lastSnapshotTs = await this.db.impl.getLatestSnapshotTimestamp();
+		const subIds = snapshot.map((e) => e.subId);
+		const recordsMap = await this.cache.fetchRegistrationRecordsBatch(subIds);
+		const registerParams = [];
+		for (const entry of snapshot) {
+			const record = recordsMap.get(entry.subId) ?? null;
+			if (!record) {
+				this.dropSubscriptionLocally(entry.subId, "registration not found after recovery");
+				continue;
+			}
+			registerParams.push({
+				entry,
+				record
+			});
+		}
+		const recompute = [];
+		const BATCH_SIZE = 50;
+		for (let i = 0; i < registerParams.length; i += BATCH_SIZE) {
+			const batch = registerParams.slice(i, i + BATCH_SIZE);
+			const params = batch.map(({ entry, record }) => ({
+				subId: entry.subId,
+				cacheKey: entry.cacheKey,
+				queryName: record.queryName,
+				args: record.args,
+				queryIdentity: record.queryIdentity,
+				instanceName: this.instanceId,
+				lastSnapshotTs
+			}));
+			try {
+				const results = await this.subManagerClient.registerSubscriptionBatch(params);
+				for (let j = 0; j < batch.length; j++) {
+					const { entry, record } = batch[j];
+					if (results[j].recompute) recompute.push({
+						subId: entry.subId,
+						queryName: record.queryName,
+						args: record.args,
+						cacheKey: entry.cacheKey,
+						notifyInstances: []
+					});
+				}
+			} catch (err) {
+				logger$2.error(err, `Sub-manager recovery: failed to batch register ${i}-${i + batch.length}`);
+			}
+		}
+		await Promise.allSettled(recompute.map((a) => this.reexecuteAffectedQuery(a)));
+		logger$2.info(`Sub-manager recovery: done (${recompute.length} reexec'd)`);
+	}
+	async runAffectedHandler(affected) {
+		await Promise.allSettled(affected.map((a) => this.reexecuteAffectedQuery(a)));
+	}
+	/**
+	* Removes a subscription from this app server's state and notifies every
+	* session that was holding it. Used during recovery when the central
+	* registration record is gone, or after a `tracked: false` reply from the
+	* sub-manager that we can't reconcile.
+	*/
+	dropSubscriptionLocally(subId, reason) {
+		const serverSub = this.serverSubscriptions.get(subId);
+		let notified = 0;
+		if (serverSub) {
+			this.serverSubscriptions.delete(subId);
+			this.stats.activeSubscriptions = Math.max(0, this.stats.activeSubscriptions - 1);
+			for (const [, session] of this.sessions) if (session.subIds.has(subId)) {
+				notified++;
+				session.subIds.delete(subId);
+				this.sendMessage(session, {
+					type: "sub:gone",
+					subId,
+					reason
+				});
+			}
+		}
+		logger$2.warn(`Dropped subscription ${subId} locally (${reason}); notified ${notified} session(s)`);
+	}
+	async handleMutationCommit(writeSet, commitTs) {
+		if (writeSet.length === 0) return;
+		const tables = [...new Set(writeSet.map((w) => w.table))];
+		logger$2.debug(`Mutation committed for tables: [${tables.join(", ")}]`);
+		try {
+			const result = await this.subManagerClient.invalidateWriteset({ writeSet });
+			logger$2.debug({ affected: result }, "Sub-managers invalidation result");
+			if (result?.affected?.length > 0) await Promise.allSettled(result.affected.map((affected) => this.dispatchAffected(affected, commitTs)));
+		} catch (err) {
+			logger$2.error(err, "Failed to notify sub-managers");
+		}
+	}
+	/**
+	* Route an affected sub to whichever instance can actually run the
+	* recompute:
+	*   • If this instance has a local session for the sub, recompute here
+	*     (fast path) and broadcast the result to every other instance.
+	*   • Otherwise broadcast a `recompute-race` to every instance in
+	*     `notifyInstances`. Each receiver tries to acquire a Redis lock
+	*     keyed by (subId, commitTs); the winner recomputes and publishes
+	*     an `update` via the normal broadcast path, losers no-op.
+	*
+	* If `notifyInstances` is empty (the sub has no live holders), we drop
+	* the message — the next subscribe will recompute fresh state.
+	*/
+	async dispatchAffected(affected, commitTs) {
+		if (this.hasLocalSessionFor(affected.subId)) {
+			await this.reexecuteAffectedQuery(affected);
+			return;
+		}
+		if (affected.notifyInstances.length === 0) {
+			logger$2.debug(`dispatchAffected: no live instances hold ${affected.subId} — dropping`);
+			return;
+		}
+		await this.publishRecomputeRace(affected, commitTs);
+	}
+	hasLocalSessionFor(subId) {
+		for (const [, session] of this.sessions) if (session.subIds.has(subId)) return true;
+		return false;
+	}
+	async publishRecomputeRace(affected, commitTs) {
+		const payload = supaliveStringify({
+			type: "recompute-race",
+			subId: affected.subId,
+			cacheKey: affected.cacheKey,
+			queryName: affected.queryName,
+			args: affected.args,
+			notifyInstances: affected.notifyInstances,
+			commitTs: commitTs.toString(),
+			originInstance: this.instanceId
+		});
+		const publishPromises = affected.notifyInstances.map(async (instance) => {
+			if (instance === this.instanceId) return;
+			const channel = `sub:instance:${instance}`;
+			try {
+				await redisRetryPolicy.execute(() => this.cache.redis.publish(channel, payload));
+			} catch (err) {
+				logger$2.error(err, `Failed to publish recompute-race to ${channel} after many retries`);
+			}
+		});
+		await Promise.all(publishPromises);
+	}
+	async reexecuteAffectedQuery(affected) {
+		let foundSession = null;
+		for (const [, session] of this.sessions) if (session.subIds.has(affected.subId)) {
+			foundSession = session;
+			break;
+		}
+		if (!foundSession) {
+			logger$2.debug(`Session not found for subId: ${affected.subId}`);
+			return;
+		}
+		try {
+			const liveResult = await this.executeLiveQuery(affected.queryName, affected.args, foundSession.serverCtx);
+			const dataHash = await getHashOf(liveResult.data);
+			const [updateResult] = await Promise.all([this.subManagerClient.updateSubscriptionReadSet({
+				cacheKey: affected.cacheKey,
+				subId: affected.subId,
+				lastSnapshotTs: liveResult.ts,
+				readSet: liveResult.readSet,
+				instanceName: this.instanceId
+			}), this.cache.setQueryCacheFor(affected.cacheKey, liveResult.data)]);
+			if (!updateResult.tracked) {
+				this.dropSubscriptionLocally(affected.subId, "no longer tracked by sub-manager");
+				return;
+			}
+			for (const [, session] of this.sessions) if (session.subIds.has(affected.subId)) this.sendMessage(session, {
+				type: "sub:update",
+				subId: affected.subId,
+				data: liveResult.data,
+				dataHash
+			});
+			if (affected.notifyInstances.length > 0) await this.publishSubscriptionUpdate(affected.subId, liveResult.data, dataHash, affected.notifyInstances);
+			logger$2.debug(`Re-executed affected query for subId: ${affected.subId}`);
+		} catch (err) {
+			logger$2.error(err, `Failed to re-execute query for subId ${affected.subId}`);
+		}
+	}
+	async executeLiveQuery(procedureName, input, serverCtx) {
+		const procedure = this.contextRegistry.getProcedure(procedureName);
+		if (!procedure || procedure.type !== "query") throw new Error(`Procedure not defined: ${procedureName}`);
+		return this.db.liveQuery(async (ctx) => {
+			const fn = procedure.fn;
+			return fn({
+				db: ctx,
+				serverCtx
+			}, input);
+		});
+	}
+	/**
+	* Resolve the segmentation key used in the subId/cacheKey hash for a
+	* query subscription. Priority:
+	*
+	*   1. Procedure-level `queryIdentity` override:
+	*        - `false`       → identity = `ANONYMOUS_IDENTITY` (cache shared across users)
+	*        - `string`      → that literal
+	*        - `function`    → ctx + input → string | null | undefined
+	*   2. `config.getUserId(serverCtx)` → falls back to ANONYMOUS_IDENTITY if it
+	*      returns null/undefined or isn't configured.
+	*/
+	resolveQueryIdentity(procedure, session, input) {
+		const override = procedure.queryIdentity;
+		if (override !== void 0) {
+			if (override === false) return ANONYMOUS_IDENTITY;
+			if (typeof override === "string") return override;
+			if (typeof override === "function") {
+				const value = override(session.serverCtx, input);
+				if (value === null || value === void 0) return ANONYMOUS_IDENTITY;
+				return value;
+			}
+		}
+		if (!this.config.getUserId) return ANONYMOUS_IDENTITY;
+		return this.config.getUserId(session.serverCtx) ?? "anonymous";
+	}
+	sendMessage(session, message) {
+		if (session.ws.readyState !== WebSocket.OPEN) return;
+		session.ws.send(supaliveStringify(message));
+		session.lastSentAt = Date.now();
+	}
+	sendMessageRaw(session, message) {
+		if (session.ws.readyState === WebSocket.OPEN) session.ws.send(message);
+	}
+	sendError(session, id, error, code) {
+		this.sendMessage(session, {
+			type: "response",
+			id,
+			success: false,
+			error,
+			code
+		});
+	}
+	async subscribeToInstanceChannel() {
+		const instanceChannel = `sub:instance:${this.instanceId}`;
+		const schemaChannel = SCHEMA_RELOAD_CHANNEL;
+		await this.redisSub.subscribe(instanceChannel, schemaChannel);
+		this.redisSub.on("connect", () => {
+			logger$2.info(`Subscribed to Redis channels: ${instanceChannel}, ${schemaChannel}`);
+		});
+		this.redisSub.on("message", (channel, message) => {
+			if (channel === instanceChannel) this.handleRemoteInstanceMessage(message).catch((err) => {
+				logger$2.error(err, "Error handling remote instance message");
+			});
+			else if (channel === schemaChannel) this.handleSchemaReload().catch((err) => {
+				logger$2.error(err, "Error handling schema reload");
+			});
+		});
+		this.redisSub.on("error", (err) => {
+			logger$2.error(err, `Subscriber error for channels: ${instanceChannel}, ${schemaChannel}`);
+		});
+	}
+	/**
+	* React to a `schema:reload` broadcast: invalidate the in-memory column
+	* type cache for the named tables (or all if omitted) and re-bootstrap
+	* from Postgres so subsequent batched writes see the fresh types. Skips
+	* messages published by this instance (we already have the new types).
+	*/
+	async handleSchemaReload() {
+		logger$2.info(`Schema reload request received in instance ${this.instanceId} — reloading schema...`);
+		try {
+			await sleep(1e3 + Math.random() * 5e3);
+			await bootstrapDbTypes(this.db, this.cache, true);
+			logger$2.info(`Schema reload applied in instance ${this.instanceId}`);
+		} catch (err) {
+			logger$2.error(err, "Failed to reload schema");
+			return;
+		}
+	}
+	/**
+	* Broadcast a schema-reload signal to every server instance (including
+	* this one — the handler skips self-originated messages, so calling
+	* after a local migration is safe). Pass `tables` to scope the reload;
+	* omit to flush everyone's cache.
+	*/
+	async publishSchemaReload(tables) {
+		const payload = JSON.stringify({
+			type: "schema:reload",
+			tables,
+			originInstance: this.instanceId
+		});
+		await redisRetryPolicy.execute(() => this.cache.redis.publish(SCHEMA_RELOAD_CHANNEL, payload));
+	}
+	async handleRemoteInstanceMessage(message) {
+		let parsed;
+		try {
+			parsed = RemoteSubscriptionMessageSchema.parse(JSON.parse(message));
+		} catch (err) {
+			logger$2.error(err, "Failed to parse remote instance message");
+			return;
+		}
+		if (parsed.originInstance === this.instanceId) return;
+		if (parsed.type === "update") {
+			for (const [, session] of this.sessions) {
+				if (!session.subIds.has(parsed.subId)) continue;
+				if (!this.serverSubscriptions.get(parsed.subId)) continue;
+				this.sendMessage(session, {
+					type: "sub:update",
+					subId: parsed.subId,
+					data: parsed.data,
+					dataHash: parsed.dataHash
+				});
+			}
+			return;
+		}
+		await this.handleRemoteRecomputeRace(parsed);
+	}
+	async handleRemoteRecomputeRace(req) {
+		if (!this.hasLocalSessionFor(req.subId)) return;
+		if (!await this.cache.tryAcquireRecomputeLock(this.instanceId, req.subId, req.commitTs, RECOMPUTE_LOCK_TTL_SECONDS)) {
+			logger$2.debug(`recompute-race: lost lock for ${req.subId}@${req.commitTs}, waiting for winner's update`);
+			return;
+		}
+		await this.reexecuteAffectedQuery({
+			subId: req.subId,
+			queryName: req.queryName,
+			args: req.args,
+			cacheKey: req.cacheKey,
+			notifyInstances: req.notifyInstances
+		});
+	}
+	async publishSubscriptionUpdate(subId, data, dataHash, notifyInstances) {
+		const payload = supaliveStringify({
+			type: "update",
+			subId,
+			data,
+			dataHash,
+			originInstance: this.instanceId
+		});
+		const publishPromises = notifyInstances.map(async (instance) => {
+			if (instance === this.instanceId) return;
+			const channel = `sub:instance:${instance}`;
+			try {
+				await redisRetryPolicy.execute(() => this.cache.redis.publish(channel, payload));
+			} catch (err) {
+				logger$2.error(err, `Failed to publish to ${channel} after many retries`);
+			}
+		});
+		await Promise.all(publishPromises);
+	}
+};
+//#endregion
+//#region src/server/hash.ts
+/**
+* FNV-1a 32-bit hash.
+*
+* Used for routing subscription operations to logical workers inside the
+* sub-manager process. Same input always returns the same 32-bit unsigned
+* integer in both JavaScript and Go, so a future Go port of the sub-manager
+* can use the identical routing without rebalancing keys.
+*
+* Reference: http://www.isthe.com/chongo/tech/comp/fnv/
+*/
+function fnv1a32(s) {
+	let h = 2166136261;
+	for (let i = 0; i < s.length; i++) {
+		h ^= s.charCodeAt(i);
+		h = h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24)) >>> 0;
+	}
+	return h >>> 0;
+}
+//#endregion
+//#region src/server/subscription-manager.ts
+const logger$1 = logger.child({ name: "SUBS_MGR" }, { level: logLevelOf("SUBS_MANAGER_SERVER_LOG_LEVEL") });
+function resolveWorkerEntry() {
+	const isTs = new URL(import.meta.url).pathname.endsWith(".ts");
+	return {
+		url: new URL(`./subscription-manager-worker-entry${isTs ? ".ts" : ".js"}`, import.meta.url),
+		isTs
+	};
+}
+function workerExecArgv(isTs) {
+	if (!isTs) return void 0;
+	if (typeof globalThis.Bun !== "undefined") return void 0;
+	return ["--import", "tsx"];
+}
+var SubscriptionWorkerHandle = class {
+	id;
+	worker;
+	pending = /* @__PURE__ */ new Map();
+	nextReqId = 1;
+	readyPromise;
+	constructor(id, init) {
+		this.id = id;
+		const entry = resolveWorkerEntry();
+		this.worker = new Worker(fileURLToPath(entry.url), { execArgv: workerExecArgv(entry.isTs) });
+		this.worker.on("message", (res) => {
+			const pending = this.pending.get(res.reqId);
+			if (!pending) return;
+			this.pending.delete(res.reqId);
+			if (res.ok) pending.resolve(res.result);
+			else {
+				const err = new Error(res.error.message);
+				if (res.error.stack) err.stack = res.error.stack;
+				pending.reject(err);
+			}
+		});
+		this.worker.on("error", (err) => {
+			logger$1.error(err, `[worker ${this.id}] worker thread errored`);
+			const e = err instanceof Error ? err : new Error(String(err));
+			for (const [, p] of this.pending) p.reject(e);
+			this.pending.clear();
+		});
+		this.readyPromise = this.send(1, init).then(() => {});
+	}
+	ready() {
+		return this.readyPromise;
+	}
+	send(type, payload) {
+		const reqId = this.nextReqId++;
+		return new Promise((resolve, reject) => {
+			this.pending.set(reqId, {
+				resolve,
+				reject
+			});
+			const req = {
+				type,
+				reqId,
+				payload
+			};
+			this.worker.postMessage(req);
+		});
+	}
+	async shutdown() {
+		try {
+			await this.send(11, null);
+		} catch (_) {}
+		await this.worker.terminate();
+	}
+};
+/**
+* One process per deployment. Routes each subscription operation to one of N
+* worker threads by hashing subId. Worker threads run in parallel on separate
+* CPU cores; this dispatcher does no Zod parsing — it reads `subId` directly
+* from the decoded payload (the internal channel is trusted) and forwards the
+* raw payload. The worker validates and parses with Zod before executing.
+*/
+var SubscriptionManager = class SubscriptionManager {
+	wss;
+	port;
+	workers;
+	pruneInterval = null;
+	static PRUNE_INTERVAL_MS = 1800 * 1e3;
+	constructor(config) {
+		this.port = config.port;
+		this.wss = new Server({ port: this.port }, subscriptionManagerDataPack);
+		this.wss.dataPack = subscriptionManagerDataPack;
+		const numWorkers = resolveWorkerCount(config.workers);
+		const maxConnectionsPerWorker = resolveMaxConnectionsPerWorker(config, numWorkers);
+		logger$1.info(`Spawning ${numWorkers} subscription worker${numWorkers === 1 ? "" : "s"}`);
+		this.workers = Array.from({ length: numWorkers }, (_, i) => new SubscriptionWorkerHandle(i + 1, {
+			workerId: i + 1,
+			database: config.database,
+			upstash: config.upstash,
+			cacheTTLSeconds: config.cacheTTLSeconds,
+			maxConnectionsPerWorker
+		}));
+		this.registerMethods();
+	}
+	async start() {
+		await Promise.all(this.workers.map((w) => w.ready()));
+		logger$1.info(`Listening on port ${this.port}`);
+		this.pruneInterval = setInterval(() => {
+			this.pruneCommitLogs().catch((err) => logger$1.error(err, "commit_logs prune failed"));
+		}, SubscriptionManager.PRUNE_INTERVAL_MS);
+		if (this.pruneInterval && typeof this.pruneInterval.unref === "function") this.pruneInterval.unref();
+	}
+	async stop() {
+		if (this.pruneInterval) {
+			clearInterval(this.pruneInterval);
+			this.pruneInterval = null;
+		}
+		this.wss.close();
+		await Promise.all(this.workers.map((w) => w.shutdown()));
+		logger$1.info("Stopped");
+	}
+	async pruneCommitLogs() {
+		const minPerWorker = await Promise.all(this.workers.map((w) => w.send(8, null)));
+		let floor = null;
+		for (const m of minPerWorker) {
+			if (m === null) continue;
+			if (floor === null || m < floor) floor = m;
+		}
+		if (floor === null) {
+			const latest = await this.workers[0].send(9, null);
+			if (latest <= 0n) return;
+			floor = latest;
+		}
+		const deleted = await this.workers[0].send(10, floor);
+		if (deleted > 0n) logger$1.info(`pruned ${deleted} commit_logs older than ts=${floor}`);
+	}
+	workerCount() {
+		return this.workers.length;
+	}
+	workerIndexFor(subId) {
+		return fnv1a32(subId) % this.workers.length;
+	}
+	workerFor(subId) {
+		return this.workers[this.workerIndexFor(subId)];
+	}
+	registerMethods() {
+		this.wss.register("registerSubscription", this.registerSubscription.bind(this));
+		this.wss.register("registerSubscriptionBatch", this.registerSubscriptionBatch.bind(this));
+		this.wss.register("updateSubscriptionReadSet", this.updateSubscriptionReadSet.bind(this));
+		this.wss.register("invalidateWriteset", this.invalidateWriteset.bind(this));
+		this.wss.register("unregisterSubscription", this.unregisterSubscription.bind(this));
+		this.wss.register("unregisterSubscriptions", this.unregisterSubscriptions.bind(this));
+	}
+	readSubId(params) {
+		return params.subId;
+	}
+	async registerSubscription(params) {
+		const subId = this.readSubId(params);
+		return this.workerFor(subId).send(2, params);
+	}
+	async registerSubscriptionBatch(params) {
+		const arr = params;
+		const byWorker = groupByToMap(arr.map((p, index) => ({
+			index,
+			p,
+			worker: this.workerFor(p.subId)
+		})), (t) => t.worker);
+		const settled = await Promise.all([...byWorker.entries()].map(async ([worker, items]) => {
+			const results = await worker.send(3, items.map((t) => t.p));
+			return items.map((t, i) => ({
+				index: t.index,
+				result: results[i]
+			}));
+		}));
+		const result = new Array(arr.length);
+		for (const { index, result: r } of settled.flat()) result[index] = r;
+		return result;
+	}
+	async updateSubscriptionReadSet(params) {
+		const subId = this.readSubId(params);
+		return this.workerFor(subId).send(4, params);
+	}
+	async unregisterSubscription(params) {
+		const subId = this.readSubId(params);
+		return this.workerFor(subId).send(5, params);
+	}
+	async unregisterSubscriptions(params) {
+		const arr = params;
+		const byWorker = groupByToMap(arr.map((p, index) => ({
+			index,
+			p,
+			worker: this.workerFor(p.subId)
+		})), (t) => t.worker);
+		const settled = await Promise.all([...byWorker.entries()].map(async ([worker, items]) => {
+			const results = await worker.send(6, items.map((t) => t.p));
+			return items.map((t, i) => ({
+				index: t.index,
+				result: results[i]
+			}));
+		}));
+		const result = new Array(arr.length);
+		for (const { index, result: r } of settled.flat()) result[index] = r;
+		return result;
+	}
+	async invalidateWriteset(params) {
+		return { affected: (await Promise.all(this.workers.map((w) => w.send(7, params)))).flat() };
+	}
+};
+function resolveWorkerCount(configured) {
+	if (typeof configured === "number" && configured > 0) return Math.floor(configured);
+	const envVal = process.env.SUPALIVE_SUB_MANAGER_WORKERS;
+	if (envVal) {
+		const n = parseInt(envVal, 10);
+		if (Number.isFinite(n) && n > 0) return n;
+	}
+	return 1;
+}
+function resolveMaxConnectionsPerWorker(config, workers) {
+	if (config.maxConnectionsPerWorker && config.maxConnectionsPerWorker > 0) return Math.floor(config.maxConnectionsPerWorker);
+	const total = config.database.maxConnections ?? (config.database.type === "mysql" ? 20 : 10);
+	return Math.max(1, Math.floor(total / workers));
+}
+//#endregion
+export { ANONYMOUS_IDENTITY, CacheLayer, DB_QUERY_TIMEOUT_MS, InvalidateWritesetParamsSchema, RegisterSubscriptionParamsSchema, SubManagerClient, SubscriptionManager, SupaliveWebSocketServer, UnregisterSubscriptionParamsSchema, UpdateSubscriptionReadSetParamsSchema, appInstanceId, bootstrapDbTypes, createDatabase, generateCacheKey, generateSubscriptionId, getHashOf, initCacheLayer, initDatabase, isProduction, logLevelOf, logger, serializeMapValue };
+
 //# sourceMappingURL=server.js.map