atom.io 0.16.3 → 0.18.0

package/realtime-server/dist/index.js

@@ -1,25 +1,219 @@
 import { __spreadProps, __spreadValues } from '../../dist/chunk-PZLG2HP3.js';
-import * as AtomIO7 from 'atom.io';
-import { atom, atomFamily, selectorFamily, setState } from 'atom.io';
+import { Subject, findInStore, getFromStore, subscribeToState, IMPLICIT, getJsonToken, getUpdateToken, assignTransactionToContinuity, setIntoStore, isRootStore, subscribeToTransaction, actUponStore } from 'atom.io/internal';
+import { parseJson, stringifyJson } from 'atom.io/json';
+import * as AtomIO from 'atom.io';
+import { selectorFamily, atomFamily, atom } from 'atom.io';
+import { SyncGroup } from 'atom.io/realtime';
+import { completeUpdateAtoms } from 'atom.io/realtime-server';
+import { spawn } from 'child_process';
 import { join } from 'atom.io/data';
 import { SetRTX } from 'atom.io/transceivers/set-rtx';
-import { IMPLICIT, getJsonToken, getUpdateToken, findInStore, subscribeToState, subscribeToTransaction } from 'atom.io/internal';
-import { parseJson } from 'atom.io/json';
 
-var userIndex = atom({
-  key: `usersIndex`,
-  mutable: true,
-  default: () => new SetRTX(),
-  toJson: (set) => set.toJSON(),
-  fromJson: (json) => SetRTX.fromJSON(json)
+var CustomSocket = class {
+  constructor(emit) {
+    this.emit = emit;
+    this.id = `no_id_retrieved`;
+    this.listeners = /* @__PURE__ */ new Map();
+    this.globalListeners = /* @__PURE__ */ new Set();
+  }
+  handleEvent(event, ...args) {
+    for (const listener of this.globalListeners) {
+      listener(event, ...args);
+    }
+    const listeners = this.listeners.get(event);
+    if (listeners) {
+      for (const listener of listeners) {
+        listener(...args);
+      }
+    }
+  }
+  on(event, listener) {
+    const listeners = this.listeners.get(event);
+    if (listeners) {
+      listeners.add(listener);
+    } else {
+      this.listeners.set(event, /* @__PURE__ */ new Set([listener]));
+    }
+    return this;
+  }
+  onAny(listener) {
+    this.globalListeners.add(listener);
+    return this;
+  }
+  off(event, listener) {
+    const listeners = this.listeners.get(event);
+    if (listeners) {
+      listeners.delete(listener);
+    }
+    return this;
+  }
+  offAny(listener) {
+    this.globalListeners.delete(listener);
+    return this;
+  }
+};
+var ChildSocket = class extends CustomSocket {
+  constructor(process2) {
+    super((event, ...args) => {
+      const stringifiedEvent = JSON.stringify([event, ...args]) + `
+`;
+      this.process.stdin.write(stringifiedEvent);
+      return this;
+    });
+    this.id = `no_id_retrieved`;
+    this.process = process2;
+    this.process.stdout.on(
+      `data`,
+      (buffer) => {
+        const stringifiedEvent = buffer.toString();
+        const parsedEvent = parseJson(stringifiedEvent);
+        this.handleEvent(...parsedEvent);
+      }
+    );
+    if (process2.pid) {
+      this.id = process2.pid.toString();
+    }
+  }
+};
+var SubjectSocket = class extends CustomSocket {
+  constructor(id) {
+    super((...args) => {
+      this.out.next(args);
+      return this;
+    });
+    this.id = `no_id_retrieved`;
+    this.id = id;
+    this.in = new Subject();
+    this.out = new Subject();
+    this.in.subscribe(`socket`, (event) => {
+      this.handleEvent(...event);
+    });
+  }
+};
+var ParentSocket = class extends CustomSocket {
+  constructor() {
+    var _a;
+    super((event, ...args) => {
+      const stringifiedEvent = JSON.stringify([event, ...args]);
+      this.process.stdout.write(stringifiedEvent);
+      return this;
+    });
+    this.id = `no_id_retrieved`;
+    this.process = process;
+    this.process.stdin.resume();
+    this.queue = [];
+    this.relays = /* @__PURE__ */ new Map();
+    this.relayServices = [];
+    this.process.stdin.on(
+      `data`,
+      (chunk) => {
+        const buffer = chunk.toString();
+        this.queue.push(...buffer.split(`
+`));
+        while (this.queue.length > 0) {
+          try {
+            const event = this.queue.shift();
+            if (event === ``)
+              continue;
+            const parsedEvent = parseJson(event);
+            this.handleEvent(...parsedEvent);
+          } catch (error) {
+            this.process.stderr.write(`\u274C ${error}
+`);
+            break;
+          }
+        }
+      }
+    );
+    process.on(`SIGINT`, () => process.exit(0));
+    if (process.pid) {
+      this.id = (_a = process.pid) == null ? void 0 : _a.toString();
+    }
+    this.on(`setup-relay`, (id) => {
+      const relay = new SubjectSocket(`relay:${id}`);
+      this.relays.set(id, relay);
+      for (const attachServices of this.relayServices) {
+        attachServices(relay);
+      }
+      this.on(`relay:${id}`, (...data) => {
+        relay.in.next(data);
+      });
+      relay.out.subscribe(`socket`, (data) => {
+        this.emit(...data);
+      });
+    });
+  }
+  relay(attachServices) {
+    this.relayServices.push(attachServices);
+    const relays = this.relays.values();
+    for (const relay of relays) {
+      attachServices(relay);
+    }
+  }
+};
+var redactorAtoms = selectorFamily({
+  key: `perspectiveRedactor`,
+  get: ({ userId, syncGroupKey }) => ({ get, find }) => {
+    const syncGroup = SyncGroup.existing.get(syncGroupKey);
+    if (!syncGroup) {
+      throw new Error(
+        `Tried to create a synchronizer for a sync group that does not exist.`
+      );
+    }
+    const userPerspectiveTokens = syncGroup.perspectives.flatMap(
+      ({ perspectiveAtoms, resourceAtoms }) => {
+        const userPerspectiveToken = find(perspectiveAtoms, userId);
+        const userPerspective = get(userPerspectiveToken);
+        const visibleTokens = [...userPerspective].map((subKey) => {
+          const resourceToken = find(resourceAtoms, subKey);
+          return resourceToken.key;
+        });
+        return visibleTokens;
+      }
+    );
+    const filterTransactionUpdate = (visible, transactionUpdate) => {
+      const updates = transactionUpdate.updates.filter((update) => {
+        if (`newValue` in update) {
+          return visible.includes(update.key);
+        }
+        return true;
+      }).map((update) => {
+        if (`updates` in update) {
+          return filterTransactionUpdate(visible, update);
+        }
+        return update;
+      });
+      const filtered = __spreadProps(__spreadValues({}, transactionUpdate), {
+        updates
+      });
+      return filtered;
+    };
+    const filter = (update) => {
+      const visibleKeys = syncGroup.globals.map(
+        (atomToken) => atomToken.key
+      );
+      visibleKeys.push(...userPerspectiveTokens);
+      return filterTransactionUpdate(visibleKeys, update);
+    };
+    return filter;
+  }
 });
-var usersOfSockets = join({
-  key: `usersOfSockets`,
-  between: [`user`, `socket`],
-  cardinality: `1:1`
+var redactedPerspectiveUpdateSelectors = selectorFamily({
+  key: `redactedPerspectiveUpdate`,
+  get: ({ userId, syncGroupKey, updateId }) => ({ get, find }) => {
+    const updateState = find(completeUpdateAtoms, updateId);
+    const update = get(updateState);
+    const redactorKey = { userId, syncGroupKey };
+    const redactorState = find(redactorAtoms, redactorKey);
+    const redact = get(redactorState);
+    if (update) {
+      return redact(update);
+    }
+    return null;
+  }
 });
-var roomIndex = atom({
-  key: `conclaveIndex`,
+var roomIndex = AtomIO.atom({
+  key: `roomIndex`,
   default: () => new SetRTX(),
   mutable: true,
   toJson: (set) => set.toJSON(),
@@ -36,7 +230,51 @@ var usersInRooms = join(
   },
   DEFAULT_USER_IN_ROOM_META
 );
-var completeUpdateAtoms = atomFamily({
+var roomArgumentsAtoms = AtomIO.atomFamily({
+  key: `roomArguments`,
+  default: [`echo Hello World!`]
+});
+var roomSelectors = AtomIO.selectorFamily({
+  key: `room`,
+  get: (roomId) => ({ get, find }) => {
+    const argumentsState = find(roomArgumentsAtoms, roomId);
+    const args = get(argumentsState);
+    const [script, options] = args;
+    return new Promise((resolve) => {
+      const room = spawn(script, options, { env: process.env });
+      const resolver = (data) => {
+        if (data.toString() === `\u2728`) {
+          room.stdout.off(`data`, resolver);
+          resolve(room);
+        }
+      };
+      room.stdout.on(`data`, resolver);
+    });
+  }
+});
+var createRoomTX = AtomIO.transaction({
+  key: `createRoom`,
+  do: ({ get, set, find }, roomId, script, options) => {
+    const args = options ? [script, options] : [script];
+    const roomArgumentsState = find(roomArgumentsAtoms, roomId);
+    set(roomArgumentsState, args);
+    set(roomIndex, (s) => s.add(roomId));
+    const roomState = find(roomSelectors, roomId);
+    const room = get(roomState);
+    return room;
+  }
+});
+var joinRoomTX = AtomIO.transaction({
+  key: `joinRoom`,
+  do: (transactors, roomId, userId, enteredAtEpoch) => {
+    const meta = { enteredAtEpoch };
+    usersInRooms.transact(transactors, ({ relations }) => {
+      relations.set(roomId, userId, meta);
+    });
+    return meta;
+  }
+});
+var completeUpdateAtoms2 = atomFamily({
   key: `completeUpdate`,
   default: null
 });
@@ -47,7 +285,7 @@ var transactionRedactorAtoms = atomFamily({
 var redactedUpdateSelectors = selectorFamily({
   key: `redactedUpdate`,
   get: ([transactionKey, updateId]) => ({ get, find }) => {
-    const update = get(find(completeUpdateAtoms, updateId));
+    const update = get(find(completeUpdateAtoms2, updateId));
     const { filter } = get(find(transactionRedactorAtoms, transactionKey));
     if (update && filter) {
       return __spreadProps(__spreadValues({}, update), { updates: filter(update.updates) });
@@ -55,64 +293,243 @@ var redactedUpdateSelectors = selectorFamily({
     return null;
   }
 });
-var userUnacknowledgedUpdatesAtoms = atomFamily({
+var userUnacknowledgedQueues = atomFamily({
   key: `unacknowledgedUpdates`,
   default: () => []
 });
-var socketUnacknowledgedUpdatesSelectors = selectorFamily({
-  key: `socketUnacknowledgedUpdates`,
-  get: (socketId) => ({ get, find }) => {
-    const userKeyState = find(usersOfSockets.states.userKeyOfSocket, socketId);
-    const userKey = get(userKeyState);
-    if (!userKey) {
-      return [];
-    }
-    const unacknowledgedUpdatesState = find(
-      userUnacknowledgedUpdatesAtoms,
-      userKey
-    );
-    const unacknowledgedUpdates = get(unacknowledgedUpdatesState);
-    return unacknowledgedUpdates;
-  },
-  set: (socketId) => ({ set, get, find }, newUpdates) => {
-    const userKeyState = find(usersOfSockets.states.userKeyOfSocket, socketId);
-    const userKey = get(userKeyState);
-    if (!userKey) {
-      return;
-    }
-    const unacknowledgedUpdatesState = find(
-      userUnacknowledgedUpdatesAtoms,
-      userKey
-    );
-    set(unacknowledgedUpdatesState, newUpdates);
-  }
-});
-var userEpochAtoms = atomFamily({
-  key: `clientEpoch`,
+var socketAtoms = atomFamily({
+  key: `sockets`,
   default: null
 });
-var socketEpochSelectors = selectorFamily({
-  key: `socketEpoch`,
-  get: (socketId) => ({ get, find }) => {
-    const userKeyState = find(usersOfSockets.states.userKeyOfSocket, socketId);
-    const userKey = get(userKeyState);
-    if (!userKey) {
-      return null;
-    }
-    const userEpochState = find(userEpochAtoms, userKey);
-    const userEpoch = get(userEpochState);
-    return userEpoch;
-  },
-  set: (socketId) => ({ set, get, find }, newEpoch) => {
-    const userKeyState = find(usersOfSockets.states.userKeyOfSocket, socketId);
-    const userKey = get(userKeyState);
+var socketIndex = atom({
+  key: `socketsIndex`,
+  mutable: true,
+  default: () => new SetRTX(),
+  toJson: (set) => set.toJSON(),
+  fromJson: (json) => SetRTX.fromJSON(json)
+});
+var userIndex = atom({
+  key: `usersIndex`,
+  mutable: true,
+  default: () => new SetRTX(),
+  toJson: (set) => set.toJSON(),
+  fromJson: (json) => SetRTX.fromJSON(json)
+});
+var usersOfSockets = join({
+  key: `usersOfSockets`,
+  between: [`user`, `socket`],
+  cardinality: `1:1`
+});
+
+// realtime-server/src/realtime-continuity-synchronizer.ts
+function realtimeContinuitySynchronizer({
+  socket: initialSocket,
+  store = IMPLICIT.STORE
+}) {
+  return function synchronizer(continuity) {
+    let socket = initialSocket;
+    const continuityKey = continuity.key;
+    const userKeyState = findInStore(
+      usersOfSockets.states.userKeyOfSocket,
+      socket.id,
+      store
+    );
+    const userKey = getFromStore(userKeyState, store);
     if (!userKey) {
-      return;
+      store.logger.error(
+        `\u274C`,
+        `continuity`,
+        continuityKey,
+        `Tried to create a synchronizer for a socket (${socket.id}) that is not connected to a user.`
+      );
+      return () => {
+      };
     }
-    const userEpochState = find(userEpochAtoms, userKey);
-    set(userEpochState, newEpoch);
-  }
-});
+    const socketKeyState = findInStore(
+      usersOfSockets.states.socketKeyOfUser,
+      userKey,
+      store
+    );
+    subscribeToState(
+      socketKeyState,
+      ({ newValue: newSocketKey }) => {
+        store.logger.info(
+          `\u{1F44B}`,
+          `continuity`,
+          continuityKey,
+          `seeing ${userKey} on new socket ${newSocketKey}`
+        );
+        if (newSocketKey === null) {
+          store.logger.error(
+            `\u274C`,
+            `continuity`,
+            continuityKey,
+            `Tried to create a synchronizer for a user (${userKey}) that is not connected to a socket.`
+          );
+          return;
+        }
+        const newSocketState = findInStore(socketAtoms, newSocketKey, store);
+        const newSocket = getFromStore(newSocketState, store);
+        socket = newSocket;
+      },
+      `sync-continuity:${continuityKey}:${userKey}`,
+      store
+    );
+    const userUnacknowledgedQueue = findInStore(
+      userUnacknowledgedQueues,
+      userKey,
+      store
+    );
+    const userUnacknowledgedUpdates = getFromStore(
+      userUnacknowledgedQueue,
+      store
+    );
+    const unsubscribeFunctions = [];
+    const sendInitialPayload = () => {
+      var _a;
+      const initialPayload = [];
+      for (const atom3 of continuity.globals) {
+        initialPayload.push(atom3, getFromStore(atom3, store));
+      }
+      for (const { perspectiveAtoms } of continuity.perspectives) {
+        const perspectiveTokensState = findInStore(
+          perspectiveAtoms,
+          userKey,
+          store
+        );
+        const perspectiveTokens = getFromStore(perspectiveTokensState, store);
+        for (const perspectiveToken of perspectiveTokens) {
+          const resource = getFromStore(perspectiveToken, store);
+          initialPayload.push(perspectiveToken, resource);
+        }
+      }
+      const epoch = isRootStore(store) ? (_a = store.transactionMeta.epoch.get(continuityKey)) != null ? _a : null : null;
+      socket == null ? void 0 : socket.emit(`continuity-init:${continuityKey}`, epoch, initialPayload);
+      for (const transaction2 of continuity.actions) {
+        const unsubscribeFromTransaction = subscribeToTransaction(
+          transaction2,
+          (update) => {
+            const updateState = findInStore(
+              completeUpdateAtoms2,
+              update.id,
+              store
+            );
+            setIntoStore(updateState, update, store);
+            const redactedUpdateKey = {
+              userId: userKey,
+              syncGroupKey: continuityKey,
+              updateId: update.id
+            };
+            const redactedUpdateState = findInStore(
+              redactedPerspectiveUpdateSelectors,
+              redactedUpdateKey,
+              store
+            );
+            const redactedUpdate = getFromStore(redactedUpdateState, store);
+            setIntoStore(
+              userUnacknowledgedQueue,
+              (updates) => {
+                if (redactedUpdate) {
+                  updates.push(redactedUpdate);
+                  updates.sort((a, b) => a.epoch - b.epoch);
+                }
+                return updates;
+              },
+              store
+            );
+            socket == null ? void 0 : socket.emit(
+              `tx-new:${continuityKey}`,
+              redactedUpdate
+            );
+          },
+          `sync-continuity:${continuityKey}:${userKey}`,
+          store
+        );
+        unsubscribeFunctions.push(unsubscribeFromTransaction);
+      }
+    };
+    socket.off(`get:${continuityKey}`, sendInitialPayload);
+    socket.on(`get:${continuityKey}`, sendInitialPayload);
+    const fillTransactionRequest = (update) => {
+      const transactionKey = update.key;
+      const updateId = update.id;
+      const performanceKey = `tx-run:${transactionKey}:${updateId}`;
+      const performanceKeyStart = `${performanceKey}:start`;
+      const performanceKeyEnd = `${performanceKey}:end`;
+      performance.mark(performanceKeyStart);
+      actUponStore(
+        { type: `transaction`, key: transactionKey },
+        updateId,
+        store
+      )(...update.params);
+      performance.mark(performanceKeyEnd);
+      const metric = performance.measure(
+        performanceKey,
+        performanceKeyStart,
+        performanceKeyEnd
+      );
+      store == null ? void 0 : store.logger.info(
+        `\u{1F680}`,
+        `transaction`,
+        transactionKey,
+        updateId,
+        metric.duration
+      );
+    };
+    socket.off(`tx-run:${continuityKey}`, fillTransactionRequest);
+    socket.on(`tx-run:${continuityKey}`, fillTransactionRequest);
+    let i = 1;
+    let next = 1;
+    const retry = setInterval(() => {
+      const toEmit = userUnacknowledgedUpdates[0];
+      store.logger.info(
+        `\u{1F504}`,
+        `continuity`,
+        continuityKey,
+        `${store.config.name} retrying ${userKey} (${i}/${next})`,
+        socket == null ? void 0 : socket.id,
+        userUnacknowledgedUpdates
+      );
+      if (toEmit && i === next) {
+        socket == null ? void 0 : socket.emit(`tx-new:${continuityKey}`, toEmit);
+        next *= 2;
+      }
+      i++;
+    }, 250);
+    const trackClientAcknowledgement = (epoch) => {
+      var _a;
+      store.logger.info(
+        `\u{1F44D}`,
+        `continuity`,
+        continuityKey,
+        `${userKey} acknowledged epoch ${epoch}`
+      );
+      i = 1;
+      next = 1;
+      const isUnacknowledged = ((_a = userUnacknowledgedUpdates[0]) == null ? void 0 : _a.epoch) === epoch;
+      if (isUnacknowledged) {
+        setIntoStore(
+          userUnacknowledgedQueue,
+          (updates) => {
+            updates.shift();
+            return updates;
+          },
+          store
+        );
+      }
+    };
+    socket.off(`ack:${continuityKey}`, trackClientAcknowledgement);
+    socket.on(`ack:${continuityKey}`, trackClientAcknowledgement);
+    return () => {
+      clearInterval(retry);
+      for (const unsubscribe of unsubscribeFunctions)
+        unsubscribe();
+      socket == null ? void 0 : socket.off(`ack:${continuityKey}`, trackClientAcknowledgement);
+      socket == null ? void 0 : socket.off(`get:${continuityKey}`, sendInitialPayload);
+      socket == null ? void 0 : socket.off(`tx-run:${continuityKey}`, fillTransactionRequest);
+    };
+  };
+}
 function realtimeStateProvider({
   socket,
   store = IMPLICIT.STORE
@@ -120,7 +537,7 @@ function realtimeStateProvider({
   return function stateProvider(token) {
     let unsubscribeFromStateUpdates;
     const fillSubRequest = () => {
-      socket.emit(`serve:${token.key}`, AtomIO7.getState(token, store));
+      socket.emit(`serve:${token.key}`, getFromStore(token, store));
       unsubscribeFromStateUpdates = subscribeToState(
         token,
         ({ newValue }) => {
@@ -154,7 +571,7 @@ function realtimeStateSynchronizer({
 }) {
   return function stateSynchronizer(token) {
     const fillGetRequest = () => {
-      socket.emit(`value:${token.key}`, AtomIO7.getState(token, store));
+      socket.emit(`value:${token.key}`, getFromStore(token, store));
     };
     socket.on(`get:${token.key}`, fillGetRequest);
     return () => {
@@ -162,89 +579,49 @@ function realtimeStateSynchronizer({
     };
   };
 }
-function realtimeFamilyProvider({
+function realtimeAtomFamilyProvider({
   socket,
   store = IMPLICIT.STORE
 }) {
   return function familyProvider(family, index) {
-    const unsubSingleCallbacksByKey = /* @__PURE__ */ new Map();
-    const unsubFamilyCallbacksByKey = /* @__PURE__ */ new Map();
-    const fillFamilyUnsubRequest = () => {
-      for (const [, unsub] of unsubFamilyCallbacksByKey) {
-        unsub();
-      }
-      unsubFamilyCallbacksByKey.clear();
-      socket.off(`unsub:${family.key}`, fillFamilyUnsubRequest);
-    };
-    const fillSingleUnsubRequest = (key) => {
-      socket.off(`unsub:${key}`, fillSingleUnsubRequest);
-      const unsub = unsubSingleCallbacksByKey.get(key);
+    const unsubCallbacksByKey = /* @__PURE__ */ new Map();
+    const fillUnsubRequest = (key) => {
+      socket.off(`unsub:${key}`, fillUnsubRequest);
+      const unsub = unsubCallbacksByKey.get(key);
       if (unsub) {
         unsub();
-        unsubSingleCallbacksByKey.delete(key);
+        unsubCallbacksByKey.delete(key);
       }
     };
     const fillSubRequest = (subKey) => {
-      var _a;
-      if (subKey === void 0) {
-        const keys = AtomIO7.getState(index, store);
-        for (const key of keys) {
-          const token = findInStore(family, key, store);
-          socket.emit(
-            `serve:${family.key}`,
-            parseJson(((_a = token.family) == null ? void 0 : _a.subKey) || `null`),
-            AtomIO7.getState(token, store)
+      const exposedSubKeys = getFromStore(index, store);
+      for (const exposedSubKey of exposedSubKeys) {
+        if (stringifyJson(exposedSubKey) === stringifyJson(subKey)) {
+          const token = findInStore(family, subKey, store);
+          socket.emit(`serve:${token.key}`, getFromStore(token, store));
+          const unsubscribe = subscribeToState(
+            token,
+            ({ newValue }) => {
+              socket.emit(`serve:${token.key}`, newValue);
+            },
+            `expose-family:${family.key}:${socket.id}`,
+            store
           );
+          unsubCallbacksByKey.set(token.key, unsubscribe);
+          socket.on(`unsub:${token.key}`, () => {
+            fillUnsubRequest(token.key);
+          });
+          break;
         }
-        const unsubscribeFromTokenCreation = family.subject.subscribe(
-          `expose-family:${socket.id}`,
-          (token) => {
-            const unsub = subscribeToState(
-              token,
-              ({ newValue }) => {
-                var _a2;
-                socket.emit(
-                  `serve:${family.key}`,
-                  parseJson(((_a2 = token.family) == null ? void 0 : _a2.subKey) || `null`),
-                  newValue
-                );
-              },
-              `expose-family:${family.key}:${socket.id}`,
-              store
-            );
-            unsubFamilyCallbacksByKey.set(token.key, unsub);
-          }
-        );
-        unsubFamilyCallbacksByKey.set(family.key, unsubscribeFromTokenCreation);
-        socket.on(`unsub:${family.key}`, fillFamilyUnsubRequest);
-      } else {
-        const token = family(subKey);
-        socket.emit(`serve:${token.key}`, AtomIO7.getState(token, store));
-        const unsubscribe = subscribeToState(
-          token,
-          ({ newValue }) => {
-            socket.emit(`serve:${token.key}`, newValue);
-          },
-          `expose-family:${family.key}:${socket.id}`,
-          store
-        );
-        unsubSingleCallbacksByKey.set(token.key, unsubscribe);
-        socket.on(`unsub:${token.key}`, () => {
-          fillSingleUnsubRequest(token.key);
-        });
       }
     };
     socket.on(`sub:${family.key}`, fillSubRequest);
     return () => {
       socket.off(`sub:${family.key}`, fillSubRequest);
-      for (const [, unsub] of unsubFamilyCallbacksByKey) {
-        unsub();
-      }
-      for (const [, unsub] of unsubSingleCallbacksByKey) {
+      for (const [, unsub] of unsubCallbacksByKey) {
         unsub();
       }
-      unsubFamilyCallbacksByKey.clear();
-      unsubSingleCallbacksByKey.clear();
+      unsubCallbacksByKey.clear();
     };
   };
 }
@@ -262,7 +639,7 @@ function realtimeMutableProvider({
       unsubscribeFromStateUpdates = null;
     };
     const fillSubRequest = () => {
-      socket.emit(`init:${token.key}`, AtomIO7.getState(jsonToken, store));
+      socket.emit(`init:${token.key}`, getFromStore(jsonToken, store));
       unsubscribeFromStateUpdates = subscribeToState(
         trackerToken,
         ({ newValue }) => {
@@ -285,110 +662,46 @@ function realtimeMutableFamilyProvider({
   store = IMPLICIT.STORE
 }) {
   return function mutableFamilyProvider(family, index) {
-    const unsubSingleCallbacksByKey = /* @__PURE__ */ new Map();
-    const unsubFamilyCallbacksByKey = /* @__PURE__ */ new Map();
-    const fillFamilyUnsubRequest = () => {
-      for (const [, unsub] of unsubFamilyCallbacksByKey) {
-        unsub();
-      }
-      unsubFamilyCallbacksByKey.clear();
-      socket.off(`unsub:${family.key}`, fillFamilyUnsubRequest);
-    };
-    const fillSingleUnsubRequest = (key) => {
-      socket.off(`unsub:${key}`, fillSingleUnsubRequest);
-      const unsub = unsubSingleCallbacksByKey.get(key);
+    const unsubCallbacksByKey = /* @__PURE__ */ new Map();
+    const fillUnsubRequest = (key) => {
+      socket.off(`unsub:${key}`, fillUnsubRequest);
+      const unsub = unsubCallbacksByKey.get(key);
       if (unsub) {
         unsub();
-        unsubSingleCallbacksByKey.delete(key);
+        unsubCallbacksByKey.delete(key);
       }
     };
     const fillSubRequest = (subKey) => {
-      var _a;
-      if (subKey === void 0) {
-        const keys = AtomIO7.getState(index, store);
-        for (const key of keys) {
-          const token = findInStore(family, key, store);
+      const exposedSubKeys = getFromStore(index, store);
+      for (const exposedSubKey of exposedSubKeys) {
+        if (stringifyJson(exposedSubKey) === stringifyJson(subKey)) {
+          const token = findInStore(family, subKey, store);
           const jsonToken = getJsonToken(token);
-          const trackerToken = getUpdateToken(token);
-          socket.emit(
-            `init:${family.key}`,
-            parseJson(((_a = jsonToken.family) == null ? void 0 : _a.subKey) || `null`),
-            AtomIO7.getState(jsonToken, store)
-          );
-          const unsubFromUpdates = subscribeToState(
-            trackerToken,
+          const updateToken = getUpdateToken(token);
+          socket.emit(`init:${token.key}`, getFromStore(jsonToken, store));
+          const unsubscribe = subscribeToState(
+            updateToken,
             ({ newValue }) => {
-              var _a2;
-              socket.emit(
-                `next:${token.key}`,
-                parseJson(((_a2 = jsonToken.family) == null ? void 0 : _a2.subKey) || `null`),
-                newValue
-              );
+              socket.emit(`next:${token.key}`, newValue);
             },
             `expose-family:${family.key}:${socket.id}`,
             store
           );
-          unsubFamilyCallbacksByKey.set(token.key, unsubFromUpdates);
+          unsubCallbacksByKey.set(token.key, unsubscribe);
+          socket.on(`unsub:${token.key}`, () => {
+            fillUnsubRequest(token.key);
+          });
+          break;
         }
-        const unsubscribeFromTokenCreation = family.subject.subscribe(
-          `expose-family:${socket.id}`,
-          (token) => {
-            var _a2;
-            const jsonToken = getJsonToken(token);
-            const trackerToken = getUpdateToken(token);
-            socket.emit(
-              `init:${family.key}`,
-              parseJson(((_a2 = jsonToken.family) == null ? void 0 : _a2.subKey) || `null`),
-              AtomIO7.getState(jsonToken, store)
-            );
-            const unsubFromUpdates = subscribeToState(
-              trackerToken,
-              ({ newValue }) => {
-                var _a3;
-                socket.emit(
-                  `next:${token.key}`,
-                  parseJson(((_a3 = jsonToken.family) == null ? void 0 : _a3.subKey) || `null`),
-                  newValue
-                );
-              },
-              `expose-family:${family.key}:${socket.id}`,
-              store
-            );
-            unsubFamilyCallbacksByKey.set(token.key, unsubFromUpdates);
-          }
-        );
-        unsubFamilyCallbacksByKey.set(family.key, unsubscribeFromTokenCreation);
-        socket.on(`unsub:${family.key}`, fillFamilyUnsubRequest);
-      } else {
-        const token = family(subKey);
-        const jsonToken = getJsonToken(token);
-        const updateToken = getUpdateToken(token);
-        socket.emit(`init:${token.key}`, AtomIO7.getState(jsonToken, store));
-        const unsubscribe = subscribeToState(
-          updateToken,
-          ({ newValue }) => {
-            socket.emit(`next:${token.key}`, newValue);
-          },
-          `expose-family:${family.key}:${socket.id}`,
-          store
-        );
-        unsubSingleCallbacksByKey.set(token.key, unsubscribe);
-        socket.on(`unsub:${token.key}`, () => {
-          fillSingleUnsubRequest(token.key);
-        });
       }
     };
     socket.on(`sub:${family.key}`, fillSubRequest);
     return () => {
       socket.off(`sub:${family.key}`, fillSubRequest);
-      for (const [, unsub] of unsubFamilyCallbacksByKey) {
+      for (const [, unsub] of unsubCallbacksByKey) {
         unsub();
       }
-      for (const [, unsub] of unsubSingleCallbacksByKey) {
-        unsub();
-      }
-      unsubFamilyCallbacksByKey.clear();
-      unsubSingleCallbacksByKey.clear();
+      unsubCallbacksByKey.clear();
     };
   };
 }
@@ -397,7 +710,7 @@ function realtimeStateReceiver({
   store = IMPLICIT.STORE
 }) {
   return function stateReceiver(token) {
-    const publish = (newValue) => setState(token, newValue, store);
+    const publish = (newValue) => setIntoStore(token, newValue, store);
     const fillPubUnclaim = () => {
       socket.off(`pub:${token.key}`, publish);
       socket.off(`unclaim:${token.key}`, fillPubUnclaim);
@@ -423,7 +736,7 @@ function realtimeActionReceiver({
       const performanceKeyStart = `${performanceKey}:start`;
       const performanceKeyEnd = `${performanceKey}:end`;
       performance.mark(performanceKeyStart);
-      AtomIO7.runTransaction(tx, update.id, store)(...update.params);
+      actUponStore(tx, update.id, store)(...update.params);
       performance.mark(performanceKeyEnd);
       const metric = performance.measure(
         performanceKey,
@@ -441,31 +754,42 @@ function realtimeActionSynchronizer({
   store = IMPLICIT.STORE
 }) {
   return function actionSynchronizer(tx, filter) {
+    assignTransactionToContinuity(`default`, tx.key, store);
     const userKeyState = findInStore(
       usersOfSockets.states.userKeyOfSocket,
       socket.id,
       store
     );
-    const userKey = AtomIO7.getState(userKeyState, store);
-    const socketUnacknowledgedUpdatesState = findInStore(
-      socketUnacknowledgedUpdatesSelectors,
-      socket.id,
+    const userKey = getFromStore(userKeyState, store);
+    if (!userKey) {
+      store.logger.error(
+        `\u274C`,
+        `transaction`,
+        tx.key,
+        `Tried to create a synchronizer for a socket (${socket.id}) that is not connected to a user.`
+      );
+      return () => {
+      };
+    }
+    const userUnacknowledgedQueue = findInStore(
+      userUnacknowledgedQueues,
+      userKey,
       store
     );
-    const socketUnacknowledgedUpdates = AtomIO7.getState(
-      socketUnacknowledgedUpdatesState,
+    const userUnacknowledgedUpdates = getFromStore(
+      userUnacknowledgedQueue,
       store
     );
     if (filter) {
       const redactorState = findInStore(transactionRedactorAtoms, tx.key, store);
-      AtomIO7.setState(redactorState, { filter }, store);
+      setIntoStore(redactorState, { filter }, store);
     }
     const fillTransactionRequest = (update) => {
       const performanceKey = `tx-run:${tx.key}:${update.id}`;
       const performanceKeyStart = `${performanceKey}:start`;
       const performanceKeyEnd = `${performanceKey}:end`;
       performance.mark(performanceKeyStart);
-      AtomIO7.runTransaction(tx, update.id, store)(...update.params);
+      actUponStore(tx, update.id, store)(...update.params);
       performance.mark(performanceKeyEnd);
       const metric = performance.measure(
         performanceKey,
@@ -481,14 +805,14 @@ function realtimeActionSynchronizer({
       unsubscribeFromTransaction = subscribeToTransaction(
         tx,
         (update) => {
-          const updateState = findInStore(completeUpdateAtoms, update.id, store);
-          AtomIO7.setState(updateState, update, store);
-          const toEmit = filter ? AtomIO7.getState(
+          const updateState = findInStore(completeUpdateAtoms2, update.id, store);
+          setIntoStore(updateState, update, store);
+          const toEmit = filter ? getFromStore(
             findInStore(redactedUpdateSelectors, [tx.key, update.id], store),
             store
           ) : update;
-          AtomIO7.setState(
-            socketUnacknowledgedUpdatesState,
+          setIntoStore(
+            userUnacknowledgedQueue,
             (updates) => {
               if (toEmit) {
                 updates.push(toEmit);
@@ -509,8 +833,7 @@ function realtimeActionSynchronizer({
     let i = 1;
     let next = 1;
     const retry = setInterval(() => {
-      const toEmit = socketUnacknowledgedUpdates[0];
-      console.log(userKey, socketUnacknowledgedUpdates);
+      const toEmit = userUnacknowledgedUpdates[0];
       if (toEmit && i === next) {
         socket.emit(`tx-new:${tx.key}`, toEmit);
         next *= 2;
@@ -521,15 +844,9 @@ function realtimeActionSynchronizer({
       var _a;
       i = 1;
       next = 1;
-      const socketEpochState = findInStore(
-        socketEpochSelectors,
-        socket.id,
-        store
-      );
-      AtomIO7.setState(socketEpochState, epoch, store);
-      if (((_a = socketUnacknowledgedUpdates[0]) == null ? void 0 : _a.epoch) === epoch) {
-        AtomIO7.setState(
-          socketUnacknowledgedUpdatesState,
+      if (((_a = userUnacknowledgedUpdates[0]) == null ? void 0 : _a.epoch) === epoch) {
+        setIntoStore(
+          userUnacknowledgedQueue,
           (updates) => {
             updates.shift();
             return updates;
@@ -551,6 +868,6 @@ function realtimeActionSynchronizer({
   };
 }
 
-export { DEFAULT_USER_IN_ROOM_META, completeUpdateAtoms, realtimeActionReceiver, realtimeActionSynchronizer, realtimeFamilyProvider, realtimeMutableFamilyProvider, realtimeMutableProvider, realtimeStateProvider, realtimeStateReceiver, realtimeStateSynchronizer, redactedUpdateSelectors, roomIndex, socketEpochSelectors, socketUnacknowledgedUpdatesSelectors, transactionRedactorAtoms, userEpochAtoms, userIndex, userUnacknowledgedUpdatesAtoms, usersInRooms, usersOfSockets };
+export { ChildSocket, CustomSocket, DEFAULT_USER_IN_ROOM_META, ParentSocket, SubjectSocket, completeUpdateAtoms2 as completeUpdateAtoms, createRoomTX, joinRoomTX, realtimeActionReceiver, realtimeActionSynchronizer, realtimeAtomFamilyProvider, realtimeContinuitySynchronizer, realtimeMutableFamilyProvider, realtimeMutableProvider, realtimeStateProvider, realtimeStateReceiver, realtimeStateSynchronizer, redactedPerspectiveUpdateSelectors, redactedUpdateSelectors, roomArgumentsAtoms, roomIndex, roomSelectors, socketAtoms, socketIndex, transactionRedactorAtoms, userIndex, userUnacknowledgedQueues, usersInRooms, usersOfSockets };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map