reflectdb 0.1.0 → 0.1.2

package/dist/cjs/vanilla/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/vanilla/index.ts
 var exports_vanilla = {};
 __export(exports_vanilla, {
-  createSyncVanilla: () => createSyncVanilla,
+  createBrowserWsTransport: () => createBrowserWsTransport,
   createSync: () => createSync,
-  createBrowserWsTransport: () => createBrowserWsTransport
+  createSyncVanilla: () => createSyncVanilla
 });
 module.exports = __toCommonJS(exports_vanilla);
 
@@ -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) {
@@ -1341,20 +1356,20 @@ function createSync(config) {
       }
     }
     const unsub = client.subscribeEphemeral(ephConfig.key, (event) => {
-      events = { ...events, [event.userId]: event.data };
+      events = { ...events, [event.clientId]: event.data };
       if (ephConfig.ttlMs) {
-        const existing = timers.get(event.userId);
+        const existing = timers.get(event.clientId);
         if (existing) {
           clearTimeout(existing);
         }
         const timer = setTimeout(() => {
           const next = { ...events };
-          delete next[event.userId];
+          delete next[event.clientId];
           events = next;
-          timers.delete(event.userId);
+          timers.delete(event.clientId);
           notifyChange();
         }, ephConfig.ttlMs);
-        timers.set(event.userId, timer);
+        timers.set(event.clientId, timer);
       }
       notifyChange();
     });

package/dist/cjs/vanilla/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[];
@@ -504,11 +515,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.
@@ -654,4 +669,4 @@ interface SyncVanillaHooks<TQueries extends SyncQueryMap> {
 	createSync: (config: VanillaSyncConfig) => TypedVanillaSync<TQueries>;
 }
 declare function createSyncVanilla<TQueries extends SyncQueryMap>(): SyncVanillaHooks<TQueries>;
-export { createSyncVanilla, createSync2 as createSync, createBrowserWsTransport, VanillaSyncConfig, VanillaSync, TypedVanillaSync, TableBinding, SyncVanillaHooks, EphemeralBinding };
+export { EphemeralBinding, SyncVanillaHooks, TableBinding, TypedVanillaSync, VanillaSync, VanillaSyncConfig, createBrowserWsTransport, createSync2 as createSync, createSyncVanilla };

package/dist/client/index.d.ts

@@ -285,6 +285,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[];
@@ -475,11 +486,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.
@@ -626,4 +641,4 @@ interface TypedSyncClient<TQueries extends SyncQueryMap> {
 	subscribeEphemeral(key: string, listener: (event: EphemeralEvent) => void): () => void;
 }
 declare function createSyncClient<TQueries extends SyncQueryMap>(config: TypedSyncClientConfig<TQueries>): TypedSyncClient<TQueries>;
-export { pushSafely, createSyncClient, createOpCreator, createMemoryStorage, TypedSyncClientConfig, TypedSyncClient, SyncOptions, SyncClientState, SyncClientConfig, SyncClient, PendingOp, OpCreator, LocalRow, ClientStore, ClientStorageAdapter };
+export { ClientStorageAdapter, ClientStore, LocalRow, OpCreator, PendingOp, SyncClient, SyncClientConfig, SyncClientState, SyncOptions, TypedSyncClient, TypedSyncClientConfig, createMemoryStorage, createOpCreator, createSyncClient, pushSafely };

package/dist/client/index.js

@@ -3,10 +3,10 @@ import {
   SyncClient,
   createOpCreator,
   pushSafely
-} from "../shared/esm-ytrd3hbq.js";
+} from "../shared/esm-8qbr4y0d.js";
 import"../shared/esm-rw7jjtrv.js";
 import"../shared/esm-3tkwvysa.js";
