reflectdb 0.1.0 → 0.1.2

package/dist/server/ephemeral/redis.d.ts

@@ -0,0 +1,136 @@
+/**
+* Ephemeral (presence, cursors, typing) storage and fan-out seam.
+*
+* The default adapter keeps state in the server process, which is correct for a
+* single node and invisible across a fleet: two clients on different instances
+* never see each other. An adapter backed by shared infrastructure (Redis, or a
+* hosted service) fixes both halves — the shared store answers "who is here"
+* for a client that just joined, and the bus carries each event to the peers
+* holding the other sockets.
+*/
+type MaybePromise<T> = T | Promise<T>;
+interface EphemeralState {
+	clientId: string;
+	userId: string;
+	key: string;
+	data: Record<string, unknown>;
+	updatedAt: number;
+	ttlMs?: number;
+}
+/** One fan-out target: subscribers of `query`, narrowed to `room` when set. */
+interface EphemeralTarget {
+	query: string;
+	room: string | null;
+}
+/**
+* An ephemeral event as it crosses the bus between server instances.
+*
+* Recipients are resolved on the origin instance and carried here as `targets`,
+* because the receiving instance holds no session for the sender and so cannot
+* re-derive them. `serverId` lets an instance drop its own echo on buses that
+* deliver published messages back to the publisher.
+*/
+interface EphemeralBroadcast {
+	serverId: string;
+	key: string;
+	clientId: string;
+	userId: string;
+	data: Record<string, unknown>;
+	ttlMs?: number;
+	targets: EphemeralTarget[];
+}
+/**
+* Backing store and fan-out bus for ephemeral state.
+*
+* `publish`/`subscribe` are optional: an adapter that omits them is a
+* single-process store, and the handler still fans out to its own sockets.
+*/
+interface EphemeralAdapter {
+	/**
+	* Record one entry, keyed by `clientId`.
+	*
+	* Peer identity is the connection, not the account: two tabs from one login
+	* are two cursors, and the client bindings key peers the same way. `userId`
+	* rides along for display and authorization, not as the entry's identity.
+	*
+	* Returns false when the adapter is at capacity, which the handler surfaces
+	* as `ephemeral_full` rather than evicting silently.
+	*/
+	set(room: string, key: string, clientId: string, userId: string, data: Record<string, unknown>, ttlMs?: number): MaybePromise<boolean>;
+	/** Live entries for one channel, keyed by clientId. */
+	get(room: string, key: string): MaybePromise<Record<string, EphemeralState>>;
+	/**
+	* Live entries for every channel in a room, keyed by channel key then
+	* clientId. Backs the snapshot a client receives when it joins.
+	*/
+	getRoom(room: string): MaybePromise<Record<string, Record<string, EphemeralState>>>;
+	remove(room: string, key: string, clientId: string): MaybePromise<void>;
+	/** Drop everything a disconnecting client published. */
+	removeClient(clientId: string): MaybePromise<void>;
+	/** Sweep entries past their TTL. Called on a timer by the handler. */
+	cleanupExpired(): MaybePromise<void>;
+	/** Current entry count, for the capacity gate and `ephemeral_full`. */
+	size(): MaybePromise<number>;
+	destroy(): MaybePromise<void>;
+	/** Hand an event to peer instances. Absent on single-process adapters. */
+	publish?(event: EphemeralBroadcast): MaybePromise<void>;
+	/**
+	* Register the handler's delivery callback for events published by peers.
+	* Called once during wiring. Absent on single-process adapters.
+	*/
+	subscribe?(onEvent: (event: EphemeralBroadcast) => void): MaybePromise<void>;
+}
+/**
+* Minimal Redis client interface — one raw-command entrypoint.
+*
+* Compatible with ioredis (`client.call`) directly. For node-redis, wrap it:
+*
+* ```ts
+* const shim = { call: (cmd, ...args) => client.sendCommand([cmd, ...args.map(String)]) };
+* ```
+*/
+interface RedisLike {
+	call(command: string, ...args: (string | number)[]): Promise<unknown>;
+}
+/**
+* Pub/sub seam — one function, because no two Redis clients agree on the shape
+* of theirs (argument order, `on("message")` vs a per-channel listener). Wire
+* yours in a two-line shim rather than have this module guess:
+*
+* ```ts
+* // ioredis (separate connection — subscribe mode blocks other commands)
+* { subscribe: (ch, onMessage) => {
+*     sub.on("message", (c, m) => { if (c === ch) onMessage(m); });
+*     return sub.subscribe(ch);
+*   } }
+*
+* // Bun
+* { subscribe: (ch, onMessage) => sub.subscribe(ch, (msg) => onMessage(msg)) }
+* ```
+*/
+interface RedisSubscriberLike {
+	subscribe(channel: string, onMessage: (payload: string) => void): Promise<unknown> | unknown;
+}
+interface RedisEphemeralConfig {
+	/** Command connection. */
+	client: RedisLike;
+	/**
+	* Separate connection used for pub/sub. Omit to run shared-state-only —
+	* peers then see each other's presence on join and on sweep, but not live.
+	*/
+	subscriber?: RedisSubscriberLike;
+	/** Key prefix. Default: "reflectdb:eph" */
+	prefix?: string;
+	/** Global entry ceiling across the fleet. Default: 100_000 */
+	maxEntries?: number;
+	/**
+	* Safety-net expiry on state hashes, in seconds. Guards against a crashed
+	* instance leaving entries behind when its clients never disconnect
+	* cleanly. Default: 86400 (24h), matching the handler's TTL clamp.
+	*/
+	hashTtlSeconds?: number;
+}
+declare function createRedisEphemeral(config: RedisEphemeralConfig): EphemeralAdapter & {
+	ready(): Promise<void>;
+};
+export { RedisEphemeralConfig, RedisLike, RedisSubscriberLike, createRedisEphemeral };

