@nxtedition/deepstream.io-client-js 32.0.22 → 32.0.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/deepstream.io-client-js",
-  "version": "32.0.22",
+  "version": "32.0.24",
   "description": "the javascript client for deepstream.io",
   "homepage": "http://deepstream.io",
   "type": "module",

package/src/client.d.ts

@@ -3,14 +3,25 @@ import type { Paths, Get } from './record/record.js'
 import type RecordHandler from './record/record-handler.js'
 import type { RecordStats, ProvideOptions, SyncOptions } from './record/record-handler.js'
 import type EventHandler from './event/event-handler.js'
-import type { EventStats } from './event/event-handler.js'
+import type { EventStats, EventProvideOptions } from './event/event-handler.js'
 import type RpcHandler from './rpc/rpc-handler.js'
 import type { RpcStats, RpcMethodDef } from './rpc/rpc-handler.js'
 
+export interface DeepstreamClientOptions {
+  reconnectIntervalIncrement?: number
+  maxReconnectInterval?: number
+  maxReconnectAttempts?: number
+  maxPacketSize?: number
+  batchSize?: number
+  schedule?: ((fn: () => void) => void) | null
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  logger?: any
+}
+
 export default function <
   Records extends Record<string, unknown> = Record<string, unknown>,
   Methods extends Record<string, RpcMethodDef> = Record<string, RpcMethodDef>,