-import"../shared/esm-b7xs9cde.js";
+import"../shared/esm-k7kedp3y.js";
 // src/client/storage/memory.ts
 function createMemoryStorage() {
   const rows = new Map;
@@ -97,10 +97,10 @@ function createSyncClient(config) {
   return client;
 }
 export {
-  pushSafely,
-  createSyncClient,
-  createOpCreator,
-  createMemoryStorage,
+  ClientStore,
   SyncClient,
-  ClientStore
+  createMemoryStorage,
+  createOpCreator,
+  createSyncClient,
+  pushSafely
 };

package/dist/client/storage/indexeddb.d.ts

@@ -82,4 +82,4 @@ declare function createIndexedDBStorage(config: {
 		configVersion: number;
 	}, storage: ClientStorageAdapter) => void | Promise<void>;
 }): ClientStorageAdapter;
-export { createIndexedDBStorage, IndexedDBMigrationContext };
+export { IndexedDBMigrationContext, createIndexedDBStorage };

package/dist/client/storage/indexeddb.js

@@ -1,4 +1,4 @@
-import"../../shared/esm-b7xs9cde.js";
+import"../../shared/esm-k7kedp3y.js";
 
 // src/client/storage/indexeddb.ts
 function createIndexedDBStorage(config) {

package/dist/core/index.d.ts

@@ -321,11 +321,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.
@@ -370,8 +374,8 @@ declare function view<
 	deps?: string[];
 	tables?: string[];
 }): SyncViewDef & {
-	row?: TRow;
-	params?: TParams;
+	row: TRow;
+	params: TParams;
 };
 /**
 * Typed ephemeral channel. Sugar over the runtime `useEphemeral` hook —
@@ -392,8 +396,8 @@ declare function presence<
 	params?: TParams;
 	ttlMs?: number;
 }): SyncPresenceDef & {
-	state?: TState;
-	params?: TParams;
+	state: TState;
+	params: TParams;
 };
 type SyncQueryEntry = SyncQueryDef | SyncViewDef | SyncPresenceDef;
 type SyncQueryMap = Record<string, SyncQueryEntry>;
@@ -403,12 +407,20 @@ type ColumnOf<TDef> = TDef extends {
 } ? keyof TDef["table"]["$inferSelect"] & string : TDef extends {
 	row: infer R extends Record<string, unknown>;
 } ? keyof R & string : string;
-/** Constrain serverSet and readonly to valid column names. Accepts either array or object form for serverSet. View/presence entries don't have these fields, so the constraint is empty. */
+/**
+* Constrain serverSet and readonly to valid column names. Accepts either array
+* or object form for serverSet.
+*
+* View/presence entries carry neither field, so they get `unknown` — the
+* identity of intersection. `Record<string, never>` reads like "no constraint"
+* but means "an object with no properties", which every view and presence entry
+* fails, making both helpers unusable inside `defineSyncQueries`.
+*/
 type FieldsConstraint<TDef> = TDef extends {
 	__view: true;
 } | {
 	__presence: true;
-} ? Record<string, never> : {
+} ? unknown : {
 	serverSet?: readonly ColumnOf<TDef>[] | Readonly<Partial<Record<ColumnOf<TDef>, ServerSetSchemaValue>>>;
 	readonly?: readonly ColumnOf<TDef>[];
 };
@@ -470,4 +482,4 @@ type InferWritableRow<
 } ? never : Omit<InferRow<TQueries, K>, (TQueries[K] extends {
 	readonly: readonly (infer R extends string)[];
 } ? R : never) | InferServerSetKeys<TQueries[K]> | PkOf<TQueries[K]>>;
