atom.io 0.31.1 → 0.32.1

package/dist/chunk-UYYKOGZQ.js

@@ -0,0 +1,1034 @@
+import { roomIndex, usersInRooms } from './chunk-X7SD2NXU.js';
+import { atomFamily, selectorFamily, transaction, editRelationsInStore, atom, SetRTX, join, parseJson, Subject, stringifyJson, findRelationsInStore, IMPLICIT, getFromStore, subscribeToState, findInStore, getJsonToken, getUpdateToken, actUponStore, setIntoStore, subscribeToTransaction, isRootStore } from './chunk-UQEYZ3OI.js';
+import { spawn } from 'node:child_process';
+
+// 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;
+        default:
+          return;
+      }
+    }
+  }
+  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();
+    }
+  }
+};
+
+// realtime-server/src/ipc-sockets/parent-socket.ts
+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 = 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 = 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 = transaction({
+  key: `leaveRoom`,
+  do: (tools, roomId, userId) => {
+    editRelationsInStore(
+      usersInRooms,
+      (relations) => {
+        relations.delete({ room: roomId, user: userId });
+      },
+      tools.env().store
+    );
+  }
+});
+var destroyRoomTX = transaction({
+  key: `destroyRoom`,
+  do: (tools, roomId) => {
+    editRelationsInStore(
+      usersInRooms,
+      (relations) => {
+        relations.delete({ room: roomId });
+      },
+      tools.env().store
+    );
+    tools.set(roomIndex, (s) => (s.delete(roomId), s));
+  }
+});
+
+// realtime-server/src/realtime-server-stores/server-sync-store.ts
+function redactTransactionUpdateContent(visibleStateKeys, updates) {
+  return updates.map((update) => {
+    switch (update.type) {
+      case `transaction_update`: {
+        const redacted = redactTransactionUpdateContent(
+          visibleStateKeys,
+          update.updates
+        );
+        return { ...update, updates: redacted };
+      }
+      case `atom_update`:
+      case `selector_update`:
+      case `molecule_creation`:
+      case `molecule_disposal`:
+      case `molecule_transfer`:
+      case `state_creation`:
+      case `state_disposal`:
+        return update;
+    }
+  }).filter((update) => {
+    switch (update.type) {
+      case `atom_update`:
+      case `selector_update`:
+        return visibleStateKeys.includes(update.key);
+      case `state_creation`:
+      case `state_disposal`:
+        return visibleStateKeys.includes(update.token.key);
+      case `molecule_creation`:
+      case `transaction_update`:
+      case `molecule_disposal`:
+      case `molecule_transfer`:
+        return true;
+    }
+  });
+}
+var redactorAtoms = atomFamily({
+  key: `redactor`,
+  default: { occlude: (updates) => updates }
+});
+var userUnacknowledgedQueues = atomFamily({
+  key: `unacknowledgedUpdates`,
+  default: () => []
+});
+
+// realtime-server/src/realtime-server-stores/server-user-store.ts
+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::`)
+});
+
+// realtime-server/src/continuity/prepare-to-send-initial-payload.ts
+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);
+  };
+}
+
+// realtime-server/src/continuity/prepare-to-serve-transaction-request.ts
+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(
+        store,
+        { type: `transaction`, key: transactionKey },
+        updateId
+      )(...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
+    );
+  };
+}
+
+// realtime-server/src/continuity/prepare-to-track-client-acknowledgement.ts
+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;
+      });
+    }
+  };
+}
+
+// realtime-server/src/continuity/subscribe-to-continuity-actions.ts
+function subscribeToContinuityActions(store, continuity, userKey, socket) {
+  const continuityKey = continuity.key;
+  const unsubscribeFunctions = [];
+  for (const transaction2 of continuity.actions) {
+    const unsubscribeFromTransaction = subscribeToTransaction(
+      store,
+      transaction2,
+      `sync-continuity:${continuityKey}:${userKey}`,
+      (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
+            );
+          }
+        }
+      }
+    );
+    unsubscribeFunctions.push(unsubscribeFromTransaction);
+  }
+  return unsubscribeFunctions;
+}
+
+// realtime-server/src/continuity/subscribe-to-continuity-perpectives.ts
+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(
+      store,
+      userViewState,
+      `sync-continuity:${continuityKey}:${userKey}:perspective:${perspective.resourceAtoms.key}`,
+      ({ 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);
+        }
+      }
+    );
+    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(
+      store,
+      socketKeyState,
+      `sync-continuity:${continuityKey}:${userKey}`,
+      ({ 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
+          );
+        }
+      }
+    );
+    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);
+    };
+  };
+}
+
+// realtime-server/src/realtime-action-receiver.ts
+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(store, tx, update.id)(...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);
+    };
+  };
+}
+
+// realtime-server/src/realtime-family-provider.ts
+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(
+            store,
+            token,
+            `expose-family:${family.key}:${socket.id}`,
+            ({ newValue }) => {
+              socket.emit(`serve:${token.key}`, newValue);
+            }
+          );
+          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();
+    };
+  };
+}
+
+// realtime-server/src/realtime-mutable-family-provider.ts
+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(
+            store,
+            updateToken,
+            `expose-family:${family.key}:${socket.id}`,
+            ({ newValue }) => {
+              socket.emit(`next:${token.key}`, newValue);
+            }
+          );
+          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();
+    };
+  };
+}
+
+// realtime-server/src/realtime-mutable-provider.ts
+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(
+        store,
+        trackerToken,
+        `expose-single:${socket.id}`,
+        ({ newValue }) => {
+          socket.emit(`next:${token.key}`, newValue);
+        }
+      );
+      socket.on(`unsub:${token.key}`, fillUnsubRequest);
+    };
+    socket.on(`sub:${token.key}`, fillSubRequest);
+    return () => {
+      socket.off(`sub:${token.key}`, fillSubRequest);
+      unsubscribeFromStateUpdates?.();
+    };
+  };
+}
+
+// realtime-server/src/realtime-state-provider.ts
+function realtimeStateProvider({
+  socket,
+  store = IMPLICIT.STORE
+}) {
+  return function stateProvider(token) {
+    let unsubscribeFromStateUpdates;
+    const fillSubRequest = () => {
+      socket.emit(`serve:${token.key}`, getFromStore(store, token));
+      unsubscribeFromStateUpdates = subscribeToState(
+        store,
+        token,
+        `expose-single:${socket.id}`,
+        ({ newValue }) => {
+          socket.emit(`serve:${token.key}`, newValue);
+        }
+      );
+      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;
+      }
+    };
+  };
+}
+
+// realtime-server/src/realtime-state-receiver.ts
+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 };