@supalive/core 1.8.1 → 1.10.0

package/dist/src/exports/server.d.ts

@@ -1,7 +1,7 @@
-import { $n as InvalidateWritesetParamsSchema, At as DevScheduler, Bt as SupaliveDb, E as Context, Ft as JobScheduler, It as QStashScheduler, Lt as QStashSchedulerOptions, Mt as EnqueueOptions, Nt as IncomingJobRequest, Pt as JobClient, Qn as InvalidateWritesetParams, Rt as ScheduleHandle, Vn as Database, Xn as CacheLayer, Zn as AffectedSubscription, ar as UnregisterSubscriptionParamsSchema, cr as UnregisterSubscriptionsResult, dr as UpdateSubscriptionReadSetResult, er as InvalidateWritesetResult, ir as UnregisterSubscriptionParams, jt as DevSchedulerOptions, lr as UpdateSubscriptionReadSetParams, nr as RegisterSubscriptionParamsSchema, or as UnregisterSubscriptionResult, rr as RegisterSubscriptionResult, rt as Router, sr as UnregisterSubscriptionsParams, tr as RegisterSubscriptionParams, ur as UpdateSubscriptionReadSetParamsSchema, zt as ScheduledJobDef } from "../../index-DgZeS3JK.js";
-import { t as MySqlDatabase } from "../../mysql-9euRTU3L.js";
-import { t as PgDatabase } from "../../postgres-B-OZJdD9.js";
-import { b as SupaliveServerConfig, p as DatabaseConfig, u as SubId, x as UpstashConfig, y as SubscriptionManagerConfig } from "../../types_server-BNuTxu-E.js";
+import { $n as AffectedSubscription, Bt as ScheduleHandle, E as Context, Ft as IncomingJobRequest, Ht as SupaliveDb, It as JobClient, Lt as JobScheduler, Mt as DevScheduler, Nt as DevSchedulerOptions, Pt as EnqueueOptions, Qn as CacheLayer, Rt as QStashScheduler, Un as Database, Vt as ScheduledJobDef, ar as RegisterSubscriptionResult, cr as UnregisterSubscriptionResult, dr as UpdateSubscriptionReadSetParams, er as InvalidateWritesetParams, fr as UpdateSubscriptionReadSetParamsSchema, ir as RegisterSubscriptionParamsSchema, nr as InvalidateWritesetResult, or as UnregisterSubscriptionParams, pr as UpdateSubscriptionReadSetResult, rr as RegisterSubscriptionParams, rt as Router, sr as UnregisterSubscriptionParamsSchema, tr as InvalidateWritesetParamsSchema, zt as QStashSchedulerOptions } from "../../index-BQRlJY_1.js";
+import { t as MySqlDatabase } from "../../mysql-CBSuONm5.js";
+import { t as PgDatabase } from "../../postgres-BKGLPrKt.js";
+import { C as SubManagerLink, S as SubManagerClient, b as SupaliveServerConfig, p as DatabaseConfig, u as SubId, x as UpstashConfig, y as SubscriptionManagerConfig } from "../../types_server-DU9JMSXd.js";
 import pino, { Level } from "pino";
 import Redis$1 from "ioredis";
 
@@ -190,7 +190,7 @@ declare const logger: pino.Logger<never, boolean>;
 declare function logLevelOf(name: string): Level;
 declare function serializeMapValue<K extends string | number | symbol, V>(map: Map<K, V>): Record<K, V>;
 //#endregion
