atom.io 0.31.1 → 0.32.1

package/realtime/dist/index.js

@@ -1,108 +1,3 @@
+export { DEFAULT_USER_IN_ROOM_META, InvariantMap, SyncGroup, continuity, roomIndex, usersInMyRoomView, usersInRooms, usersInThisRoomIndex } from '../../dist/chunk-X7SD2NXU.js';
+import '../../dist/chunk-UQEYZ3OI.js';
 import '../../dist/chunk-XWL6SNVU.js';
-import { assignTransactionToContinuity, IMPLICIT, setEpochNumberOfContinuity } from 'atom.io/internal';
-import { atom, selectorFamily } from 'atom.io';
-import { join, getInternalRelations } from 'atom.io/data';
-import { SetRTX } from 'atom.io/transceivers/set-rtx';
-
-var InvariantMap = class extends Map {
-  set(key, value) {
-    if (this.has(key)) {
-      console.warn(`Tried to set a key that already exists in an InvariantMap`, {
-        key,
-        value
-      });
-      return this;
-    }
-    return super.set(key, value);
-  }
-  clear() {
-    throw new Error(`Cannot clear an InvariantMap`);
-  }
-};
-var SyncGroup = class _SyncGroup {
-  constructor(key) {
-    this.key = key;
-  }
-  type = `continuity`;
-  globals = [];
-  actions = [];
-  perspectives = [];
-  static existing = new InvariantMap();
-  static create(key, builder) {
-    const group = new _SyncGroup(key);
-    const { type, globals, actions, perspectives } = builder(group);
-    const token = { type, key, globals, actions, perspectives };
-    _SyncGroup.existing.set(key, token);
-    return token;
-  }
-  add(...args) {
-    const zeroth = args[0];
-    switch (zeroth.type) {
-      case `atom`:
-      case `mutable_atom`:
-        this.globals.push(...args);
-        break;
-      case `transaction`:
-        this.actions.push(...args);
-        break;
-      case `atom_family`:
-        {
-          const [family, index] = args;
-          this.perspectives.push({
-            type: `realtime_perspective`,
-            resourceAtoms: family,
-            viewAtoms: index
-          });
-        }
-        break;
-    }
-    return this;
-  }
-};
-function continuity(options) {
-  const { key, config } = options;
-  const token = SyncGroup.create(key, config);
-  const { actions } = token;
-  for (const action of actions) {
-    assignTransactionToContinuity(key, action.key, IMPLICIT.STORE);
-  }
-  setEpochNumberOfContinuity(key, -1, IMPLICIT.STORE);
-  return token;
-}
-var usersInThisRoomIndex = atom({
-  key: `usersInRoomIndex`,
-  mutable: true,
-  default: () => new SetRTX(),
-  toJson: (set) => set.toJSON(),
-  fromJson: (json) => SetRTX.fromJSON(json)
-});
-var roomIndex = atom({
-  key: `roomIndex`,
-  default: () => new SetRTX(),
-  mutable: true,
-  toJson: (set) => set.toJSON(),
-  fromJson: (json) => SetRTX.fromJSON(json)
-});
-var DEFAULT_USER_IN_ROOM_META = {
-  enteredAtEpoch: 0
-};
-var usersInRooms = join(
-  {
-    key: `usersInRooms`,
-    between: [`room`, `user`],
-    cardinality: `1:n`,
-    isAType: (input) => typeof input === `string`,
-    isBType: (input) => typeof input === `string`
-  },
-  DEFAULT_USER_IN_ROOM_META
-);
-var usersInMyRoomView = selectorFamily({
-  key: `usersInMyRoomView`,
-  get: (myUsername) => ({ find }) => {
-    const usersInRoomsAtoms = getInternalRelations(usersInRooms);
-    const myRoomIndex = find(usersInRoomsAtoms, myUsername);
-    return [myRoomIndex];
-  }
-});
-
-export { DEFAULT_USER_IN_ROOM_META, InvariantMap, SyncGroup, continuity, roomIndex, usersInMyRoomView, usersInRooms, usersInThisRoomIndex };

