atom.io 0.25.6 → 0.26.0

package/realtime-server/dist/index.cjs

@@ -1,965 +0,0 @@
-'use strict';
-
-var json = require('atom.io/json');
-var internal = require('atom.io/internal');
-var setRtx = require('atom.io/transceivers/set-rtx');
-var data = require('atom.io/data');
-var AtomIO = require('atom.io');
-var realtime = require('atom.io/realtime');
-var child_process = require('child_process');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var AtomIO__namespace = /*#__PURE__*/_interopNamespace(AtomIO);
-
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-
-// realtime-server/src/ipc-sockets/custom-socket.ts
-var CustomSocket = class {
-  constructor(emit) {
-    this.emit = emit;
-    this.id = `no_id_retrieved`;
-    this.listeners = /* @__PURE__ */ new Map();
-    this.globalListeners = /* @__PURE__ */ new Set();
-  }
-  handleEvent(event, ...args) {
-    for (const listener of this.globalListeners) {
-      listener(event, ...args);
-    }
-    const listeners = this.listeners.get(event);
-    if (listeners) {
-      for (const listener of listeners) {
-        listener(...args);
-      }
-    }
-  }
-  on(event, listener) {
-    const listeners = this.listeners.get(event);
-    if (listeners) {
-      listeners.add(listener);
-    } else {
-      this.listeners.set(event, /* @__PURE__ */ new Set([listener]));
-    }
-    return this;
-  }
-  onAny(listener) {
-    this.globalListeners.add(listener);
-    return this;
-  }
-  off(event, listener) {
-    const listeners = this.listeners.get(event);
-    if (listeners) {
-      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 {
-  constructor(process2, key, logger = console) {
-    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;
-    this.incompleteData = ``;
-    this.unprocessedEvents = [];
-    this.incompleteLog = ``;
-    this.unprocessedLogs = [];
-    this.id = `#####`;
-    this.process = process2;
-    this.process.stdout.on(
-      `data`,
-      (buffer) => {
-        const chunk = buffer.toString();
-        if (chunk === `\u2728`) {
-          return;
-        }
-        this.unprocessedEvents.push(...chunk.split(``));
-        const newInput = this.unprocessedEvents.shift();
-        this.incompleteData += newInput != null ? newInput : ``;
-        try {
-          if (this.incompleteData.startsWith(`error`)) {
-            console.log(`\u2757`, this.incompleteData);
-          }
-          let parsedEvent = json.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 = json.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) => {
-      var _a;
-      const chunk = buf.toString();
-      this.unprocessedLogs.push(...chunk.split(``));
-      const newInput = this.unprocessedLogs.shift();
-      this.incompleteLog += newInput != null ? newInput : ``;
-      try {
-        let parsedLog = json.parseJson(this.incompleteLog);
-        this.handleLog(parsedLog);
-        while (this.unprocessedLogs.length > 0) {
-          this.incompleteLog = (_a = this.unprocessedLogs.shift()) != null ? _a : ``;
-          if (this.incompleteLog) {
-            parsedLog = json.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();
-    }
-  }
-  handleLog(arg) {
-    if (Array.isArray(arg)) {
-      const [level, ...rest] = arg;
-      switch (level) {
-        case `i`:
-          this.logger.info(this.id, this.key, ...rest);
-          break;
-        case `w`:
-          this.logger.warn(this.id, this.key, ...rest);
-          break;
-        case `e`:
-          this.logger.error(this.id, this.key, ...rest);
-          break;
-      }
-    }
-  }
-};
-var SubjectSocket = class extends CustomSocket {
-  constructor(id) {
-    super((...args) => {
-      this.out.next(args);
-      return this;
-    });
-    this.id = `no_id_retrieved`;
-    this.disposalFunctions = [];
-    this.id = id;
-    this.in = new internal.Subject();
-    this.out = new internal.Subject();
-    this.in.subscribe(`socket`, (event) => {
-      this.handleEvent(...event);
-    });
-  }
-  dispose() {
-    for (const dispose of this.disposalFunctions) {
-      dispose();
-    }
-  }
-};
-var ParentSocket = class extends CustomSocket {
-  constructor() {
-    var _a;
-    super((event, ...args) => {
-      const stringifiedEvent = JSON.stringify([event, ...args]);
-      this.process.stdout.write(stringifiedEvent + ``);
-      return this;
-    });
-    this.incompleteData = ``;
-    this.unprocessedEvents = [];
-    this.id = `#####`;
-    this.logger = {
-      info: (...args) => {
-        this.log(`i`, ...args);
-      },
-      warn: (...args) => {
-        this.log(`w`, ...args);
-      },
-      error: (...args) => {
-        this.log(`e`, ...args);
-      }
-    };
-    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 != null ? newInput : ``;
-        try {
-          const parsedData = json.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 = json.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 = (_a = process.pid) == null ? void 0 : _a.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(`\u2728`);
-  }
-  log(...args) {
-    this.process.stderr.write(
-      json.stringifyJson(
-        args.map(
-          (arg) => arg instanceof setRtx.SetRTX ? `{ ${arg.toJSON().members.join(` | `)} }` : arg
-        )
-      ) + ``
-    );
-  }
-  relay(attachServices) {
-    this.logger.info(`\u{1F517}`, `running relay method`);
-    this.relayServices.push(attachServices);
-  }
-};
-function realtimeActionReceiver({
-  socket,
-  store = internal.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);
-      internal.actUponStore(tx, update.id, store)(...update.params);
-      performance.mark(performanceKeyEnd);
-      const metric = performance.measure(
-        performanceKey,
-        performanceKeyStart,
-        performanceKeyEnd
-      );
-      store == null ? void 0 : 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);
-    };
-  };
-}
-var roomArgumentsAtoms = AtomIO.atomFamily({
-  key: `roomArguments`,
-  default: [`echo`, [`Hello World!`]]
-});
-var roomSelectors = AtomIO.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 = child_process.spawn(script, options, { env: process.env });
-        const resolver = (data) => {
-          if (data.toString() === `\u2728`) {
-            room.stdout.off(`data`, resolver);
-            resolve(room);
-          }
-        };
-        room.stdout.on(`data`, resolver);
-      }
-    );
-    return new ChildSocket(child, roomId);
-  }
-});
-
-// realtime-server/src/realtime-server-stores/server-room-external-actions.ts
-var createRoomTX = AtomIO__namespace.transaction({
-  key: `createRoom`,
-  do: ({ get, set, find }, roomId, script, options) => {
-    const args = options ? [script, options] : [script];
-    const roomArgumentsState = find(roomArgumentsAtoms, roomId);
-    set(roomArgumentsState, args);
-    set(realtime.roomIndex, (s) => s.add(roomId));
-    const roomState = find(roomSelectors, roomId);
-    const room = get(roomState);
-    return room;
-  }
-});
-var joinRoomTX = AtomIO__namespace.transaction({
-  key: `joinRoom`,
-  do: (tools, roomId, userId, enteredAtEpoch) => {
-    const meta = { enteredAtEpoch };
-    data.editRelationsInStore(
-      realtime.usersInRooms,
-      (relations) => {
-        relations.set({ room: roomId, user: userId }, meta);
-      },
-      tools.env().store
-    );
-    return meta;
-  }
-});
-var leaveRoomTX = AtomIO__namespace.transaction({
-  key: `leaveRoom`,
-  do: (tools, roomId, userId) => {
-    data.editRelationsInStore(
-      realtime.usersInRooms,
-      (relations) => {
-        relations.delete({ room: roomId, user: userId });
-      },
-      tools.env().store
-    );
-  }
-});
-var destroyRoomTX = AtomIO__namespace.transaction({
-  key: `destroyRoom`,
-  do: (tools, roomId) => {
-    data.editRelationsInStore(
-      realtime.usersInRooms,
-      (relations) => {
-        relations.delete({ room: roomId });
-      },
-      tools.env().store
-    );
-    tools.set(realtime.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 __spreadProps(__spreadValues({}, 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 actionOcclusionAtoms = AtomIO.atomFamily({
-  key: `transactionRedactor`,
-  default: { occlude: (updates) => updates }
-});
-var userUnacknowledgedQueues = AtomIO.atomFamily({
-  key: `unacknowledgedUpdates`,
-  default: () => []
-});
-var socketAtoms = AtomIO.atomFamily({
-  key: `sockets`,
-  default: null
-});
-var socketIndex = AtomIO.atom({
-  key: `socketsIndex`,
-  mutable: true,
-  default: () => new setRtx.SetRTX(),
-  toJson: (set) => set.toJSON(),
-  fromJson: (json) => setRtx.SetRTX.fromJSON(json)
-});
-var userIndex = AtomIO.atom({
-  key: `usersIndex`,
-  mutable: true,
-  default: () => new setRtx.SetRTX(),
-  toJson: (set) => set.toJSON(),
-  fromJson: (json) => setRtx.SetRTX.fromJSON(json)
-});
-var usersOfSockets = data.join({
-  key: `usersOfSockets`,
-  between: [`user`, `socket`],
-  cardinality: `1:1`
-});
-
-// realtime-server/src/realtime-continuity-synchronizer.ts
-function realtimeContinuitySynchronizer({
-  socket: initialSocket,
-  store = internal.IMPLICIT.STORE
-}) {
-  return function synchronizer(continuity) {
-    let socket = initialSocket;
-    const continuityKey = continuity.key;
-    const userKeyState = data.findRelationsInStore(
-      usersOfSockets,
-      socket.id,
-      store
-    ).userKeyOfSocket;
-    const userKey = internal.getFromStore(userKeyState, store);
-    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 = data.findRelationsInStore(
-      usersOfSockets,
-      userKey,
-      store
-    ).socketKeyOfUser;
-    internal.subscribeToState(
-      socketKeyState,
-      ({ newValue: newSocketKey }) => {
-        store.logger.info(
-          `\u{1F44B}`,
-          `continuity`,
-          continuityKey,
-          `seeing ${userKey} on new socket ${newSocketKey}`
-        );
-        if (newSocketKey === null) {
-          store.logger.error(
-            `\u274C`,
-            `continuity`,
-            continuityKey,
-            `Tried to create a synchronizer for a user (${userKey}) that is not connected to a socket.`
-          );
-          return;
-        }
-        const newSocketState = internal.findInStore(socketAtoms, newSocketKey, store);
-        const newSocket = internal.getFromStore(newSocketState, store);
-        socket = newSocket;
-      },
-      `sync-continuity:${continuityKey}:${userKey}`,
-      store
-    );
-    const userUnacknowledgedQueue = internal.findInStore(
-      userUnacknowledgedQueues,
-      userKey,
-      store
-    );
-    internal.getFromStore(
-      userUnacknowledgedQueue,
-      store
-    );
-    const unsubscribeFunctions = [];
-    const revealPerspectives = () => {
-      const unsubFns = [];
-      for (const perspective of continuity.perspectives) {
-        const { viewAtoms } = perspective;
-        const userViewState = internal.findInStore(viewAtoms, userKey, store);
-        const unsubscribe = internal.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` ? internal.getJsonToken(token, store) : token;
-              const resource = internal.getFromStore(resourceToken, store);
-              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 == null ? void 0 : socket.emit(`reveal:${continuityKey}`, revealed);
-            }
-            if (concealed.length > 0) {
-              socket == null ? void 0 : socket.emit(`conceal:${continuityKey}`, concealed);
-            }
-          },
-          `sync-continuity:${continuityKey}:${userKey}:perspective:${perspective.resourceAtoms.key}`,
-          store
-        );
-        unsubFns.push(unsubscribe);
-      }
-      return () => {
-        for (const unsubscribe of unsubFns) unsubscribe();
-      };
-    };
-    const unsubscribeFromPerspectives = revealPerspectives();
-    const sendInitialPayload = () => {
-      var _a;
-      const initialPayload = [];
-      for (const atom2 of continuity.globals) {
-        const resourceToken = atom2.type === `mutable_atom` ? internal.getJsonToken(atom2, store) : atom2;
-        initialPayload.push(resourceToken, internal.getFromStore(atom2, store));
-      }
-      for (const perspective of continuity.perspectives) {
-        const { viewAtoms, resourceAtoms } = perspective;
-        const userViewState = internal.findInStore(viewAtoms, userKey, store);
-        const userView = internal.getFromStore(userViewState, store);
-        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` ? internal.getJsonToken(visibleToken, store) : visibleToken;
-          const resource = internal.getFromStore(resourceToken, store);
-          initialPayload.push(resourceToken, resource);
-        }
-      }
-      const epoch = internal.isRootStore(store) ? (_a = store.transactionMeta.epoch.get(continuityKey)) != null ? _a : null : null;
-      socket == null ? void 0 : socket.emit(`continuity-init:${continuityKey}`, epoch, initialPayload);
-      for (const transaction2 of continuity.actions) {
-        const unsubscribeFromTransaction = internal.subscribeToTransaction(
-          transaction2,
-          (update) => {
-            try {
-              const visibleKeys = continuity.globals.map((atom2) => atom2.key).concat(
-                continuity.perspectives.flatMap((perspective) => {
-                  const { viewAtoms } = perspective;
-                  const userPerspectiveTokenState = internal.findInStore(
-                    viewAtoms,
-                    userKey,
-                    store
-                  );
-                  const visibleTokens = internal.getFromStore(
-                    userPerspectiveTokenState,
-                    store
-                  );
-                  return visibleTokens.map((token) => {
-                    const key = token.type === `mutable_atom` ? `*` + token.key : token.key;
-                    return key;
-                  });
-                })
-              );
-              const redactedUpdates = redactTransactionUpdateContent(
-                visibleKeys,
-                update.updates
-              );
-              const redactedUpdate = __spreadProps(__spreadValues({}, update), {
-                updates: redactedUpdates
-              });
-              socket == null ? void 0 : socket.emit(
-                `tx-new:${continuityKey}`,
-                redactedUpdate
-              );
-            } catch (thrown) {
-              if (thrown instanceof Error) {
-                store.logger.error(
-                  `\u274C`,
-                  `continuity`,
-                  continuityKey,
-                  `failed to send update from transaction ${transaction2.key} to ${userKey}`,
-                  thrown.message
-                );
-              }
-            }
-          },
-          `sync-continuity:${continuityKey}:${userKey}`,
-          store
-        );
-        unsubscribeFunctions.push(unsubscribeFromTransaction);
-      }
-    };
-    socket.off(`get:${continuityKey}`, sendInitialPayload);
-    socket.on(`get:${continuityKey}`, sendInitialPayload);
-    const fillTransactionRequest = (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 {
-        internal.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} with update ${updateId}`,
-            thrown.message
-          );
-        }
-      }
-      performance.mark(performanceKeyEnd);
-      const metric = performance.measure(
-        performanceKey,
-        performanceKeyStart,
-        performanceKeyEnd
-      );
-      store == null ? void 0 : store.logger.info(
-        `\u{1F680}`,
-        `transaction`,
-        transactionKey,
-        updateId,
-        metric.duration
-      );
-      const valuesOfCardsViewKey = `valuesOfCardsView("${userKey}")`;
-      const rootsOfCardValueView = store.selectorAtoms.getRelatedKeys(valuesOfCardsViewKey);
-      const myCardValueView = store.valueMap.get(valuesOfCardsViewKey);
-      store.logger.info(
-        `\u{1F441}`,
-        `continuity`,
-        continuityKey,
-        `seeing ${userKey} card values`,
-        {
-          valuesOfCardsViewKey,
-          rootsOfCardValueView,
-          myCardValueView
-        }
-      );
-    };
-    socket.off(`tx-run:${continuityKey}`, fillTransactionRequest);
-    socket.on(`tx-run:${continuityKey}`, fillTransactionRequest);
-    return () => {
-      for (const unsubscribe of unsubscribeFunctions) unsubscribe();
-      unsubscribeFromPerspectives();
-      socket == null ? void 0 : socket.off(`get:${continuityKey}`, sendInitialPayload);
-      socket == null ? void 0 : socket.off(`tx-run:${continuityKey}`, fillTransactionRequest);
-    };
-  };
-}
-function realtimeAtomFamilyProvider({
-  socket,
-  store = internal.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 = internal.getFromStore(index, store);
-      for (const exposedSubKey of exposedSubKeys) {
-        if (json.stringifyJson(exposedSubKey) === json.stringifyJson(subKey)) {
-          const token = internal.findInStore(family, subKey, store);
-          socket.emit(`serve:${token.key}`, internal.getFromStore(token, store));
-          const unsubscribe = internal.subscribeToState(
-            token,
-            ({ newValue }) => {
-              socket.emit(`serve:${token.key}`, newValue);
-            },
-            `expose-family:${family.key}:${socket.id}`,
-            store
-          );
-          unsubCallbacksByKey.set(token.key, unsubscribe);
-          socket.on(`unsub:${token.key}`, () => {
-            fillUnsubRequest(token.key);
-          });
-          break;
-        }
-      }
-    };
-    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 = internal.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 = internal.getFromStore(index, store);
-      for (const exposedSubKey of exposedSubKeys) {
-        if (json.stringifyJson(exposedSubKey) === json.stringifyJson(subKey)) {
-          const token = internal.findInStore(family, subKey, store);
-          internal.getFromStore(token, store);
-          const jsonToken = internal.getJsonToken(token, store);
-          const updateToken = internal.getUpdateToken(token);
-          socket.emit(`init:${token.key}`, internal.getFromStore(jsonToken, store));
-          const unsubscribe = internal.subscribeToState(
-            updateToken,
-            ({ newValue }) => {
-              socket.emit(`next:${token.key}`, newValue);
-            },
-            `expose-family:${family.key}:${socket.id}`,
-            store
-          );
-          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 = internal.IMPLICIT.STORE
-}) {
-  return function mutableProvider(token) {
-    let unsubscribeFromStateUpdates = null;
-    const jsonToken = internal.getJsonToken(token, store);
-    const trackerToken = internal.getUpdateToken(token);
-    const fillUnsubRequest = () => {
-      socket.off(`unsub:${token.key}`, fillUnsubRequest);
-      unsubscribeFromStateUpdates == null ? void 0 : unsubscribeFromStateUpdates();
-      unsubscribeFromStateUpdates = null;
-    };
-    const fillSubRequest = () => {
-      socket.emit(`init:${token.key}`, internal.getFromStore(jsonToken, store));
-      unsubscribeFromStateUpdates = internal.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 == null ? void 0 : unsubscribeFromStateUpdates();
-    };
-  };
-}
-function realtimeStateProvider({
-  socket,
-  store = internal.IMPLICIT.STORE
-}) {
-  return function stateProvider(token) {
-    let unsubscribeFromStateUpdates;
-    const fillSubRequest = () => {
-      socket.emit(`serve:${token.key}`, internal.getFromStore(token, store));
-      unsubscribeFromStateUpdates = internal.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 = void 0;
-        }
-      };
-      socket.on(`unsub:${token.key}`, fillUnsubRequest);
-    };
-    socket.on(`sub:${token.key}`, fillSubRequest);
-    return () => {
-      socket.off(`sub:${token.key}`, fillSubRequest);
-      if (unsubscribeFromStateUpdates) {
-        unsubscribeFromStateUpdates();
-        unsubscribeFromStateUpdates = void 0;
-      }
-    };
-  };
-}
-function realtimeStateReceiver({
-  socket,
-  store = internal.IMPLICIT.STORE
-}) {
-  return function stateReceiver(token) {
-    const publish = (newValue) => {
-      internal.setIntoStore(token, newValue, store);
-    };
-    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);
-    };
-  };
-}
-
-exports.ChildSocket = ChildSocket;
-exports.CustomSocket = CustomSocket;
-exports.ParentSocket = ParentSocket;
-exports.SubjectSocket = SubjectSocket;
-exports.actionOcclusionAtoms = actionOcclusionAtoms;
-exports.createRoomTX = createRoomTX;
-exports.destroyRoomTX = destroyRoomTX;
-exports.joinRoomTX = joinRoomTX;
-exports.leaveRoomTX = leaveRoomTX;
-exports.realtimeActionReceiver = realtimeActionReceiver;
-exports.realtimeAtomFamilyProvider = realtimeAtomFamilyProvider;
-exports.realtimeContinuitySynchronizer = realtimeContinuitySynchronizer;
-exports.realtimeMutableFamilyProvider = realtimeMutableFamilyProvider;
-exports.realtimeMutableProvider = realtimeMutableProvider;
-exports.realtimeStateProvider = realtimeStateProvider;
-exports.realtimeStateReceiver = realtimeStateReceiver;
-exports.redactTransactionUpdateContent = redactTransactionUpdateContent;
-exports.roomArgumentsAtoms = roomArgumentsAtoms;
-exports.roomSelectors = roomSelectors;
-exports.socketAtoms = socketAtoms;
-exports.socketIndex = socketIndex;
-exports.userIndex = userIndex;
-exports.userUnacknowledgedQueues = userUnacknowledgedQueues;
-exports.usersOfSockets = usersOfSockets;