-//#region src/server/subscription-manager.d.ts
+//#region src/server/sub-manager.d.ts
 /**
  * One process per deployment. Routes each subscription operation to one of N
  * worker threads by hashing subId. Worker threads run in parallel on separate
@@ -199,14 +199,30 @@ declare function serializeMapValue<K extends string | number | symbol, V>(map: M
  * raw payload. The worker validates and parses with Zod before executing.
  */
 declare class SubscriptionManager {
-  private wss;
-  private port;
+  private wss?;
+  private port?;
+  private listen;
   private workers;
   private pruneInterval;
   private static readonly PRUNE_INTERVAL_MS;
   constructor(config: SubscriptionManagerConfig);
+  /**
+   * Build the single in-process worker for {@link SubscriptionManagerConfig.inline}
+   * mode. Reuses the host server's {@link SubscriptionManagerConfig.db} +
+   * {@link SubscriptionManagerConfig.cache} when provided (borrowed — not closed
+   * on stop); otherwise opens its own pool/cache from `database`/`upstash`.
+   */
+  private buildInlineWorker;
   start(): Promise<void>;
   stop(): Promise<void>;
+  /**
+   * A direct, in-process {@link SubManagerLink} to this manager, for embedding
+   * it in the app server (pass as `SupaliveServerConfig.subManager`). Calls the
+   * dispatch handlers directly — no socket, no serialization. The recovery
+   * callbacks are no-ops: an in-process link never disconnects, so the app
+   * server's reconnect/buffer machinery is inert.
+   */
+  localLink(): SubManagerLink;
   private pruneCommitLogs;
   /** Fan a watermark value out to every worker's in-memory copy. Worker 0 (the
    * pruner/seeder) already has it, but re-sending is harmless — {@link
@@ -225,122 +241,6 @@ declare class SubscriptionManager {
   private invalidateWriteset;
 }
 //#endregion
-//#region src/server/subscription-manager-client.d.ts
-/**
- * Callback the app server registers to process invalidations that were
- * deferred during a sub-manager outage. When the sub-manager reconnects and
- * the buffered writeSets are flushed in one batched RPC, the resulting
- * `affected[]` is handed to this callback — which is expected to do the
- * same work as the normal per-mutation `reexecuteAffectedQuery` path.
- */
-type AffectedHandler = (affected: AffectedSubscription[]) => Promise<void>;
-/**
- * Callback the app server registers to drive recovery on sub-manager
- * reconnect. Iterates `serverSubscriptions`, reads `sl:reg:<subId>` from
- * Redis, and re-registers each known sub. Resolves when complete; only then
- * does the client's buffer flush and gated calls release.
- */
-type RecoveryDriver = () => Promise<void>;
-interface SubManagerClientOptions {
-  url: string;
-  /**
-   * Maximum number of buffered WriteEntry records held during an outage.
-   * If exceeded, the buffer is dropped — the commit-log replay path during
-   * the next register call will catch up any missed invalidations, at the
-   * cost of a brief recompute spike. Default 50_000 entries.
-   */
-  invalidateBufferLimit?: number;
-}
-/**
- * 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.
- */
-declare class SubManagerClient {
-  private client;
-  private state;
-  private hasConnectedOnce;
-  /** Resolves whenever state transitions to 'ready'. Replaced on each busy→ready cycle. */
-  private readyPromise;
-  private resolveReady;
-  /** Writeset entries accumulated while state === 'busy'. Flushed as one RPC after recovery. */
-  private bufferedWriteSets;
-  private readonly bufferLimit;
-  private bufferDroppedDuringOutage;
-  private recoveryDriver?;
-  private affectedHandler?;
-  constructor(urlOrOptions: string | SubManagerClientOptions);
-  /**
-   * 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: RecoveryDriver): void;
-  /**
-   * Wire up the handler invoked when batched invalidate results land
-   * after recovery. The handler is expected to drive
-   * `reexecuteAffectedQuery` for each entry.
-   */
-  setAffectedHandler(handler: AffectedHandler): void;
-  registerSubscription(params: RegisterSubscriptionParams): Promise<RegisterSubscriptionResult>;
-  registerSubscriptionBatch(params: RegisterSubscriptionParams[]): Promise<RegisterSubscriptionResult[]>;
-  updateSubscriptionReadSet(params: UpdateSubscriptionReadSetParams): Promise<UpdateSubscriptionReadSetResult>;
-  unregisterSubscription(params: UnregisterSubscriptionParams): Promise<UnregisterSubscriptionResult>;
-  unregisterSubscriptions(params: UnregisterSubscriptionsParams): Promise<UnregisterSubscriptionsResult>;
-  /**
-   * 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.
-   */
-  invalidateWriteset(params: InvalidateWritesetParams): Promise<InvalidateWritesetResult>;
-  /**
-   * 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.
-   */
-  private call;
-  private appendToBuffer;
-  private flushBuffer;
-  private markBusy;
-  private markReady;
-  private handleClose;
-  private handleOpen;
-  private runRecovery;
-  /**
-   * Test/inspection helpers.
-   */
-  /** @internal */
-  isReady(): boolean;
-  /** @internal */
-  bufferSize(): number;
-}
-//#endregion
 //#region src/db/init_db.d.ts
 /**
  * Current core runtime-bootstrap version. Bump this whenever core needs a new
@@ -426,5 +326,5 @@ declare function generateSubscriptionId(procedure: string, input: unknown | stri
  */
 declare function generateCacheKey(queryName: string, input: unknown | string, queryIdentity: string): Promise<string>;
 //#endregion
-export { ANONYMOUS_IDENTITY, type AffectedSubscription, CORE_VERSION, CacheLayer, DB_QUERY_TIMEOUT_MS, DevScheduler, type DevSchedulerOptions, type EnqueueOptions, type IncomingJobRequest, InitCacheLayerOptions, InitDbOptions, type InvalidateWritesetParams, InvalidateWritesetParamsSchema, type InvalidateWritesetResult, JobClient, type JobScheduler, QStashScheduler, type QStashSchedulerOptions, type RegisterSubscriptionParams, RegisterSubscriptionParamsSchema, type RegisterSubscriptionResult, type ScheduleHandle, type ScheduledJobDef, type SubId, SubManagerClient, SubscriptionManager, SupaliveWebSocketServer, type UnregisterSubscriptionParams, UnregisterSubscriptionParamsSchema, type UnregisterSubscriptionResult, type UpdateSubscriptionReadSetParams, UpdateSubscriptionReadSetParamsSchema, type UpdateSubscriptionReadSetResult, appInstanceId, bootstrapDbTypes, createDatabase, generateCacheKey, generateSubscriptionId, getHashOf, initCacheLayer, initCore, initDatabase, isProduction, logLevelOf, logger, serializeMapValue };
+export { ANONYMOUS_IDENTITY, type AffectedSubscription, CORE_VERSION, CacheLayer, DB_QUERY_TIMEOUT_MS, DevScheduler, type DevSchedulerOptions, type EnqueueOptions, type IncomingJobRequest, InitCacheLayerOptions, InitDbOptions, type InvalidateWritesetParams, InvalidateWritesetParamsSchema, type InvalidateWritesetResult, JobClient, type JobScheduler, QStashScheduler, type QStashSchedulerOptions, type RegisterSubscriptionParams, RegisterSubscriptionParamsSchema, type RegisterSubscriptionResult, type ScheduleHandle, type ScheduledJobDef, type SubId, SubManagerClient, type SubManagerLink, SubscriptionManager, SupaliveWebSocketServer, type UnregisterSubscriptionParams, UnregisterSubscriptionParamsSchema, type UnregisterSubscriptionResult, type UpdateSubscriptionReadSetParams, UpdateSubscriptionReadSetParamsSchema, type UpdateSubscriptionReadSetResult, appInstanceId, bootstrapDbTypes, createDatabase, generateCacheKey, generateSubscriptionId, getHashOf, initCacheLayer, initCore, initDatabase, isProduction, logLevelOf, logger, serializeMapValue };
 //# sourceMappingURL=server.d.ts.map

package/dist/src/exports/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","names":[],"sources":["../../../src/server/supalive-server.ts","../../../src/logger.ts","../../../src/server/subscription-manager.ts","../../../src/server/subscription-manager-client.ts","../../../src/db/init_db.ts","../../../src/server/sub_hash.ts"],"mappings":"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"}
+{"version":3,"file":"server.d.ts","names":[],"sources":["../../../src/server/supalive-server.ts","../../../src/logger.ts","../../../src/server/sub-manager.ts","../../../src/db/init_db.ts","../../../src/server/sub_hash.ts"],"mappings":"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"}

package/dist/src/exports/server.js

@@ -4,7 +4,7 @@ import { r as evaluateCacheFreshness } from "../../overlap-checker-BqR9qCfy.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-DiYQbfeA.js";
-import { C as RetentionWatermark, D as logger, E as logLevelOf, O as serializeMapValue, S as RETENTION_WATERMARK_CHANNEL, T as isProduction, _ as UnregisterSubscriptionResultSchema, a as createDatabase, b as UpdateSubscriptionReadSetParamsSchema, c as initDatabase, d as InvalidateWritesetResultSchema, g as UnregisterSubscriptionParamsSchema, h as RegisterSubscriptionResultSchema, i as bootstrapDbTypes, l as CacheLayer, m as RegisterSubscriptionParamsSchema, n as CORE_VERSION, o as initCacheLayer, p as RegisterSubscriptionBatchResultSchema, r as DB_QUERY_TIMEOUT_MS, s as initCore, u as InvalidateWritesetParamsSchema, w as appInstanceId, x as UpdateSubscriptionReadSetResultSchema, y as UnregisterSubscriptionsResultSchema } from "../../subscription-worker-DC9v3_Xn.js";
+import { C as appInstanceId, D as serializeMapValue, E as logger, S as RetentionWatermark, T as logLevelOf, _ as UnregisterSubscriptionResultSchema, a as bootstrapDbTypes, b as UpdateSubscriptionReadSetResultSchema, c as initCore, d as InvalidateWritesetParamsSchema, f as InvalidateWritesetResultSchema, g as UnregisterSubscriptionParamsSchema, h as RegisterSubscriptionResultSchema, i as DB_QUERY_TIMEOUT_MS, l as initDatabase, m as RegisterSubscriptionParamsSchema, n as SubscriptionWorker, o as createDatabase, p as RegisterSubscriptionBatchResultSchema, r as CORE_VERSION, s as initCacheLayer, t as dispatchWorkerMessage, u as CacheLayer, v as UnregisterSubscriptionsResultSchema, w as isProduction, x as RETENTION_WATERMARK_CHANNEL, y as UpdateSubscriptionReadSetParamsSchema } from "../../sub-worker-dispatch-G8V8asfR.js";
 import { createServer } from "http";
 import { WebSocket, WebSocketServer } from "ws";
 import { v4 } from "uuid";
@@ -118,7 +118,7 @@ async function runCachedQuery(deps, procedure, procedureName, input, serverCtx,
 	return result.data;
 }
 //#endregion
-//#region src/server/subscription-manager-client.ts
+//#region src/server/sub-manager-client.ts
 const logger$5 = logger.child({ name: "SUBS_MGR_CLIENT" }, { level: logLevelOf("SUB_MANAGER_CLIENT_LOG_LEVEL") });
 const subscriptionManagerDataPack = {
 	encode: (data) => supaliveStringify(data),
@@ -828,8 +828,9 @@ var SupaliveWebSocketServer = class {
 			...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);
+		if (config.subManager) this.subManagerClient = config.subManager;
+		else if (config.subManagerUrl) this.subManagerClient = new SubManagerClient(config.subManagerUrl);
+		else throw new Error("either `subManager` (in-process link) or `subManagerUrl` (WebSocket URL) is required");
 		this.cache = config.cacheLayer;
 		this.redisSub = config.redisSubClient;
 		this.appPubSubChannels = new Set(config.appPubSub?.channels ?? []);
@@ -1812,12 +1813,12 @@ function fnv1a32(s) {
 	return h >>> 0;
 }
 //#endregion
-//#region src/server/subscription-manager.ts
+//#region src/server/sub-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),
+		url: new URL(`./sub-manager-worker-entry${isTs ? ".ts" : ".js"}`, import.meta.url),
 		isTs
 	};
 }