package/realtime/src/realtime-continuity.ts

@@ -94,6 +94,7 @@ export class SyncGroup {
 				this.actions.push(...(args as TransactionToken<any>[]))
 				break
 			case `atom_family`:
+			case `mutable_atom_family`:
 				{
 					const [family, index] = args as [
 						AtomFamilyToken<any, any>,
@@ -122,9 +123,9 @@ export function continuity(options: ContinuityOptions): ContinuityToken {
 	const token = SyncGroup.create(key, config)
 	const { actions } = token
 	for (const action of actions) {
-		assignTransactionToContinuity(key, action.key, IMPLICIT.STORE)
+		assignTransactionToContinuity(IMPLICIT.STORE, key, action.key)
 	}
-	setEpochNumberOfContinuity(key, -1, IMPLICIT.STORE)
+	setEpochNumberOfContinuity(IMPLICIT.STORE, key, -1)
 	return token
 }
 

package/realtime/src/shared-room-store.ts

@@ -1,6 +1,5 @@
 import type { MutableAtomToken } from "atom.io"
-import { atom, selectorFamily } from "atom.io"
-import { getInternalRelations, join } from "atom.io/data"
+import { atom, getInternalRelations, join, selectorFamily } from "atom.io"
 import type { SetRTXJson } from "atom.io/transceivers/set-rtx"
 import { SetRTX } from "atom.io/transceivers/set-rtx"
 

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

@@ -13,19 +13,19 @@ declare function useConcealState(store: Store): (concealed: AtomToken<unknown>[]
 
 declare function useRevealState(store: Store): (revealed: Json.Array) => void;
 
-declare function pullAtom<J extends Json.Serializable>(token: AtomIO.RegularAtomToken<J>, socket: Socket$1, store: Store): () => void;
+declare function pullAtom<J extends Json.Serializable>(store: Store, socket: Socket$1, token: AtomIO.RegularAtomToken<J>): () => void;
 
-declare function pullAtomFamilyMember<J extends Json.Serializable>(token: AtomIO.RegularAtomToken<J>, socket: Socket$1, store: Store): () => void;
+declare function pullAtomFamilyMember<J extends Json.Serializable>(store: Store, socket: Socket$1, token: AtomIO.RegularAtomToken<J>): () => 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 pullMutableAtom<T extends Transceiver<any>, J extends Json.Serializable>(store: Store, socket: Socket$1, token: AtomIO.MutableAtomToken<T, J>): () => 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 pullMutableAtomFamilyMember<T extends Transceiver<any>, J extends Json.Serializable>(store: Store, socket: Socket$1, token: AtomIO.MutableAtomToken<T, J>): () => void;
 
-declare function pullSelector<T>(token: AtomIO.SelectorToken<T>, socket: Socket$1, store: Store): () => void;
+declare function pullSelector<T>(store: Store, socket: Socket$1, token: AtomIO.SelectorToken<T>): () => void;
 
-declare function pullSelectorFamilyMember<T>(token: AtomIO.SelectorToken<T>, socket: Socket$1, store: Store): () => void;
+declare function pullSelectorFamilyMember<T>(store: Store, socket: Socket$1, token: AtomIO.SelectorToken<T>): () => void;
 
-declare function pushState<J extends Json.Serializable>(token: AtomIO.WritableToken<J>, socket: Socket$1, store: Internal.Store): () => void;
+declare function pushState<J extends Json.Serializable>(store: Internal.Store, socket: Socket$1, token: AtomIO.WritableToken<J>): () => void;
 
 declare const myIdState__INTERNAL: AtomIO.RegularAtomToken<string | undefined>;
 declare const myIdState: AtomIO.ReadonlySelectorToken<string | undefined>;
@@ -34,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$1, store: Internal.Store): () => void;
+declare function serverAction<F extends Internal.Func>(store: Internal.Store, socket: Socket$1, token: AtomIO.TransactionToken<F>): () => void;
 
-declare function syncContinuity(continuity: ContinuityToken, socket: Socket$1, store: Store): () => void;
+declare function syncContinuity(store: Store, socket: Socket$1, continuity: ContinuityToken): () => void;
 
 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,510 +1,4 @@
+export { confirmedUpdateQueue, myIdState, myIdState__INTERNAL, myUsernameState, optimisticUpdateQueue, pullAtom, pullAtomFamilyMember, pullMutableAtom, pullMutableAtomFamilyMember, pullSelector, pullSelectorFamilyMember, pushState, serverAction, syncContinuity, useConcealState, useRegisterAndAttemptConfirmedUpdate, useRevealState } from '../../dist/chunk-3ZFTRSNG.js';
+import '../../dist/chunk-4LWKCEW3.js';
+import '../../dist/chunk-UQEYZ3OI.js';
 import '../../dist/chunk-XWL6SNVU.js';
-import * as Internal 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';
-
-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);
-  };
-  socket.on(`serve:${token.key}`, setServedValue);
-  socket.emit(`sub:${token.key}`);
-  return () => {
-    socket.off(`serve:${token.key}`, setServedValue);
-    socket.emit(`unsub:${token.key}`);
-  };
-}
-function pullAtomFamilyMember(token, socket, store) {
-  if (!(`family` in token)) {
-    console.error(`Token is not a family member:`, token);
-    return () => {
-    };
-  }
-  const { key: familyKey, subKey: serializedSubKey } = token.family;
-  const subKey = parseJson(serializedSubKey);
-  socket?.on(`serve:${token.key}`, (data) => {
-    setIntoStore(store, token, data);
-  });
-  socket?.emit(`sub:${familyKey}`, subKey);
-  return () => {
-    socket?.off(`serve:${token.key}`);
-    socket?.emit(`unsub:${token.key}`);
-  };
-}
-function pullMutableAtom(token, socket, store) {
-  const jsonToken = getJsonToken(store, token);
-  const updateToken = getUpdateToken(token);
-  socket.on(`init:${token.key}`, (data) => {
-    setIntoStore(store, jsonToken, data);
-  });
-  socket.on(
-    `next:${token.key}`,
-    (data) => {
-      setIntoStore(store, updateToken, data);
-    }
-  );
-  socket.emit(`sub:${token.key}`);
-  return () => {
-    socket.off(`init:${token.key}`);
-    socket.off(`next:${token.key}`);
-    socket.emit(`unsub:${token.key}`);
-  };
-}
-function pullMutableAtomFamilyMember(token, socket, store) {
-  if (!(`family` in token)) {
-    console.error(`Token is not a family member:`, token);
-    return () => {
-    };
-  }
-  const { key: familyKey, subKey: serializedSubKey } = token.family;
-  const subKey = parseJson(serializedSubKey);
-  socket.on(`init:${token.key}`, (data) => {
-    const jsonToken = getJsonToken(store, token);
-    setIntoStore(store, jsonToken, data);
-  });
-  socket.on(
-    `next:${token.key}`,
-    (data) => {
-      const trackerToken = getUpdateToken(token);
-      setIntoStore(store, trackerToken, data);
-    }
-  );
-  socket.emit(`sub:${familyKey}`, subKey);
-  return () => {
-    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}`);
-  Internal.subscribeToState(
-    token,
-    ({ newValue }) => {
-      socket.emit(`pub:${token.key}`, newValue);
-    },
-    `push`,
-    store
-  );
-  return () => {
-    socket.off(`pub:${token.key}`);
-    socket.emit(`unclaim:${token.key}`);
-  };
-}
-var myIdState__INTERNAL = AtomIO.atom({
-  key: `mySocketId__INTERNAL`,
-  default: undefined
-});
-var myIdState = AtomIO.selector({
-  key: `mySocketId`,
-  get: ({ get }) => get(myIdState__INTERNAL)
-});
-var myUsernameState = AtomIO.atom({
-  key: `myName`,
-  default: null,
-  effects: typeof window === `undefined` ? [] : [persistSync(window.localStorage, JSON, `myUsername`)]
-});
-var optimisticUpdateQueue2 = AtomIO.atom({
-  key: `updateQueue`,
-  default: []
-});
-var confirmedUpdateQueue2 = AtomIO.atom(
-  {
-    key: `serverConfirmedUpdateQueue`,
-    default: []
-  }
-);
-function serverAction(token, socket, store) {
-  const unsubscribeFromLocalUpdates = Internal.subscribeToTransaction(
-    token,
-    (clientUpdate) => {
-      socket.emit(`tx-run:${token.key}`, clientUpdate);
-    },
-    `tx-run:${token.key}:${socket.id}`,
-    store
-  );
-  return () => {
-    unsubscribeFromLocalUpdates();
-  };
-}
-function syncContinuity(continuity, socket, store) {
-  const continuityKey = continuity.key;
-  const optimisticUpdates = getFromStore(store, optimisticUpdateQueue);
-  const confirmedUpdates = getFromStore(store, confirmedUpdateQueue);
-  const initializeContinuity = (epoch, payload) => {
-    socket.off(`continuity-init:${continuityKey}`, initializeContinuity);
-    let i = 0;
-    let k;
-    let v;
-    for (const x of payload) {
-      if (i % 2 === 0) {
-        k = x;
-      } else {
-        v = x;
-        if (`type` in k && k.type === `mutable_atom`) {
-          k = getJsonToken(store, k);
-        }
-        setIntoStore(store, k, v);
-      }
-      i++;
-    }
-    setEpochNumberOfContinuity(continuityKey, epoch, store);
-  };
-  socket.off(`continuity-init:${continuityKey}`);
-  socket.on(`continuity-init:${continuityKey}`, initializeContinuity);
-  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) => {
-    assignTransactionToContinuity(continuityKey, transaction.key, store);
-    const unsubscribeFromTransactionUpdates = 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`
-          );
-          setIntoStore(store, optimisticUpdateQueue, (queue) => {
-            queue.push(clientUpdate);
-            queue.sort((a, b) => a.epoch - b.epoch);
-            return queue;
-          });
-        } else {
-          store.logger.info(
-            `\u{1F91E}`,
-            `continuity`,
-            continuityKey,
-            `replacing existing optimistic update at index ${optimisticUpdateIndex}`
-          );
-          setIntoStore(store, optimisticUpdateQueue, (queue) => {
-            queue[optimisticUpdateIndex] = clientUpdate;
-            return queue;
-          });
-        }
-        socket.emit(`tx-run:${continuityKey}`, {
-          id: clientUpdate.id,
-          key: transaction.key,
-          params: clientUpdate.params
-        });
-      },
-      `tx-run:${continuityKey}`,
-      store
-    );
-    return unsubscribeFromTransactionUpdates;
-  });
-  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}`);
-    socket.off(`tx-new:${continuityKey}`);
-    for (const unsubscribe of unsubscribeFunctions) unsubscribe();
-  };
-}
-
-export { confirmedUpdateQueue2 as confirmedUpdateQueue, myIdState, myIdState__INTERNAL, myUsernameState, optimisticUpdateQueue2 as optimisticUpdateQueue, pullAtom, pullAtomFamilyMember, pullMutableAtom, pullMutableAtomFamilyMember, pullSelector, pullSelectorFamilyMember, pushState, serverAction, syncContinuity, useConcealState, useRegisterAndAttemptConfirmedUpdate, useRevealState };