atom.io 0.31.0 → 0.32.0

package/realtime-server/dist/index.js

@@ -1,1002 +1,4 @@
+export { ChildSocket, CustomSocket, ParentSocket, SubjectSocket, createRoomTX, destroyRoomTX, joinRoomTX, leaveRoomTX, prepareToExposeRealtimeContinuity, realtimeActionReceiver, realtimeAtomFamilyProvider, realtimeMutableFamilyProvider, realtimeMutableProvider, realtimeStateProvider, realtimeStateReceiver, redactTransactionUpdateContent, redactorAtoms, roomArgumentsAtoms, roomSelectors, socketAtoms, socketIndex, userIndex, userUnacknowledgedQueues, usersOfSockets } from '../../dist/chunk-R3ZUK5EH.js';
+import '../../dist/chunk-NF7FJKJD.js';
+import '../../dist/chunk-GY2XQYZY.js';
 import '../../dist/chunk-XWL6SNVU.js';
-import { editRelationsInStore, join, findRelationsInStore } from 'atom.io/data';
-import { Subject, getFromStore, subscribeToState, findInStore, IMPLICIT, getJsonToken, getUpdateToken, isRootStore, actUponStore, setIntoStore, subscribeToTransaction } from 'atom.io/internal';
-import * as AtomIO from 'atom.io';
-import { atomFamily, selectorFamily, atom } from 'atom.io';
-import { roomIndex, usersInRooms } from 'atom.io/realtime';
-import { spawn } from 'node:child_process';
-import { parseJson, stringifyJson } from 'atom.io/json';
-import { SetRTX } from 'atom.io/transceivers/set-rtx';
-
-// realtime-server/src/ipc-sockets/custom-socket.ts
-var CustomSocket = class {
-  constructor(emit) {
-    this.emit = emit;
-    this.listeners = /* @__PURE__ */ new Map();
-    this.globalListeners = /* @__PURE__ */ new Set();
-  }
-  listeners;
-  globalListeners;
-  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);
-      }
-    }
-  }
-  id = `no_id_retrieved`;
-  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) {
-      if (listener) {
-        listeners.delete(listener);
-      } else {
-        this.listeners.delete(event);
-      }
-    }
-    return this;
-  }
-  offAny(listener) {
-    this.globalListeners.delete(listener);
-    return this;
-  }
-};
-
-// realtime-server/src/ipc-sockets/child-socket.ts
-var ChildSocket = class extends CustomSocket {
-  incompleteData = ``;
-  unprocessedEvents = [];
-  incompleteLog = ``;
-  unprocessedLogs = [];
-  id = `#####`;
-  process;
-  key;
-  logger;
-  handleLog(arg) {
-    if (Array.isArray(arg)) {
-      const [level, ...rest] = arg;
-      switch (level) {
-        case `i`:
-          this.logger.info(...rest);
-          break;
-        case `w`:
-          this.logger.warn(...rest);
-          break;
-        case `e`:
-          this.logger.error(...rest);
-          break;
-      }
-    }
-  }
-  constructor(process2, key, logger) {
-    super((event, ...args) => {
-      const stringifiedEvent = JSON.stringify([event, ...args]) + ``;
-      const errorHandler = (err) => {
-        if (err.code === `EPIPE`) {
-          console.error(`EPIPE error during write`, this.process.stdin);
-        }
-        this.process.stdin.removeListener(`error`, errorHandler);
-      };
-      this.process.stdin.once(`error`, errorHandler);
-      this.process.stdin.write(stringifiedEvent);
-      return this;
-    });
-    this.process = process2;
-    this.key = key;
-    this.logger = logger ?? {
-      info: (...args) => {
-        console.info(this.id, this.key, ...args);
-      },
-      warn: (...args) => {
-        console.warn(this.id, this.key, ...args);
-      },
-      error: (...args) => {
-        console.error(this.id, this.key, ...args);
-      }
-    };
-    this.process.stdout.on(
-      `data`,
-      (buffer) => {
-        const chunk = buffer.toString();
-        if (chunk === `ALIVE`) {
-          return;
-        }
-        this.unprocessedEvents.push(...chunk.split(``));
-        const newInput = this.unprocessedEvents.shift();
-        this.incompleteData += newInput ?? ``;
-        try {
-          if (this.incompleteData.startsWith(`error`)) {
-            console.log(`\u2757`, this.incompleteData);
-          }
-          let parsedEvent = parseJson(this.incompleteData);
-          this.handleEvent(...parsedEvent);
-          while (this.unprocessedEvents.length > 0) {
-            const event = this.unprocessedEvents.shift();
-            if (event) {
-              if (this.unprocessedEvents.length === 0) {
-                this.incompleteData = event;
-              }
-              parsedEvent = parseJson(event);
-              this.handleEvent(...parsedEvent);
-            }
-          }
-          this.incompleteData = ``;
-        } catch (error) {
-          console.warn(`\u26A0\uFE0F----------------\u26A0\uFE0F`);
-          console.warn(this.incompleteData);
-          console.warn(`\u26A0\uFE0F----------------\u26A0\uFE0F`);
-          console.error(error);
-        }
-      }
-    );
-    this.process.stderr.on(`data`, (buf) => {
-      const chunk = buf.toString();
-      this.unprocessedLogs.push(...chunk.split(``));
-      const newInput = this.unprocessedLogs.shift();
-      this.incompleteLog += newInput ?? ``;
-      try {
-        let parsedLog = parseJson(this.incompleteLog);
-        this.handleLog(parsedLog);
-        while (this.unprocessedLogs.length > 0) {
-          this.incompleteLog = this.unprocessedLogs.shift() ?? ``;
-          if (this.incompleteLog) {
-            parsedLog = parseJson(this.incompleteLog);
-            this.handleLog(parsedLog);
-          }
-        }
-      } catch (error) {
-        console.error(`\u274C\u274C\u274C`);
-        console.error(this.incompleteLog);
-        console.error(error);
-        console.error(`\u274C\u274C\u274C\uFE0F`);
-      }
-    });
-    if (process2.pid) {
-      this.id = process2.pid.toString();
-    }
-  }
-};
-var SubjectSocket = class extends CustomSocket {
-  in;
-  out;
-  id = `no_id_retrieved`;
-  disposalFunctions = [];
-  constructor(id) {
-    super((...args) => {
-      this.out.next(args);
-      return this;
-    });
-    this.id = id;
-    this.in = new Subject();
-    this.out = new Subject();
-    this.in.subscribe(`socket`, (event) => {
-      this.handleEvent(...event);
-    });
-  }
-  dispose() {
-    for (const dispose of this.disposalFunctions) {
-      dispose();
-    }
-  }
-};
-var ParentSocket = class extends CustomSocket {
-  incompleteData = ``;
-  unprocessedEvents = [];
-  relays;
-  relayServices;
-  process;
-  id = `#####`;
-  log(...args) {
-    this.process.stderr.write(
-      stringifyJson(
-        args.map(
-          (arg) => arg instanceof SetRTX ? `{ ${arg.toJSON().members.join(` | `)} }` : arg
-        )
-      ) + ``
-    );
-  }
-  logger = {
-    info: (...args) => {
-      this.log(`i`, ...args);
-    },
-    warn: (...args) => {
-      this.log(`w`, ...args);
-    },
-    error: (...args) => {
-      this.log(`e`, ...args);
-    }
-  };
-  constructor() {
-    super((event, ...args) => {
-      const stringifiedEvent = JSON.stringify([event, ...args]);
-      this.process.stdout.write(stringifiedEvent + ``);
-      return this;
-    });
-    this.process = process;
-    this.process.stdin.resume();
-    this.relays = /* @__PURE__ */ new Map();
-    this.relayServices = [];
-    this.process.stdin.on(
-      `data`,
-      (buffer) => {
-        const chunk = buffer.toString();
-        this.unprocessedEvents.push(...chunk.split(``));
-        const newInput = this.unprocessedEvents.shift();
-        this.incompleteData += newInput ?? ``;
-        try {
-          const parsedData = parseJson(this.incompleteData);
-          this.logger.info(`\u{1F3B0}`, `received`, parsedData);
-          this.handleEvent(...parsedData);
-          while (this.unprocessedEvents.length > 0) {
-            const event = this.unprocessedEvents.shift();
-            if (event) {
-              if (this.unprocessedEvents.length === 0) {
-                this.incompleteData = event;
-              }
-              const parsedEvent = parseJson(event);
-              this.handleEvent(...parsedEvent);
-            }
-          }
-          this.incompleteData = ``;
-        } catch (thrown) {
-          if (thrown instanceof Error) {
-            this.logger.error(`\u2757`, thrown.message, thrown.cause, thrown.stack);
-          }
-        }
-      }
-    );
-    this.on(`exit`, () => {
-      this.logger.info(`\u{1F525}`, this.id, `received "exit"`);
-      process.exit(0);
-    });
-    process.on(`exit`, (code) => {
-      this.logger.info(`\u{1F525}`, this.id, `exited with code ${code}`);
-    });
-    process.on(`end`, () => {
-      this.logger.info(`\u{1F525}`, this.id, `ended`);
-      process.exit(0);
-    });
-    process.on(`SIGTERM`, () => {
-      this.logger.error(`\u{1F525}`, this.id, `terminated`);
-      process.exit(0);
-    });
-    process.on(`SIGINT`, () => {
-      this.logger.error(`\u{1F525}`, this.id, `interrupted`);
-      process.exit(0);
-    });
-    if (process.pid) {
-      this.id = process.pid?.toString();
-    }
-    this.on(`user-joins`, (username) => {
-      this.logger.info(`\u{1F464}`, `user`, username, `joined`);
-      const relay = new SubjectSocket(`user:${username}`);
-      this.relays.set(username, relay);
-      this.logger.info(
-        `\u{1F517}`,
-        `attaching services:`,
-        `[${[...this.relayServices.keys()].join(`, `)}]`
-      );
-      for (const attachServices of this.relayServices) {
-        const cleanup = attachServices(relay);
-        if (cleanup) {
-          relay.disposalFunctions.push(cleanup);
-        }
-      }
-      this.on(`user:${username}`, (...data) => {
-        relay.in.next(data);
-      });
-      relay.out.subscribe(`socket`, (data) => {
-        this.emit(...data);
-      });
-    });
-    this.on(`user-leaves`, (username) => {
-      const relay = this.relays.get(username);
-      this.off(`relay:${username}`);
-      if (relay) {
-        relay.dispose();
-        this.relays.delete(username);
-      }
-    });
-    process.stdout.write(`ALIVE`);
-  }
-  relay(attachServices) {
-    this.logger.info(`\u{1F517}`, `running relay method`);
-    this.relayServices.push(attachServices);
-  }
-};
-
-// realtime-server/src/realtime-server-stores/server-room-external-store.ts
-var roomArgumentsAtoms = atomFamily({
-  key: `roomArguments`,
-  default: [`echo`, [`Hello World!`]]
-});
-var roomSelectors = selectorFamily({
-  key: `room`,
-  get: (roomId) => async ({ get, find }) => {
-    const argumentsState = find(roomArgumentsAtoms, roomId);
-    const args = get(argumentsState);
-    const [script, options] = args;
-    const child = await new Promise(
-      (resolve) => {
-        const room = spawn(script, options, { env: process.env });
-        const resolver = (data) => {
-          if (data.toString() === `ALIVE`) {
-            room.stdout.off(`data`, resolver);
-            resolve(room);
-          }
-        };
-        room.stdout.on(`data`, resolver);
-      }
-    );
-    return new ChildSocket(child, roomId);
-  }
-});
-
-// realtime-server/src/realtime-server-stores/server-room-external-actions.ts
-var createRoomTX = AtomIO.transaction({
-  key: `createRoom`,
-  do: ({ get, set, find }, roomId, script, options) => {
-    const args = options ? [script, options] : [script];
-    const roomArgumentsState = find(roomArgumentsAtoms, roomId);
-    set(roomArgumentsState, args);
-    set(roomIndex, (s) => s.add(roomId));
-    const roomState = find(roomSelectors, roomId);
-    const room = get(roomState);
-    return room;
-  }
-});
-var joinRoomTX = AtomIO.transaction({
-  key: `joinRoom`,
-  do: (tools, roomId, userId, enteredAtEpoch) => {
-    const meta = { enteredAtEpoch };
-    editRelationsInStore(
-      usersInRooms,
-      (relations) => {
-        relations.set({ room: roomId, user: userId }, meta);
-      },
-      tools.env().store
-    );
-    return meta;
-  }
-});
-var leaveRoomTX = AtomIO.transaction({
-  key: `leaveRoom`,
-  do: (tools, roomId, userId) => {
-    editRelationsInStore(
-      usersInRooms,
-      (relations) => {
-        relations.delete({ room: roomId, user: userId });
-      },
-      tools.env().store
-    );
-  }
-});
-var destroyRoomTX = AtomIO.transaction({
-  key: `destroyRoom`,
-  do: (tools, roomId) => {
-    editRelationsInStore(
-      usersInRooms,
-      (relations) => {
-        relations.delete({ room: roomId });
-      },
-      tools.env().store
-    );
-    tools.set(roomIndex, (s) => (s.delete(roomId), s));
-  }
-});
-function redactTransactionUpdateContent(visibleStateKeys, updates) {
-  return updates.map((update) => {
-    switch (update.type) {
-      case `transaction_update`: {
-        const redacted = redactTransactionUpdateContent(
-          visibleStateKeys,
-          update.updates
-        );
-        return { ...update, updates: redacted };
-      }
-      default:
-        return update;
-    }
-  }).filter((update) => {
-    switch (update.type) {
-      case `atom_update`:
-      case `selector_update`:
-        return visibleStateKeys.includes(update.key);
-      case `state_creation`:
-        return visibleStateKeys.includes(update.token.key);
-      case `molecule_creation`:
-        return true;
-      case `transaction_update`:
-        return true;
-    }
-  });
-}
-var redactorAtoms = atomFamily({
-  key: `redactor`,
-  default: { occlude: (updates) => updates }
-});
-var userUnacknowledgedQueues = atomFamily({
-  key: `unacknowledgedUpdates`,
-  default: () => []
-});
-var socketAtoms = atomFamily({
-  key: `sockets`,
-  default: null
-});
-var socketIndex = atom({
-  key: `socketsIndex`,
-  mutable: true,
-  default: () => new SetRTX(),
-  toJson: (set) => set.toJSON(),
-  fromJson: (json) => SetRTX.fromJSON(json)
-});
-var userIndex = atom({
-  key: `usersIndex`,
-  mutable: true,
-  default: () => new SetRTX(),
-  toJson: (set) => set.toJSON(),
-  fromJson: (json) => SetRTX.fromJSON(json)
-});
-var usersOfSockets = join({
-  key: `usersOfSockets`,
-  between: [`user`, `socket`],
-  cardinality: `1:1`,
-  isAType: (s) => s.startsWith(`user::`),
-  isBType: (s) => s.startsWith(`socket::`)
-});
-function prepareToSendInitialPayload(store, continuity, userKey, socket) {
-  const continuityKey = continuity.key;
-  return function sendInitialPayload() {
-    const initialPayload = [];
-    for (const atom2 of continuity.globals) {
-      const resourceToken = atom2.type === `mutable_atom` ? getJsonToken(store, atom2) : atom2;
-      const resource = getFromStore(store, resourceToken);
-      initialPayload.push(resourceToken, resource);
-    }
-    for (const perspective of continuity.perspectives) {
-      const { viewAtoms, resourceAtoms } = perspective;
-      const userViewState = findInStore(store, viewAtoms, userKey);
-      const userView = getFromStore(store, userViewState);
-      store.logger.info(`\u{1F441}`, `atom`, resourceAtoms.key, `${userKey} can see`, {
-        viewAtoms,
-        resourceAtoms,
-        userView
-      });
-      for (const visibleToken of userView) {
-        const resourceToken = visibleToken.type === `mutable_atom` ? getJsonToken(store, visibleToken) : visibleToken;
-        const resource = getFromStore(store, resourceToken);
-        initialPayload.push(resourceToken, resource);
-      }
-    }
-    const epoch = isRootStore(store) ? store.transactionMeta.epoch.get(continuityKey) ?? null : null;
-    socket?.emit(`continuity-init:${continuityKey}`, epoch, initialPayload);
-  };
-}
-function prepareToServeTransactionRequest(store, continuity, userKey) {
-  const continuityKey = continuity.key;
-  return function serveTransactionRequest(update) {
-    store.logger.info(`\u{1F6CE}\uFE0F`, `continuity`, continuityKey, `received`, 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);
-    try {
-      actUponStore(
-        { type: `transaction`, key: transactionKey },
-        updateId,
-        store
-      )(...update.params);
-    } catch (thrown) {
-      if (thrown instanceof Error) {
-        store.logger.error(
-          `\u274C`,
-          `continuity`,
-          continuityKey,
-          `failed to run transaction ${transactionKey} from ${userKey} with update ${updateId}`,
-          thrown.message
-        );
-      }
-    }
-    performance.mark(performanceKeyEnd);
-    const metric = performance.measure(
-      performanceKey,
-      performanceKeyStart,
-      performanceKeyEnd
-    );
-    store?.logger.info(
-      `\u{1F680}`,
-      `transaction`,
-      transactionKey,
-      updateId,
-      userKey,
-      metric.duration
-    );
-  };
-}
-function prepareToTrackClientAcknowledgement(store, continuity, userKey, userUnacknowledgedUpdates) {
-  const continuityKey = continuity.key;
-  return function trackClientAcknowledgement(epoch) {
-    store.logger.info(
-      `\u{1F44D}`,
-      `continuity`,
-      continuityKey,
-      `${userKey} acknowledged epoch ${epoch}`
-    );
-    const isUnacknowledged = userUnacknowledgedUpdates[0]?.epoch === epoch;
-    if (isUnacknowledged) {
-      setIntoStore(store, userUnacknowledgedQueues, userKey, (updates) => {
-        updates.shift();
-        store.logger.info(
-          `\u{1F44D}`,
-          `continuity`,
-          continuityKey,
-          `${userKey} unacknowledged update queue now has`,
-          updates.length,
-          `items`
-        );
-        return updates;
-      });
-    }
-  };
-}
-function subscribeToContinuityActions(store, continuity, userKey, socket) {
-  const continuityKey = continuity.key;
-  const unsubscribeFunctions = [];
-  for (const transaction2 of continuity.actions) {
-    const unsubscribeFromTransaction = subscribeToTransaction(
-      transaction2,
-      (update) => {
-        try {
-          const visibleKeys = continuity.globals.map((atom2) => {
-            if (atom2.type === `atom`) {
-              return atom2.key;
-            }
-            return getUpdateToken(atom2).key;
-          }).concat(
-            continuity.perspectives.flatMap((perspective) => {
-              const { viewAtoms } = perspective;
-              const userPerspectiveTokenState = findInStore(
-                store,
-                viewAtoms,
-                userKey
-              );
-              const visibleTokens = getFromStore(
-                store,
-                userPerspectiveTokenState
-              );
-              return visibleTokens.map((token) => {
-                const key = token.type === `mutable_atom` ? `*` + token.key : token.key;
-                return key;
-              });
-            })
-          );
-          const redactedUpdates = redactTransactionUpdateContent(
-            visibleKeys,
-            update.updates
-          );
-          const redactedUpdate = {
-            ...update,
-            updates: redactedUpdates
-          };
-          setIntoStore(store, userUnacknowledgedQueues, userKey, (updates) => {
-            if (redactedUpdate) {
-              updates.push(redactedUpdate);
-              updates.sort((a, b) => a.epoch - b.epoch);
-              store.logger.info(
-                `\u{1F44D}`,
-                `continuity`,
-                continuityKey,
-                `${userKey} unacknowledged update queue now has`,
-                updates.length,
-                `items`
-              );
-            }
-            return updates;
-          });
-          socket?.emit(
-            `tx-new:${continuityKey}`,
-            redactedUpdate
-          );
-        } catch (thrown) {
-          if (thrown instanceof Error) {
-            store.logger.error(
-              `\u274C`,
-              `continuity`,
-              continuityKey,
-              `${userKey} failed to send update from transaction ${transaction2.key} to ${userKey}`,
-              thrown.message
-            );
-          }
-        }
-      },
-      `sync-continuity:${continuityKey}:${userKey}`,
-      store
-    );
-    unsubscribeFunctions.push(unsubscribeFromTransaction);
-  }
-  return unsubscribeFunctions;
-}
-function subscribeToContinuityPerspectives(store, continuity, userKey, socket) {
-  const continuityKey = continuity.key;
-  const unsubFns = [];
-  for (const perspective of continuity.perspectives) {
-    const { viewAtoms } = perspective;
-    const userViewState = findInStore(store, viewAtoms, userKey);
-    const unsubscribeFromUserView = subscribeToState(
-      userViewState,
-      ({ oldValue, newValue }) => {
-        const oldKeys = oldValue.map((token) => token.key);
-        const newKeys = newValue.map((token) => token.key);
-        const concealed = oldValue.filter(
-          (token) => !newKeys.includes(token.key)
-        );
-        const revealed = newValue.filter((token) => !oldKeys.includes(token.key)).flatMap((token) => {
-          const resourceToken = token.type === `mutable_atom` ? getJsonToken(store, token) : token;
-          const resource = getFromStore(store, resourceToken);
-          return [resourceToken, resource];
-        });
-        store.logger.info(
-          `\u{1F441}`,
-          `atom`,
-          perspective.resourceAtoms.key,
-          `${userKey} has a new perspective`,
-          { oldKeys, newKeys, revealed, concealed }
-        );
-        if (revealed.length > 0) {
-          socket?.emit(`reveal:${continuityKey}`, revealed);
-        }
-        if (concealed.length > 0) {
-          socket?.emit(`conceal:${continuityKey}`, concealed);
-        }
-      },
-      `sync-continuity:${continuityKey}:${userKey}:perspective:${perspective.resourceAtoms.key}`,
-      store
-    );
-    unsubFns.push(unsubscribeFromUserView);
-  }
-  return unsubFns;
-}
-
-// realtime-server/src/continuity/prepare-to-sync-realtime-continuity.ts
-function prepareToExposeRealtimeContinuity({
-  socket: initialSocket,
-  store = IMPLICIT.STORE
-}) {
-  return function syncRealtimeContinuity(continuity) {
-    let socket = initialSocket;
-    const continuityKey = continuity.key;
-    const userKeyState = findRelationsInStore(
-      usersOfSockets,
-      `socket::${socket.id}`,
-      store
-    ).userKeyOfSocket;
-    const userKey = getFromStore(store, userKeyState);
-    if (!userKey) {
-      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 socketKeyState = findRelationsInStore(
-      usersOfSockets,
-      userKey,
-      store
-    ).socketKeyOfUser;
-    subscribeToState(
-      socketKeyState,
-      ({ newValue: newSocketKey }) => {
-        store.logger.info(
-          `\u{1F44B}`,
-          `continuity`,
-          continuityKey,
-          `seeing ${userKey} on new socket ${newSocketKey}`
-        );
-        if (newSocketKey === null) {
-          store.logger.warn(
-            `\u274C`,
-            `continuity`,
-            continuityKey,
-            `User (${userKey}) is not connected to a socket, waiting for them to reappear.`
-          );
-          return;
-        }
-        const newSocketState = findInStore(store, socketAtoms, newSocketKey);
-        const newSocket = getFromStore(store, newSocketState);
-        socket = newSocket;
-        for (const unacknowledgedUpdate of userUnacknowledgedUpdates) {
-          socket?.emit(
-            `tx-new:${continuityKey}`,
-            unacknowledgedUpdate
-          );
-        }
-      },
-      `sync-continuity:${continuityKey}:${userKey}`,
-      store
-    );
-    const userUnacknowledgedUpdates = getFromStore(
-      store,
-      userUnacknowledgedQueues,
-      userKey
-    );
-    const unsubscribeFunctions = [];
-    const unsubscribeFromPerspectives = subscribeToContinuityPerspectives(
-      store,
-      continuity,
-      userKey,
-      socket
-    );
-    const unsubscribeFromTransactions = subscribeToContinuityActions(
-      store,
-      continuity,
-      userKey,
-      socket
-    );
-    unsubscribeFunctions.push(
-      ...unsubscribeFromPerspectives,
-      ...unsubscribeFromTransactions
-    );
-    const sendInitialPayload = prepareToSendInitialPayload(
-      store,
-      continuity,
-      userKey,
-      initialSocket
-    );
-    socket.off(`get:${continuityKey}`, sendInitialPayload);
-    socket.on(`get:${continuityKey}`, sendInitialPayload);
-    const fillTransactionRequest = prepareToServeTransactionRequest(
-      store,
-      continuity,
-      userKey
-    );
-    socket.off(`tx-run:${continuityKey}`, fillTransactionRequest);
-    socket.on(`tx-run:${continuityKey}`, fillTransactionRequest);
-    const trackClientAcknowledgement = prepareToTrackClientAcknowledgement(
-      store,
-      continuity,
-      userKey,
-      userUnacknowledgedUpdates
-    );
-    socket?.on(`ack:${continuityKey}`, trackClientAcknowledgement);
-    return () => {
-      for (const unsubscribe of unsubscribeFunctions) unsubscribe();
-      socket?.off(`ack:${continuityKey}`, trackClientAcknowledgement);
-      socket?.off(`get:${continuityKey}`, sendInitialPayload);
-      socket?.off(`tx-run:${continuityKey}`, fillTransactionRequest);
-    };
-  };
-}
-function realtimeActionReceiver({
-  socket,
-  store = IMPLICIT.STORE
-}) {
-  return function actionReceiver(tx) {
-    const fillTransactionRequest = (update) => {
-      const performanceKey = `tx-run:${tx.key}:${update.id}`;
-      const performanceKeyStart = `${performanceKey}:start`;
-      const performanceKeyEnd = `${performanceKey}:end`;
-      performance.mark(performanceKeyStart);
-      actUponStore(tx, update.id, store)(...update.params);
-      performance.mark(performanceKeyEnd);
-      const metric = performance.measure(
-        performanceKey,
-        performanceKeyStart,
-        performanceKeyEnd
-      );
-      store?.logger.info(`\u{1F680}`, `transaction`, tx.key, update.id, metric.duration);
-    };
-    socket.on(`tx-run:${tx.key}`, fillTransactionRequest);
-    return () => {
-      socket.off(`tx-run:${tx.key}`, fillTransactionRequest);
-    };
-  };
-}
-function realtimeAtomFamilyProvider({
-  socket,
-  store = IMPLICIT.STORE
-}) {
-  return function familyProvider(family, index) {
-    const unsubCallbacksByKey = /* @__PURE__ */ new Map();
-    const fillUnsubRequest = (key) => {
-      socket.off(`unsub:${key}`, fillUnsubRequest);
-      const unsub = unsubCallbacksByKey.get(key);
-      if (unsub) {
-        unsub();
-        unsubCallbacksByKey.delete(key);
-      }
-    };
-    const fillSubRequest = (subKey) => {
-      const exposedSubKeys = getFromStore(store, index);
-      for (const exposedSubKey of exposedSubKeys) {
-        if (stringifyJson(exposedSubKey) === stringifyJson(subKey)) {
-          const token = findInStore(store, family, subKey);
-          socket.emit(`serve:${token.key}`, getFromStore(store, token));
-          const unsubscribe = subscribeToState(
-            token,
-            ({ newValue }) => {
-              socket.emit(`serve:${token.key}`, newValue);
-            },
-            `expose-family:${family.key}:${socket.id}`,
-            store
-          );
-          unsubCallbacksByKey.set(token.key, unsubscribe);
-          socket.on(`unsub:${token.key}`, () => {
-            fillUnsubRequest(token.key);
-          });
-          break;
-        }
-      }
-    };
-    socket.on(`sub:${family.key}`, fillSubRequest);
-    return () => {
-      socket.off(`sub:${family.key}`, fillSubRequest);
-      for (const [, unsub] of unsubCallbacksByKey) {
-        unsub();
-      }
-      unsubCallbacksByKey.clear();
-    };
-  };
-}
-function realtimeMutableFamilyProvider({
-  socket,
-  store = IMPLICIT.STORE
-}) {
-  return function mutableFamilyProvider(family, index) {
-    const unsubCallbacksByKey = /* @__PURE__ */ new Map();
-    const fillUnsubRequest = (key) => {
-      socket.off(`unsub:${key}`, fillUnsubRequest);
-      const unsub = unsubCallbacksByKey.get(key);
-      if (unsub) {
-        unsub();
-        unsubCallbacksByKey.delete(key);
-      }
-    };
-    const fillSubRequest = (subKey) => {
-      const exposedSubKeys = getFromStore(store, index);
-      for (const exposedSubKey of exposedSubKeys) {
-        if (stringifyJson(exposedSubKey) === stringifyJson(subKey)) {
-          const token = findInStore(store, family, subKey);
-          getFromStore(store, token);
-          const jsonToken = getJsonToken(store, token);
-          const updateToken = getUpdateToken(token);
-          socket.emit(`init:${token.key}`, getFromStore(store, jsonToken));
-          const unsubscribe = subscribeToState(
-            updateToken,
-            ({ newValue }) => {
-              socket.emit(`next:${token.key}`, newValue);
-            },
-            `expose-family:${family.key}:${socket.id}`,
-            store
-          );
-          unsubCallbacksByKey.set(token.key, unsubscribe);
-          socket.on(`unsub:${token.key}`, () => {
-            fillUnsubRequest(token.key);
-          });
-          break;
-        }
-      }
-    };
-    socket.on(`sub:${family.key}`, fillSubRequest);
-    return () => {
-      socket.off(`sub:${family.key}`, fillSubRequest);
-      for (const [, unsub] of unsubCallbacksByKey) {
-        unsub();
-      }
-      unsubCallbacksByKey.clear();
-    };
-  };
-}
-function realtimeMutableProvider({
-  socket,
-  store = IMPLICIT.STORE
-}) {
-  return function mutableProvider(token) {
-    let unsubscribeFromStateUpdates = null;
-    const jsonToken = getJsonToken(store, token);
-    const trackerToken = getUpdateToken(token);
-    const fillUnsubRequest = () => {
-      socket.off(`unsub:${token.key}`, fillUnsubRequest);
-      unsubscribeFromStateUpdates?.();
-      unsubscribeFromStateUpdates = null;
-    };
-    const fillSubRequest = () => {
-      socket.emit(`init:${token.key}`, getFromStore(store, jsonToken));
-      unsubscribeFromStateUpdates = subscribeToState(
-        trackerToken,
-        ({ newValue }) => {
-          socket.emit(`next:${token.key}`, newValue);
-        },
-        `expose-single:${socket.id}`,
-        store
-      );
-      socket.on(`unsub:${token.key}`, fillUnsubRequest);
-    };
-    socket.on(`sub:${token.key}`, fillSubRequest);
-    return () => {
-      socket.off(`sub:${token.key}`, fillSubRequest);
-      unsubscribeFromStateUpdates?.();
-    };
-  };
-}
-function realtimeStateProvider({
-  socket,
-  store = IMPLICIT.STORE
-}) {
-  return function stateProvider(token) {
-    let unsubscribeFromStateUpdates;
-    const fillSubRequest = () => {
-      socket.emit(`serve:${token.key}`, getFromStore(store, token));
-      unsubscribeFromStateUpdates = subscribeToState(
-        token,
-        ({ newValue }) => {
-          socket.emit(`serve:${token.key}`, newValue);
-        },
-        `expose-single:${socket.id}`,
-        store
-      );
-      const fillUnsubRequest = () => {
-        socket.off(`unsub:${token.key}`, fillUnsubRequest);
-        if (unsubscribeFromStateUpdates) {
-          unsubscribeFromStateUpdates();
-          unsubscribeFromStateUpdates = undefined;
-        }
-      };
-      socket.on(`unsub:${token.key}`, fillUnsubRequest);
-    };
-    socket.on(`sub:${token.key}`, fillSubRequest);
-    return () => {
-      socket.off(`sub:${token.key}`, fillSubRequest);
-      if (unsubscribeFromStateUpdates) {
-        unsubscribeFromStateUpdates();
-        unsubscribeFromStateUpdates = undefined;
-      }
-    };
-  };
-}
-function realtimeStateReceiver({
-  socket,
-  store = IMPLICIT.STORE
-}) {
-  return function stateReceiver(token) {
-    const publish = (newValue) => {
-      setIntoStore(store, token, newValue);
-    };
-    const fillPubUnclaim = () => {
-      socket.off(`pub:${token.key}`, publish);
-      socket.off(`unclaim:${token.key}`, fillPubUnclaim);
-    };
-    const fillPubClaim = () => {
-      socket.on(`pub:${token.key}`, publish);
-      socket.on(`unclaim:${token.key}`, fillPubUnclaim);
-    };
-    socket.on(`claim:${token.key}`, fillPubClaim);
-    return () => {
-      socket.off(`claim:${token.key}`, fillPubClaim);
-      socket.off(`pub:${token.key}`, publish);
-    };
-  };
-}
-
-export { ChildSocket, CustomSocket, ParentSocket, SubjectSocket, createRoomTX, destroyRoomTX, joinRoomTX, leaveRoomTX, prepareToExposeRealtimeContinuity, realtimeActionReceiver, realtimeAtomFamilyProvider, realtimeMutableFamilyProvider, realtimeMutableProvider, realtimeStateProvider, realtimeStateReceiver, redactTransactionUpdateContent, redactorAtoms, roomArgumentsAtoms, roomSelectors, socketAtoms, socketIndex, userIndex, userUnacknowledgedQueues, usersOfSockets };