reflectdb 0.1.0 → 0.1.2

package/dist/cjs/client/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,12 +107,12 @@ var init_types = __esm(() => {
 // src/client/index.ts
 var exports_client = {};
 __export(exports_client, {
-  pushSafely: () => pushSafely,
-  createSyncClient: () => createSyncClient,
-  createOpCreator: () => createOpCreator,
-  createMemoryStorage: () => createMemoryStorage,
+  ClientStore: () => ClientStore,
   SyncClient: () => SyncClient,
-  ClientStore: () => ClientStore
+  createMemoryStorage: () => createMemoryStorage,
+  createOpCreator: () => createOpCreator,
+  createSyncClient: () => createSyncClient,
+  pushSafely: () => pushSafely
 });
 module.exports = __toCommonJS(exports_client);
 
@@ -414,7 +414,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 ?? {};
@@ -435,7 +435,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);
@@ -480,10 +486,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) {

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

@@ -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/cjs/client/storage/indexeddb.d.cts

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

package/dist/cjs/core/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,26 +107,26 @@ var init_types = __esm(() => {
 // src/core/index.ts
 var exports_core = {};
 __export(exports_core, {
-  view: () => view,
-  unpackHlc: () => unpackHlc,
-  t: () => t,
-  sendHlc: () => sendHlc,
-  receiveHlc: () => receiveHlc,
-  reasonFromError: () => reasonFromError,
-  presence: () => presence,
-  packHlc: () => packHlc,
-  isErrorReason: () => isErrorReason,
-  defineSyncQueries: () => defineSyncQueries,
-  createHlc: () => createHlc,
-  compareHlc: () => compareHlc,
-  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,
+  compareHlc: () => compareHlc,
+  createHlc: () => createHlc,
+  defineSyncQueries: () => defineSyncQueries,
+  isErrorReason: () => isErrorReason,
+  packHlc: () => packHlc,
+  presence: () => presence,
+  reasonFromError: () => reasonFromError,
+  receiveHlc: () => receiveHlc,
+  sendHlc: () => sendHlc,
+  t: () => t,
+  unpackHlc: () => unpackHlc,
+  view: () => view
 });
 module.exports = __toCommonJS(exports_core);
 

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

@@ -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/cjs/react/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,18 +107,18 @@ var init_types = __esm(() => {
 // src/react/index.ts
 var exports_react = {};
 __export(exports_react, {
-  useTotalCount: () => useTotalCount,
-  useSyncStatus: () => useSyncStatus,
-  useSyncClient: () => useSyncClient,
-  useSync: () => useSync,
-  useRow: () => useRow,
-  usePendingCount: () => usePendingCount,
-  useLoadMore: () => useLoadMore,
-  useEphemeral: () => useEphemeral,
-  derivePresenceKey: () => derivePresenceKey,
-  createSyncReact: () => createSyncReact,
+  SyncContext: () => SyncContext,
   SyncProvider: () => SyncProvider,
-  SyncContext: () => SyncContext
+  createSyncReact: () => createSyncReact,
+  derivePresenceKey: () => derivePresenceKey,
+  useEphemeral: () => useEphemeral,
+  useLoadMore: () => useLoadMore,
+  usePendingCount: () => usePendingCount,
+  useRow: () => useRow,
+  useSync: () => useSync,
+  useSyncClient: () => useSyncClient,
+  useSyncStatus: () => useSyncStatus,
+  useTotalCount: () => useTotalCount
 });
 module.exports = __toCommonJS(exports_react);
 
@@ -427,7 +427,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 ?? {};
@@ -448,7 +448,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);
@@ -493,10 +499,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) {
@@ -1176,7 +1191,7 @@ function pushSafely(client) {
 }
 
 // src/react/context.tsx
-var jsx_dev_runtime = require("react/jsx-dev-runtime");
+var jsx_runtime = require("react/jsx-runtime");
 var SyncContext = import_react.createContext(null);
 function createBrowserWsTransport(url) {
   let ws = null;
@@ -1292,10 +1307,10 @@ function SyncProvider({
   }, [url, clientId, storage, managedTables]);
   if (!ctx)
     return null;
-  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(SyncContext.Provider, {
+  return /* @__PURE__ */ jsx_runtime.jsx(SyncContext.Provider, {
     value: ctx,
     children
-  }, undefined, false, undefined, this);
+  });
 }
 function useSyncClient() {
   const ctx = import_react.useContext(SyncContext);
@@ -1361,21 +1376,21 @@ function useEphemeral(config) {
   const timersRef = import_react2.useRef(new Map);
   import_react2.useEffect(() => {
     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 () => {
@@ -1492,8 +1507,8 @@ function createSyncReact(queries) {
       userId,
       ttlMs
     });
-    const peers = import_react3.useMemo(() => Object.entries(events).map(([uid, state]) => ({
-      userId: uid,
+    const peers = import_react3.useMemo(() => Object.entries(events).map(([peerId, state]) => ({
+      userId: peerId,
       state
     })), [events]);
     return { peers, set: broadcast };

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

@@ -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/cjs/server/drizzle.cjs

@@ -41,8 +41,8 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 // src/server/drizzle.ts
 var exports_drizzle = {};
 __export(exports_drizzle, {
-  drizzleTxAtomic: () => drizzleTxAtomic,
-  drizzleTable: () => drizzleTable
+  drizzleTable: () => drizzleTable,
+  drizzleTxAtomic: () => drizzleTxAtomic
 });
 module.exports = __toCommonJS(exports_drizzle);
 var import_node_module2 = require("node:module");

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

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