-export { view, unpackHlc, t, sendHlc, receiveHlc, reasonFromError, presence, packHlc, isErrorReason, defineSyncQueries, createHlc, compareHlc, UnsyncMessage, TransportSendError, TableMeta, TOMBSTONE_RETENTION_MS, SyncViewDef, SyncQueryMap, SyncQueryEntry, SyncQueryDef, SyncPresenceDef, SyncOp, SyncMessage, SyncError, SyncDeclareMessage, SnapshotMessage, ShapeConfig, ShapeChangedMessage, ServerTransport, ServerMessage, SUPPORTED_PROTOCOL_VERSIONS, SERVER_TOMBSTONE_RETENTION_MS, ResumeRejectedMessage, ResumeMessage, ResumeCompleteMessage, RequiresParams, RejectMessage, ReauthMessage, RateLimitConfig, PROTOCOL_VERSION, OpsMessage, OpType, OpStatus, MutationError, MAX_CLOCK_DRIFT_MS, MAX_BATCH_SIZE, LoadMoreMessage, InferWritableRow, InferState, InferRow, InferParams, HelloRejectMessage, HelloMessage, HelloAckMessage, HLC, ErrorReason, EphemeralMessage, EphemeralEvent, DrizzleTableLike, DisconnectMessage, Dialect, DeltaMessage, CustomConflictPolicy, CountChangedMessage, ConflictResolver, ConflictPolicy, CompactionConfig, ClientTransport, ClientOp, ClientMessage, BootstrapMessage, BootstrapCompleteMessage, AuthMessage, AuthContext, AckMessage };
+export { AckMessage, AuthContext, AuthMessage, BootstrapCompleteMessage, BootstrapMessage, ClientMessage, ClientOp, ClientTransport, CompactionConfig, ConflictPolicy, ConflictResolver, CountChangedMessage, CustomConflictPolicy, DeltaMessage, Dialect, DisconnectMessage, DrizzleTableLike, EphemeralEvent, EphemeralMessage, ErrorReason, HLC, HelloAckMessage, HelloMessage, HelloRejectMessage, InferParams, InferRow, InferState, InferWritableRow, LoadMoreMessage, MAX_BATCH_SIZE, MAX_CLOCK_DRIFT_MS, MutationError, OpStatus, OpType, OpsMessage, PROTOCOL_VERSION, RateLimitConfig, ReauthMessage, RejectMessage, RequiresParams, ResumeCompleteMessage, ResumeMessage, ResumeRejectedMessage, SERVER_TOMBSTONE_RETENTION_MS, SUPPORTED_PROTOCOL_VERSIONS, ServerMessage, ServerTransport, ShapeChangedMessage, ShapeConfig, SnapshotMessage, SyncDeclareMessage, SyncError, SyncMessage, SyncOp, SyncPresenceDef, SyncQueryDef, SyncQueryEntry, SyncQueryMap, SyncViewDef, TOMBSTONE_RETENTION_MS, TableMeta, TransportSendError, UnsyncMessage, compareHlc, createHlc, defineSyncQueries, isErrorReason, packHlc, presence, reasonFromError, receiveHlc, sendHlc, t, unpackHlc, view };

package/dist/core/index.js

@@ -18,7 +18,7 @@ import {
   isErrorReason,
   reasonFromError
 } from "../shared/esm-3tkwvysa.js";
