atom.io 0.30.6 → 0.31.0

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

@@ -1,23 +1,31 @@
 import * as AtomIO from 'atom.io';
+import { AtomToken } from 'atom.io';
 import * as Internal from 'atom.io/internal';
-import { Store, Transceiver, Func } from 'atom.io/internal';
+import { Store, Func, Transceiver } from 'atom.io/internal';
+import { Socket } from 'atom.io/realtime-server';
 import { Json } from 'atom.io/json';
-import { Socket } from 'socket.io-client';
+import { Socket as Socket$1 } from 'socket.io-client';
 import { ContinuityToken } from 'atom.io/realtime';
 
-declare function pullAtom<J extends Json.Serializable>(token: AtomIO.RegularAtomToken<J>, socket: Socket, store: Store): () => void;
+declare const useRegisterAndAttemptConfirmedUpdate: (store: Store, continuityKey: string, socket: Socket, optimisticUpdates: AtomIO.TransactionUpdate<any>[], confirmedUpdates: AtomIO.TransactionUpdate<any>[]) => (confirmed: AtomIO.TransactionUpdate<Func>) => void;
 
-declare function pullAtomFamilyMember<J extends Json.Serializable>(token: AtomIO.RegularAtomToken<J>, socket: Socket, store: Store): () => void;
+declare function useConcealState(store: Store): (concealed: AtomToken<unknown>[]) => void;
 
-declare function pullMutableAtom<T extends Transceiver<any>, J extends Json.Serializable>(token: AtomIO.MutableAtomToken<T, J>, socket: Socket, store: Store): () => void;
+declare function useRevealState(store: Store): (revealed: Json.Array) => void;
 
-declare function pullMutableAtomFamilyMember<T extends Transceiver<any>, J extends Json.Serializable>(token: AtomIO.MutableAtomToken<T, J>, socket: Socket, store: Store): () => void;
+declare function pullAtom<J extends Json.Serializable>(token: AtomIO.RegularAtomToken<J>, socket: Socket$1, store: Store): () => void;
 
-declare function pullSelector<T>(token: AtomIO.SelectorToken<T>, socket: Socket, store: Store): () => void;
+declare function pullAtomFamilyMember<J extends Json.Serializable>(token: AtomIO.RegularAtomToken<J>, socket: Socket$1, store: Store): () => void;
 
-declare function pullSelectorFamilyMember<T>(token: AtomIO.SelectorToken<T>, socket: Socket, store: Store): () => void;
+declare function pullMutableAtom<T extends Transceiver<any>, J extends Json.Serializable>(token: AtomIO.MutableAtomToken<T, J>, socket: Socket$1, store: Store): () => void;
 
-declare function pushState<J extends Json.Serializable>(token: AtomIO.WritableToken<J>, socket: Socket, store: Internal.Store): () => void;
+declare function pullMutableAtomFamilyMember<T extends Transceiver<any>, J extends Json.Serializable>(token: AtomIO.MutableAtomToken<T, J>, socket: Socket$1, store: Store): () => void;
+
+declare function pullSelector<T>(token: AtomIO.SelectorToken<T>, socket: Socket$1, store: Store): () => void;
+
+declare function pullSelectorFamilyMember<T>(token: AtomIO.SelectorToken<T>, socket: Socket$1, store: Store): () => void;
+
+declare function pushState<J extends Json.Serializable>(token: AtomIO.WritableToken<J>, socket: Socket$1, store: Internal.Store): () => void;
 
 declare const myIdState__INTERNAL: AtomIO.RegularAtomToken<string | undefined>;
 declare const myIdState: AtomIO.ReadonlySelectorToken<string | undefined>;
@@ -26,8 +34,8 @@ declare const myUsernameState: AtomIO.RegularAtomToken<string | null>;
 declare const optimisticUpdateQueue: AtomIO.RegularAtomToken<AtomIO.TransactionUpdate<any>[]>;
 declare const confirmedUpdateQueue: AtomIO.RegularAtomToken<AtomIO.TransactionUpdate<any>[]>;
 
