atom.io 0.17.0 → 0.18.0

package/realtime-server/dist/index.cjs

@@ -1,10 +1,13 @@
 'use strict';
 
+var internal = require('atom.io/internal');
+var json = require('atom.io/json');
 var AtomIO = require('atom.io');
+var realtime = require('atom.io/realtime');
+var realtimeServer = require('atom.io/realtime-server');
+var child_process = require('child_process');
 var data = require('atom.io/data');
 var setRtx = require('atom.io/transceivers/set-rtx');
-var internal = require('atom.io/internal');
-var json = require('atom.io/json');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -45,20 +48,211 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var userIndex = AtomIO.atom({
-  key: `usersIndex`,
-  mutable: true,
-  default: () => new setRtx.SetRTX(),
-  toJson: (set) => set.toJSON(),
-  fromJson: (json) => setRtx.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 = json.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 internal.Subject();
+    this.out = new internal.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 = json.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 = AtomIO.selectorFamily({
+  key: `perspectiveRedactor`,
+  get: ({ userId, syncGroupKey }) => ({ get, find }) => {
+    const syncGroup = realtime.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 = data.join({
-  key: `usersOfSockets`,
-  between: [`user`, `socket`],
-  cardinality: `1:1`
+var redactedPerspectiveUpdateSelectors = AtomIO.selectorFamily({
+  key: `redactedPerspectiveUpdate`,
+  get: ({ userId, syncGroupKey, updateId }) => ({ get, find }) => {
+    const updateState = find(realtimeServer.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 = AtomIO.atom({
-  key: `conclaveIndex`,
+var roomIndex = AtomIO__namespace.atom({
+  key: `roomIndex`,
   default: () => new setRtx.SetRTX(),
   mutable: true,
   toJson: (set) => set.toJSON(),
@@ -75,7 +269,51 @@ var usersInRooms = data.join(
   },
   DEFAULT_USER_IN_ROOM_META
 );
-var completeUpdateAtoms = AtomIO.atomFamily({
+var roomArgumentsAtoms = AtomIO__namespace.atomFamily({
+  key: `roomArguments`,
+  default: [`echo Hello World!`]
+});
+var roomSelectors = AtomIO__namespace.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 = child_process.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__namespace.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__namespace.transaction({
+  key: `joinRoom`,
+  do: (transactors, roomId, userId, enteredAtEpoch) => {
+    const meta = { enteredAtEpoch };
+    usersInRooms.transact(transactors, ({ relations }) => {
+      relations.set(roomId, userId, meta);
+    });
+    return meta;
+  }
+});
+var completeUpdateAtoms2 = AtomIO.atomFamily({
   key: `completeUpdate`,
   default: null
 });
@@ -86,7 +324,7 @@ var transactionRedactorAtoms = AtomIO.atomFamily({
 var redactedUpdateSelectors = AtomIO.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) });
@@ -94,64 +332,243 @@ var redactedUpdateSelectors = AtomIO.selectorFamily({
     return null;
   }
 });
-var userUnacknowledgedUpdatesAtoms = AtomIO.atomFamily({
+var userUnacknowledgedQueues = AtomIO.atomFamily({
   key: `unacknowledgedUpdates`,
   default: () => []
 });
-var socketUnacknowledgedUpdatesSelectors = AtomIO.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 = AtomIO.atomFamily({
-  key: `clientEpoch`,
+var socketAtoms = AtomIO.atomFamily({
+  key: `sockets`,
   default: null
 });
-var socketEpochSelectors = AtomIO.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 = AtomIO.atom({
+  key: `socketsIndex`,
+  mutable: true,
+  default: () => new setRtx.SetRTX(),
+  toJson: (set) => set.toJSON(),
+  fromJson: (json) => setRtx.SetRTX.fromJSON(json)
+});
+var userIndex = AtomIO.atom({
+  key: `usersIndex`,
+  mutable: true,
+  default: () => new setRtx.SetRTX(),
+  toJson: (set) => set.toJSON(),
+  fromJson: (json) => setRtx.SetRTX.fromJSON(json)
+});
+var usersOfSockets = data.join({
+  key: `usersOfSockets`,
+  between: [`user`, `socket`],
+  cardinality: `1:1`
+});
+
+// realtime-server/src/realtime-continuity-synchronizer.ts
+function realtimeContinuitySynchronizer({
+  socket: initialSocket,
+  store = internal.IMPLICIT.STORE
+}) {
+  return function synchronizer(continuity) {
+    let socket = initialSocket;
+    const continuityKey = continuity.key;
+    const userKeyState = internal.findInStore(
+      usersOfSockets.states.userKeyOfSocket,
+      socket.id,
+      store
+    );
+    const userKey = internal.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 = internal.findInStore(
+      usersOfSockets.states.socketKeyOfUser,
+      userKey,
+      store
+    );
+    internal.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 = internal.findInStore(socketAtoms, newSocketKey, store);
+        const newSocket = internal.getFromStore(newSocketState, store);
+        socket = newSocket;
+      },
+      `sync-continuity:${continuityKey}:${userKey}`,
+      store
+    );
+    const userUnacknowledgedQueue = internal.findInStore(
+      userUnacknowledgedQueues,
+      userKey,
+      store
+    );
+    const userUnacknowledgedUpdates = internal.getFromStore(
+      userUnacknowledgedQueue,
+      store
+    );
+    const unsubscribeFunctions = [];
+    const sendInitialPayload = () => {
+      var _a;
+      const initialPayload = [];
+      for (const atom3 of continuity.globals) {
+        initialPayload.push(atom3, internal.getFromStore(atom3, store));
+      }
+      for (const { perspectiveAtoms } of continuity.perspectives) {
+        const perspectiveTokensState = internal.findInStore(
+          perspectiveAtoms,
+          userKey,
+          store
+        );
+        const perspectiveTokens = internal.getFromStore(perspectiveTokensState, store);
+        for (const perspectiveToken of perspectiveTokens) {
+          const resource = internal.getFromStore(perspectiveToken, store);
+          initialPayload.push(perspectiveToken, resource);
+        }
+      }
+      const epoch = internal.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 = internal.subscribeToTransaction(
+          transaction2,
+          (update) => {
+            const updateState = internal.findInStore(
+              completeUpdateAtoms2,
+              update.id,
+              store
+            );
+            internal.setIntoStore(updateState, update, store);
+            const redactedUpdateKey = {
+              userId: userKey,
+              syncGroupKey: continuityKey,
+              updateId: update.id
+            };
+            const redactedUpdateState = internal.findInStore(
+              redactedPerspectiveUpdateSelectors,
+              redactedUpdateKey,
+              store
+            );
+            const redactedUpdate = internal.getFromStore(redactedUpdateState, store);
+            internal.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);
+      internal.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) {
+        internal.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 = internal.IMPLICIT.STORE
@@ -201,89 +618,49 @@ function realtimeStateSynchronizer({
     };
   };
 }
-function realtimeFamilyProvider({
+function realtimeAtomFamilyProvider({
   socket,
   store = internal.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 = internal.getFromStore(index, store);
-        for (const key of keys) {
-          const token = internal.findInStore(family, key, store);
-          socket.emit(
-            `serve:${family.key}`,
-            json.parseJson(((_a = token.family) == null ? void 0 : _a.subKey) || `null`),
-            internal.getFromStore(token, store)
+      const exposedSubKeys = internal.getFromStore(index, store);
+      for (const exposedSubKey of exposedSubKeys) {
+        if (json.stringifyJson(exposedSubKey) === json.stringifyJson(subKey)) {
+          const token = internal.findInStore(family, subKey, store);
+          socket.emit(`serve:${token.key}`, internal.getFromStore(token, store));
+          const unsubscribe = internal.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 = internal.subscribeToState(
-              token,
-              ({ newValue }) => {
-                var _a2;
-                socket.emit(
-                  `serve:${family.key}`,
-                  json.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}`, internal.getFromStore(token, store));
-        const unsubscribe = internal.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();
     };
   };
 }
@@ -324,110 +701,46 @@ function realtimeMutableFamilyProvider({
   store = internal.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 = internal.getFromStore(index, store);
-        for (const key of keys) {
-          const token = internal.findInStore(family, key, store);
+      const exposedSubKeys = internal.getFromStore(index, store);
+      for (const exposedSubKey of exposedSubKeys) {
+        if (json.stringifyJson(exposedSubKey) === json.stringifyJson(subKey)) {
+          const token = internal.findInStore(family, subKey, store);
           const jsonToken = internal.getJsonToken(token);
-          const trackerToken = internal.getUpdateToken(token);
-          socket.emit(
-            `init:${family.key}`,
-            json.parseJson(((_a = jsonToken.family) == null ? void 0 : _a.subKey) || `null`),
-            internal.getFromStore(jsonToken, store)
-          );
-          const unsubFromUpdates = internal.subscribeToState(
-            trackerToken,
+          const updateToken = internal.getUpdateToken(token);
+          socket.emit(`init:${token.key}`, internal.getFromStore(jsonToken, store));
+          const unsubscribe = internal.subscribeToState(
+            updateToken,
             ({ newValue }) => {
-              var _a2;
-              socket.emit(
-                `next:${token.key}`,
-                json.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 = internal.getJsonToken(token);
-            const trackerToken = internal.getUpdateToken(token);
-            socket.emit(
-              `init:${family.key}`,
-              json.parseJson(((_a2 = jsonToken.family) == null ? void 0 : _a2.subKey) || `null`),
-              internal.getFromStore(jsonToken, store)
-            );
-            const unsubFromUpdates = internal.subscribeToState(
-              trackerToken,
-              ({ newValue }) => {
-                var _a3;
-                socket.emit(
-                  `next:${token.key}`,
-                  json.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 = internal.getJsonToken(token);
-        const updateToken = internal.getUpdateToken(token);
-        socket.emit(`init:${token.key}`, internal.getFromStore(jsonToken, store));
-        const unsubscribe = internal.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) {
-        unsub();
-      }
-      for (const [, unsub] of unsubSingleCallbacksByKey) {
+      for (const [, unsub] of unsubCallbacksByKey) {
         unsub();
       }
-      unsubFamilyCallbacksByKey.clear();
-      unsubSingleCallbacksByKey.clear();
+      unsubCallbacksByKey.clear();
     };
   };
 }
@@ -462,7 +775,7 @@ function realtimeActionReceiver({
       const performanceKeyStart = `${performanceKey}:start`;
       const performanceKeyEnd = `${performanceKey}:end`;
       performance.mark(performanceKeyStart);
-      AtomIO__namespace.runTransaction(tx, update.id, store)(...update.params);
+      internal.actUponStore(tx, update.id, store)(...update.params);
       performance.mark(performanceKeyEnd);
       const metric = performance.measure(
         performanceKey,
@@ -480,19 +793,30 @@ function realtimeActionSynchronizer({
   store = internal.IMPLICIT.STORE
 }) {
   return function actionSynchronizer(tx, filter) {
+    internal.assignTransactionToContinuity(`default`, tx.key, store);
     const userKeyState = internal.findInStore(
       usersOfSockets.states.userKeyOfSocket,
       socket.id,
       store
     );
     const userKey = internal.getFromStore(userKeyState, store);
-    const socketUnacknowledgedUpdatesState = internal.findInStore(
-      socketUnacknowledgedUpdatesSelectors,
-      socket.id,
+    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 = internal.findInStore(
+      userUnacknowledgedQueues,
+      userKey,
       store
     );
-    const socketUnacknowledgedUpdates = internal.getFromStore(
-      socketUnacknowledgedUpdatesState,
+    const userUnacknowledgedUpdates = internal.getFromStore(
+      userUnacknowledgedQueue,
       store
     );
     if (filter) {
@@ -504,7 +828,7 @@ function realtimeActionSynchronizer({
       const performanceKeyStart = `${performanceKey}:start`;
       const performanceKeyEnd = `${performanceKey}:end`;
       performance.mark(performanceKeyStart);
-      AtomIO__namespace.runTransaction(tx, update.id, store)(...update.params);
+      internal.actUponStore(tx, update.id, store)(...update.params);
       performance.mark(performanceKeyEnd);
       const metric = performance.measure(
         performanceKey,
@@ -520,14 +844,14 @@ function realtimeActionSynchronizer({
       unsubscribeFromTransaction = internal.subscribeToTransaction(
         tx,
         (update) => {
-          const updateState = internal.findInStore(completeUpdateAtoms, update.id, store);
+          const updateState = internal.findInStore(completeUpdateAtoms2, update.id, store);
           internal.setIntoStore(updateState, update, store);
           const toEmit = filter ? internal.getFromStore(
             internal.findInStore(redactedUpdateSelectors, [tx.key, update.id], store),
             store
           ) : update;
           internal.setIntoStore(
-            socketUnacknowledgedUpdatesState,
+            userUnacknowledgedQueue,
             (updates) => {
               if (toEmit) {
                 updates.push(toEmit);
@@ -548,8 +872,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;
@@ -560,15 +883,9 @@ function realtimeActionSynchronizer({
       var _a;
       i = 1;
       next = 1;
-      const socketEpochState = internal.findInStore(
-        socketEpochSelectors,
-        socket.id,
-        store
-      );
-      internal.setIntoStore(socketEpochState, epoch, store);
-      if (((_a = socketUnacknowledgedUpdates[0]) == null ? void 0 : _a.epoch) === epoch) {
+      if (((_a = userUnacknowledgedUpdates[0]) == null ? void 0 : _a.epoch) === epoch) {
         internal.setIntoStore(
-          socketUnacknowledgedUpdatesState,
+          userUnacknowledgedQueue,
           (updates) => {
             updates.shift();
             return updates;
@@ -590,24 +907,33 @@ function realtimeActionSynchronizer({
   };
 }
 
+exports.ChildSocket = ChildSocket;
+exports.CustomSocket = CustomSocket;
 exports.DEFAULT_USER_IN_ROOM_META = DEFAULT_USER_IN_ROOM_META;
-exports.completeUpdateAtoms = completeUpdateAtoms;
+exports.ParentSocket = ParentSocket;
+exports.SubjectSocket = SubjectSocket;
+exports.completeUpdateAtoms = completeUpdateAtoms2;
+exports.createRoomTX = createRoomTX;
+exports.joinRoomTX = joinRoomTX;
 exports.realtimeActionReceiver = realtimeActionReceiver;
 exports.realtimeActionSynchronizer = realtimeActionSynchronizer;
-exports.realtimeFamilyProvider = realtimeFamilyProvider;
+exports.realtimeAtomFamilyProvider = realtimeAtomFamilyProvider;
+exports.realtimeContinuitySynchronizer = realtimeContinuitySynchronizer;
 exports.realtimeMutableFamilyProvider = realtimeMutableFamilyProvider;
 exports.realtimeMutableProvider = realtimeMutableProvider;
 exports.realtimeStateProvider = realtimeStateProvider;
 exports.realtimeStateReceiver = realtimeStateReceiver;
 exports.realtimeStateSynchronizer = realtimeStateSynchronizer;
+exports.redactedPerspectiveUpdateSelectors = redactedPerspectiveUpdateSelectors;
 exports.redactedUpdateSelectors = redactedUpdateSelectors;
+exports.roomArgumentsAtoms = roomArgumentsAtoms;
 exports.roomIndex = roomIndex;
-exports.socketEpochSelectors = socketEpochSelectors;
-exports.socketUnacknowledgedUpdatesSelectors = socketUnacknowledgedUpdatesSelectors;
+exports.roomSelectors = roomSelectors;
+exports.socketAtoms = socketAtoms;
+exports.socketIndex = socketIndex;
 exports.transactionRedactorAtoms = transactionRedactorAtoms;
-exports.userEpochAtoms = userEpochAtoms;
 exports.userIndex = userIndex;
-exports.userUnacknowledgedUpdatesAtoms = userUnacknowledgedUpdatesAtoms;
+exports.userUnacknowledgedQueues = userUnacknowledgedQueues;
 exports.usersInRooms = usersInRooms;
 exports.usersOfSockets = usersOfSockets;
 //# sourceMappingURL=out.js.map