-import"../shared/esm-b7xs9cde.js";
+import"../shared/esm-k7kedp3y.js";
 // src/core/schema.ts
 function view(opts) {
   return { __view: true, ...opts };
@@ -33,24 +33,24 @@ function t() {
   return;
 }
 export {
-  view,
-  unpackHlc,
-  t,
-  sendHlc,
-  receiveHlc,
-  reasonFromError,
-  presence,
-  packHlc,
-  isErrorReason,
-  defineSyncQueries,
-  createHlc,
-  compareHlc,
-  TransportSendError,
-  TOMBSTONE_RETENTION_MS,
-  SUPPORTED_PROTOCOL_VERSIONS,
-  SERVER_TOMBSTONE_RETENTION_MS,
-  PROTOCOL_VERSION,
-  MutationError,
+  MAX_BATCH_SIZE,
   MAX_CLOCK_DRIFT_MS,
-  MAX_BATCH_SIZE
+  MutationError,
+  PROTOCOL_VERSION,
+  SERVER_TOMBSTONE_RETENTION_MS,
+  SUPPORTED_PROTOCOL_VERSIONS,
+  TOMBSTONE_RETENTION_MS,
+  TransportSendError,
+  compareHlc,
+  createHlc,
+  defineSyncQueries,
+  isErrorReason,
+  packHlc,
+  presence,
+  reasonFromError,
+  receiveHlc,
+  sendHlc,
+  t,
+  unpackHlc,
+  view
 };

package/dist/react/index.d.ts

@@ -268,6 +268,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[];
@@ -531,6 +542,9 @@ declare function usePendingCount2(): number;
 *
 * ```tsx
 * function CursorTracker({ userId }: { userId: string }) {
+* `events` is keyed by the peer's `clientId`, so two tabs from one account
+* appear as two peers.
+*
 *   const { events, broadcast } = useEphemeral({
 *     key: "cursor",
 *     userId,
@@ -546,8 +560,8 @@ declare function usePendingCount2(): number;
 *
 *   return (
 *     <div>
-*       {Object.entries(events).map(([uid, data]) => (
-*         <div key={uid}>User {uid}: {JSON.stringify(data)}</div>
+*       {Object.entries(events).map(([peerId, data]) => (
+*         <div key={peerId}>Peer {peerId}: {JSON.stringify(data)}</div>
 *       ))}
 *     </div>
 *   );
@@ -579,11 +593,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.
@@ -745,4 +763,4 @@ type UseSyncOptions<
 	window?: number;
 };
 declare function createSyncReact<TQueries extends SyncQueryMap>(queries?: TQueries): SyncReactHooks<TQueries>;
-export { useTotalCount2 as useTotalCount, useSyncStatus2 as useSyncStatus, useSyncClient, useSync2 as useSync, useRow2 as useRow, usePendingCount2 as usePendingCount, useLoadMore2 as useLoadMore, useEphemeral2 as useEphemeral, derivePresenceKey, createSyncReact, SyncProviderProps, SyncProvider2 as SyncProvider, SyncContext };
+export { SyncContext, SyncProvider2 as SyncProvider, SyncProviderProps, createSyncReact, derivePresenceKey, useEphemeral2 as useEphemeral, useLoadMore2 as useLoadMore, usePendingCount2 as usePendingCount, useRow2 as useRow, useSync2 as useSync, useSyncClient, useSyncStatus2 as useSyncStatus, useTotalCount2 as useTotalCount };

package/dist/react/index.js

@@ -1,14 +1,14 @@
 import {
   SyncClient,
   pushSafely
-} from "../shared/esm-ytrd3hbq.js";
+} from "../shared/esm-8qbr4y0d.js";
 import"../shared/esm-rw7jjtrv.js";
 import"../shared/esm-3tkwvysa.js";
-import"../shared/esm-b7xs9cde.js";
+import"../shared/esm-k7kedp3y.js";
 
 // src/react/context.tsx
 import { createContext, useContext, useEffect, useMemo, useRef, useState } from "react";
-import { jsxDEV } from "react/jsx-dev-runtime";
+import { jsx } from "react/jsx-runtime";
 var SyncContext = createContext(null);
 function createBrowserWsTransport(url) {
   let ws = null;
@@ -124,10 +124,10 @@ function SyncProvider({
   }, [url, clientId, storage, managedTables]);
   if (!ctx)
     return null;
-  return /* @__PURE__ */ jsxDEV(SyncContext.Provider, {
+  return /* @__PURE__ */ jsx(SyncContext.Provider, {
     value: ctx,
     children
-  }, undefined, false, undefined, this);
+  });
 }
 function useSyncClient() {
   const ctx = useContext(SyncContext);
@@ -201,21 +201,21 @@ function useEphemeral(config) {
   const timersRef = useRef2(new Map);
   useEffect2(() => {
     const unsub = client.subscribeEphemeral(config.key, (event) => {
-      setEvents((prev) => ({ ...prev, [event.userId]: event.data }));
+      setEvents((prev) => ({ ...prev, [event.clientId]: event.data }));
       if (config.ttlMs) {
-        const existing = timersRef.current.get(event.userId);
+        const existing = timersRef.current.get(event.clientId);
         if (existing) {
           clearTimeout(existing);
         }
         const timer = setTimeout(() => {
           setEvents((prev) => {
             const next = { ...prev };
-            delete next[event.userId];
+            delete next[event.clientId];
             return next;
           });
-          timersRef.current.delete(event.userId);
+          timersRef.current.delete(event.clientId);
         }, config.ttlMs);
-        timersRef.current.set(event.userId, timer);
+        timersRef.current.set(event.clientId, timer);
       }
     });
     return () => {
@@ -332,8 +332,8 @@ function createSyncReact(queries) {
       userId,
       ttlMs
     });
-    const peers = useMemo3(() => Object.entries(events).map(([uid, state]) => ({
-      userId: uid,
+    const peers = useMemo3(() => Object.entries(events).map(([peerId, state]) => ({
+      userId: peerId,
       state
     })), [events]);
     return { peers, set: broadcast };
@@ -351,16 +351,16 @@ function createSyncReact(queries) {
   };
 }
 export {
-  useTotalCount,
-  useSyncStatus,
-  useSyncClient,
-  useSync,
-  useRow,
-  usePendingCount,
-  useLoadMore,
-  useEphemeral,
-  derivePresenceKey,
-  createSyncReact,
+  SyncContext,
   SyncProvider,
-  SyncContext
+  createSyncReact,
+  derivePresenceKey,
+  useEphemeral,
+  useLoadMore,
+  usePendingCount,
+  useRow,
+  useSync,
+  useSyncClient,
+  useSyncStatus,
+  useTotalCount
 };

package/dist/server/drizzle.d.ts

@@ -230,4 +230,4 @@ declare function drizzleTable<
 * has a single source of truth.
 */
 declare const drizzleTxAtomic: TxAtomicAdapter;
-export { drizzleTxAtomic, drizzleTable, DrizzleTableOpts };
+export { DrizzleTableOpts, drizzleTable, drizzleTxAtomic };

package/dist/server/drizzle.js

@@ -2,8 +2,8 @@ import {
   drizzleTable,
   drizzleTxAtomic
 } from "../shared/esm-z1xse19c.js";
-import"../shared/esm-b7xs9cde.js";
+import"../shared/esm-k7kedp3y.js";
 export {
-  drizzleTxAtomic,
-  drizzleTable
+  drizzleTable,
+  drizzleTxAtomic
 };

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

@@ -0,0 +1,102 @@
+/**
+* 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>;
+}
+declare class EphemeralManager implements EphemeralAdapter {
+	private store;
+	private clientIndex;
+	private entryCount;
+	private maxEntries;
+	constructor(maxEntries?: number);
+	set(room: string, key: string, clientId: string, userId: string, data: Record<string, unknown>, ttlMs?: number): boolean;
+	private addToClientIndex;
+	private removeFromClientIndex;
+	get(room: string, key: string): Record<string, EphemeralState>;
+	getRoom(room: string): Record<string, Record<string, EphemeralState>>;
+	remove(room: string, key: string, clientId: string): void;
+	removeClient(clientId: string): void;
+	cleanupExpired(): void;
+	size(): number;
+	destroy(): void;
+}
+/** Convenience factory mirroring the other adapters. */
+declare function createMemoryEphemeral(maxEntries?: number): EphemeralManager;
+export { EphemeralAdapter, EphemeralBroadcast, EphemeralManager, EphemeralState, EphemeralTarget, MaybePromise, createMemoryEphemeral };

package/dist/server/ephemeral/index.js

@@ -0,0 +1,9 @@
+import {
+  EphemeralManager,
+  createMemoryEphemeral
+} from "../../shared/esm-g0marxk7.js";
+import"../../shared/esm-k7kedp3y.js";
+export {
+  EphemeralManager,
+  createMemoryEphemeral
+};