-declare function serverAction<F extends Internal.Func>(token: AtomIO.TransactionToken<F>, socket: Socket, store: Internal.Store): () => void;
+declare function serverAction<F extends Internal.Func>(token: AtomIO.TransactionToken<F>, socket: Socket$1, store: Internal.Store): () => void;
 
-declare function syncContinuity<F extends Func>(continuity: ContinuityToken, socket: Socket, store: Store): () => void;
+declare function syncContinuity(continuity: ContinuityToken, socket: Socket$1, store: Store): () => void;
 
-export { confirmedUpdateQueue, myIdState, myIdState__INTERNAL, myUsernameState, optimisticUpdateQueue, pullAtom, pullAtomFamilyMember, pullMutableAtom, pullMutableAtomFamilyMember, pullSelector, pullSelectorFamilyMember, pushState, serverAction, syncContinuity };
+export { confirmedUpdateQueue, myIdState, myIdState__INTERNAL, myUsernameState, optimisticUpdateQueue, pullAtom, pullAtomFamilyMember, pullMutableAtom, pullMutableAtomFamilyMember, pullSelector, pullSelectorFamilyMember, pushState, serverAction, syncContinuity, useConcealState, useRegisterAndAttemptConfirmedUpdate, useRevealState };

package/realtime-client/dist/index.js

@@ -1,11 +1,231 @@
 import '../../dist/chunk-XWL6SNVU.js';
 import * as Internal from 'atom.io/internal';
-import { setIntoStore, getJsonToken, getUpdateToken, getFromStore, assignTransactionToContinuity, subscribeToTransaction, disposeAtom, setEpochNumberOfContinuity, getEpochNumberOfContinuity, isRootStore, ingestTransactionUpdate, growMoleculeInStore, initFamilyMemberInStore, actUponStore } from 'atom.io/internal';
+import { setIntoStore, getEpochNumberOfContinuity, isRootStore, ingestTransactionUpdate, setEpochNumberOfContinuity, disposeAtom, getJsonToken, getUpdateToken, getFromStore, assignTransactionToContinuity, subscribeToTransaction, actUponStore } from 'atom.io/internal';
+import { confirmedUpdateQueue, optimisticUpdateQueue } from 'atom.io/realtime-client';
 import { parseJson } from 'atom.io/json';
 import * as AtomIO from 'atom.io';
 import { persistSync } from 'atom.io/web';
-import { optimisticUpdateQueue as optimisticUpdateQueue$1, confirmedUpdateQueue as confirmedUpdateQueue$1 } from 'atom.io/realtime-client';
 