->(url: string, options?: unknown): DeepstreamClient<Records, Methods>
+>(url: string, options?: DeepstreamClientOptions): DeepstreamClient<Records, Methods>
 
 export type {
   DsRecord,
@@ -19,9 +30,12 @@ export type {
   RpcHandler,
   RpcMethodDef,
   ProvideOptions,
+  EventProvideOptions,
   SyncOptions,
   Paths,
   Get,
+  ConnectionStateName,
+  DeepstreamErrorEventName,
 }
 
 type RecordStateConstants = Readonly<{
@@ -77,6 +91,36 @@ type EventConstants = Readonly<{
 }>
 type EventKey = keyof EventConstants
 type EventName = EventConstants[EventKey]
+type DeepstreamErrorEventName = Exclude<
+  EventName,
+  'connectionStateChanged' | 'connected' | 'MAX_RECONNECTION_ATTEMPTS_REACHED'
+>
+
+export interface DeepstreamError extends Error {
+  topic?: string
+  event?: EventName | null
+  data?: unknown
+}
+
+export interface DeepstreamMessage {
+  raw: string | null
+  topic: string | null
+  action: string | null
+  data: string[]
+}
+
+export interface DeepstreamClientEventMap {
+  connectionStateChanged: (state: ConnectionStateName) => void
+  connected: (connected: boolean) => void
+  MAX_RECONNECTION_ATTEMPTS_REACHED: (attempt: number) => void
+  error: (error: DeepstreamError) => void
+  recv: (message: DeepstreamMessage) => void
+  send: (message: DeepstreamMessage) => void
+}
+
+type DeepstreamErrorEventMap = {
+  [K in DeepstreamErrorEventName]: (error: DeepstreamError) => void
+}
 
 export interface DeepstreamClient<
   Records extends Record<string, unknown> = Record<string, unknown>,
@@ -87,11 +131,21 @@ export interface DeepstreamClient<
   rpc: RpcHandler<Methods>
   record: RecordHandler<Records>
   user: string | null
-  on: (evt: EventName, callback: (...args: unknown[]) => void) => void
-  off: (evt: EventName, callback: (...args: unknown[]) => void) => void
+  on<K extends keyof (DeepstreamClientEventMap & DeepstreamErrorEventMap)>(
+    evt: K,
+    callback: (DeepstreamClientEventMap & DeepstreamErrorEventMap)[K],
+  ): this
+  off<K extends keyof (DeepstreamClientEventMap & DeepstreamErrorEventMap)>(
+    evt: K,
+    callback: (DeepstreamClientEventMap & DeepstreamErrorEventMap)[K],
+  ): this
   getConnectionState: () => ConnectionStateName
   close: () => void
-  login: unknown
+  login(callback: (success: boolean, authData: unknown) => void): this
+  login(
+    authParams: Record<string, unknown>,
+    callback: (success: boolean, authData: unknown) => void,
+  ): this
   stats: {
     record: RecordStats
     rpc: RpcStats

package/src/client.test-d.ts

@@ -1,7 +1,8 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import make, { type DeepstreamClient } from './client.js'
+import make, { type DeepstreamClient, type DeepstreamError } from './client.js'
 import { expectAssignable, expectError, expectType } from 'tsd'
 import type { Observable } from 'rxjs'
+import type { EmptyObject } from 'type-fest'
 
 interface Records extends Record<string, unknown> {
   o: {
@@ -22,6 +23,11 @@ interface Records extends Record<string, unknown> {
       }
     }
   }
+  possiblyEmpty:
+    | {
+        pe1: string
+      }
+    | EmptyObject
   c: Circular
   m: {
     m1: string
@@ -62,7 +68,7 @@ expectAssignable<{ n0?: { n1: { n2: { n3: string } } } } | undefined>(await ds.r
 expectAssignable<{ n1: { n2: { n3: string } } } | undefined>(await ds.record.get('n', 'n0'))
 
 // set withouth path
-ds.record.set('n', {}) // empty should always work
+ds.record.set('possiblyEmpty', {}) // empty should always work
 ds.record.set('n', { n0: { n1: { n2: { n3: 'test' } } } })
 expectError(ds.record.set('n', { n0: {} })) // nested props are required
 
@@ -96,10 +102,14 @@ expectError(ds.record.set('n', 'n1.x2', {}))
 expectError(ds.record.set('n', 'n1.n2.n3', { n4: 22 }))
 
 expectAssignable<string>(await ds.record.get('p', 'p1'))
+expectAssignable<{ name: string; version: string; state: number; data: string }>(
+  await ds.record.get2('p', 'p1'),
+)
 expectAssignable<string>(await ds.record.get('p', 'p1', { signal: new AbortController().signal }))
 expectAssignable<string>(await ds.record.get('p', { path: 'p1' }))
 expectAssignable<string | undefined>(await ds.record.get('p', 'p2'))
 expectAssignable<unknown>(await ds.record.get('p', 'x1'))
+expectAssignable<string | undefined>(await ds.record.get('possiblyEmpty', 'pe1'))
 
 // observe with options
 expectAssignable<Observable<{ p1: string; p2?: string; p3: { p4: string } }>>(
@@ -179,6 +189,16 @@ expectAssignable<Promise<void>>(
 )
 expectAssignable<Promise<void>>(ds.record.update('p', 'p1', (data) => data, { timeout: 5000 }))
 
+// update: updater receives version as second argument
+ds.record.update('p', (data, version) => {
+  expectType<string>(version)
+  return data
+})
+ds.record.update('p', 'p1', (data, version) => {
+  expectType<string>(version)
+  return data
+})
+
 // Circular
 expectAssignable<string | undefined>(await ds.record.get('c', 'a.b1'))
 
@@ -210,6 +230,19 @@ expectAssignable<Promise<typeof rec>>(rec.when({ state: 2, timeout: 5000 }))
 expectAssignable<Promise<typeof rec>>(rec.when(2, { timeout: 5000 }))
 expectAssignable<Promise<typeof rec>>(rec.when(2, { signal: new AbortController().signal }))
 
+// Record.subscribe: callback receives (record, opaque)
+rec.subscribe((record, opaque) => {
+  expectType<typeof rec>(record)
+  expectType<unknown>(opaque)
+})
+rec.subscribe((record, opaque) => {}, 'my-opaque-token')
+
+// Record.unsubscribe: same callback signature
+rec.unsubscribe((record, opaque) => {
+  expectType<typeof rec>(record)
+  expectType<unknown>(opaque)
+})
+
 // Record.update with options
 expectAssignable<Promise<void>>(rec.update((x) => x, { signal: new AbortController().signal }))
 expectAssignable<Promise<void>>(rec.update((x) => x, { timeout: 5000 }))
@@ -220,7 +253,68 @@ expectAssignable<Promise<void>>(
 expectAssignable<Promise<void>>(rec.update('o0', (x) => x, { timeout: 5000 }))
 expectAssignable<Promise<void>>(rec.update('o0', (x) => x, { state: 2 }))
 
+// Record.update: updater receives version as second argument
+rec.update((x, version) => {
+  expectType<string>(version)
+  return x
+})
+rec.update('o0', (x, version) => {
+  expectType<string>(version)
+  return x
+})
+
 const state = 'VOID'
 expectType<0>(ds.record.STATE[state])
 const unknownState: string = 'VOID'
 expectType<number>(ds.record.STATE[unknownState])
+
+// record.getRecord: [Symbol.dispose] is present
+const recDispose = ds.record.getRecord('o')
+recDispose[Symbol.dispose]()
+
+// record.provide: returns Disposer | void
+expectAssignable<(() => void) | void>(ds.record.provide('pattern*', () => ({})))
+const recordDisposer = ds.record.provide('pattern*', () => ({}))
+if (recordDisposer) {
+  recordDisposer()
+  recordDisposer[Symbol.dispose]()
+}
+
+// event.provide: returns (() => void) | void
+expectAssignable<(() => void) | void>(ds.event.provide('pattern*', () => {}, {}))
+
+// client.on/off: 'error' is a valid event name
+ds.on('error', (err) => {})
+ds.off('error', (err) => {})
+expectError(ds.on('unknownEvent', () => {}))
+
+// client.on: callback arg types per event
+ds.on('error', (err) => {
+  expectType<DeepstreamError>(err)
+})
+ds.on('connectionError', (err) => {
+  expectType<DeepstreamError>(err)
+})
+ds.on('connectionStateChanged', (state) => {
+  expectType<
+    | 'CLOSED'
+    | 'AWAITING_CONNECTION'
+    | 'CHALLENGING'
+    | 'AWAITING_AUTHENTICATION'
+    | 'AUTHENTICATING'
+    | 'OPEN'
+    | 'ERROR'
+    | 'RECONNECTING'
+  >(state)
+})
+ds.on('connected', (connected) => {
+  expectType<boolean>(connected)
+})
+ds.on('MAX_RECONNECTION_ATTEMPTS_REACHED', (attempt) => {
+  expectType<number>(attempt)
+})
+
+// client.on: wrong callback arg types are errors
+expectError(ds.on('connectionStateChanged', (state: number) => {}))
+expectError(ds.on('connected', (connected: string) => {}))
+expectError(ds.on('MAX_RECONNECTION_ATTEMPTS_REACHED', (attempt: string) => {}))

package/src/event/event-handler.d.ts

@@ -4,13 +4,22 @@ export default class EventHandler {
   connected: boolean
   stats: EventStats
   subscribe: (name: string, callback: (data: unknown) => void) => void
-  unsubscribe: (name: string, callback: (data: unknown) => void) => void
+  unsubscribe: (name: string, callback?: (data: unknown) => void) => void
   on: (name: string, callback: (data: unknown) => void) => this
   once: (name: string, callback: (data: unknown) => void) => this
   off: (name: string, callback: (data: unknown) => void) => this
   observe: <Data>(name: string) => Observable<Data>
   emit: <Data>(name: string, data?: Data) => void
-  provide: (pattern: string, callback: (name: string) => void, options: unknown) => () => void
+  provide: (
+    pattern: string,
+    callback: (name: string) => void,
+    options: EventProvideOptions,
+  ) => (() => void) | void
+}
+
+export interface EventProvideOptions {
+  mode?: 'unicast' | (string & {})
+  stringify?: ((input: unknown) => string) | null
 }
 
 export interface EventStats {

package/src/event/event-handler.js

@@ -71,21 +71,21 @@ EventHandler.prototype.unsubscribe = function (name, callback) {
   }
 }
 
-EventHandler.on = function (name, callback) {
+EventHandler.prototype.on = function (name, callback) {
   this.subscribe(name, callback)
   return this
 }
 
-EventHandler.once = function (name, callback) {
+EventHandler.prototype.once = function (name, callback) {
   const fn = (...args) => {
-    this.unsubscribe(fn)
-    callback(...args)
+    this.unsubscribe(name, fn)
+    callback(name, ...args)
   }
   this.subscribe(name, fn)
   return this
 }
 
-EventHandler.off = function (name, callback) {
+EventHandler.prototype.off = function (name, callback) {
   this.unsubscribe(name, callback)
   return this
 }

package/src/message/connection.js

@@ -28,7 +28,6 @@ export default function Connection(client, url, options) {
     action: null,
     data: null,
   }
-  this._decoder = new globalThis.TextDecoder()
   this._recvQueue = new FixedQueue()
   this._reconnectTimeout = null
   this._reconnectionAttempt = 0
@@ -96,9 +95,20 @@ Connection.prototype._createEndpoint = function () {
       generateMask() {},
     })
     this._endpoint.binaryType = 'nodebuffer'
+    this._endpoint.onmessage = ({ data: buf }) => {
+      this._onMessage(buf.toString('utf8', buf[0] >= 128 ? buf[0] - 128 : 0, buf.length))
+    }
   } else {
+    const decoder = new globalThis.TextDecoder()
     this._endpoint = new BrowserWebSocket(this._url)
     this._endpoint.binaryType = 'arraybuffer'
+    this._endpoint.onmessage = ({ data }) => {
+      let buf = new Uint8Array(data)
+      if (buf[0] >= 128) {
+        buf = buf.subarray(buf[0] - 128)
+      }
+      this._onMessage(decoder.decode(buf))
+    }
   }
 
   this._corked = false
@@ -106,8 +116,6 @@ Connection.prototype._createEndpoint = function () {
   this._endpoint.onopen = this._onOpen.bind(this)
   this._endpoint.onerror = this._onError.bind(this)
   this._endpoint.onclose = this._onClose.bind(this)
-  this._endpoint.onmessage = ({ data }) =>
-    this._onMessage(typeof data === 'string' ? data : this._decoder.decode(data))
 }
 
 Connection.prototype.send = function (message) {

package/src/record/record-handler.d.ts

@@ -1,12 +1,6 @@
 import type { Observable } from 'rxjs'
 import type DsRecord from './record.js'
-import type {
-  EmptyObject,
-  Get,
-  UpdateOptions,
-  ObserveOptions,
-  ObserveOptionsWithPath,
-} from './record.js'
+import type { Get, UpdateOptions, ObserveOptions, ObserveOptionsWithPath } from './record.js'
 
 type Lookup<Table, Name> = Name extends keyof Table ? Table[Name] : unknown
 
@@ -32,8 +26,8 @@ export default class RecordHandler<Records = Record<string, unknown>> {
   }
 
   JSON: {
-    EMPTY: EmptyObject
-    EMPTY_OBJ: EmptyObject
+    EMPTY: Record<string, unknown>
+    EMPTY_OBJ: Record<string, unknown>
     EMPTY_ARR: []
   }
 
@@ -46,13 +40,44 @@ export default class RecordHandler<Records = Record<string, unknown>> {
     pattern: string,
     callback: (key: string) => unknown,
     optionsOrRecursive?: ProvideOptions | boolean,
-  ) => Disposer
+  ) => Disposer | void
+
+  put: (
+    name: string,
+    version: string,
+    data: Record<string, unknown> | null,
+    parent?: string,
+  ) => void
+
+  getAsync: {
+    <Name extends string>(
+      name: Name,
+      options: ObserveOptions,
+    ):
+      | { value: Lookup<Records, Name>; async: false }
+      | { value: Promise<Lookup<Records, Name>>; async: true }
+
+    <Name extends string, Path extends string | string[]>(
+      name: Name,
+      path: Path,
+      options?: ObserveOptions,
+    ):
+      | { value: Get<Lookup<Records, Name>, Path>; async: false }
+      | { value: Promise<Get<Lookup<Records, Name>, Path>>; async: true }
+
+    <Name extends string>(
+      name: Name,
+      state?: number,
+    ):
+      | { value: Lookup<Records, Name>; async: false }
+      | { value: Promise<Lookup<Records, Name>>; async: true }
+  }
 
   sync: (options?: SyncOptions) => Promise<void>
 
   set: {
     // without path:
-    <Name extends string>(name: Name, data: Lookup<Records, Name> | EmptyObject): void
+    <Name extends string>(name: Name, data: Lookup<Records, Name>): void
 
     // with path:
     <Name extends string, Path extends string | string[]>(
@@ -67,14 +92,17 @@ export default class RecordHandler<Records = Record<string, unknown>> {
   update: {
     <Name extends string>(
       name: Name,
-      updater: (data: Lookup<Records, Name>) => Lookup<Records, Name> | EmptyObject,
+      updater: (data: Lookup<Records, Name>, version: string) => Lookup<Records, Name>,
       options?: UpdateOptions,
     ): Promise<void>
 
     <Name extends string, Path extends string | string[]>(
       name: Name,
       path: Path,
-      updater: (data: Get<Lookup<Records, Name>, Path>) => Get<Lookup<Records, Name>, Path>,
+      updater: (
+        data: Get<Lookup<Records, Name>, Path>,
+        version: string,
+      ) => Get<Lookup<Records, Name>, Path>,
       options?: UpdateOptions,
     ): Promise<void>
   }
@@ -113,6 +141,73 @@ export default class RecordHandler<Records = Record<string, unknown>> {
     ): Observable<Get<Lookup<Records, Name>, Path>>
   }
 
+  observe2: {
+    <Name extends string>(
+      name: Name,
+      options: ObserveOptions,
+    ): Observable<{
+      name: string
+      version: string
+      state: number
+      data: Lookup<Records, Name>
+    }>
+
+    <Name extends string, Path extends string | string[]>(
+      name: Name,
+      options: ObserveOptionsWithPath<Path>,
+    ): Observable<{
+      name: string
+      version: string
+      state: number
+      data: Get<Lookup<Records, Name>, Path>
+    }>
+
+    <Name extends string>(
+      name: Name,
+      state?: number,
+      options?: ObserveOptions,
+    ): Observable<{
+      name: string
+      version: string
+      state: number
+      data: Lookup<Records, Name>
+    }>
+
+    <Name extends string, Path extends string | string[]>(
+      name: Name,
+      state?: number,
+      options?: ObserveOptionsWithPath<Path>,
+    ): Observable<{
+      name: string
+      version: string
+      state: number
+      data: Get<Lookup<Records, Name>, Path>
+    }>
+
+    <Name extends string, Path extends string | string[]>(
+      name: Name,
+      path: Path,
+      options?: ObserveOptionsWithPath<Path>,
+    ): Observable<{
+      name: string
+      version: string
+      state: number
+      data: Get<Lookup<Records, Name>, Path>
+    }>
+
+    <Name extends string, Path extends string | string[]>(
+      name: Name,
+      path: Path,
+      state?: number,
+      options?: ObserveOptionsWithPath<Path>,
+    ): Observable<{
+      name: string
+      version: string
+      state: number
+      data: Get<Lookup<Records, Name>, Path>
+    }>
+  }
+
   get: {
     <Name extends string>(name: Name, options: ObserveOptions): Promise<Lookup<Records, Name>>
 
@@ -147,11 +242,11 @@ export default class RecordHandler<Records = Record<string, unknown>> {
     ): Promise<Get<Lookup<Records, Name>, Path>>
   }
 
-  observe2: {
+  get2: {
     <Name extends string>(
       name: Name,
       options: ObserveOptions,
-    ): Observable<{
+    ): Promise<{
       name: string
       version: string
       state: number
@@ -161,7 +256,7 @@ export default class RecordHandler<Records = Record<string, unknown>> {
     <Name extends string, Path extends string | string[]>(
       name: Name,
       options: ObserveOptionsWithPath<Path>,
-    ): Observable<{
+    ): Promise<{
       name: string
       version: string
       state: number
@@ -172,7 +267,7 @@ export default class RecordHandler<Records = Record<string, unknown>> {
       name: Name,
       state?: number,
       options?: ObserveOptions,
-    ): Observable<{
+    ): Promise<{
       name: string
       version: string
       state: number
@@ -183,7 +278,7 @@ export default class RecordHandler<Records = Record<string, unknown>> {
       name: Name,
       state?: number,
       options?: ObserveOptionsWithPath<Path>,
-    ): Observable<{
+    ): Promise<{
       name: string
       version: string
       state: number
@@ -194,7 +289,7 @@ export default class RecordHandler<Records = Record<string, unknown>> {
       name: Name,
       path: Path,
       options?: ObserveOptionsWithPath<Path>,
-    ): Observable<{
+    ): Promise<{
       name: string
       version: string
       state: number
@@ -206,7 +301,7 @@ export default class RecordHandler<Records = Record<string, unknown>> {
       path: Path,
       state?: number,
       options?: ObserveOptionsWithPath<Path>,
-    ): Observable<{
+    ): Promise<{
       name: string
       version: string
       state: number
@@ -223,12 +318,13 @@ export interface RecordStats {
   pruning: number
   patching: number
   subscriptions: number
+  listeners: number
 }
 
 export interface ProvideOptions {
   recursive?: boolean
   stringify?: ((input: unknown) => string) | null
-  mode: undefined | null | 'unicast'
+  mode?: null | 'unicast' | (string & {})
 }
 
 export interface SyncOptions {

package/src/record/record-handler.js

@@ -3,7 +3,6 @@ import LegacyListener from '../utils/legacy-listener.js'
 import UnicastListener from '../utils/unicast-listener.js'
 import * as C from '../constants/constants.js'
 import * as rxjs from 'rxjs'
-import invariant from 'invariant'
 import jsonPath from '@nxtedition/json-path'
 import * as utils from '../utils/utils.js'
 import xuid from 'xuid'
@@ -121,10 +120,6 @@ class RecordHandler {
     this._stats = {
       updating: 0,
       created: 0,
-      destroyed: 0,
-      records: 0,
-      pruning: 0,
-      patching: 0,
     }
 
     this._syncQueue = []
@@ -161,12 +156,6 @@ class RecordHandler {
   }
 
   _onPruning(rec, value) {
-    if (value) {
-      this._stats.pruning += 1
-    } else {
-      this._stats.pruning -= 1
-    }
-
     if (value) {
       this._pruning.add(rec)
     } else {
@@ -175,16 +164,10 @@ class RecordHandler {
   }
 
   _onUpdating(rec, value) {
-    const callbacks = this._updating.get(rec)
-
     if (value) {
-      invariant(!callbacks, 'updating callbacks must not exist')
-      this._stats.updating += 1
       this._updating.set(rec, [])
     } else {
-      invariant(callbacks, 'updating callbacks must exist')
-
-      this._stats.updating -= 1
+      const callbacks = this._updating.get(rec)
       this._updating.delete(rec)
       for (const callback of callbacks) {
         callback()
@@ -194,11 +177,8 @@ class RecordHandler {
 
   _onPatching(rec, value) {
     if (value) {
-      this._stats.patching += 1
       this._patching.set(rec, [])
     } else {
-      this._stats.patching -= 1
-
       const callbacks = this._patching.get(rec)
       this._patching.delete(rec)
       for (const callback of callbacks) {
@@ -213,13 +193,18 @@ class RecordHandler {
 
   get stats() {
     let subscriptions = 0
-    for (const listener of this._listeners.values()) {
-      subscriptions += listener.subscriptions ?? 0
+    for (const { stats } of this._listeners.values()) {
+      subscriptions += stats.subscriptions ?? 0
     }
 
     return {
       ...this._stats,
       subscriptions,
+      patching: this._patching.size,
+      updating: this._updating.size,
+      putting: this._putting.size,
+      records: this._records.size,
+      listeners: this._listeners.size,
     }
   }
 

package/src/record/record.d.ts

@@ -1,36 +1,15 @@
 import type RecordHandler from './record-handler.js'
-import type { Get, EmptyObject, SingleKeyObject } from 'type-fest'
-export type { Get, Paths, EmptyObject } from 'type-fest'
+import type { Get as _Get, AllUnionFields } from 'type-fest'
+export type { Paths } from 'type-fest'
 
-// When getting, for convenience, we say the data might be partial under some
-// circumstances.
-//
-// When you e.g. do record.get or record.update, there is always a possibility
-// that the data object is empty. The naive correct type for that would be
-// `Data | EmptyObject`. However, that forces the user to always type guard
-// against the empty object case. This type tries to allow the user to skip
-// that check in some cases, where it should be safe to do so.
-export type GettablePossibleEmpty<Data> = keyof Data extends never
-  ? EmptyObject // If there are no keys at all
-  : Partial<Data> extends Data
-    ? // All properties in Data are already optional, so we can safely return it
-      // as is. The user just need to check the properties themselves instead.
-      Data
-    : SingleKeyObject<Data> extends never
-      ? // There are more than one property in Data, and some of them are
-          // required. That means that the user must always check for the empty
-          // object case.
-          Data | EmptyObject
-      : // There is exactly one property in Data, and it is required. In this
-        // particular case, we can safely use Data as the "empty" type, but
-        // with the single property turned optional.
-        {
-          [K in keyof Data]+?: Data[K]
-        }
-
-// When setting the data must fully adhere to the Data type, or exactly an
-// empty object.
-export type SettablePossibleEmpty<Data> = Data | EmptyObject
+// HACK: Wrap type-fest's Get to get rid of EmptyObject from union
+type RemoveSymbolKeys<T> = {
+  [K in keyof T as K extends symbol ? never : K]: T[K]
+}
+export type Get<BaseType, Path extends string | readonly string[]> = _Get<
+  RemoveSymbolKeys<AllUnionFields<BaseType>>,
+  Path
+>
 
 export interface WhenOptions {
   signal?: AbortSignal
@@ -45,6 +24,7 @@ export interface UpdateOptions {
 }
 
 export interface ObserveOptions {
+  key?: string
   signal?: AbortSignal
   timeout?: number
   state?: number
@@ -67,12 +47,21 @@ export default class Record<Data = unknown> {
 
   ref(): Record<Data>
   unref(): Record<Data>
-  subscribe(callback: (record: Record<Data>) => void, opaque?: unknown): Record<Data>
-  unsubscribe(callback: (record: Record<Data>) => void, opaque?: unknown): Record<Data>
+  [Symbol.dispose](): void
+  subscribe(
+    callback: (record: Record<Data>, opaque: unknown) => void,
+    opaque?: unknown,
+  ): Record<Data>
+  unsubscribe(
+    callback: (record: Record<Data>, opaque: unknown) => void,
+    opaque?: unknown,
+  ): Record<Data>
 
   get: {
     // with path
     <P extends string | string[]>(path: P): Get<Data, P>
+    // with function mapper
+    <R>(fn: (data: Data) => R): R
     // without path
     (): Data
     (path: undefined | string | string[]): unknown
@@ -85,7 +74,7 @@ export default class Record<Data = unknown> {
       dataAtPath: unknown extends Get<Data, P> ? never : Get<Data, P>,
     ): void
     // without path
-    (data: SettablePossibleEmpty<Data>): void
+    (data: Data): void
   }
 
   when: {
@@ -97,13 +86,13 @@ export default class Record<Data = unknown> {
   update: {
     // without path
     (
-      updater: (data: Readonly<Data>) => SettablePossibleEmpty<Data>,
+      updater: (data: Readonly<Data>, version: string) => Data,
       options?: UpdateOptions,
     ): Promise<void>
     // with path
     <P extends string | string[]>(
       path: P,
-      updater: (dataAtPath: Readonly<Get<Data, P>>) => Get<Data, P>,
+      updater: (dataAtPath: Readonly<Get<Data, P>>, version: string) => Get<Data, P>,
       options?: UpdateOptions,
     ): Promise<void>
   }

package/src/rpc/rpc-handler.d.ts

@@ -10,8 +10,11 @@ export default class RpcHandler<
 
   provide: <Name extends keyof Methods>(
     name: Name,
-    callback: (args: Methods[Name][0], response: RpcResponse<Methods[Name][1]>) => void,
-  ) => UnprovideFn
+    callback: (
+      args: Methods[Name][0],
+      response: RpcResponse<Methods[Name][1]>,
+    ) => Methods[Name][1] | Promise<Methods[Name][1]> | Promise<void> | void,
+  ) => UnprovideFn | void
 
   unprovide: <Name extends keyof Methods>(name: Name) => void
 
@@ -22,7 +25,7 @@ export default class RpcHandler<
       ReturnValue extends Name extends keyof Methods ? Methods[Name][1] : unknown,
     >(
       name: Name,
-      args: Args,
+      args?: Args,
     ): Promise<ReturnValue>
     <
       Name extends keyof Methods | string,
@@ -30,7 +33,7 @@ export default class RpcHandler<
       ReturnValue extends Name extends keyof Methods ? Methods[Name][1] : unknown,
     >(
       name: Name,
-      args: Args,
+      args: Args | undefined,
       callback: (error: unknown, response: ReturnValue) => void,
     ): void
   }

package/src/rpc/rpc-handler.test-d.ts

@@ -0,0 +1,40 @@
+import make from '../client.js'
+import { expectAssignable, expectError, expectType } from 'tsd'
+
+interface Methods extends Record<string, [unknown, unknown]> {
+  greet: [{ name: string }, { message: string }]
+}
+
+const ds = make<Record<string, unknown>, Methods>('')
+
+// provide: callback may return void, a value, or a Promise — all valid
+ds.rpc.provide('greet', (_args, _response) => {})
+ds.rpc.provide('greet', (_args, _response) => ({ message: 'hello' }))
+ds.rpc.provide('greet', async (_args, _response) => ({ message: 'hello' }))
+// async callback that uses response.send() directly — returns Promise<void>
+ds.rpc.provide('greet', async (_args, response) => {
+  response.send({ message: 'hello' })
+})
+
+// provide: returning the wrong shape is an error
+expectError(ds.rpc.provide('greet', (_args, _response) => ({ notMessage: 'hello' })))
+
+// provide: response.completed is boolean
+ds.rpc.provide('greet', (_args, response) => {
+  expectType<boolean>(response.completed)
+})
+
+// provide: return type is UnprovideFn | void
+expectAssignable<(() => void) | void>(ds.rpc.provide('greet', () => {}))
+
+// make: args is optional (no args)
+expectAssignable<Promise<{ message: string }>>(ds.rpc.make('greet'))
+// make: args provided
+expectAssignable<Promise<{ message: string }>>(ds.rpc.make('greet', { name: 'world' }))
+// make: args explicitly undefined
+expectAssignable<Promise<{ message: string }>>(ds.rpc.make('greet', undefined))
+// make: callback form — args required positionally but can be undefined
+ds.rpc.make('greet', undefined, (err, res) => {
+  expectType<unknown>(err)
+  expectAssignable<{ message: string } | undefined>(res)
+})

package/src/rpc/rpc-response.d.ts

@@ -1,4 +1,5 @@
 export default class RpcResponse<Data> {
+  completed: boolean
   reject: () => void
   error: (error: Error | string) => void
   send: (data: Data) => void

package/src/utils/multicast-listener.js

@@ -0,0 +1,252 @@
+import * as rxjs from 'rxjs'
+import * as C from '../constants/constants.js'
+import { h64ToString, findBigIntPaths } from '../utils/utils.js'
+
+export default class Listener {
+  constructor(topic, pattern, callback, handler, { recursive = false, stringify = null } = {}) {
+    this._topic = topic
+    this._pattern = pattern
+    this._callback = callback
+    this._handler = handler
+    this._client = this._handler._client
+    this._connection = this._handler._connection
+    this._subscriptions = new Map()
+    this._recursive = recursive
+    this._stringify = stringify || JSON.stringify
+
+    this._$onConnectionStateChange()
+  }
+
+  get connected() {
+    return this._connection.connected
+  }
+
+  get stats() {
+    return {
+      subscriptions: this._subscriptions.size,
+    }
+  }
+
+  _$destroy() {
+    this._reset()
+
+    if (this.connected) {
+      this._connection.sendMsg(this._topic, C.ACTIONS.UNLISTEN, [this._pattern])
+    }
+  }
+
+  _$onMessage(message) {
+    if (!this.connected) {
+      this._client._$onError(
+        C.TOPIC.RECORD,
+        C.EVENT.NOT_CONNECTED,
+        new Error('received message while not connected'),
+        message,
+      )
+      return
+    }
+
+    const name = message.data[1]
+
+    if (message.action === C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_FOUND) {
+      if (this._subscriptions.has(name)) {
+        this._error(name, 'invalid add: listener exists')
+        return
+      }
+
+      // TODO (refactor): Move to class
+      const provider = {
+        name,
+        value$: null,
+        sending: false,
+        accepted: false,
+        version: null,
+        timeout: null,
+        patternSubscription: null,
+        valueSubscription: null,
+      }
+      provider.stop = () => {
+        if (this.connected && provider.accepted) {
+          this._connection.sendMsg(this._topic, C.ACTIONS.LISTEN_REJECT, [
+            this._pattern,
+            provider.name,
+          ])
+        }
+
+        provider.value$ = null
+        provider.version = null
+        provider.accepted = false
+        provider.sending = false
+
+        clearTimeout(provider.timeout)
+        provider.timeout = null
+
+        provider.patternSubscription?.unsubscribe()
+        provider.patternSubscription = null
+
+        provider.valueSubscription?.unsubscribe()
+        provider.valueSubscription = null
+      }
+      provider.send = () => {
+        provider.sending = false
+
+        if (!provider.patternSubscription) {
+          return
+        }
+
+        const accepted = Boolean(provider.value$)
+        if (provider.accepted === accepted) {
+          return
+        }
+
+        this._connection.sendMsg(
+          this._topic,
+          accepted ? C.ACTIONS.LISTEN_ACCEPT : C.ACTIONS.LISTEN_REJECT,
+          [this._pattern, provider.name],
+        )
+
+        provider.version = null
+        provider.accepted = accepted
+      }
+      provider.next = (value$) => {
+        if (!value$) {
+          value$ = null
+        } else if (typeof value$.subscribe !== 'function') {
+          value$ = rxjs.of(value$) // Compat for recursive with value
+        }
+
+        if (Boolean(provider.value$) !== Boolean(value$) && !provider.sending) {
+          provider.sending = true
+          queueMicrotask(provider.send)
+        }
+
+        provider.value$ = value$
+
+        if (provider.valueSubscription) {
+          provider.valueSubscription.unsubscribe()
+          provider.valueSubscription = provider.value$?.subscribe(provider.observer)
+        }
+      }
+      provider.error = (err) => {
+        provider.stop()
+        // TODO (feat): backoff retryCount * delay?
+        // TODO (feat): backoff option?
+        provider.timeout = setTimeout(() => {
+          provider.start()
+        }, 10e3)
+        this._error(provider.name, err)
+      }
+      provider.observer = {
+        next: (value) => {
+          if (value == null) {
+            provider.next(null) // TODO (fix): This is weird...
+            return
+          }
+
+          if (this._topic === C.TOPIC.EVENT) {
+            this._handler.emit(provider.name, value)
+          } else if (this._topic === C.TOPIC.RECORD) {
+            if (typeof value !== 'object' && typeof value !== 'string') {
+              this._error(provider.name, 'invalid value')
+              return
+            }
+
+            if (typeof value !== 'string') {
+              try {
+                value = this._stringify(value)
+              } catch (err) {
+                const bigIntPaths = /BigInt/.test(err.message) ? findBigIntPaths(value) : undefined
+                this._error(
+                  Object.assign(new Error(`invalid value: ${value}`), {
+                    cause: err,
+                    data: { name: provider.name, bigIntPaths },
+                  }),
+                )
+                return
+              }
+            }
+
+            const body = value
+            const hash = h64ToString(body)
+            const version = `INF-${hash}`
+
+            if (provider.version !== version) {
+              provider.version = version
+              this._connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.UPDATE, [
+                provider.name,
+                version,
+                body,
+              ])
+            }
+          }
+        },
+        error: provider.error,
+      }
+      provider.start = () => {
+        try {
+          const ret$ = this._callback(name)
+          if (this._recursive && typeof ret$?.subscribe === 'function') {
+            provider.patternSubscription = ret$.subscribe(provider)
+          } else {
+            provider.patternSubscription = rxjs.of(ret$).subscribe(provider)
+          }
+        } catch (err) {
+          this._error(provider.name, err)
+        }
+      }
+
+      provider.start()
+
+      this._subscriptions.set(provider.name, provider)
+    } else if (message.action === C.ACTIONS.LISTEN_ACCEPT) {
+      const provider = this._subscriptions.get(name)
+      if (!provider?.value$) {
+        return
+      }
+
+      if (provider.valueSubscription) {
+        this._error(
+          name,
+          'invalid accept: listener started (pattern:' + this._pattern + ' name:' + name + ')',
+        )
+      } else {
+        // TODO (fix): provider.version = message.data[2]
+        provider.valueSubscription = provider.value$.subscribe(provider.observer)
+      }
+    } else if (message.action === C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_REMOVED) {
+      const provider = this._subscriptions.get(name)
+
+      if (!provider) {
+        this._error(
+          name,
+          'invalid remove: listener missing (pattern:' + this._pattern + ' name:' + name + ')',
+        )
+      } else {
+        provider.stop()
+        this._subscriptions.delete(provider.name)
+      }
+    } else {
+      return false
+    }
+    return true
+  }
+
+  _$onConnectionStateChange() {
+    if (this.connected) {
+      this._connection.sendMsg(this._topic, C.ACTIONS.LISTEN, [this._pattern])
+    } else {
+      this._reset()
+    }
+  }
+
+  _error(name, err) {
+    this._client._$onError(this._topic, C.EVENT.LISTENER_ERROR, err, [this._pattern, name])
+  }
+
+  _reset() {
+    for (const provider of this._subscriptions.values()) {
+      provider.stop()
+    }
+    this._subscriptions.clear()
+  }
+}

package/src/utils/utils.js

@@ -83,14 +83,6 @@ export function setTimeout(callback, timeoutDuration) {
   }
 }
 
-export function setInterval(callback, intervalDuration) {
-  if (intervalDuration !== null) {
-    return setInterval(callback, intervalDuration)
-  } else {
-    return -1
-  }
-}
-
 export function compareRev(a, b) {
   if (!a) {
     return b ? -1 : 0