atom.io 0.17.0 → 0.18.1

package/realtime-client/dist/index.cjs

@@ -1,8 +1,9 @@
 'use strict';
 
-var Internal3 = require('atom.io/internal');
+var Internal = require('atom.io/internal');
 var json = require('atom.io/json');
 var AtomIO = require('atom.io');
+var realtimeClient = require('atom.io/realtime-client');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -22,13 +23,13 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var Internal3__namespace = /*#__PURE__*/_interopNamespace(Internal3);
+var Internal__namespace = /*#__PURE__*/_interopNamespace(Internal);
 var AtomIO__namespace = /*#__PURE__*/_interopNamespace(AtomIO);
 
-// realtime-client/src/pull-state.ts
-function pullState(token, socket, store) {
+// realtime-client/src/pull-atom.ts
+function pullAtom(token, socket, store) {
   const setServedValue = (data) => {
-    Internal3.setIntoStore(token, data, store);
+    Internal.setIntoStore(token, data, store);
   };
   socket.on(`serve:${token.key}`, setServedValue);
   socket.emit(`sub:${token.key}`);
@@ -37,7 +38,7 @@ function pullState(token, socket, store) {
     socket.emit(`unsub:${token.key}`);
   };
 }
-function pullFamilyMember(token, socket, store) {
+function pullAtomFamilyMember(token, socket, store) {
   if (!(`family` in token)) {
     console.error(`Token is not a family member:`, token);
     return () => {
@@ -46,7 +47,7 @@ function pullFamilyMember(token, socket, store) {
   const { key: familyKey, subKey: serializedSubKey } = token.family;
   const subKey = json.parseJson(serializedSubKey);
   socket == null ? void 0 : socket.on(`serve:${token.key}`, (data) => {
-    Internal3.setIntoStore(token, data, store);
+    Internal.setIntoStore(token, data, store);
   });
   socket == null ? void 0 : socket.emit(`sub:${familyKey}`, subKey);
   return () => {
@@ -54,16 +55,16 @@ function pullFamilyMember(token, socket, store) {
     socket == null ? void 0 : socket.emit(`unsub:${token.key}`);
   };
 }
-function pullMutableState(token, socket, store) {
-  const jsonToken = Internal3.getJsonToken(token);
-  const updateToken = Internal3.getUpdateToken(token);
+function pullMutableAtom(token, socket, store) {
+  const jsonToken = Internal.getJsonToken(token);
+  const updateToken = Internal.getUpdateToken(token);
   socket.on(`init:${token.key}`, (data) => {
-    Internal3.setIntoStore(jsonToken, data, store);
+    Internal.setIntoStore(jsonToken, data, store);
   });
   socket.on(
     `next:${token.key}`,
     (data) => {
-      Internal3.setIntoStore(updateToken, data, store);
+      Internal.setIntoStore(updateToken, data, store);
     }
   );
   socket.emit(`sub:${token.key}`);
@@ -73,7 +74,7 @@ function pullMutableState(token, socket, store) {
     socket.emit(`unsub:${token.key}`);
   };
 }
-function pullMutableFamilyMember(token, socket, store) {
+function pullMutableAtomFamilyMember(token, socket, store) {
   if (!(`family` in token)) {
     console.error(`Token is not a family member:`, token);
     return () => {
@@ -81,26 +82,89 @@ function pullMutableFamilyMember(token, socket, store) {
   }
   const { key: familyKey, subKey: serializedSubKey } = token.family;
   const subKey = json.parseJson(serializedSubKey);
-  socket == null ? void 0 : socket.on(`init:${token.key}`, (data) => {
-    const jsonToken = Internal3.getJsonToken(token);
-    Internal3.setIntoStore(jsonToken, data, store);
+  socket.on(`init:${token.key}`, (data) => {
+    const jsonToken = Internal.getJsonToken(token);
+    Internal.setIntoStore(jsonToken, data, store);
   });
-  socket == null ? void 0 : socket.on(
+  socket.on(
     `next:${token.key}`,
     (data) => {
-      const trackerToken = Internal3.getUpdateToken(token);
-      Internal3.setIntoStore(trackerToken, data, store);
+      const trackerToken = Internal.getUpdateToken(token);
+      Internal.setIntoStore(trackerToken, data, store);
     }
   );
-  socket == null ? void 0 : socket.emit(`sub:${familyKey}`, subKey);
+  socket.emit(`sub:${familyKey}`, subKey);
   return () => {
-    socket == null ? void 0 : socket.off(`serve:${token.key}`);
-    socket == null ? void 0 : socket.emit(`unsub:${token.key}`);
+    socket.off(`serve:${token.key}`);
+    socket.emit(`unsub:${token.key}`);
+  };
+}
+
+// realtime-client/src/pull-selector.ts
+function pullSelector(token, socket, store) {
+  const atomKeys = store.selectorAtoms.getRelatedKeys(token.key);
+  const unsubscribes = [];
+  if (atomKeys) {
+    for (const atomKey of atomKeys) {
+      const atom3 = store.atoms.get(atomKey);
+      if (!atom3) {
+        continue;
+      }
+      switch (atom3.type) {
+        case `atom`: {
+          unsubscribes.push(pullAtom(atom3, socket, store));
+          break;
+        }
+        case `mutable_atom`: {
+          unsubscribes.push(pullMutableAtom(atom3, socket, store));
+          break;
+        }
+      }
+    }
+  }
+  return () => {
+    for (const unsubscribe of unsubscribes) {
+      unsubscribe();
+    }
+  };
+}
+
+// realtime-client/src/pull-selector-family-member.ts
+function pullSelectorFamilyMember(token, socket, store) {
+  if (!(`family` in token)) {
+    console.error(`Token is not a family member:`, token);
+    return () => {
+    };
+  }
+  const atomKeys = store.selectorAtoms.getRelatedKeys(token.key);
+  const unsubscribes = [];
+  if (atomKeys) {
+    for (const atomKey of atomKeys) {
+      const atom3 = store.atoms.get(atomKey);
+      if (!atom3) {
+        continue;
+      }
+      switch (atom3.type) {
+        case `atom`: {
+          unsubscribes.push(pullAtomFamilyMember(atom3, socket, store));
+          break;
+        }
+        case `mutable_atom`: {
+          unsubscribes.push(pullMutableAtomFamilyMember(atom3, socket, store));
+          break;
+        }
+      }
+    }
+  }
+  return () => {
+    for (const unsubscribe of unsubscribes) {
+      unsubscribe();
+    }
   };
 }
 function pushState(token, socket, store) {
   socket.emit(`claim:${token.key}`);
-  Internal3__namespace.subscribeToState(
+  Internal__namespace.subscribeToState(
     token,
     ({ newValue }) => {
       socket.emit(`pub:${token.key}`, newValue);
@@ -113,145 +177,225 @@ function pushState(token, socket, store) {
     socket.emit(`unclaim:${token.key}`);
   };
 }
-function serverAction(token, socket, store) {
-  const unsubscribeFromLocalUpdates = Internal3__namespace.subscribeToTransaction(
-    token,
-    (clientUpdate) => {
-      socket.emit(`tx-run:${token.key}`, clientUpdate);
-    },
-    `tx-run:${token.key}:${socket.id}`,
-    store
-  );
-  return () => {
-    unsubscribeFromLocalUpdates();
-  };
-}
+
+// __unstable__/web-effects/src/storage.ts
+var persistAtom = (storage) => ({ stringify, parse }) => (key) => ({ setSelf, onSet }) => {
+  const savedValue = storage.getItem(key);
+  if (savedValue != null)
+    setSelf(parse(savedValue));
+  onSet(({ newValue }) => {
+    if (newValue == null) {
+      storage.removeItem(key);
+      return;
+    }
+    storage.setItem(key, stringify(newValue));
+  });
+};
+var lazyLocalStorageEffect = persistAtom(localStorage)(JSON);
+
+// realtime-client/src/realtime-client-stores/client-main-store.ts
 var myIdState__INTERNAL = AtomIO__namespace.atom({
-  key: `myId__INTERNAL`,
+  key: `mySocketId__INTERNAL`,
   default: void 0
 });
 var myIdState = AtomIO__namespace.selector({
-  key: `myId`,
+  key: `mySocketId`,
   get: ({ get }) => get(myIdState__INTERNAL)
 });
-var optimisticUpdateQueueState = AtomIO__namespace.atom({
-  key: `updateQueue`,
-  default: []
+var usernameEffects = typeof window === `undefined` ? [] : [lazyLocalStorageEffect(`myUsername`)];
+var myUsernameState = AtomIO__namespace.atom({
+  key: `myUsername`,
+  default: null,
+  effects: usernameEffects
 });
-var confirmedUpdateQueueState = AtomIO__namespace.atom({
-  key: `serverConfirmedUpdateQueue`,
+var optimisticUpdateQueue = AtomIO__namespace.atom({
+  key: `updateQueue`,
   default: []
 });
-
-// internal/src/transaction/is-root-store.ts
-function isRootStore(store) {
-  return `epoch` in store.transactionMeta;
-}
-
-// realtime-client/src/sync-server-action.ts
-function syncAction(token, socket, store) {
-  const optimisticQueue = Internal3__namespace.getFromStore(
-    optimisticUpdateQueueState,
-    store
-  );
-  const confirmedQueue = Internal3__namespace.getFromStore(confirmedUpdateQueueState, store);
-  const unsubscribeFromLocalUpdates = Internal3__namespace.subscribeToTransaction(
+var confirmedUpdateQueue = AtomIO__namespace.atom(
+  {
+    key: `serverConfirmedUpdateQueue`,
+    default: []
+  }
+);
+function serverAction(token, socket, store) {
+  const unsubscribeFromLocalUpdates = Internal__namespace.subscribeToTransaction(
     token,
     (clientUpdate) => {
-      const optimisticUpdateQueueIndex = optimisticQueue.findIndex(
-        (update) => update.id === clientUpdate.id
-      );
-      if (optimisticUpdateQueueIndex === -1) {
-        Internal3__namespace.setIntoStore(
-          optimisticUpdateQueueState,
-          (queue) => {
-            queue.push(clientUpdate);
-            queue.sort((a, b) => a.epoch - b.epoch);
-            return queue;
-          },
-          store
-        );
-        socket.emit(`tx-run:${token.key}`, clientUpdate);
-      } else {
-        Internal3__namespace.setIntoStore(
-          optimisticUpdateQueueState,
-          (queue) => {
-            queue[optimisticUpdateQueueIndex] = clientUpdate;
-            return queue;
-          },
-          store
-        );
-        socket.emit(`tx-run:${token.key}`, clientUpdate);
-      }
+      socket.emit(`tx-run:${token.key}`, clientUpdate);
     },
-    `tx-run:${token.key}`,
+    `tx-run:${token.key}:${socket.id}`,
     store
   );
-  const reconcileUpdates = (optimisticUpdate, confirmedUpdate) => {
-    Internal3__namespace.setIntoStore(
-      optimisticUpdateQueueState,
-      (queue) => {
-        queue.shift();
-        return queue;
-      },
-      store
-    );
-    if (optimisticUpdate.id === confirmedUpdate.id) {
-      const clientResult = JSON.stringify(optimisticUpdate.updates);
-      const serverResult = JSON.stringify(confirmedUpdate.updates);
-      if (clientResult === serverResult) {
+  return () => {
+    unsubscribeFromLocalUpdates();
+  };
+}
+function syncContinuity(continuity, socket, store) {
+  const continuityKey = continuity.key;
+  const optimisticUpdates = Internal.getFromStore(realtimeClient.optimisticUpdateQueue, store);
+  const confirmedUpdates = Internal.getFromStore(realtimeClient.confirmedUpdateQueue, store);
+  const initializeContinuity = (epoch, payload) => {
+    socket.off(`continuity-init:${continuityKey}`, initializeContinuity);
+    let i = 0;
+    let k = ``;
+    let v = null;
+    for (const x of payload) {
+      if (i % 2 === 0) {
+        k = x;
+      } else {
+        v = x;
+        if (`type` in k && k.type === `mutable_atom`) {
+          k = Internal.getJsonToken(k);
+        }
+        Internal.setIntoStore(k, v, store);
+      }
+      i++;
+    }
+    Internal.setEpochNumberOfContinuity(continuityKey, epoch, store);
+  };
+  socket.off(`continuity-init:${continuityKey}`);
+  socket.on(`continuity-init:${continuityKey}`, initializeContinuity);
+  const registerAndAttemptConfirmedUpdate = (confirmedUpdate) => {
+    function reconcileEpoch(optimisticUpdate, confirmedUpdate2) {
+      store.logger.info(
+        `\u{1F9D1}\u200D\u2696\uFE0F`,
+        `continuity`,
+        continuityKey,
+        `reconciling updates`
+      );
+      Internal.setIntoStore(
+        realtimeClient.optimisticUpdateQueue,
+        (queue) => {
+          queue.shift();
+          return queue;
+        },
+        store
+      );
+      if (optimisticUpdate.id === confirmedUpdate2.id) {
+        const clientResult = JSON.stringify(optimisticUpdate.updates);
+        const serverResult = JSON.stringify(confirmedUpdate2.updates);
+        if (clientResult === serverResult) {
+          store.logger.info(
+            `\u2705`,
+            `continuity`,
+            continuityKey,
+            `results for ${optimisticUpdate.id} match between client and server`
+          );
+          socket.emit(`ack:${continuityKey}`, confirmedUpdate2.epoch);
+          return;
+        }
+      } else {
         store.logger.info(
-          `\u2705`,
-          `transaction`,
-          token.key,
-          `results for ${optimisticUpdate.id} match between client and server`
+          `\u274C`,
+          `continuity`,
+          continuityKey,
+          `thought update #${confirmedUpdate2.epoch} was ${optimisticUpdate.key}:${optimisticUpdate.id}, but it was actually ${confirmedUpdate2.key}:${confirmedUpdate2.id}`
         );
-        socket.emit(`tx-ack:${token.key}`, confirmedUpdate.epoch);
-        return;
       }
-    } else {
       store.logger.info(
-        `\u274C`,
-        `transaction`,
-        token.key,
-        `${store.config.name} thought update #${confirmedUpdate.epoch} was ${optimisticUpdate.key}:${optimisticUpdate.id}, but it was actually ${confirmedUpdate.key}:${confirmedUpdate.id}`
+        `\u{1F9D1}\u200D\u2696\uFE0F`,
+        `continuity`,
+        continuityKey,
+        `updates do not match`,
+        optimisticUpdate,
+        confirmedUpdate2
       );
-    }
-    for (const subsequentOptimistic of optimisticQueue.toReversed()) {
-      Internal3__namespace.ingestTransactionUpdate(`oldValue`, subsequentOptimistic, store);
-    }
-    Internal3__namespace.ingestTransactionUpdate(`oldValue`, optimisticUpdate, store);
-    Internal3__namespace.ingestTransactionUpdate(`newValue`, confirmedUpdate, store);
-    socket.emit(`tx-ack:${token.key}`, confirmedUpdate.epoch);
-    for (const subsequentOptimistic of optimisticQueue) {
-      const token2 = Object.assign(
-        { type: `transaction` },
-        subsequentOptimistic
+      const reversedOptimisticUpdates = optimisticUpdates.toReversed();
+      for (const subsequentOptimistic of reversedOptimisticUpdates) {
+        Internal.ingestTransactionUpdate(`oldValue`, subsequentOptimistic, store);
+      }
+      store.logger.info(
+        `\u23EA`,
+        `continuity`,
+        continuityKey,
+        `undid optimistic updates:`,
+        reversedOptimisticUpdates
+      );
+      Internal.ingestTransactionUpdate(`oldValue`, optimisticUpdate, store);
+      store.logger.info(
+        `\u23EA`,
+        `continuity`,
+        continuityKey,
+        `undid zeroth optimistic update`,
+        optimisticUpdate
+      );
+      Internal.ingestTransactionUpdate(`newValue`, confirmedUpdate2, store);
+      store.logger.info(
+        `\u23E9`,
+        `continuity`,
+        continuityKey,
+        `applied confirmed update`,
+        confirmedUpdate2
+      );
+      socket.emit(`ack:${continuityKey}`, confirmedUpdate2.epoch);
+      for (const subsequentOptimistic of optimisticUpdates) {
+        const token = {
+          type: `transaction`,
+          key: subsequentOptimistic.key
+        };
+        const { id, params } = subsequentOptimistic;
+        Internal.actUponStore(token, id, store)(...params);
+      }
+      store.logger.info(
+        `\u23E9`,
+        `continuity`,
+        continuityKey,
+        `reapplied subsequent optimistic updates:`,
+        optimisticUpdates
       );
-      const { id, params } = subsequentOptimistic;
-      AtomIO__namespace.runTransaction(token2, id, store)(...params);
     }
-  };
-  const registerAndAttemptConfirmedUpdate = (confirmedUpdate) => {
-    const zerothOptimisticUpdate = optimisticQueue[0];
+    store.logger.info(
+      `\u{1F9D1}\u200D\u2696\uFE0F`,
+      `continuity`,
+      continuityKey,
+      `integrating confirmed update`,
+      { confirmedUpdate, confirmedUpdates, optimisticUpdates }
+    );
+    const zerothOptimisticUpdate = optimisticUpdates[0];
     if (zerothOptimisticUpdate) {
-      if (zerothOptimisticUpdate.epoch === confirmedUpdate.epoch) {
-        reconcileUpdates(zerothOptimisticUpdate, confirmedUpdate);
-        for (const nextConfirmed of confirmedQueue) {
-          const nextOptimistic = optimisticQueue[0];
-          if (nextConfirmed.epoch === nextOptimistic.epoch) {
-            reconcileUpdates(nextOptimistic, nextConfirmed);
+      store.logger.info(
+        `\u{1F9D1}\u200D\u2696\uFE0F`,
+        `continuity`,
+        continuityKey,
+        `has optimistic updates to reconcile`
+      );
+      if (confirmedUpdate.epoch === zerothOptimisticUpdate.epoch) {
+        store.logger.info(
+          `\u{1F9D1}\u200D\u2696\uFE0F`,
+          `continuity`,
+          continuityKey,
+          `epoch of confirmed update #${confirmedUpdate.epoch} matches zeroth optimistic update`
+        );
+        reconcileEpoch(zerothOptimisticUpdate, confirmedUpdate);
+        for (const nextConfirmed of confirmedUpdates) {
+          const nextOptimistic = optimisticUpdates[0];
+          if (nextConfirmed.epoch === (nextOptimistic == null ? void 0 : nextOptimistic.epoch)) {
+            reconcileEpoch(nextOptimistic, nextConfirmed);
           } else {
             break;
           }
         }
       } else {
-        const hasEnqueuedOptimisticUpdate = optimisticQueue.some(
+        store.logger.info(
+          `\u{1F9D1}\u200D\u2696\uFE0F`,
+          `continuity`,
+          continuityKey,
+          `epoch of confirmed update #${confirmedUpdate.epoch} does not match zeroth optimistic update #${zerothOptimisticUpdate.epoch}`
+        );
+        const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
           (update) => update.epoch === confirmedUpdate.epoch
         );
-        if (hasEnqueuedOptimisticUpdate) {
-          Internal3__namespace.setIntoStore(
-            confirmedUpdateQueueState,
+        if (!confirmedUpdateIsAlreadyEnqueued) {
+          store.logger.info(
+            `\u{1F448}`,
+            `continuity`,
+            continuityKey,
+            `pushing confirmed update to queue`,
+            confirmedUpdate
+          );
+          Internal.setIntoStore(
+            realtimeClient.confirmedUpdateQueue,
             (queue) => {
               queue.push(confirmedUpdate);
               queue.sort((a, b) => a.epoch - b.epoch);
@@ -262,58 +406,168 @@ function syncAction(token, socket, store) {
         }
       }
     } else {
-      if (isRootStore(store) && store.transactionMeta.epoch === confirmedUpdate.epoch - 1) {
-        Internal3__namespace.ingestTransactionUpdate(`newValue`, confirmedUpdate, store);
-        socket.emit(`tx-ack:${token.key}`, confirmedUpdate.epoch);
-        store.transactionMeta.epoch = confirmedUpdate.epoch;
-      } else if (isRootStore(store)) {
+      store.logger.info(
+        `\u{1F9D1}\u200D\u2696\uFE0F`,
+        `continuity`,
+        continuityKey,
+        `has no optimistic updates to deal with`
+      );
+      const continuityEpoch = Internal.getEpochNumberOfContinuity(continuityKey, store);
+      const isRoot = Internal.isRootStore(store);
+      if (isRoot && continuityEpoch === confirmedUpdate.epoch - 1) {
         store.logger.info(
-          `\u274C`,
-          `transaction`,
-          token.key,
-          `received out-of-order update from server`,
+          `\u2705`,
+          `continuity`,
+          continuityKey,
+          `integrating update #${confirmedUpdate.epoch} (${confirmedUpdate.key} ${confirmedUpdate.id})`
+        );
+        Internal.ingestTransactionUpdate(`newValue`, confirmedUpdate, store);
+        socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch);
+        Internal.setEpochNumberOfContinuity(continuityKey, confirmedUpdate.epoch, store);
+      } else if (isRoot && continuityEpoch !== void 0) {
+        store.logger.info(
+          `\u{1F9D1}\u200D\u2696\uFE0F`,
+          `continuity`,
+          continuityKey,
+          `received update #${confirmedUpdate.epoch} but still waiting for update #${continuityEpoch + 1}`,
           {
-            clientEpoch: store.transactionMeta.epoch,
+            clientEpoch: continuityEpoch,
             serverEpoch: confirmedUpdate.epoch
           }
         );
+        const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
+          (update) => update.epoch === confirmedUpdate.epoch
+        );
+        if (confirmedUpdateIsAlreadyEnqueued) {
+          store.logger.info(
+            `\u{1F44D}`,
+            `continuity`,
+            continuityKey,
+            `confirmed update #${confirmedUpdate.epoch} is already enqueued`
+          );
+        } else {
+          store.logger.info(
+            `\u{1F448}`,
+            `continuity`,
+            continuityKey,
+            `pushing confirmed update #${confirmedUpdate.epoch} to queue`
+          );
+          Internal.setIntoStore(
+            realtimeClient.confirmedUpdateQueue,
+            (queue) => {
+              queue.push(confirmedUpdate);
+              queue.sort((a, b) => a.epoch - b.epoch);
+              return queue;
+            },
+            store
+          );
+        }
       }
     }
   };
-  socket.off(`tx-new:${token.key}`, registerAndAttemptConfirmedUpdate);
-  socket.on(`tx-new:${token.key}`, registerAndAttemptConfirmedUpdate);
-  socket.emit(`tx-sub:${token.key}`);
-  const unsubscribeFromIncomingUpdates = () => {
-    socket.off(`tx-new:${token.key}`, registerAndAttemptConfirmedUpdate);
-    socket.emit(`tx-unsub:${token.key}`);
-  };
-  return () => {
-    unsubscribeFromLocalUpdates();
-    unsubscribeFromIncomingUpdates();
-  };
-}
-function syncState(token, socket, store) {
-  const setServedValue = (data) => {
-    Internal3.setIntoStore(token, data, store);
-  };
-  socket.on(`value:${token.key}`, setServedValue);
-  socket.emit(`get:${token.key}`);
+  socket.off(`tx-new:${continuityKey}`);
+  socket.on(`tx-new:${continuityKey}`, registerAndAttemptConfirmedUpdate);
+  const unsubscribeFunctions = continuity.actions.map((transaction) => {
+    Internal.assignTransactionToContinuity(continuityKey, transaction.key, store);
+    const unsubscribeFromTransactionUpdates = Internal.subscribeToTransaction(
+      transaction,
+      (clientUpdate) => {
+        store.logger.info(
+          `\u{1F91E}`,
+          `continuity`,
+          continuityKey,
+          `enqueuing optimistic update`
+        );
+        const optimisticUpdateIndex = optimisticUpdates.findIndex(
+          (update) => update.id === clientUpdate.id
+        );
+        if (optimisticUpdateIndex === -1) {
+          store.logger.info(
+            `\u{1F91E}`,
+            `continuity`,
+            continuityKey,
+            `enqueuing new optimistic update`
+          );
+          Internal.setIntoStore(
+            realtimeClient.optimisticUpdateQueue,
+            (queue) => {
+              queue.push(clientUpdate);
+              queue.sort((a, b) => a.epoch - b.epoch);
+              return queue;
+            },
+            store
+          );
+        } else {
+          store.logger.info(
+            `\u{1F91E}`,
+            `continuity`,
+            continuityKey,
+            `replacing existing optimistic update at index ${optimisticUpdateIndex}`
+          );
+          Internal.setIntoStore(
+            realtimeClient.optimisticUpdateQueue,
+            (queue) => {
+              queue[optimisticUpdateIndex] = clientUpdate;
+              return queue;
+            },
+            store
+          );
+        }
+        socket.emit(`tx-run:${continuityKey}`, {
+          id: clientUpdate.id,
+          key: transaction.key,
+          params: clientUpdate.params
+        });
+      },
+      `tx-run:${continuityKey}`,
+      store
+    );
+    return unsubscribeFromTransactionUpdates;
+  });
+  socket.on(`reveal:${continuityKey}`, (revealed) => {
+    let i = 0;
+    let k = ``;
+    let v = null;
+    for (const x of revealed) {
+      if (i % 2 === 0) {
+        k = x;
+      } else {
+        v = x;
+        Internal.setIntoStore(k, v, store);
+      }
+      i++;
+    }
+  });
+  socket.on(
+    `conceal:${continuityKey}`,
+    (concealed) => {
+      for (const token of concealed) {
+        Internal.deleteAtom(token, store);
+      }
+    }
+  );
+  socket.emit(`get:${continuityKey}`);
   return () => {
-    socket.off(`value:${token.key}`, setServedValue);
+    socket.off(`continuity-init:${continuityKey}`);
+    socket.off(`tx-new:${continuityKey}`);
+    for (const unsubscribe of unsubscribeFunctions)
+      unsubscribe();
   };
 }
 
-exports.confirmedUpdateQueueState = confirmedUpdateQueueState;
+exports.confirmedUpdateQueue = confirmedUpdateQueue;
 exports.myIdState = myIdState;
 exports.myIdState__INTERNAL = myIdState__INTERNAL;
-exports.optimisticUpdateQueueState = optimisticUpdateQueueState;
-exports.pullFamilyMember = pullFamilyMember;
-exports.pullMutableFamilyMember = pullMutableFamilyMember;
-exports.pullMutableState = pullMutableState;
-exports.pullState = pullState;
+exports.myUsernameState = myUsernameState;
+exports.optimisticUpdateQueue = optimisticUpdateQueue;
+exports.pullAtom = pullAtom;
+exports.pullAtomFamilyMember = pullAtomFamilyMember;
+exports.pullMutableAtom = pullMutableAtom;
+exports.pullMutableAtomFamilyMember = pullMutableAtomFamilyMember;
+exports.pullSelector = pullSelector;
+exports.pullSelectorFamilyMember = pullSelectorFamilyMember;
 exports.pushState = pushState;
 exports.serverAction = serverAction;
-exports.syncAction = syncAction;
-exports.syncState = syncState;
+exports.syncContinuity = syncContinuity;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.cjs.map