package/dist/server/ephemeral/redis.js

@@ -0,0 +1,186 @@
+import"../../shared/esm-k7kedp3y.js";
+
+// src/server/ephemeral/redis.ts
+var DEFAULT_PREFIX = "reflectdb:eph";
+var DEFAULT_MAX_ENTRIES = 1e5;
+var DEFAULT_HASH_TTL_SECONDS = 24 * 60 * 60;
+var SWEEP_BATCH = 1000;
+function packed(room, key, clientId) {
+  return `${room}\x00${key}\x00${clientId}`;
+}
+function unpack(value) {
+  const [room, key, clientId] = value.split("\x00");
+  return { room, key, clientId };
+}
+function hashEntries(reply) {
+  if (Array.isArray(reply)) {
+    const out = [];
+    for (let i = 0;i + 1 < reply.length; i += 2) {
+      out.push([String(reply[i]), String(reply[i + 1])]);
+    }
+    return out;
+  }
+  if (reply && typeof reply === "object") {
+    return Object.entries(reply).map(([k, v]) => [k, String(v)]);
+  }
+  return [];
+}
+function toStringArray(reply) {
+  return Array.isArray(reply) ? reply.map((v) => String(v)) : [];
+}
+var SET_SCRIPT = `
+local isNew = 0
+if redis.call('HEXISTS', KEYS[1], ARGV[1]) == 0 then
+  local count = tonumber(redis.call('GET', KEYS[5]) or '0')
+  if count >= tonumber(ARGV[6]) then return 0 end
+  isNew = 1
+end
+redis.call('HSET', KEYS[1], ARGV[1], ARGV[2])
+redis.call('EXPIRE', KEYS[1], ARGV[7])
+redis.call('SADD', KEYS[2], ARGV[4])
+redis.call('EXPIRE', KEYS[2], ARGV[7])
+redis.call('SADD', KEYS[3], ARGV[3])
+redis.call('EXPIRE', KEYS[3], ARGV[7])
+if ARGV[5] ~= '' then
+  redis.call('ZADD', KEYS[4], ARGV[5], ARGV[3])
+else
+  redis.call('ZREM', KEYS[4], ARGV[3])
+end
+if isNew == 1 then redis.call('INCR', KEYS[5]) end
+return 1
+`;
+var REMOVE_SCRIPT = `
+if redis.call('HDEL', KEYS[1], ARGV[1]) == 0 then return 0 end
+redis.call('ZREM', KEYS[3], ARGV[2])
+redis.call('SREM', KEYS[5], ARGV[2])
+if redis.call('HLEN', KEYS[1]) == 0 then
+  redis.call('SREM', KEYS[2], ARGV[3])
+end
+local count = tonumber(redis.call('GET', KEYS[4]) or '0')
+if count > 0 then redis.call('DECR', KEYS[4]) end
+return 1
+`;
+function createRedisEphemeral(config) {
+  const client = config.client;
+  const p = config.prefix ?? DEFAULT_PREFIX;
+  const maxEntries = config.maxEntries ?? DEFAULT_MAX_ENTRIES;
+  const hashTtl = config.hashTtlSeconds ?? DEFAULT_HASH_TTL_SECONDS;
+  const stateKey = (room, key) => `${p}:s:${room}:${key}`;
+  const roomKeysKey = (room) => `${p}:rk:${room}`;
+  const clientKey = (clientId) => `${p}:c:${clientId}`;
+  const expKey = `${p}:exp`;
+  const countKey = `${p}:n`;
+  const busChannel = `${p}:bus`;
+  let readyPromise = null;
+  let onEventCallback = null;
+  function parseState(raw) {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  function isLive(state, now) {
+    return !state.ttlMs || now - state.updatedAt <= state.ttlMs;
+  }
+  async function removeEntry(room, key, clientId) {
+    await client.call("EVAL", REMOVE_SCRIPT, 5, stateKey(room, key), roomKeysKey(room), expKey, countKey, clientKey(clientId), clientId, packed(room, key, clientId), key);
+  }
+  async function ready() {
+    if (readyPromise)
+      return readyPromise;
+    const subscriber = config.subscriber;
+    if (!subscriber)
+      return;
+    readyPromise = (async () => {
+      await subscriber.subscribe(busChannel, (payload) => {
+        if (!onEventCallback)
+          return;
+        try {
+          onEventCallback(JSON.parse(payload));
+        } catch {}
+      });
+    })();
+    return readyPromise;
+  }
+  return {
+    ready,
+    async set(room, key, clientId, userId, data, ttlMs) {
+      const now = Date.now();
+      const state = {
+        clientId,
+        userId,
+        key,
+        data,
+        updatedAt: now,
+        ttlMs
+      };
+      const entry = packed(room, key, clientId);
+      const result = await client.call("EVAL", SET_SCRIPT, 5, stateKey(room, key), roomKeysKey(room), clientKey(clientId), expKey, countKey, clientId, JSON.stringify(state), entry, key, ttlMs ? String(now + ttlMs) : "", String(maxEntries), String(hashTtl));
+      return Number(result) === 1;
+    },
+    async get(room, key) {
+      const reply = await client.call("HGETALL", stateKey(room, key));
+      const now = Date.now();
+      const out = {};
+      for (const [entryClientId, raw] of hashEntries(reply)) {
+        const state = parseState(raw);
+        if (state && isLive(state, now))
+          out[entryClientId] = state;
+      }
+      return out;
+    },
+    async getRoom(room) {
+      const keys = toStringArray(await client.call("SMEMBERS", roomKeysKey(room)));
+      const now = Date.now();
+      const out = {};
+      for (const key of keys) {
+        const reply = await client.call("HGETALL", stateKey(room, key));
+        const channel = {};
+        for (const [entryClientId, raw] of hashEntries(reply)) {
+          const state = parseState(raw);
+          if (state && isLive(state, now))
+            channel[entryClientId] = state;
+        }
+        if (Object.keys(channel).length > 0)
+          out[key] = channel;
+      }
+      return out;
+    },
+    async remove(room, key, clientId) {
+      await removeEntry(room, key, clientId);
+    },
+    async removeClient(clientId) {
+      const entries = toStringArray(await client.call("SMEMBERS", clientKey(clientId)));
+      for (const value of entries) {
+        const { room, key, clientId: owner } = unpack(value);
+        await removeEntry(room, key, owner);
+      }
+      await client.call("DEL", clientKey(clientId));
+    },
+    async cleanupExpired() {
+      const due = toStringArray(await client.call("ZRANGEBYSCORE", expKey, "-inf", String(Date.now()), "LIMIT", 0, SWEEP_BATCH));
+      for (const value of due) {
+        const { room, key, clientId } = unpack(value);
+        await removeEntry(room, key, clientId);
+      }
+    },
+    async size() {
+      const reply = await client.call("GET", countKey);
+      return reply == null ? 0 : Number(reply);
+    },
+    async destroy() {
+      onEventCallback = null;
+    },
+    async publish(event) {
+      await client.call("PUBLISH", busChannel, JSON.stringify(event));
+    },
+    async subscribe(onEvent) {
+      onEventCallback = onEvent;
+      await ready();
+    }
+  };
+}
+export {
+  createRedisEphemeral
+};

package/dist/server/index.d.ts

@@ -250,11 +250,15 @@ interface DrizzleTableLike {
 /**
 * Value supplied per serverSet field in the schema's object form.
 * Either a static value or a function that receives the request context.
+*
+* The static arm is enumerated rather than written as `unknown`: a union with
+* `unknown` collapses to `unknown`, which strips the contextual type from the
+* callback arm and makes every `(ctx) => …` an implicit `any` under `strict`.
 */
-type ServerSetSchemaValue = unknown | ((ctx: {
+type ServerSetSchemaValue = ((ctx: {
 	auth: unknown;
 	params: unknown;
-}) => unknown);
+}) => unknown) | string | number | bigint | boolean | symbol | null | undefined | Date | readonly unknown[] | Record<string, unknown>;
 /**
 * Schema-side `serverSet` declaration. Two shapes:
 *  - `string[]` — keys only; values are supplied at `implement(...)` time.
@@ -319,6 +323,88 @@ type InferServerSetKeys<TDef> = TDef extends {
 	serverSet: infer O extends Readonly<Record<string, unknown>>;
 } ? keyof O & string : never;
 /**
+* Ephemeral (presence, cursors, typing) storage and fan-out seam.
+*
+* The default adapter keeps state in the server process, which is correct for a
+* single node and invisible across a fleet: two clients on different instances
+* never see each other. An adapter backed by shared infrastructure (Redis, or a
+* hosted service) fixes both halves — the shared store answers "who is here"
+* for a client that just joined, and the bus carries each event to the peers
+* holding the other sockets.
+*/
+type MaybePromise<T> = T | Promise<T>;
+interface EphemeralState {
+	clientId: string;
+	userId: string;
+	key: string;
+	data: Record<string, unknown>;
+	updatedAt: number;
+	ttlMs?: number;
+}
+/** One fan-out target: subscribers of `query`, narrowed to `room` when set. */
+interface EphemeralTarget {
+	query: string;
+	room: string | null;
+}
+/**
+* An ephemeral event as it crosses the bus between server instances.
+*
+* Recipients are resolved on the origin instance and carried here as `targets`,
+* because the receiving instance holds no session for the sender and so cannot
+* re-derive them. `serverId` lets an instance drop its own echo on buses that
+* deliver published messages back to the publisher.
+*/
+interface EphemeralBroadcast {
+	serverId: string;
+	key: string;
+	clientId: string;
+	userId: string;
+	data: Record<string, unknown>;
+	ttlMs?: number;
+	targets: EphemeralTarget[];
+}
+/**
+* Backing store and fan-out bus for ephemeral state.
+*
+* `publish`/`subscribe` are optional: an adapter that omits them is a
+* single-process store, and the handler still fans out to its own sockets.
+*/
+interface EphemeralAdapter {
+	/**
+	* Record one entry, keyed by `clientId`.
+	*
+	* Peer identity is the connection, not the account: two tabs from one login
+	* are two cursors, and the client bindings key peers the same way. `userId`
+	* rides along for display and authorization, not as the entry's identity.
+	*
+	* Returns false when the adapter is at capacity, which the handler surfaces
+	* as `ephemeral_full` rather than evicting silently.
+	*/
+	set(room: string, key: string, clientId: string, userId: string, data: Record<string, unknown>, ttlMs?: number): MaybePromise<boolean>;
+	/** Live entries for one channel, keyed by clientId. */
+	get(room: string, key: string): MaybePromise<Record<string, EphemeralState>>;
+	/**
+	* Live entries for every channel in a room, keyed by channel key then
+	* clientId. Backs the snapshot a client receives when it joins.
+	*/
+	getRoom(room: string): MaybePromise<Record<string, Record<string, EphemeralState>>>;
+	remove(room: string, key: string, clientId: string): MaybePromise<void>;
+	/** Drop everything a disconnecting client published. */
+	removeClient(clientId: string): MaybePromise<void>;
+	/** Sweep entries past their TTL. Called on a timer by the handler. */
+	cleanupExpired(): MaybePromise<void>;
+	/** Current entry count, for the capacity gate and `ephemeral_full`. */
+	size(): MaybePromise<number>;
+	destroy(): MaybePromise<void>;
+	/** Hand an event to peer instances. Absent on single-process adapters. */
+	publish?(event: EphemeralBroadcast): MaybePromise<void>;
+	/**
+	* Register the handler's delivery callback for events published by peers.
+	* Called once during wiring. Absent on single-process adapters.
+	*/
+	subscribe?(onEvent: (event: EphemeralBroadcast) => void): MaybePromise<void>;
+}
+/**
 * Adapter contract for `server.tx({ atomic: true })` — pluggable so non-drizzle
 * data layers (kysely, prisma, raw SQL) can wrap their own BEGIN/COMMIT/ROLLBACK
 * without reflectdb hard-coding a drizzle dependency.
@@ -456,6 +542,16 @@ declare class ResultCache {
 	private cache;
 	/**
 	* Update the cached result set and return the diff.
+	*
+	* Rows are snapshotted, not referenced. A query that hands back live objects
+	* — an in-memory store, a game loop mutating rows in place, an ORM returning
+	* tracked entities — would otherwise have the cache holding the very objects
+	* the next write mutates, so every later diff compares a row against itself,
+	* finds nothing changed, and the client silently stops receiving updates.
+	*
+	* The copy is shallow: mutating a nested object inside a row in place is
+	* still invisible to change detection.
+	*
 	* @param idField - The field name used as the row identifier (default: "id")
 	*/
 	set(clientId: string, queryName: string, rows: Record<string, unknown>[], idField?: string): DiffResult;
@@ -467,6 +563,21 @@ declare class ResultCache {
 	* already has rows it never received.
 	*/
 	diffOnly(clientId: string, queryName: string, rows: Record<string, unknown>[], idField?: string): DiffResult;
+	/**
+	* Forget one row of one client's cached result.
+	*
+	* The cache mirrors what a client is believed to hold, and a writer is
+	* excluded from the broadcast of its own write because it already applied
+	* that write optimistically. For a delete that means the row is gone on the
+	* client while the cache still holds it — and if the same rowId is later
+	* re-created, the next diff reports it as an *update* against the dead row
+	* and sends only the fields that happen to differ. The client, whose local
+	* row is just its own optimistic payload, would silently never receive the
+	* unchanged server-owned columns. Dropping the row here keeps the mirror
+	* honest, so a re-created rowId diffs as a fresh insert carrying every
+	* column.
+	*/
+	evictRow(clientId: string, queryName: string, rowId: string): void;
 	clear(clientId: string, queryName: string): void;
 	clearClient(clientId: string): void;
 	private getOrCreateClientCache;
@@ -662,6 +773,8 @@ declare class MessageHandler<TAuth extends AuthContext = AuthContext> {
 	private broadcast;
 	private ops;
 	private ephemeralManager;
+	/** Bus subscription is wired once, on the first adapter that offers one. */
+	private ephemeralBusReady;
 	private ephemeralCleanupTimer;
 	private eagerBuffer;
 	private replay;
@@ -701,6 +814,13 @@ declare class MessageHandler<TAuth extends AuthContext = AuthContext> {
 	setEphemeralRateLimit(perSecond: number): void;
 	setMaxBatchSize(size: number): void;
 	setMaxEphemeralEntries(max: number): void;
+	/**
+	* Swap the ephemeral store. An adapter that implements `subscribe` also
+	* makes this instance a bus participant, so presence spans the fleet.
+	*/
+	setEphemeralAdapter(adapter: EphemeralAdapter): void;
+	/** Drop everything a client published, whatever the adapter costs. */
+	private forgetEphemeralClient;
 	setMinSchemaVersion(version: number): void;
 	setMaxConnectionsPerUser(max: number | null): void;
 	private enforceConnectionCap;
@@ -761,6 +881,23 @@ declare class MessageHandler<TAuth extends AuthContext = AuthContext> {
 	*/
 	private allowEphemeral;
 	private handleEphemeral;
+	/**
+	* Deliver one ephemeral event to this instance's sockets.
+	*
+	* `exclude` is the sender when the event originated here, and undefined
+	* when it arrived over the bus — the sender's socket lives elsewhere.
+	*/
+	private fanOutEphemeral;
+	/** An event published by a peer instance. State is already in the shared store. */
+	private deliverRemoteEphemeral;
+	/**
+	* Replay a room's live presence to a client that just subscribed.
+	*
+	* Without this a joiner sees nobody until each peer happens to move again —
+	* the stored state existed but was never served. Replayed as ordinary
+	* `ephemeral` events, so clients need no new message type to benefit.
+	*/
+	private sendPresenceSnapshot;
 	/** Public reserve-or-replay gate for REST idempotency. Returns true when fresh. */
 	reserveOpId(opId: string): Promise<boolean>;
 	runCompaction(minOpAge: number): Promise<number>;
@@ -915,6 +1052,18 @@ interface ServerConfig<TDb = unknown> {
 	* this is absent. See `TxAtomicAdapter`.
 	*/
 	txAtomic?: TxAtomicAdapter;
+	/**
+	* Ephemeral (presence, cursors, typing) storage and fan-out.
+	*
+	* The default is in-process: correct on one node, invisible across a fleet,
+	* since each instance holds its own map and its own sockets. Supply an
+	* adapter backed by shared infrastructure to make presence span instances.
+	*/
+	ephemeral?: {
+		adapter?: EphemeralAdapter;
+		/** Entry ceiling for the default in-process store. Default: 10_000. */
+		maxEntries?: number;
+	};
 }
 interface QueryContext<TAuth extends AuthContext = AuthContext> {
 	auth: TAuth;
@@ -1472,6 +1621,11 @@ interface BunStatement<Row> {
 	run(...params: SqlValue[]): {
 		changes: number;
 	};
+	/**
+	* Releases the statement's sqlite handle. Optional so a hand-rolled stand-in
+	* need not implement it; `bun:sqlite` always does.
+	*/
+	finalize?(): void;
 }
 interface BunDatabase {
 	run(sql: string, ...params: SqlValue[][]): {
@@ -1564,6 +1718,18 @@ declare class BroadcastEngine<TAuth extends AuthContext = AuthContext> {
 	private withLock;
 	private executeWithTimeout;
 	/**
+	* Forget a row the writer itself removed, in every query that depends on
+	* `tableName`.
+	*
+	* The writer is skipped by `broadcastChanges` because it applied its own op
+	* optimistically, which leaves its cached result claiming a row the client
+	* has already dropped. Re-creating that same rowId would then diff as an
+	* update against the dead row and send only the columns that differ, so the
+	* writer would never receive the server-owned columns that happen to match
+	* the row it deleted.
+	*/
+	forgetWriterRow(tableName: string, clientId: string, rowId: string): void;
+	/**
 	* After a write to `tableName`, re-run every dependent query and send each
 	* subscriber the rows that changed for them.
 	*
@@ -1647,6 +1813,13 @@ interface OpProcessorDeps<TAuth extends AuthContext> {
 	receiveClientHlc(hlc: string): void;
 	send(clientId: string, message: ServerMessage): Promise<void>;
 	broadcastChanges(tableName: string, excludeClientId: string): Promise<void>;
+	/**
+	* Drop a row the writer deleted from the writer's own cached result set.
+	* The writer is excluded from the broadcast of its own op, so without this
+	* the cache keeps a row the client no longer holds — and a later re-insert
+	* of the same rowId diffs as a partial update against that dead row.
+	*/
+	forgetWriterRow(tableName: string, clientId: string, rowId: string): void;
 }
 /**
 * Applies client ops: replay reservation, enforcement, conflict resolution,
@@ -1795,6 +1968,16 @@ interface TypedServerConfig<
 	maxBroadcastConcurrency?: number;
 	/** Adapter that wraps `server.tx({ atomic: true })` writes in a transaction. */
 	txAtomic?: TxAtomicAdapter;
+	/**
+	* Ephemeral (presence, cursors, typing) storage and fan-out. Defaults to an
+	* in-process store, which is invisible across a fleet — supply an adapter
+	* backed by shared infrastructure to make presence span instances.
+	*/
+	ephemeral?: {
+		adapter?: EphemeralAdapter;
+		/** Entry ceiling for the default in-process store. Default: 10_000. */
+		maxEntries?: number;
+	};
 }
 type ImplementParams<
 	TQueries extends SyncQueryMap,
@@ -1818,14 +2001,22 @@ type IsServerSetArrayForm<
 	serverSet: readonly string[];
 } ? true : false;
 /** Value: static or a function receiving auth/params context */
+/**
+* A serverSet entry: a static value, or a function of the request context.
+*
+* The static arm is spelled out rather than written as `unknown`, because
+* `unknown | ((ctx) => …)` collapses to `unknown` and the callback's parameter
+* then has no contextual type — every `(ctx) => …` would be an implicit `any`
+* under `strict`.
+*/
 type ServerSetValue<
 	TAuth extends AuthContext,
 	TQueries extends SyncQueryMap,
 	K extends keyof TQueries
-> = unknown | ((ctx: {
+> = ((ctx: {
 	auth: TAuth;
 	params: ImplementParams<TQueries, K>;
-}) => unknown);
+}) => unknown) | string | number | bigint | boolean | symbol | null | undefined | Date | readonly unknown[] | Record<string, unknown>;
 /**
 * `serverSet` shape on `implement(...)`:
 *  - schema declares no `serverSet` → field disallowed.
@@ -1985,4 +2176,4 @@ declare function createSyncServer<
 	TDb = unknown,
 	TAuth extends AuthContext = AuthContext
 >(config: TypedServerConfig<TQueries, TDb>): TypedSyncServer<TQueries, TAuth, TDb>;
-export { stableStringify, resolveRoomKey, resolveConflict, processOp, enforceServerSet, enforceReadonly, enforceClockDrift, enforceBatchSize, drizzleTxAtomic, drizzleTable, defineTable, createSyncServer, createSqliteStorage, createServer, createRateLimiter, createPostgresStorage, TypedSyncServer, TypedServerConfig, TxProxy, TxOptions, TxFn, TxAtomicAdapter, TableAdapter, SyncServer, SyncEvent, StorageAdapter, SqliteStorageConfig, SessionManager, ServerConfig, ServerClock, ScopeFilter, SERVER_HLC_META_KEY, RoomResolution, RoomCallback, ResultCache, RestConfig, ResolvedOp, RateLimiter, QuerySubscription, QueryRegistration, QueryOptions, QueryContext, QueryCallback, PostgresStorageConfig, PostgresClient, PipelineResult, PipelineContext, OpResult, OpProcessorDeps, OpProcessor, OpLogEntry, MutationError, MutationContext, MutateResult, MessageHandler, ImplementOptions, HandlerConfig, ExistingRow, EnforcementResult, EnforcementContext, DrizzleTableOpts, DiffResult, DefineTableOpts, ConflictResult, ConflictInput, ClientSession, BroadcastEngineDeps, BroadcastEngine, BatchContext, AuthorizeAction, AuthCallback };
+export { AuthCallback, AuthorizeAction, BatchContext, BroadcastEngine, BroadcastEngineDeps, ClientSession, ConflictInput, ConflictResult, DefineTableOpts, DiffResult, DrizzleTableOpts, EnforcementContext, EnforcementResult, ExistingRow, HandlerConfig, ImplementOptions, MessageHandler, MutateResult, MutationContext, MutationError, OpLogEntry, OpProcessor, OpProcessorDeps, OpResult, PipelineContext, PipelineResult, PostgresClient, PostgresStorageConfig, QueryCallback, QueryContext, QueryOptions, QueryRegistration, QuerySubscription, RateLimiter, ResolvedOp, RestConfig, ResultCache, RoomCallback, RoomResolution, SERVER_HLC_META_KEY, ScopeFilter, ServerClock, ServerConfig, SessionManager, SqliteStorageConfig, StorageAdapter, SyncEvent, SyncServer, TableAdapter, TxAtomicAdapter, TxFn, TxOptions, TxProxy, TypedServerConfig, TypedSyncServer, createPostgresStorage, createRateLimiter, createServer, createSqliteStorage, createSyncServer, defineTable, drizzleTable, drizzleTxAtomic, enforceBatchSize, enforceClockDrift, enforceReadonly, enforceServerSet, processOp, resolveConflict, resolveRoomKey, stableStringify };