atom.io 0.18.3 → 0.19.1

package/realtime-server/dist/index.cjs

@@ -5,8 +5,8 @@ var internal = require('atom.io/internal');
 var setRtx = require('atom.io/transceivers/set-rtx');
 var AtomIO = require('atom.io');
 var realtime = require('atom.io/realtime');
-var child_process = require('child_process');
 var data = require('atom.io/data');
+var child_process = require('child_process');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -216,8 +216,8 @@ var SubjectSocket = class extends CustomSocket {
     });
   }
   dispose() {
-    for (const dispose of this.disposalFunctions) {
-      dispose();
+    for (const dispose2 of this.disposalFunctions) {
+      dispose2();
     }
   }
 };
@@ -338,6 +338,138 @@ var ParentSocket = class extends CustomSocket {
     this.relayServices.push(attachServices);
   }
 };
+function capitalize(string) {
+  return string[0].toUpperCase() + string.slice(1);
+}
+function getJoinMap(store) {
+  if (`joins` in store && store.joins instanceof Map) {
+    return store.joins;
+  }
+  const joins = /* @__PURE__ */ new Map();
+  store.joins = joins;
+  return joins;
+}
+function getJoin(token, store) {
+  var _a;
+  const joinMap = getJoinMap(store);
+  let join2 = joinMap.get(token.key);
+  if (join2 === void 0) {
+    const rootJoinMap = getJoinMap(internal.IMPLICIT.STORE);
+    join2 = (_a = rootJoinMap.get(token.key)) == null ? void 0 : _a.in(store);
+    if (join2 === void 0) {
+      throw new Error(
+        `Join "${token.key}" not found in store "${store.config.name}"`
+      );
+    }
+    joinMap.set(token.key, join2);
+  }
+  return join2;
+}
+function findRelationsInStore(token, key, store) {
+  const join2 = getJoin(token, store);
+  let relations;
+  switch (token.cardinality) {
+    case `1:1`: {
+      const keyAB = `${token.a}KeyOf${capitalize(token.b)}`;
+      const keyBA = `${token.b}KeyOf${capitalize(token.a)}`;
+      relations = {
+        get [keyAB]() {
+          const familyAB = join2.states[keyAB];
+          const state = internal.findInStore(familyAB, key, store);
+          return state;
+        },
+        get [keyBA]() {
+          const familyBA = join2.states[keyBA];
+          const state = internal.findInStore(familyBA, key, store);
+          return state;
+        }
+      };
+      const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
+      if (entryAB in join2.states) {
+        const entryBA = `${token.b}EntryOf${capitalize(token.a)}`;
+        Object.assign(relations, {
+          get [entryAB]() {
+            const familyAB = join2.states[entryAB];
+            const state = internal.findInStore(familyAB, key, store);
+            return state;
+          },
+          get [entryBA]() {
+            const familyBA = join2.states[entryBA];
+            const state = internal.findInStore(familyBA, key, store);
+            return state;
+          }
+        });
+      }
+      break;
+    }
+    case `1:n`: {
+      const keyAB = `${token.a}KeyOf${capitalize(token.b)}`;
+      const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
+      relations = {
+        get [keyAB]() {
+          const familyAB = join2.states[keyAB];
+          const state = internal.findInStore(familyAB, key, store);
+          return state;
+        },
+        get [keysBA]() {
+          const familyBA = join2.states[keysBA];
+          const state = internal.findInStore(familyBA, key, store);
+          return state;
+        }
+      };
+      const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
+      if (entryAB in join2.states) {
+        const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
+        Object.assign(relations, {
+          get [entryAB]() {
+            const familyAB = join2.states[entryAB];
+            const state = internal.findInStore(familyAB, key, store);
+            return state;
+          },
+          get [entriesBA]() {
+            const familyBA = join2.states[entriesBA];
+            const state = internal.findInStore(familyBA, key, store);
+            return state;
+          }
+        });
+      }
+      break;
+    }
+    case `n:n`: {
+      const keysAB = `${token.a}KeysOf${capitalize(token.b)}`;
+      const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
+      relations = {
+        get [keysAB]() {
+          const familyAB = join2.states[keysAB];
+          const state = internal.findInStore(familyAB, key, store);
+          return state;
+        },
+        get [keysBA]() {
+          const familyBA = join2.states[keysBA];
+          const state = internal.findInStore(familyBA, key, store);
+          return state;
+        }
+      };
+      const entriesAB = `${token.a}EntriesOf${capitalize(token.b)}`;
+      if (entriesAB in join2.states) {
+        const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
+        Object.assign(relations, {
+          get [entriesAB]() {
+            const familyAB = join2.states[entriesAB];
+            const state = internal.findInStore(familyAB, key, store);
+            return state;
+          },
+          get [entriesBA]() {
+            const familyBA = join2.states[entriesBA];
+            const state = internal.findInStore(familyBA, key, store);
+            return state;
+          }
+        });
+      }
+    }
+  }
+  return relations;
+}
 AtomIO.selectorFamily({
   key: `perspectiveRedactor`,
   get: ({ userId, syncGroupKey }) => ({ get, find }) => {
@@ -442,26 +574,38 @@ var joinRoomTX = AtomIO__namespace.transaction({
   key: `joinRoom`,
   do: (transactors, roomId, userId, enteredAtEpoch) => {
     const meta = { enteredAtEpoch };
-    realtime.usersInRooms.transact(transactors, ({ relations }) => {
-      relations.set(roomId, userId, meta);
-    });
+    data.editRelationsInStore(
+      realtime.usersInRooms,
+      (relations) => {
+        relations.set({ room: roomId, user: userId }, meta);
+      },
+      transactors.env().store
+    );
     return meta;
   }
 });
 var leaveRoomTX = AtomIO__namespace.transaction({
   key: `leaveRoom`,
   do: (transactors, roomId, userId) => {
-    realtime.usersInRooms.transact(transactors, ({ relations }) => {
-      relations.delete({ room: roomId, user: userId });
-    });
+    data.editRelationsInStore(
+      realtime.usersInRooms,
+      (relations) => {
+        relations.delete({ room: roomId, user: userId });
+      },
+      transactors.env().store
+    );
   }
 });
 var destroyRoomTX = AtomIO__namespace.transaction({
   key: `destroyRoom`,
   do: (transactors, roomId) => {
-    realtime.usersInRooms.transact(transactors, ({ relations }) => {
-      relations.delete({ room: roomId });
-    });
+    data.editRelationsInStore(
+      realtime.usersInRooms,
+      (relations) => {
+        relations.delete({ room: roomId });
+      },
+      transactors.env().store
+    );
     transactors.set(realtime.roomIndex, (s) => (s.delete(roomId), s));
   }
 });
@@ -522,11 +666,11 @@ function realtimeContinuitySynchronizer({
   return function synchronizer(continuity) {
     let socket = initialSocket;
     const continuityKey = continuity.key;
-    const userKeyState = internal.findInStore(
-      usersOfSockets.states.userKeyOfSocket,
+    const userKeyState = findRelationsInStore(
+      usersOfSockets,
       socket.id,
       store
-    );
+    ).userKeyOfSocket;
     const userKey = internal.getFromStore(userKeyState, store);
     if (!userKey) {
       store.logger.error(
@@ -538,11 +682,11 @@ function realtimeContinuitySynchronizer({
       return () => {
       };
     }
-    const socketKeyState = internal.findInStore(
-      usersOfSockets.states.socketKeyOfUser,
+    const socketKeyState = findRelationsInStore(
+      usersOfSockets,
       userKey,
       store
-    );
+    ).socketKeyOfUser;
     internal.subscribeToState(
       socketKeyState,
       ({ newValue: newSocketKey }) => {

package/realtime-server/dist/index.d.ts

@@ -1,7 +1,6 @@
-import * as atom_io_internal from 'atom.io/internal';
 import { Subject, Transceiver, Store } from 'atom.io/internal';
 import { Json, Stringified, JsonIO } from 'atom.io/json';
-import { ChildProcessWithoutNullStreams } from 'child_process';
+import { ChildProcessWithoutNullStreams } from 'node:child_process';
 import { ContinuityToken, UserInRoomMeta } from 'atom.io/realtime';
 import * as AtomIO from 'atom.io';
 import { TransactionUpdateContent, TransactionUpdate, WritableToken } from 'atom.io';
@@ -104,99 +103,10 @@ declare const actionOcclusionAtoms: AtomIO.RegularAtomFamilyTokenWithCall<{
 }, string>;
 declare const userUnacknowledgedQueues: AtomIO.RegularAtomFamilyTokenWithCall<Pick<TransactionUpdate<any>, "key" | "epoch" | "id" | "updates" | "output">[], string>;
 
-type primitive = boolean | number | string | null;
-
-type Serializable = primitive | Readonly<{
-    [key: string]: Serializable;
-}> | ReadonlyArray<Serializable>;
-type Object$1<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
-
-type Refinement<Unrefined, Refined extends Unrefined> = (value: Unrefined) => value is Refined;
-type Cardinality = `1:1` | `1:n` | `n:n`;
-
-interface JunctionEntries<Content extends Object$1 | null> extends Object$1 {
-    readonly relations: [string, string[]][];
-    readonly contents: [string, Content][];
-}
-interface JunctionSchema<ASide extends string, BSide extends string> extends Object$1 {
-    readonly between: [a: ASide, b: BSide];
-    readonly cardinality: Cardinality;
-}
-type BaseExternalStoreConfiguration = {
-    addRelation: (a: string, b: string) => void;
-    deleteRelation: (a: string, b: string) => void;
-    replaceRelationsSafely: (a: string, bs: string[]) => void;
-    replaceRelationsUnsafely: (a: string, bs: string[]) => void;
-    getRelatedKeys: (key: string) => Set<string> | undefined;
-    has: (a: string, b?: string) => boolean;
-};
-type ExternalStoreWithContentConfiguration<Content extends Object$1> = {
-    getContent: (contentKey: string) => Content | undefined;
-    setContent: (contentKey: string, content: Content) => void;
-    deleteContent: (contentKey: string) => void;
-};
-type Empty<Obj extends object> = {
-    [Key in keyof Obj]?: undefined;
-};
-type ExternalStoreConfiguration<Content extends Object$1 | null> = Content extends Object$1 ? BaseExternalStoreConfiguration & ExternalStoreWithContentConfiguration<Content> : BaseExternalStoreConfiguration & Empty<ExternalStoreWithContentConfiguration<Object$1>>;
-type JunctionAdvancedConfiguration<Content extends Object$1 | null> = {
-    externalStore?: ExternalStoreConfiguration<Content>;
-    isContent?: Refinement<unknown, Content>;
-    makeContentKey?: (a: string, b: string) => string;
-};
-type JunctionJSON<ASide extends string, BSide extends string, Content extends Object$1 | null> = JunctionEntries<Content> & JunctionSchema<ASide, BSide>;
-declare class Junction<const ASide extends string, const BSide extends string, const Content extends Object$1 | null = null> {
-    readonly a: ASide;
-    readonly b: BSide;
-    readonly cardinality: Cardinality;
-    readonly relations: Map<string, Set<string>>;
-    readonly contents: Map<string, Content>;
-    isContent: Refinement<unknown, Content> | null;
-    makeContentKey: (a: string, b: string) => string;
-    getRelatedKeys(key: string): Set<string> | undefined;
-    protected addRelation(a: string, b: string): void;
-    protected deleteRelation(a: string, b: string): void;
-    protected replaceRelationsUnsafely(a: string, bs: string[]): void;
-    protected replaceRelationsSafely(a: string, bs: string[]): void;
-    protected getContentInternal(contentKey: string): Content | undefined;
-    protected setContent(contentKey: string, content: Content): void;
-    protected deleteContent(contentKey: string): void;
-    constructor(data: JunctionSchema<ASide, BSide> & Partial<JunctionEntries<Content>>, config?: JunctionAdvancedConfiguration<Content>);
-    toJSON(): JunctionJSON<ASide, BSide, Content>;
-    set(a: string, ...rest: Content extends null ? [b: string] : [b: string, content: Content]): this;
-    set(relation: {
-        [Key in ASide | BSide]: string;
-    }, ...rest: Content extends null ? [] | [b?: undefined] : [content: Content]): this;
-    delete(a: string, b?: string): this;
-    delete(relation: Record<ASide | BSide, string> | Record<ASide, string> | Record<BSide, string>, b?: undefined): this;
-    getRelatedKey(key: string): string | undefined;
-    replaceRelations(a: string, relations: Content extends null ? string[] : Record<string, Content>, config?: {
-        reckless: boolean;
-    }): this;
-    getContent(a: string, b: string): Content | undefined;
-    getRelationEntries(input: Record<ASide, string> | Record<BSide, string>): [string, Content][];
-    has(a: string, b?: string): boolean;
-}
-
 declare const socketAtoms: AtomIO.RegularAtomFamilyTokenWithCall<Socket | null, string>;
 declare const socketIndex: AtomIO.MutableAtomToken<SetRTX<string>, atom_io_transceivers_set_rtx.SetRTXJson<string>>;
 declare const userIndex: AtomIO.MutableAtomToken<SetRTX<string>, atom_io_transceivers_set_rtx.SetRTXJson<string>>;
-declare const usersOfSockets: {
-    readonly relations: Junction<"user", "socket", null>;
-    readonly states: {
-        readonly socketKeyOfUser: AtomIO.ReadonlySelectorFamily<string | null, string>;
-        readonly userKeyOfSocket: AtomIO.ReadonlySelectorFamily<string | null, string>;
-    };
-    readonly in: (store: atom_io_internal.Store) => atom_io_data.Join<"user", "socket", "1:1", null>;
-    readonly transact: (transactors: Readonly<{
-        get: <S>(state: AtomIO.ReadonlySelectorToken<S> | AtomIO.WritableToken<S>) => S;
-        set: <S_1, New extends S_1>(state: AtomIO.WritableToken<S_1>, newValue: New | ((oldValue: S_1) => New)) => void;
-        find: typeof AtomIO.findState;
-    }>, run: (join: atom_io_data.Join<"user", "socket", "1:1", null>) => void) => void;
-    readonly core: {
-        readonly findRelatedKeysState: AtomIO.MutableAtomFamily<SetRTX<string>, atom_io_transceivers_set_rtx.SetRTXJson<string>, string>;
-    };
-};
+declare const usersOfSockets: atom_io_data.JoinToken<"user", "socket", "1:1", null>;
 
 type StateProvider = ReturnType<typeof realtimeStateProvider>;
 declare function realtimeStateProvider({ socket, store, }: ServerConfig): <J extends Json.Serializable>(token: AtomIO.WritableToken<J>) => () => void;

package/realtime-server/dist/index.js

@@ -1,12 +1,14 @@
+import { findRelationsInStore } from '../../dist/chunk-7ZR244C2.js';
+import '../../dist/chunk-WX2NCOZR.js';
 import { __spreadProps, __spreadValues } from '../../dist/chunk-U2IICNHQ.js';
 import { parseJson, stringifyJson } from 'atom.io/json';
-import { getUpdateToken, IMPLICIT, Subject, findInStore, getFromStore, subscribeToState, getJsonToken, isRootStore, subscribeToTransaction, actUponStore, setIntoStore } from 'atom.io/internal';
+import { getUpdateToken, IMPLICIT, Subject, getFromStore, subscribeToState, findInStore, getJsonToken, isRootStore, subscribeToTransaction, actUponStore, setIntoStore } from 'atom.io/internal';
 import { SetRTX } from 'atom.io/transceivers/set-rtx';
 import * as AtomIO from 'atom.io';
 import { selectorFamily, atomFamily, atom } from 'atom.io';
 import { SyncGroup, roomIndex, usersInRooms } from 'atom.io/realtime';
+import { editRelationsInStore, join } from 'atom.io/data';
 import { spawn } from 'child_process';
-import { join } from 'atom.io/data';
 
 // realtime-server/src/ipc-sockets/custom-socket.ts
 var CustomSocket = class {
@@ -402,26 +404,38 @@ var joinRoomTX = AtomIO.transaction({
   key: `joinRoom`,
   do: (transactors, roomId, userId, enteredAtEpoch) => {
     const meta = { enteredAtEpoch };
-    usersInRooms.transact(transactors, ({ relations }) => {
-      relations.set(roomId, userId, meta);
-    });
+    editRelationsInStore(
+      usersInRooms,
+      (relations) => {
+        relations.set({ room: roomId, user: userId }, meta);
+      },
+      transactors.env().store
+    );
     return meta;
   }
 });
 var leaveRoomTX = AtomIO.transaction({
   key: `leaveRoom`,
   do: (transactors, roomId, userId) => {
-    usersInRooms.transact(transactors, ({ relations }) => {
-      relations.delete({ room: roomId, user: userId });
-    });
+    editRelationsInStore(
+      usersInRooms,
+      (relations) => {
+        relations.delete({ room: roomId, user: userId });
+      },
+      transactors.env().store
+    );
   }
 });
 var destroyRoomTX = AtomIO.transaction({
   key: `destroyRoom`,
   do: (transactors, roomId) => {
-    usersInRooms.transact(transactors, ({ relations }) => {
-      relations.delete({ room: roomId });
-    });
+    editRelationsInStore(
+      usersInRooms,
+      (relations) => {
+        relations.delete({ room: roomId });
+      },
+      transactors.env().store
+    );
     transactors.set(roomIndex, (s) => (s.delete(roomId), s));
   }
 });
@@ -482,11 +496,11 @@ function realtimeContinuitySynchronizer({
   return function synchronizer(continuity) {
     let socket = initialSocket;
     const continuityKey = continuity.key;
-    const userKeyState = findInStore(
-      usersOfSockets.states.userKeyOfSocket,
+    const userKeyState = findRelationsInStore(
+      usersOfSockets,
       socket.id,
       store
-    );
+    ).userKeyOfSocket;
     const userKey = getFromStore(userKeyState, store);
     if (!userKey) {
       store.logger.error(
@@ -498,11 +512,11 @@ function realtimeContinuitySynchronizer({
       return () => {
       };
     }
-    const socketKeyState = findInStore(
-      usersOfSockets.states.socketKeyOfUser,
+    const socketKeyState = findRelationsInStore(
+      usersOfSockets,
       userKey,
       store
-    );
+    ).socketKeyOfUser;
     subscribeToState(
       socketKeyState,
       ({ newValue: newSocketKey }) => {

package/realtime-server/src/ipc-sockets/child-socket.ts

@@ -1,4 +1,4 @@
-import type { ChildProcessWithoutNullStreams } from "child_process"
+import type { ChildProcessWithoutNullStreams } from "node:child_process"
 
 import type { Json } from "atom.io/json"
 import { parseJson } from "atom.io/json"

package/realtime-server/src/realtime-continuity-synchronizer.ts

@@ -15,6 +15,7 @@ import type { ContinuityToken } from "atom.io/realtime"
 import type { ServerConfig, Socket } from "."
 import { socketAtoms, usersOfSockets } from "."
 
+import { findRelationsInStore } from "../../data/src/join"
 import {
 	redactTransactionUpdateContent,
 	userUnacknowledgedQueues,
@@ -31,11 +32,11 @@ export function realtimeContinuitySynchronizer({
 		let socket: Socket | null = initialSocket
 
 		const continuityKey = continuity.key
-		const userKeyState = findInStore(
-			usersOfSockets.states.userKeyOfSocket,
+		const userKeyState = findRelationsInStore(
+			usersOfSockets,
 			socket.id,
 			store,
-		)
+		).userKeyOfSocket
 		const userKey = getFromStore(userKeyState, store)
 		if (!userKey) {
 			store.logger.error(
@@ -46,11 +47,12 @@ export function realtimeContinuitySynchronizer({
 			)
 			return () => {}
 		}
-		const socketKeyState = findInStore(
-			usersOfSockets.states.socketKeyOfUser,
+
+		const socketKeyState = findRelationsInStore(
+			usersOfSockets,
 			userKey,
 			store,
-		)
+		).socketKeyOfUser
 		subscribeToState(
 			socketKeyState,
 			({ newValue: newSocketKey }) => {

package/realtime-server/src/realtime-server-stores/server-room-external-actions.ts

@@ -1,5 +1,5 @@
 import * as AtomIO from "atom.io"
-import type { Loadable } from "atom.io/data"
+import { type Loadable, editRelations, editRelationsInStore } from "atom.io/data"
 import type { UserInRoomMeta } from "atom.io/realtime"
 import { roomIndex, usersInRooms } from "atom.io/realtime"
 
@@ -33,9 +33,13 @@ export const joinRoomTX = AtomIO.transaction<
 	key: `joinRoom`,
 	do: (transactors, roomId, userId, enteredAtEpoch) => {
 		const meta = { enteredAtEpoch }
-		usersInRooms.transact(transactors, ({ relations }) => {
-			relations.set(roomId, userId, meta)
-		})
+		editRelationsInStore(
+			usersInRooms,
+			(relations) => {
+				relations.set({ room: roomId, user: userId }, meta)
+			},
+			transactors.env().store,
+		)
 		return meta
 	},
 })
@@ -46,9 +50,13 @@ export const leaveRoomTX = AtomIO.transaction<
 >({
 	key: `leaveRoom`,
 	do: (transactors, roomId, userId) => {
-		usersInRooms.transact(transactors, ({ relations }) => {
-			relations.delete({ room: roomId, user: userId })
-		})
+		editRelationsInStore(
+			usersInRooms,
+			(relations) => {
+				relations.delete({ room: roomId, user: userId })
+			},
+			transactors.env().store,
+		)
 	},
 })
 export type LeaveRoomIO = AtomIO.TransactionIO<typeof leaveRoomTX>
@@ -56,9 +64,13 @@ export type LeaveRoomIO = AtomIO.TransactionIO<typeof leaveRoomTX>
 export const destroyRoomTX = AtomIO.transaction<(roomId: string) => void>({
 	key: `destroyRoom`,
 	do: (transactors, roomId) => {
-		usersInRooms.transact(transactors, ({ relations }) => {
-			relations.delete({ room: roomId })
-		})
+		editRelationsInStore(
+			usersInRooms,
+			(relations) => {
+				relations.delete({ room: roomId })
+			},
+			transactors.env().store,
+		)
 		transactors.set(roomIndex, (s) => (s.delete(roomId), s))
 	},
 })

package/realtime-server/src/realtime-server-stores/server-room-external-store.ts

@@ -1,5 +1,5 @@
-import type { ChildProcessWithoutNullStreams } from "child_process"
-import { spawn } from "child_process"
+import type { ChildProcessWithoutNullStreams } from "node:child_process"
+import { spawn } from "node:child_process"
 
 import { atomFamily, selectorFamily } from "atom.io"
 import type { Loadable } from "atom.io/data"

package/realtime-testing/dist/index.cjs

@@ -11,6 +11,7 @@ var RTS = require('atom.io/realtime-server');
 var Happy = require('happy-dom');
 var SocketIO = require('socket.io');
 var socket_ioClient = require('socket.io-client');
+require('atom.io/transceivers/set-rtx');
 var jsxRuntime = require('react/jsx-runtime');
 
 function _interopNamespace(e) {
@@ -62,6 +63,42 @@ var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 
 // ../anvl/src/object/entries.ts
 var recordToEntries = (obj) => Object.entries(obj);
+function getJoinMap(store) {
+  if (`joins` in store && store.joins instanceof Map) {
+    return store.joins;
+  }
+  const joins = /* @__PURE__ */ new Map();
+  store.joins = joins;
+  return joins;
+}
+function getJoin(token, store) {
+  var _a;
+  const joinMap = getJoinMap(store);
+  let join = joinMap.get(token.key);
+  if (join === void 0) {
+    const rootJoinMap = getJoinMap(internal.IMPLICIT.STORE);
+    join = (_a = rootJoinMap.get(token.key)) == null ? void 0 : _a.in(store);
+    if (join === void 0) {
+      throw new Error(
+        `Join "${token.key}" not found in store "${store.config.name}"`
+      );
+    }
+    joinMap.set(token.key, join);
+  }
+  return join;
+}
+function editRelationsInStore(token, change, store) {
+  const join = getJoin(token, store);
+  const target = internal.newest(store);
+  if (internal.isChildStore(target)) {
+    const { transactors } = target.transactionMeta;
+    join.transact(transactors, ({ relations }) => {
+      change(relations);
+    });
+  } else {
+    change(join.relations);
+  }
+}
 
 // __unstable__/web-effects/src/storage.ts
 var persistAtom = (storage) => ({ stringify, parse }) => (key) => ({ setSelf, onSet }) => {
@@ -117,8 +154,13 @@ var setupRealtimeTestServer = (options) => {
     if (token === `test` && socket.id) {
       const socketState = internal.findInStore(RTS__namespace.socketAtoms, socket.id, silo.store);
       internal.setIntoStore(socketState, socket, silo.store);
-      const usersOfSockets2 = RTS__namespace.usersOfSockets.in(silo.store);
-      usersOfSockets2.relations.set(socket.id, username);
+      editRelationsInStore(
+        RTS__namespace.usersOfSockets,
+        (relations) => {
+          relations.set(socket.id, username);
+        },
+        silo.store
+      );
       internal.setIntoStore(RTS__namespace.userIndex, (index) => index.add(username), silo.store);
       internal.setIntoStore(RTS__namespace.socketIndex, (index) => index.add(socket.id), silo.store);
       console.log(`${username} connected on ${socket.id}`);
@@ -130,7 +172,7 @@ var setupRealtimeTestServer = (options) => {
   server.on(`connection`, (socket) => {
     options.server({ socket, silo });
   });
-  const dispose = () => {
+  const dispose2 = () => {
     server.close();
     const roomKeys = internal.getFromStore(RT__namespace.roomIndex, silo.store);
     for (const roomKey of roomKeys) {
@@ -145,7 +187,7 @@ var setupRealtimeTestServer = (options) => {
   return {
     name: `SERVER`,
     silo,
-    dispose,
+    dispose: dispose2,
     port
   };
 };
@@ -172,12 +214,12 @@ var setupRealtimeTestClient = (options, name, port) => {
       }
     );
     const prettyPrint = () => console.log(react.prettyDOM(renderResult.container));
-    const dispose = () => {
+    const dispose2 = () => {
       renderResult.unmount();
       socket.disconnect();
       internal.clearStore(silo.store);
     };
-    testClient.dispose = dispose;
+    testClient.dispose = dispose2;
     return {
       name,
       silo,

package/realtime-testing/dist/index.js

@@ -1,5 +1,7 @@
 import { myUsernameState } from '../../dist/chunk-O47EQUM6.js';
-import { recordToEntries } from '../../dist/chunk-CVBEVTM5.js';
+import { editRelationsInStore } from '../../dist/chunk-7ZR244C2.js';
+import '../../dist/chunk-WX2NCOZR.js';
+import { recordToEntries } from '../../dist/chunk-7VCCW45K.js';
 import '../../dist/chunk-BWWVY5O5.js';
 import { __spreadProps, __spreadValues } from '../../dist/chunk-U2IICNHQ.js';
 import * as http from 'http';
@@ -29,8 +31,13 @@ var setupRealtimeTestServer = (options) => {
     if (token === `test` && socket.id) {
       const socketState = findInStore(RTS.socketAtoms, socket.id, silo.store);
       setIntoStore(socketState, socket, silo.store);
-      const usersOfSockets2 = RTS.usersOfSockets.in(silo.store);
-      usersOfSockets2.relations.set(socket.id, username);
+      editRelationsInStore(
+        RTS.usersOfSockets,
+        (relations) => {
+          relations.set(socket.id, username);
+        },
+        silo.store
+      );
       setIntoStore(RTS.userIndex, (index) => index.add(username), silo.store);
       setIntoStore(RTS.socketIndex, (index) => index.add(socket.id), silo.store);
       console.log(`${username} connected on ${socket.id}`);