+var useRegisterAndAttemptConfirmedUpdate = (store, continuityKey, socket, optimisticUpdates, confirmedUpdates) => (confirmed) => {
+  function reconcileEpoch(optimisticUpdate, confirmedUpdate) {
+    store.logger.info(
+      `\u{1F9D1}\u200D\u2696\uFE0F`,
+      `continuity`,
+      continuityKey,
+      `reconciling updates`
+    );
+    setIntoStore(store, optimisticUpdateQueue, (queue) => {
+      queue.shift();
+      return queue;
+    });
+    if (optimisticUpdate.id === confirmedUpdate.id) {
+      const clientResult = JSON.stringify(optimisticUpdate.updates);
+      const serverResult = JSON.stringify(confirmedUpdate.updates);
+      if (clientResult === serverResult) {
+        store.logger.info(
+          `\u2705`,
+          `continuity`,
+          continuityKey,
+          `results for ${optimisticUpdate.id} match between client and server`
+        );
+        socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch);
+        return;
+      }
+    } else {
+      store.logger.info(
+        `\u274C`,
+        `continuity`,
+        continuityKey,
+        `thought update #${confirmedUpdate.epoch} was ${optimisticUpdate.key}:${optimisticUpdate.id}, but it was actually ${confirmedUpdate.key}:${confirmedUpdate.id}`
+      );
+    }
+    store.logger.info(
+      `\u{1F9D1}\u200D\u2696\uFE0F`,
+      `continuity`,
+      continuityKey,
+      `updates do not match`,
+      optimisticUpdate,
+      confirmedUpdate
+    );
+    const reversedOptimisticUpdates = optimisticUpdates.toReversed();
+    for (const subsequentOptimistic of reversedOptimisticUpdates) {
+      ingestTransactionUpdate(`oldValue`, subsequentOptimistic, store);
+    }
+    store.logger.info(
+      `\u23EA`,
+      `continuity`,
+      continuityKey,
+      `undid optimistic updates:`,
+      reversedOptimisticUpdates
+    );
+    ingestTransactionUpdate(`oldValue`, optimisticUpdate, store);
+    store.logger.info(
+      `\u23EA`,
+      `continuity`,
+      continuityKey,
+      `undid zeroth optimistic update`,
+      optimisticUpdate
+    );
+    ingestTransactionUpdate(`newValue`, confirmedUpdate, store);
+    store.logger.info(
+      `\u23E9`,
+      `continuity`,
+      continuityKey,
+      `applied confirmed update`,
+      confirmedUpdate
+    );
+    socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch);
+    for (const subsequentOptimistic of optimisticUpdates) {
+      const token = {
+        type: `transaction`,
+        key: subsequentOptimistic.key
+      };
+      const { id, params } = subsequentOptimistic;
+      actUponStore(token, id, store)(...params);
+    }
+    store.logger.info(
+      `\u23E9`,
+      `continuity`,
+      continuityKey,
+      `reapplied subsequent optimistic updates:`,
+      optimisticUpdates
+    );
+  }
+  store.logger.info(
+    `\u{1F9D1}\u200D\u2696\uFE0F`,
+    `continuity`,
+    continuityKey,
+    `integrating confirmed update`,
+    { confirmedUpdate: confirmed, confirmedUpdates, optimisticUpdates }
+  );
+  const zerothOptimisticUpdate = optimisticUpdates[0];
+  if (zerothOptimisticUpdate) {
+    store.logger.info(
+      `\u{1F9D1}\u200D\u2696\uFE0F`,
+      `continuity`,
+      continuityKey,
+      `has optimistic updates to reconcile`
+    );
+    if (confirmed.epoch === zerothOptimisticUpdate.epoch) {
+      store.logger.info(
+        `\u{1F9D1}\u200D\u2696\uFE0F`,
+        `continuity`,
+        continuityKey,
+        `epoch of confirmed update #${confirmed.epoch} matches zeroth optimistic update`
+      );
+      reconcileEpoch(zerothOptimisticUpdate, confirmed);
+      for (const nextConfirmed of confirmedUpdates) {
+        const nextOptimistic = optimisticUpdates[0];
+        if (nextConfirmed.epoch === nextOptimistic?.epoch) {
+          reconcileEpoch(nextOptimistic, nextConfirmed);
+        } else {
+          break;
+        }
+      }
+    } else {
+      store.logger.info(
+        `\u{1F9D1}\u200D\u2696\uFE0F`,
+        `continuity`,
+        continuityKey,
+        `epoch of confirmed update #${confirmed.epoch} does not match zeroth optimistic update #${zerothOptimisticUpdate.epoch}`
+      );
+      const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
+        (update) => update.epoch === confirmed.epoch
+      );
+      if (!confirmedUpdateIsAlreadyEnqueued) {
+        store.logger.info(
+          `\u{1F448}`,
+          `continuity`,
+          continuityKey,
+          `pushing confirmed update to queue`,
+          confirmed
+        );
+        setIntoStore(store, confirmedUpdateQueue, (queue) => {
+          queue.push(confirmed);
+          queue.sort((a, b) => a.epoch - b.epoch);
+          return queue;
+        });
+      }
+    }
+  } else {
+    store.logger.info(
+      `\u{1F9D1}\u200D\u2696\uFE0F`,
+      `continuity`,
+      continuityKey,
+      `has no optimistic updates to deal with`
+    );
+    const continuityEpoch = getEpochNumberOfContinuity(continuityKey, store);
+    const isRoot = isRootStore(store);
+    if (isRoot && continuityEpoch === confirmed.epoch - 1) {
+      store.logger.info(
+        `\u2705`,
+        `continuity`,
+        continuityKey,
+        `integrating update #${confirmed.epoch} (${confirmed.key} ${confirmed.id})`
+      );
+      ingestTransactionUpdate(`newValue`, confirmed, store);
+      socket.emit(`ack:${continuityKey}`, confirmed.epoch);
+      setEpochNumberOfContinuity(continuityKey, confirmed.epoch, store);
+    } else if (isRoot && continuityEpoch !== undefined) {
+      store.logger.info(
+        `\u{1F9D1}\u200D\u2696\uFE0F`,
+        `continuity`,
+        continuityKey,
+        `received update #${confirmed.epoch} but still waiting for update #${continuityEpoch + 1}`,
+        {
+          clientEpoch: continuityEpoch,
+          serverEpoch: confirmed.epoch
+        }
+      );
+      const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
+        (update) => update.epoch === confirmed.epoch
+      );
+      if (confirmedUpdateIsAlreadyEnqueued) {
+        store.logger.info(
+          `\u{1F44D}`,
+          `continuity`,
+          continuityKey,
+          `confirmed update #${confirmed.epoch} is already enqueued`
+        );
+      } else {
+        store.logger.info(
+          `\u{1F448}`,
+          `continuity`,
+          continuityKey,
+          `pushing confirmed update #${confirmed.epoch} to queue`
+        );
+        setIntoStore(store, confirmedUpdateQueue, (queue) => {
+          queue.push(confirmed);
+          queue.sort((a, b) => a.epoch - b.epoch);
+          return queue;
+        });
+      }
+    }
+  }
+};
+function useConcealState(store) {
+  return (concealed) => {
+    for (const token of concealed) {
+      disposeAtom(token, store);
+    }
+  };
+}
+function useRevealState(store) {
+  return (revealed) => {
+    let i = 0;
+    let k;
+    let v;
+    for (const x of revealed) {
+      if (i % 2 === 0) {
+        k = x;
+      } else {
+        v = x;
+        setIntoStore(store, k, v);
+      }
+      i++;
+    }
+  };
+}
 function pullAtom(token, socket, store) {
   const setServedValue = (data) => {
     setIntoStore(store, token, data);
@@ -158,7 +378,7 @@ function pushState(token, socket, store) {
 }
 var myIdState__INTERNAL = AtomIO.atom({
   key: `mySocketId__INTERNAL`,
-  default: void 0
+  default: undefined
 });
 var myIdState = AtomIO.selector({
   key: `mySocketId`,
@@ -169,11 +389,11 @@ var myUsernameState = AtomIO.atom({
   default: null,
   effects: typeof window === `undefined` ? [] : [persistSync(window.localStorage, JSON, `myUsername`)]
 });
-var optimisticUpdateQueue = AtomIO.atom({
+var optimisticUpdateQueue2 = AtomIO.atom({
   key: `updateQueue`,
   default: []
 });
-var confirmedUpdateQueue = AtomIO.atom(
+var confirmedUpdateQueue2 = AtomIO.atom(
   {
     key: `serverConfirmedUpdateQueue`,
     default: []
@@ -194,8 +414,8 @@ function serverAction(token, socket, store) {
 }
 function syncContinuity(continuity, socket, store) {
   const continuityKey = continuity.key;
-  const optimisticUpdates = getFromStore(store, optimisticUpdateQueue$1);
-  const confirmedUpdates = getFromStore(store, confirmedUpdateQueue$1);
+  const optimisticUpdates = getFromStore(store, optimisticUpdateQueue);
+  const confirmedUpdates = getFromStore(store, confirmedUpdateQueue);
   const initializeContinuity = (epoch, payload) => {
     socket.off(`continuity-init:${continuityKey}`, initializeContinuity);
     let i = 0;
@@ -217,203 +437,13 @@ function syncContinuity(continuity, socket, store) {
   };
   socket.off(`continuity-init:${continuityKey}`);
   socket.on(`continuity-init:${continuityKey}`, initializeContinuity);
-  const registerAndAttemptConfirmedUpdate = (confirmed) => {
-    function reconcileEpoch(optimisticUpdate, confirmedUpdate) {
-      store.logger.info(
-        `\u{1F9D1}\u200D\u2696\uFE0F`,
-        `continuity`,
-        continuityKey,
-        `reconciling updates`
-      );
-      setIntoStore(store, optimisticUpdateQueue$1, (queue) => {
-        queue.shift();
-        return queue;
-      });
-      if (optimisticUpdate.id === confirmedUpdate.id) {
-        const clientResult = JSON.stringify(optimisticUpdate.updates);
-        const serverResult = JSON.stringify(confirmedUpdate.updates);
-        if (clientResult === serverResult) {
-          store.logger.info(
-            `\u2705`,
-            `continuity`,
-            continuityKey,
-            `results for ${optimisticUpdate.id} match between client and server`
-          );
-          socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch);
-          return;
-        }
-      } else {
-        store.logger.info(
-          `\u274C`,
-          `continuity`,
-          continuityKey,
-          `thought update #${confirmedUpdate.epoch} was ${optimisticUpdate.key}:${optimisticUpdate.id}, but it was actually ${confirmedUpdate.key}:${confirmedUpdate.id}`
-        );
-      }
-      store.logger.info(
-        `\u{1F9D1}\u200D\u2696\uFE0F`,
-        `continuity`,
-        continuityKey,
-        `updates do not match`,
-        optimisticUpdate,
-        confirmedUpdate
-      );
-      const reversedOptimisticUpdates = optimisticUpdates.toReversed();
-      for (const subsequentOptimistic of reversedOptimisticUpdates) {
-        ingestTransactionUpdate(`oldValue`, subsequentOptimistic, store);
-      }
-      store.logger.info(
-        `\u23EA`,
-        `continuity`,
-        continuityKey,
-        `undid optimistic updates:`,
-        reversedOptimisticUpdates
-      );
-      ingestTransactionUpdate(`oldValue`, optimisticUpdate, store);
-      store.logger.info(
-        `\u23EA`,
-        `continuity`,
-        continuityKey,
-        `undid zeroth optimistic update`,
-        optimisticUpdate
-      );
-      ingestTransactionUpdate(`newValue`, confirmedUpdate, store);
-      store.logger.info(
-        `\u23E9`,
-        `continuity`,
-        continuityKey,
-        `applied confirmed update`,
-        confirmedUpdate
-      );
-      socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch);
-      for (const subsequentOptimistic of optimisticUpdates) {
-        const token = {
-          type: `transaction`,
-          key: subsequentOptimistic.key
-        };
-        const { id, params } = subsequentOptimistic;
-        actUponStore(token, id, store)(...params);
-      }
-      store.logger.info(
-        `\u23E9`,
-        `continuity`,
-        continuityKey,
-        `reapplied subsequent optimistic updates:`,
-        optimisticUpdates
-      );
-    }
-    store.logger.info(
-      `\u{1F9D1}\u200D\u2696\uFE0F`,
-      `continuity`,
-      continuityKey,
-      `integrating confirmed update`,
-      { confirmedUpdate: confirmed, confirmedUpdates, optimisticUpdates }
-    );
-    const zerothOptimisticUpdate = optimisticUpdates[0];
-    if (zerothOptimisticUpdate) {
-      store.logger.info(
-        `\u{1F9D1}\u200D\u2696\uFE0F`,
-        `continuity`,
-        continuityKey,
-        `has optimistic updates to reconcile`
-      );
-      if (confirmed.epoch === zerothOptimisticUpdate.epoch) {
-        store.logger.info(
-          `\u{1F9D1}\u200D\u2696\uFE0F`,
-          `continuity`,
-          continuityKey,
-          `epoch of confirmed update #${confirmed.epoch} matches zeroth optimistic update`
-        );
-        reconcileEpoch(zerothOptimisticUpdate, confirmed);
-        for (const nextConfirmed of confirmedUpdates) {
-          const nextOptimistic = optimisticUpdates[0];
-          if (nextConfirmed.epoch === nextOptimistic?.epoch) {
-            reconcileEpoch(nextOptimistic, nextConfirmed);
-          } else {
-            break;
-          }
-        }
-      } else {
-        store.logger.info(
-          `\u{1F9D1}\u200D\u2696\uFE0F`,
-          `continuity`,
-          continuityKey,
-          `epoch of confirmed update #${confirmed.epoch} does not match zeroth optimistic update #${zerothOptimisticUpdate.epoch}`
-        );
-        const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
-          (update) => update.epoch === confirmed.epoch
-        );
-        if (!confirmedUpdateIsAlreadyEnqueued) {
-          store.logger.info(
-            `\u{1F448}`,
-            `continuity`,
-            continuityKey,
-            `pushing confirmed update to queue`,
-            confirmed
-          );
-          setIntoStore(store, confirmedUpdateQueue$1, (queue) => {
-            queue.push(confirmed);
-            queue.sort((a, b) => a.epoch - b.epoch);
-            return queue;
-          });
-        }
-      }
-    } else {
-      store.logger.info(
-        `\u{1F9D1}\u200D\u2696\uFE0F`,
-        `continuity`,
-        continuityKey,
-        `has no optimistic updates to deal with`
-      );
-      const continuityEpoch = getEpochNumberOfContinuity(continuityKey, store);
-      const isRoot = isRootStore(store);
-      if (isRoot && continuityEpoch === confirmed.epoch - 1) {
-        store.logger.info(
-          `\u2705`,
-          `continuity`,
-          continuityKey,
-          `integrating update #${confirmed.epoch} (${confirmed.key} ${confirmed.id})`
-        );
-        ingestTransactionUpdate(`newValue`, confirmed, store);
-        socket.emit(`ack:${continuityKey}`, confirmed.epoch);
-        setEpochNumberOfContinuity(continuityKey, confirmed.epoch, store);
-      } else if (isRoot && continuityEpoch !== void 0) {
-        store.logger.info(
-          `\u{1F9D1}\u200D\u2696\uFE0F`,
-          `continuity`,
-          continuityKey,
-          `received update #${confirmed.epoch} but still waiting for update #${continuityEpoch + 1}`,
-          {
-            clientEpoch: continuityEpoch,
-            serverEpoch: confirmed.epoch
-          }
-        );
-        const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
-          (update) => update.epoch === confirmed.epoch
-        );
-        if (confirmedUpdateIsAlreadyEnqueued) {
-          store.logger.info(
-            `\u{1F44D}`,
-            `continuity`,
-            continuityKey,
-            `confirmed update #${confirmed.epoch} is already enqueued`
-          );
-        } else {
-          store.logger.info(
-            `\u{1F448}`,
-            `continuity`,
-            continuityKey,
-            `pushing confirmed update #${confirmed.epoch} to queue`
-          );
-          setIntoStore(store, confirmedUpdateQueue$1, (queue) => {
-            queue.push(confirmed);
-            queue.sort((a, b) => a.epoch - b.epoch);
-            return queue;
-          });
-        }
-      }
-    }
-  };
+  const registerAndAttemptConfirmedUpdate = useRegisterAndAttemptConfirmedUpdate(
+    store,
+    continuityKey,
+    socket,
+    optimisticUpdates,
+    confirmedUpdates
+  );
   socket.off(`tx-new:${continuityKey}`);
   socket.on(`tx-new:${continuityKey}`, registerAndAttemptConfirmedUpdate);
   const unsubscribeFunctions = continuity.actions.map((transaction) => {
@@ -437,7 +467,7 @@ function syncContinuity(continuity, socket, store) {
             continuityKey,
             `enqueuing new optimistic update`
           );
-          setIntoStore(store, optimisticUpdateQueue$1, (queue) => {
+          setIntoStore(store, optimisticUpdateQueue, (queue) => {
             queue.push(clientUpdate);
             queue.sort((a, b) => a.epoch - b.epoch);
             return queue;
@@ -449,7 +479,7 @@ function syncContinuity(continuity, socket, store) {
             continuityKey,
             `replacing existing optimistic update at index ${optimisticUpdateIndex}`
           );
-          setIntoStore(store, optimisticUpdateQueue$1, (queue) => {
+          setIntoStore(store, optimisticUpdateQueue, (queue) => {
             queue[optimisticUpdateIndex] = clientUpdate;
             return queue;
           });
@@ -465,28 +495,10 @@ function syncContinuity(continuity, socket, store) {
     );
     return unsubscribeFromTransactionUpdates;
   });
-  socket.on(`reveal:${continuityKey}`, (revealed) => {
-    let i = 0;
-    let k;
-    let v;
-    for (const x of revealed) {
-      if (i % 2 === 0) {
-        k = x;
-      } else {
-        v = x;
-        upsertState(k, v, store);
-      }
-      i++;
-    }
-  });
-  socket.on(
-    `conceal:${continuityKey}`,
-    (concealed) => {
-      for (const token of concealed) {
-        disposeAtom(token, store);
-      }
-    }
-  );
+  const revealState = useRevealState(store);
+  const concealState = useConcealState(store);
+  socket.on(`reveal:${continuityKey}`, revealState);
+  socket.on(`conceal:${continuityKey}`, concealState);
   socket.emit(`get:${continuityKey}`);
   return () => {
     socket.off(`continuity-init:${continuityKey}`);
@@ -494,20 +506,5 @@ function syncContinuity(continuity, socket, store) {
     for (const unsubscribe of unsubscribeFunctions) unsubscribe();
   };
 }
-function upsertState(store, token, value) {
-  if (token.family) {
-    const family = store.families.get(token.family.key);
-    if (family) {
-      const molecule = store.molecules.get(token.family.subKey);
-      if (molecule) {
-        growMoleculeInStore(molecule, family, store);
-      } else if (store.config.lifespan === `immortal`) {
-        throw new Error(`No molecule found for key "${token.family.subKey}"`);
-      }
-      initFamilyMemberInStore(store, family, parseJson(token.family.subKey));
-    }
-  }
-  setIntoStore(store, token, value);
-}
 
-export { confirmedUpdateQueue, myIdState, myIdState__INTERNAL, myUsernameState, optimisticUpdateQueue, pullAtom, pullAtomFamilyMember, pullMutableAtom, pullMutableAtomFamilyMember, pullSelector, pullSelectorFamilyMember, pushState, serverAction, syncContinuity };
+export { confirmedUpdateQueue2 as confirmedUpdateQueue, myIdState, myIdState__INTERNAL, myUsernameState, optimisticUpdateQueue2 as optimisticUpdateQueue, pullAtom, pullAtomFamilyMember, pullMutableAtom, pullMutableAtomFamilyMember, pullSelector, pullSelectorFamilyMember, pushState, serverAction, syncContinuity, useConcealState, useRegisterAndAttemptConfirmedUpdate, useRevealState };

package/realtime-client/src/continuity/index.ts

@@ -0,0 +1,3 @@
+export * from "./register-and-attempt-confirmed-update"
+export * from "./use-conceal-state"
+export * from "./use-reveal-state"