@@ -1826,7 +1827,7 @@ function workerExecArgv(isTs) {
 	if (typeof globalThis.Bun !== "undefined") return void 0;
 	return ["--import", "tsx"];
 }
-var SubscriptionWorkerHandle = class {
+var ThreadWorkerHandle = class {
 	id;
 	worker;
 	pending = /* @__PURE__ */ new Map();
@@ -1881,6 +1882,38 @@ var SubscriptionWorkerHandle = class {
 	}
 };
 /**
+* In-process worker handle: holds a live {@link SubscriptionWorker} and drives
+* it via {@link dispatchWorkerMessage} with `trusted: true`. Every `send` is a
+* direct `await worker.method(payload)` on the main event loop — no
+* `postMessage`, no structured-clone. Used when the manager is embedded in the
+* app server. When `ownsDb` is false the db is borrowed from the host server
+* and is NOT closed on shutdown.
+*/
+var InlineWorkerHandle = class {
+	id;
+	worker;
+	db;
+	ownsDb;
+	constructor(id, worker, db, ownsDb) {
+		this.id = id;
+		this.worker = worker;
+		this.db = db;
+		this.ownsDb = ownsDb;
+	}
+	ready() {
+		return Promise.resolve();
+	}
+	send(type, payload) {
+		return dispatchWorkerMessage(this.worker, this.db, type, payload, { trusted: true });
+	}
+	async shutdown() {
+		if (!this.ownsDb) return;
+		try {
+			await this.db.close();
+		} catch (_) {}
+	}
+};
+/**
 * 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
@@ -1890,28 +1923,72 @@ var SubscriptionWorkerHandle = class {
 var SubscriptionManager = class SubscriptionManager {
 	wss;
 	port;
+	listen;
 	workers;
 	pruneInterval = null;
 	static PRUNE_INTERVAL_MS = 10080 * 60 * 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();
+		this.listen = config.listen !== false;
+		if (this.listen) {
+			if (config.port == null) throw new Error("SubscriptionManager: `port` is required unless `listen: false`");
+			this.port = config.port;
+			this.wss = new Server({ port: this.port }, subscriptionManagerDataPack);
+			this.wss.dataPack = subscriptionManagerDataPack;
+		}
+		const inline = config.inline === true;
+		let numWorkers = resolveWorkerCount(config.workers);
+		if (inline && numWorkers !== 1) {
+			logger$1.warn(`inline mode runs on the main event loop; forcing workers=1 (was ${numWorkers})`);
+			numWorkers = 1;
+		}
+		if (inline) this.workers = [this.buildInlineWorker(config)];
+		else {
+			if (!config.database || !config.upstash) throw new Error("SubscriptionManager: `database` and `upstash` are required in threaded (non-inline) mode");
+			const maxConnectionsPerWorker = resolveMaxConnectionsPerWorker(config, numWorkers);
+			logger$1.info(`Spawning ${numWorkers} subscription worker${numWorkers === 1 ? "" : "s"}`);
+			this.workers = Array.from({ length: numWorkers }, (_, i) => new ThreadWorkerHandle(i + 1, {
+				workerId: i + 1,
+				database: config.database,
+				upstash: config.upstash,
+				cacheTTLSeconds: config.cacheTTLSeconds,
+				maxConnectionsPerWorker
+			}));
+		}
+		if (this.listen) this.registerMethods();
+	}
+	/**
+	* Build the single in-process worker for {@link SubscriptionManagerConfig.inline}
+	* mode. Reuses the host server's {@link SubscriptionManagerConfig.db} +
+	* {@link SubscriptionManagerConfig.cache} when provided (borrowed — not closed
+	* on stop); otherwise opens its own pool/cache from `database`/`upstash`.
+	*/
+	buildInlineWorker(config) {
+		let db;
+		let cache;
+		let ownsDb;
+		if (config.db && config.cache) {
+			db = config.db;
+			cache = config.cache;
+			ownsDb = false;
+			logger$1.info("Inline subscription worker: reusing host db + cache");
+		} else {
+			if (!config.database || !config.upstash) throw new Error("SubscriptionManager inline mode needs either { db, cache } to reuse, or { database, upstash } to build its own");
+			const { cacheLayer } = initCacheLayer({
+				upstash: config.upstash,
+				cacheTtlSeconds: config.cacheTTLSeconds,
+				commandMaxRetries: 5,
+				createSubClient: false
+			});
+			cache = cacheLayer;
+			db = createDatabase(config.database, 1);
+			ownsDb = true;
+			logger$1.info("Inline subscription worker: built own db + cache");
+		}
+		return new InlineWorkerHandle(1, new SubscriptionWorker(1, cache, db), db, ownsDb);
 	}
 	async start() {
 		await Promise.all(this.workers.map((w) => w.ready()));
-		logger$1.info(`Listening on port ${this.port}`);
+		logger$1.info(this.listen ? `Listening on port ${this.port}` : "Started (embedded, in-process)");
 		try {
 			const minRetainedTs = await this.workers[0].send(12, null);
 			await this.broadcastRetentionWatermark(minRetainedTs);
@@ -1928,10 +2005,29 @@ var SubscriptionManager = class SubscriptionManager {
 			clearInterval(this.pruneInterval);
 			this.pruneInterval = null;
 		}
-		this.wss.close();
+		this.wss?.close();
 		await Promise.all(this.workers.map((w) => w.shutdown()));
 		logger$1.info("Stopped");
 	}
+	/**
+	* A direct, in-process {@link SubManagerLink} to this manager, for embedding
+	* it in the app server (pass as `SupaliveServerConfig.subManager`). Calls the
+	* dispatch handlers directly — no socket, no serialization. The recovery
+	* callbacks are no-ops: an in-process link never disconnects, so the app
+	* server's reconnect/buffer machinery is inert.
+	*/
+	localLink() {
+		return {
+			registerSubscription: (p) => this.registerSubscription(p),
+			registerSubscriptionBatch: (p) => this.registerSubscriptionBatch(p),
+			updateSubscriptionReadSet: (p) => this.updateSubscriptionReadSet(p),
+			unregisterSubscription: (p) => this.unregisterSubscription(p),
+			unregisterSubscriptions: (p) => this.unregisterSubscriptions(p),
+			invalidateWriteset: (p) => this.invalidateWriteset(p),
+			setRecoveryDriver: () => {},
+			setAffectedHandler: () => {}
+		};
+	}
 	async pruneCommitLogs() {
 		const minPerWorker = await Promise.all(this.workers.map((w) => w.send(8, null)));
 		let minRetainedTs = null;
@@ -1964,12 +2060,14 @@ var SubscriptionManager = class SubscriptionManager {
 		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));
+		const wss = this.wss;
+		if (!wss) return;
+		wss.register("registerSubscription", this.registerSubscription.bind(this));
+		wss.register("registerSubscriptionBatch", this.registerSubscriptionBatch.bind(this));
+		wss.register("updateSubscriptionReadSet", this.updateSubscriptionReadSet.bind(this));
+		wss.register("invalidateWriteset", this.invalidateWriteset.bind(this));
+		wss.register("unregisterSubscription", this.unregisterSubscription.bind(this));
+		wss.register("unregisterSubscriptions", this.unregisterSubscriptions.bind(this));
 	}
 	readSubId(params) {
 		return params.subId;
@@ -2037,7 +2135,7 @@ function resolveWorkerCount(configured) {
 }
 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);
+	const total = config.database?.maxConnections ?? (config.database?.type === "mysql" ? 20 : 10);
 	return Math.max(1, Math.floor(total / workers));
 }
 //#endregion