reflectdb 0.1.0 → 0.1.2

package/dist/cjs/server/index.d.cts

@@ -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 };

package/dist/cjs/svelte/index.cjs

@@ -41,16 +41,16 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 // src/core/types.ts
 var exports_types = {};
 __export(exports_types, {
-  reasonFromError: () => reasonFromError,
-  isErrorReason: () => isErrorReason,
-  TransportSendError: () => TransportSendError,
-  TOMBSTONE_RETENTION_MS: () => TOMBSTONE_RETENTION_MS,
-  SUPPORTED_PROTOCOL_VERSIONS: () => SUPPORTED_PROTOCOL_VERSIONS,
-  SERVER_TOMBSTONE_RETENTION_MS: () => SERVER_TOMBSTONE_RETENTION_MS,
-  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
-  MutationError: () => MutationError,
+  MAX_BATCH_SIZE: () => MAX_BATCH_SIZE,
   MAX_CLOCK_DRIFT_MS: () => MAX_CLOCK_DRIFT_MS,
-  MAX_BATCH_SIZE: () => MAX_BATCH_SIZE
+  MutationError: () => MutationError,
+  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+  SERVER_TOMBSTONE_RETENTION_MS: () => SERVER_TOMBSTONE_RETENTION_MS,
+  SUPPORTED_PROTOCOL_VERSIONS: () => SUPPORTED_PROTOCOL_VERSIONS,
+  TOMBSTONE_RETENTION_MS: () => TOMBSTONE_RETENTION_MS,
+  TransportSendError: () => TransportSendError,
+  isErrorReason: () => isErrorReason,
+  reasonFromError: () => reasonFromError
 });
 function isErrorReason(value) {
   return typeof value === "string" && VALID_ERROR_REASONS.has(value);
@@ -107,9 +107,9 @@ var init_types = __esm(() => {
 // src/svelte/index.ts
 var exports_svelte = {};
 __export(exports_svelte, {
-  createSyncSvelte: () => createSyncSvelte,
+  createBrowserWsTransport: () => createBrowserWsTransport,
   createSyncStore: () => createSyncStore,
-  createBrowserWsTransport: () => createBrowserWsTransport
+  createSyncSvelte: () => createSyncSvelte
 });
 module.exports = __toCommonJS(exports_svelte);
 
@@ -415,7 +415,7 @@ class ClientStore {
       if (existing?.serverHlc && compareHlc(hlc, existing.serverHlc) <= 0) {
         return;
       }
-      this.setRow(table, rowId, payload ?? {}, colClocks ?? { _row: hlc }, hlc);
+      this.setRow(table, rowId, this.withPk(table, rowId, payload ?? {}), colClocks ?? { _row: hlc }, hlc);
       return;
     }
     const incomingClocks = colClocks ?? {};
@@ -436,7 +436,13 @@ class ClientStore {
     }
     const newRowHlc = existing.serverHlc && compareHlc(existing.serverHlc, hlc) >= 0 ? existing.serverHlc : hlc;
     mergedClocks._row = newRowHlc;
-    this.setRow(table, rowId, mergedData, mergedClocks, newRowHlc);
+    this.setRow(table, rowId, this.withPk(table, rowId, mergedData), mergedClocks, newRowHlc);
+  }
+  withPk(table, rowId, data) {
+    const pk = this.tableMeta.get(table)?.pk ?? "id";
+    if (data[pk] !== undefined)
+      return data;
+    return { ...data, [pk]: rowId };
   }
   revertOp(opId, serverRow) {
     const pending = this.pendingOps.find((p) => p.op.id === opId);
@@ -481,10 +487,19 @@ class ClientStore {
         delete payload[field];
       }
     }
+    if (op.op === "insert" && payload) {
+      payload = this.withPk(op.table, op.rowId, payload);
+    }
     if (op.op === "delete") {
       this.setRow(op.table, op.rowId, null, { _row: op.hlc }, op.hlc);
     } else if (op.op === "insert") {
-      this.setRow(op.table, op.rowId, payload ?? {}, { _row: op.hlc }, op.hlc);
+      const existing = this.getRow(op.table, op.rowId);
+      if (existing?.data) {
+        const merged = { ...existing.data, ...payload };
+        this.setRow(op.table, op.rowId, merged, existing.colClocks, existing.serverHlc);
+      } else {
+        this.setRow(op.table, op.rowId, payload ?? {}, { _row: op.hlc }, op.hlc);
+      }
     } else {
       const existing = this.getRow(op.table, op.rowId);
       if (existing?.data) {
@@ -1323,21 +1338,21 @@ function createSyncStore(config) {
       }
     }
     const unsub = client.subscribeEphemeral(cfg.key, (event) => {
-      current = { ...current, [event.userId]: event.data };
+      current = { ...current, [event.clientId]: event.data };
       notifySubscribers();
       if (cfg.ttlMs) {
-        const existing = timers.get(event.userId);
+        const existing = timers.get(event.clientId);
         if (existing) {
           clearTimeout(existing);
         }
         const timer = setTimeout(() => {
           const next = { ...current };
-          delete next[event.userId];
+          delete next[event.clientId];
           current = next;
-          timers.delete(event.userId);
+          timers.delete(event.clientId);
           notifySubscribers();
         }, cfg.ttlMs);
-        timers.set(event.userId, timer);
+        timers.set(event.clientId, timer);
       }
     });
     const events = {

package/dist/cjs/svelte/index.d.cts

@@ -267,6 +267,17 @@ declare class ClientStore {
 	clearTable(table: string): void;
 	applySnapshot(table: string, rows: Record<string, unknown>[], colClocks: Record<string, Record<string, string>>, append?: boolean, pk?: string): void;
 	applyDelta(table: string, op: string, rowId: string, payload: Record<string, unknown> | null, hlc: string, colClocks?: Record<string, string>): void;
+	/**
+	* Guarantee a materialized row carries its own primary key.
+	*
+	* A delta's payload is not always a whole row: eager broadcasts forward the
+	* writer's payload verbatim, and the typed API omits the pk from what a
+	* client may write — so an eagerly-broadcast insert describes a row with no
+	* id in it. Rows are addressed by `rowId` everywhere in the protocol, so the
+	* key is never in doubt; only the materialized object was missing it, and
+	* `rows.map(r => r.id)` came back undefined.
+	*/
+	private withPk;
 	revertOp(opId: string, serverRow: Record<string, unknown> | null | undefined): void;
 	setTableMeta(meta: Record<string, {
 		serverSet: string[];
@@ -496,11 +507,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.
@@ -642,4 +657,4 @@ interface SyncSvelteHooks<TQueries extends SyncQueryMap> {
 	createStore: (config: SyncStoreConfig) => TypedSyncStore<TQueries>;
 }
 declare function createSyncSvelte<TQueries extends SyncQueryMap>(): SyncSvelteHooks<TQueries>;
-export { createSyncSvelte, createSyncStore, createBrowserWsTransport, TypedSyncStore, SyncSvelteHooks, SyncStoreConfig, SyncStore, Readable };
+export { Readable, SyncStore, SyncStoreConfig, SyncSvelteHooks, TypedSyncStore, createBrowserWsTransport, createSyncStore, createSyncSvelte };

package/dist/cjs/transport/bun-ws.cjs

@@ -41,16 +41,16 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 // src/core/types.ts
 var exports_types = {};
 __export(exports_types, {
-  reasonFromError: () => reasonFromError,
-  isErrorReason: () => isErrorReason,
-  TransportSendError: () => TransportSendError,
-  TOMBSTONE_RETENTION_MS: () => TOMBSTONE_RETENTION_MS,
-  SUPPORTED_PROTOCOL_VERSIONS: () => SUPPORTED_PROTOCOL_VERSIONS,
-  SERVER_TOMBSTONE_RETENTION_MS: () => SERVER_TOMBSTONE_RETENTION_MS,
-  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
-  MutationError: () => MutationError,
+  MAX_BATCH_SIZE: () => MAX_BATCH_SIZE,
   MAX_CLOCK_DRIFT_MS: () => MAX_CLOCK_DRIFT_MS,
-  MAX_BATCH_SIZE: () => MAX_BATCH_SIZE
+  MutationError: () => MutationError,
+  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+  SERVER_TOMBSTONE_RETENTION_MS: () => SERVER_TOMBSTONE_RETENTION_MS,
+  SUPPORTED_PROTOCOL_VERSIONS: () => SUPPORTED_PROTOCOL_VERSIONS,
+  TOMBSTONE_RETENTION_MS: () => TOMBSTONE_RETENTION_MS,
+  TransportSendError: () => TransportSendError,
+  isErrorReason: () => isErrorReason,
+  reasonFromError: () => reasonFromError
 });
 function isErrorReason(value) {
   return typeof value === "string" && VALID_ERROR_REASONS.has(value);

package/dist/cjs/transport/bun-ws.d.cts

@@ -212,4 +212,4 @@ declare function createBunWsServerTransport(cfg?: BunWsServerConfig): {
 		pong?(ws: BunServerWebSocket<BunWsTransportData>): void;
 	};
 };
-export { createBunWsServerTransport, BunWsTransportData, BunWsServerConfig };
+export { BunWsServerConfig, BunWsTransportData, createBunWsServerTransport };

package/dist/cjs/transport/polling.cjs

@@ -41,16 +41,16 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 // src/core/types.ts
 var exports_types = {};
 __export(exports_types, {
-  reasonFromError: () => reasonFromError,
-  isErrorReason: () => isErrorReason,
-  TransportSendError: () => TransportSendError,
-  TOMBSTONE_RETENTION_MS: () => TOMBSTONE_RETENTION_MS,
-  SUPPORTED_PROTOCOL_VERSIONS: () => SUPPORTED_PROTOCOL_VERSIONS,
-  SERVER_TOMBSTONE_RETENTION_MS: () => SERVER_TOMBSTONE_RETENTION_MS,
-  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
-  MutationError: () => MutationError,
+  MAX_BATCH_SIZE: () => MAX_BATCH_SIZE,
   MAX_CLOCK_DRIFT_MS: () => MAX_CLOCK_DRIFT_MS,
-  MAX_BATCH_SIZE: () => MAX_BATCH_SIZE
+  MutationError: () => MutationError,
+  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+  SERVER_TOMBSTONE_RETENTION_MS: () => SERVER_TOMBSTONE_RETENTION_MS,
+  SUPPORTED_PROTOCOL_VERSIONS: () => SUPPORTED_PROTOCOL_VERSIONS,
+  TOMBSTONE_RETENTION_MS: () => TOMBSTONE_RETENTION_MS,
+  TransportSendError: () => TransportSendError,
+  isErrorReason: () => isErrorReason,
+  reasonFromError: () => reasonFromError
 });
 function isErrorReason(value) {
   return typeof value === "string" && VALID_ERROR_REASONS.has(value);
@@ -108,9 +108,9 @@ var init_types = __esm(() => {
 init_types();
 var exports_polling = {};
 __export(exports_polling, {
-  pollingBodyTooLarge: () => pollingBodyTooLarge,
+  createPollingClientTransport: () => createPollingClientTransport,
   createPollingServerTransport: () => createPollingServerTransport,
-  createPollingClientTransport: () => createPollingClientTransport
+  pollingBodyTooLarge: () => pollingBodyTooLarge
 });
 module.exports = __toCommonJS(exports_polling);
 function pollingBodyTooLarge(body, limit = 1e6) {

package/dist/cjs/transport/polling.d.cts

@@ -207,4 +207,4 @@ interface PollingClientConfig {
 	headers?: Record<string, string>;
 }
 declare function createPollingClientTransport(config: PollingClientConfig): ClientTransport;
-export { pollingBodyTooLarge, createPollingServerTransport, createPollingClientTransport, PollingServerConfig, PollingClientConfig };
+export { PollingClientConfig, PollingServerConfig, createPollingClientTransport, createPollingServerTransport, pollingBodyTooLarge };

package/dist/cjs/transport/sse.cjs

@@ -41,16 +41,16 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 // src/core/types.ts
 var exports_types = {};
 __export(exports_types, {
-  reasonFromError: () => reasonFromError,
-  isErrorReason: () => isErrorReason,
-  TransportSendError: () => TransportSendError,
-  TOMBSTONE_RETENTION_MS: () => TOMBSTONE_RETENTION_MS,
-  SUPPORTED_PROTOCOL_VERSIONS: () => SUPPORTED_PROTOCOL_VERSIONS,
-  SERVER_TOMBSTONE_RETENTION_MS: () => SERVER_TOMBSTONE_RETENTION_MS,
-  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
-  MutationError: () => MutationError,
+  MAX_BATCH_SIZE: () => MAX_BATCH_SIZE,
   MAX_CLOCK_DRIFT_MS: () => MAX_CLOCK_DRIFT_MS,
-  MAX_BATCH_SIZE: () => MAX_BATCH_SIZE
+  MutationError: () => MutationError,
+  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+  SERVER_TOMBSTONE_RETENTION_MS: () => SERVER_TOMBSTONE_RETENTION_MS,
+  SUPPORTED_PROTOCOL_VERSIONS: () => SUPPORTED_PROTOCOL_VERSIONS,
+  TOMBSTONE_RETENTION_MS: () => TOMBSTONE_RETENTION_MS,
+  TransportSendError: () => TransportSendError,
+  isErrorReason: () => isErrorReason,
+  reasonFromError: () => reasonFromError
 });
 function isErrorReason(value) {
   return typeof value === "string" && VALID_ERROR_REASONS.has(value);
@@ -108,8 +108,8 @@ var init_types = __esm(() => {
 init_types();
 var exports_sse = {};
 __export(exports_sse, {
-  createSseServerTransport: () => createSseServerTransport,
-  createSseClientTransport: () => createSseClientTransport
+  createSseClientTransport: () => createSseClientTransport,
+  createSseServerTransport: () => createSseServerTransport
 });
 module.exports = __toCommonJS(exports_sse);
 function createSseServerTransport(cfg = {}) {

package/dist/cjs/transport/sse.d.cts

@@ -202,4 +202,4 @@ interface SseClientConfig {
 	headers?: Record<string, string>;
 }
 declare function createSseClientTransport(config: SseClientConfig): ClientTransport;
-export { createSseServerTransport, createSseClientTransport, SseServerConfig, SseClientConfig };
+export { SseClientConfig, SseServerConfig, createSseClientTransport, createSseServerTransport };

package/dist/cjs/transport/ws.cjs

@@ -41,16 +41,16 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 // src/core/types.ts
 var exports_types = {};
 __export(exports_types, {
-  reasonFromError: () => reasonFromError,
-  isErrorReason: () => isErrorReason,
-  TransportSendError: () => TransportSendError,
-  TOMBSTONE_RETENTION_MS: () => TOMBSTONE_RETENTION_MS,
-  SUPPORTED_PROTOCOL_VERSIONS: () => SUPPORTED_PROTOCOL_VERSIONS,
-  SERVER_TOMBSTONE_RETENTION_MS: () => SERVER_TOMBSTONE_RETENTION_MS,
-  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
-  MutationError: () => MutationError,
+  MAX_BATCH_SIZE: () => MAX_BATCH_SIZE,
   MAX_CLOCK_DRIFT_MS: () => MAX_CLOCK_DRIFT_MS,
-  MAX_BATCH_SIZE: () => MAX_BATCH_SIZE
+  MutationError: () => MutationError,
+  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+  SERVER_TOMBSTONE_RETENTION_MS: () => SERVER_TOMBSTONE_RETENTION_MS,
+  SUPPORTED_PROTOCOL_VERSIONS: () => SUPPORTED_PROTOCOL_VERSIONS,
+  TOMBSTONE_RETENTION_MS: () => TOMBSTONE_RETENTION_MS,
+  TransportSendError: () => TransportSendError,
+  isErrorReason: () => isErrorReason,
+  reasonFromError: () => reasonFromError
 });
 function isErrorReason(value) {
   return typeof value === "string" && VALID_ERROR_REASONS.has(value);
@@ -108,9 +108,9 @@ var init_types = __esm(() => {
 init_types();
 var exports_ws = {};
 __export(exports_ws, {
-  isOriginAllowed: () => isOriginAllowed,
+  createWsClientTransport: () => createWsClientTransport,
   createWsServerTransport: () => createWsServerTransport,
-  createWsClientTransport: () => createWsClientTransport
+  isOriginAllowed: () => isOriginAllowed
 });
 module.exports = __toCommonJS(exports_ws);
 function trySend(clientId, ws, data, maxBufferedBytes) {

package/dist/cjs/transport/ws.d.cts

@@ -233,4 +233,4 @@ interface WebSocketLike {
 	/** Bytes queued but not yet flushed. Used for outbound backpressure. */
 	bufferedAmount?: number;
 }
-export { isOriginAllowed, createWsServerTransport, createWsClientTransport, WsServerTransportConfig, WsServerConfig, WsClientConfig, WebSocketLike };
+export { WebSocketLike, WsClientConfig, WsServerConfig, WsServerTransportConfig, createWsClientTransport, createWsServerTransport, isOriginAllowed };