atom.io 0.17.0 → 0.18.1

package/realtime-server/dist/index.cjs

@@ -1,10 +1,12 @@
 'use strict';
 
+var json = require('atom.io/json');
+var internal = require('atom.io/internal');
+var setRtx = require('atom.io/transceivers/set-rtx');
 var AtomIO = require('atom.io');
+var realtime = require('atom.io/realtime');
+var child_process = require('child_process');
 var data = require('atom.io/data');
-var setRtx = require('atom.io/transceivers/set-rtx');
-var internal = require('atom.io/internal');
-var json = require('atom.io/json');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -45,113 +47,722 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var userIndex = AtomIO.atom({
-  key: `usersIndex`,
-  mutable: true,
-  default: () => new setRtx.SetRTX(),
-  toJson: (set) => set.toJSON(),
-  fromJson: (json) => setRtx.SetRTX.fromJSON(json)
+
+// 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 || ``;
+        try {
+          if (this.incompleteData.startsWith(`error`)) {
+            console.log(`\u2757`, this.incompleteData);
+          }
+          const 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;
+              }
+              const parsedEvent2 = json.parseJson(event);
+              this.handleEvent(...parsedEvent2);
+            }
+          }
+          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 || ``;
+      try {
+        const parsedLog = json.parseJson(this.incompleteLog);
+        this.handleLog(parsedLog);
+        while (this.unprocessedLogs.length > 0) {
+          this.incompleteLog = (_a = this.unprocessedLogs.shift()) != null ? _a : ``;
+          if (this.incompleteLog) {
+            const parsedLog2 = json.parseJson(this.incompleteLog);
+            this.handleLog(parsedLog2);
+          }
+        }
+      } 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 || ``;
+        try {
+          const parsedEvent = json.parseJson(this.incompleteData);
+          this.logger.info(`\u{1F3B0}`, `received`, parsedEvent);
+          this.handleEvent(...parsedEvent);
+          while (this.unprocessedEvents.length > 0) {
+            const event = this.unprocessedEvents.shift();
+            if (event) {
+              if (this.unprocessedEvents.length === 0) {
+                this.incompleteData = event;
+              }
+              const parsedEvent2 = json.parseJson(event);
+              this.handleEvent(...parsedEvent2);
+            }
+          }
+          this.incompleteData = ``;
+        } catch (thrown) {
+          if (thrown instanceof Error) {
+            this.logger.error(`\u2757`, thrown.message, thrown.cause, thrown.stack);
+          }
+        }
+      }
+    );
+    this.on(`exit`, () => {
+      process.exit(0);
+    });
+    process.on(`exit`, () => {
+      this.logger.info(`\u{1F525}`, this.id, `exited`);
+      process.exit(0);
+    });
+    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);
+  }
+};
+AtomIO.selectorFamily({
+  key: `perspectiveRedactor`,
+  get: ({ userId, syncGroupKey }) => ({ get, find }) => {
+    const syncGroup = realtime.SyncGroup.existing.get(syncGroupKey);
+    if (!syncGroup) {
+      throw new Error(
+        `Tried to create a synchronizer for a sync group that does not exist.`
+      );
+    }
+    const userPerspectiveTokens = syncGroup.perspectives.flatMap(
+      ({ viewAtoms }) => {
+        const userPerspectiveToken = find(viewAtoms, userId);
+        const userPerspective = get(userPerspectiveToken);
+        const visibleTokens = [...userPerspective].map((token) => {
+          return token.type === `mutable_atom` ? internal.getUpdateToken(token).key : token.key;
+        });
+        internal.IMPLICIT.STORE.logger.info(
+          `\u{1F52D}`,
+          `continuity`,
+          syncGroupKey,
+          `${userId} can see ${visibleTokens.length} tokens in ${viewAtoms.key}`,
+          visibleTokens
+        );
+        return visibleTokens;
+      }
+    );
+    const filterTransactionUpdate = (visible, transactionUpdate) => {
+      internal.IMPLICIT.STORE.logger.info(
+        `\u{1F58C}`,
+        `continuity`,
+        syncGroupKey,
+        `redacting updates from ${transactionUpdate.epoch}:${transactionUpdate.key}:${transactionUpdate.id}`,
+        visible,
+        transactionUpdate.updates
+      );
+      const updates = transactionUpdate.updates.filter((update) => {
+        if (`newValue` in update) {
+          return visible.includes(update.key);
+        }
+        return true;
+      }).map((update) => {
+        if (`updates` in update) {
+          return filterTransactionUpdate(visible, update);
+        }
+        return update;
+      });
+      const filtered = __spreadProps(__spreadValues({}, transactionUpdate), {
+        updates
+      });
+      return filtered;
+    };
+    const filter = (update) => {
+      const visibleKeys = syncGroup.globals.map(
+        (atomToken) => atomToken.type === `mutable_atom` ? internal.getUpdateToken(atomToken).key : atomToken.key
+      );
+      visibleKeys.push(...userPerspectiveTokens);
+      return filterTransactionUpdate(visibleKeys, update);
+    };
+    return filter;
+  }
 });
-var usersOfSockets = data.join({
-  key: `usersOfSockets`,
-  between: [`user`, `socket`],
-  cardinality: `1:1`
+var roomArgumentsAtoms = AtomIO.atomFamily({
+  key: `roomArguments`,
+  default: [`echo`, [`Hello World!`]]
 });
-var roomIndex = AtomIO.atom({
-  key: `conclaveIndex`,
-  default: () => new setRtx.SetRTX(),
-  mutable: true,
-  toJson: (set) => set.toJSON(),
-  fromJson: (json) => setRtx.SetRTX.fromJSON(json)
+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);
+  }
 });
-var DEFAULT_USER_IN_ROOM_META = {
-  enteredAtEpoch: 0
-};
-var usersInRooms = data.join(
-  {
-    key: `usersInRooms`,
-    between: [`room`, `user`],
-    cardinality: `1:n`
-  },
-  DEFAULT_USER_IN_ROOM_META
-);
-var completeUpdateAtoms = AtomIO.atomFamily({
-  key: `completeUpdate`,
-  default: null
+
+// 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 transactionRedactorAtoms = AtomIO.atomFamily({
-  key: `transactionRedactor`,
-  default: { filter: (updates) => updates }
+var joinRoomTX = AtomIO__namespace.transaction({
+  key: `joinRoom`,
+  do: (transactors, roomId, userId, enteredAtEpoch) => {
+    const meta = { enteredAtEpoch };
+    realtime.usersInRooms.transact(transactors, ({ relations }) => {
+      relations.set(roomId, userId, meta);
+    });
+    return meta;
+  }
 });
-var redactedUpdateSelectors = AtomIO.selectorFamily({
-  key: `redactedUpdate`,
-  get: ([transactionKey, updateId]) => ({ get, find }) => {
-    const update = get(find(completeUpdateAtoms, updateId));
-    const { filter } = get(find(transactionRedactorAtoms, transactionKey));
-    if (update && filter) {
-      return __spreadProps(__spreadValues({}, update), { updates: filter(update.updates) });
-    }
-    return null;
+var leaveRoomTX = AtomIO__namespace.transaction({
+  key: `leaveRoom`,
+  do: (transactors, roomId, userId) => {
+    realtime.usersInRooms.transact(transactors, ({ relations }) => {
+      relations.delete({ room: roomId, user: userId });
+    });
   }
 });
-var userUnacknowledgedUpdatesAtoms = AtomIO.atomFamily({
-  key: `unacknowledgedUpdates`,
-  default: () => []
+var destroyRoomTX = AtomIO__namespace.transaction({
+  key: `destroyRoom`,
+  do: (transactors, roomId) => {
+    realtime.usersInRooms.transact(transactors, ({ relations }) => {
+      relations.delete({ room: roomId });
+    });
+    transactors.set(realtime.roomIndex, (s) => (s.delete(roomId), s));
+  }
 });
-var socketUnacknowledgedUpdatesSelectors = AtomIO.selectorFamily({
-  key: `socketUnacknowledgedUpdates`,
-  get: (socketId) => ({ get, find }) => {
-    const userKeyState = find(usersOfSockets.states.userKeyOfSocket, socketId);
-    const userKey = get(userKeyState);
-    if (!userKey) {
-      return [];
+function redactTransactionUpdateContent(visibleStateKeys, updates) {
+  return updates.map((update) => {
+    if (`newValue` in update) {
+      return update;
     }
-    const unacknowledgedUpdatesState = find(
-      userUnacknowledgedUpdatesAtoms,
-      userKey
+    const redacted = redactTransactionUpdateContent(
+      visibleStateKeys,
+      update.updates
     );
-    const unacknowledgedUpdates = get(unacknowledgedUpdatesState);
-    return unacknowledgedUpdates;
-  },
-  set: (socketId) => ({ set, get, find }, newUpdates) => {
-    const userKeyState = find(usersOfSockets.states.userKeyOfSocket, socketId);
-    const userKey = get(userKeyState);
-    if (!userKey) {
-      return;
+    return __spreadProps(__spreadValues({}, update), { updates: redacted });
+  }).filter((update) => {
+    if (`newValue` in update) {
+      return visibleStateKeys.includes(update.key);
     }
-    const unacknowledgedUpdatesState = find(
-      userUnacknowledgedUpdatesAtoms,
-      userKey
-    );
-    set(unacknowledgedUpdatesState, newUpdates);
-  }
+    return true;
+  });
+}
+var actionOcclusionAtoms = AtomIO.atomFamily({
+  key: `transactionRedactor`,
+  default: { occlude: (updates) => updates }
 });
-var userEpochAtoms = AtomIO.atomFamily({
-  key: `clientEpoch`,
+var userUnacknowledgedQueues = AtomIO.atomFamily({
+  key: `unacknowledgedUpdates`,
+  default: () => []
+});
+var socketAtoms = AtomIO.atomFamily({
+  key: `sockets`,
   default: null
 });
-var socketEpochSelectors = AtomIO.selectorFamily({
-  key: `socketEpoch`,
-  get: (socketId) => ({ get, find }) => {
-    const userKeyState = find(usersOfSockets.states.userKeyOfSocket, socketId);
-    const userKey = get(userKeyState);
-    if (!userKey) {
-      return null;
-    }
-    const userEpochState = find(userEpochAtoms, userKey);
-    const userEpoch = get(userEpochState);
-    return userEpoch;
-  },
-  set: (socketId) => ({ set, get, find }, newEpoch) => {
-    const userKeyState = find(usersOfSockets.states.userKeyOfSocket, socketId);
-    const userKey = get(userKeyState);
+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 = internal.findInStore(
+      usersOfSockets.states.userKeyOfSocket,
+      socket.id,
+      store
+    );
+    const userKey = internal.getFromStore(userKeyState, store);
     if (!userKey) {
-      return;
+      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 userEpochState = find(userEpochAtoms, userKey);
-    set(userEpochState, newEpoch);
-  }
-});
+    const socketKeyState = internal.findInStore(
+      usersOfSockets.states.socketKeyOfUser,
+      userKey,
+      store
+    );
+    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 unsubscribeFunctions2 = [];
+      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) : 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
+        );
+        unsubscribeFunctions2.push(unsubscribe);
+      }
+      return () => {
+        for (const unsubscribe of unsubscribeFunctions2)
+          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) : 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) : 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 realtimeStateProvider({
   socket,
   store = internal.IMPLICIT.STORE
@@ -201,89 +812,49 @@ function realtimeStateSynchronizer({
     };
   };
 }
-function realtimeFamilyProvider({
+function realtimeAtomFamilyProvider({
   socket,
   store = internal.IMPLICIT.STORE
 }) {
   return function familyProvider(family, index) {
-    const unsubSingleCallbacksByKey = /* @__PURE__ */ new Map();
-    const unsubFamilyCallbacksByKey = /* @__PURE__ */ new Map();
-    const fillFamilyUnsubRequest = () => {
-      for (const [, unsub] of unsubFamilyCallbacksByKey) {
-        unsub();
-      }
-      unsubFamilyCallbacksByKey.clear();
-      socket.off(`unsub:${family.key}`, fillFamilyUnsubRequest);
-    };
-    const fillSingleUnsubRequest = (key) => {
-      socket.off(`unsub:${key}`, fillSingleUnsubRequest);
-      const unsub = unsubSingleCallbacksByKey.get(key);
+    const unsubCallbacksByKey = /* @__PURE__ */ new Map();
+    const fillUnsubRequest = (key) => {
+      socket.off(`unsub:${key}`, fillUnsubRequest);
+      const unsub = unsubCallbacksByKey.get(key);
       if (unsub) {
         unsub();
-        unsubSingleCallbacksByKey.delete(key);
+        unsubCallbacksByKey.delete(key);
       }
     };
     const fillSubRequest = (subKey) => {
-      var _a;
-      if (subKey === void 0) {
-        const keys = internal.getFromStore(index, store);
-        for (const key of keys) {
-          const token = internal.findInStore(family, key, store);
-          socket.emit(
-            `serve:${family.key}`,
-            json.parseJson(((_a = token.family) == null ? void 0 : _a.subKey) || `null`),
-            internal.getFromStore(token, store)
+      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;
         }
-        const unsubscribeFromTokenCreation = family.subject.subscribe(
-          `expose-family:${socket.id}`,
-          (token) => {
-            const unsub = internal.subscribeToState(
-              token,
-              ({ newValue }) => {
-                var _a2;
-                socket.emit(
-                  `serve:${family.key}`,
-                  json.parseJson(((_a2 = token.family) == null ? void 0 : _a2.subKey) || `null`),
-                  newValue
-                );
-              },
-              `expose-family:${family.key}:${socket.id}`,
-              store
-            );
-            unsubFamilyCallbacksByKey.set(token.key, unsub);
-          }
-        );
-        unsubFamilyCallbacksByKey.set(family.key, unsubscribeFromTokenCreation);
-        socket.on(`unsub:${family.key}`, fillFamilyUnsubRequest);
-      } else {
-        const token = family(subKey);
-        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
-        );
-        unsubSingleCallbacksByKey.set(token.key, unsubscribe);
-        socket.on(`unsub:${token.key}`, () => {
-          fillSingleUnsubRequest(token.key);
-        });
       }
     };
     socket.on(`sub:${family.key}`, fillSubRequest);
     return () => {
       socket.off(`sub:${family.key}`, fillSubRequest);
-      for (const [, unsub] of unsubFamilyCallbacksByKey) {
-        unsub();
-      }
-      for (const [, unsub] of unsubSingleCallbacksByKey) {
+      for (const [, unsub] of unsubCallbacksByKey) {
         unsub();
       }
-      unsubFamilyCallbacksByKey.clear();
-      unsubSingleCallbacksByKey.clear();
+      unsubCallbacksByKey.clear();
     };
   };
 }
@@ -324,110 +895,46 @@ function realtimeMutableFamilyProvider({
   store = internal.IMPLICIT.STORE
 }) {
   return function mutableFamilyProvider(family, index) {
-    const unsubSingleCallbacksByKey = /* @__PURE__ */ new Map();
-    const unsubFamilyCallbacksByKey = /* @__PURE__ */ new Map();
-    const fillFamilyUnsubRequest = () => {
-      for (const [, unsub] of unsubFamilyCallbacksByKey) {
-        unsub();
-      }
-      unsubFamilyCallbacksByKey.clear();
-      socket.off(`unsub:${family.key}`, fillFamilyUnsubRequest);
-    };
-    const fillSingleUnsubRequest = (key) => {
-      socket.off(`unsub:${key}`, fillSingleUnsubRequest);
-      const unsub = unsubSingleCallbacksByKey.get(key);
+    const unsubCallbacksByKey = /* @__PURE__ */ new Map();
+    const fillUnsubRequest = (key) => {
+      socket.off(`unsub:${key}`, fillUnsubRequest);
+      const unsub = unsubCallbacksByKey.get(key);
       if (unsub) {
         unsub();
-        unsubSingleCallbacksByKey.delete(key);
+        unsubCallbacksByKey.delete(key);
       }
     };
     const fillSubRequest = (subKey) => {
-      var _a;
-      if (subKey === void 0) {
-        const keys = internal.getFromStore(index, store);
-        for (const key of keys) {
-          const token = internal.findInStore(family, key, store);
+      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);
           const jsonToken = internal.getJsonToken(token);
-          const trackerToken = internal.getUpdateToken(token);
-          socket.emit(
-            `init:${family.key}`,
-            json.parseJson(((_a = jsonToken.family) == null ? void 0 : _a.subKey) || `null`),
-            internal.getFromStore(jsonToken, store)
-          );
-          const unsubFromUpdates = internal.subscribeToState(
-            trackerToken,
+          const updateToken = internal.getUpdateToken(token);
+          socket.emit(`init:${token.key}`, internal.getFromStore(jsonToken, store));
+          const unsubscribe = internal.subscribeToState(
+            updateToken,
             ({ newValue }) => {
-              var _a2;
-              socket.emit(
-                `next:${token.key}`,
-                json.parseJson(((_a2 = jsonToken.family) == null ? void 0 : _a2.subKey) || `null`),
-                newValue
-              );
+              socket.emit(`next:${token.key}`, newValue);
             },
             `expose-family:${family.key}:${socket.id}`,
             store
           );
-          unsubFamilyCallbacksByKey.set(token.key, unsubFromUpdates);
+          unsubCallbacksByKey.set(token.key, unsubscribe);
+          socket.on(`unsub:${token.key}`, () => {
+            fillUnsubRequest(token.key);
+          });
+          break;
         }
-        const unsubscribeFromTokenCreation = family.subject.subscribe(
-          `expose-family:${socket.id}`,
-          (token) => {
-            var _a2;
-            const jsonToken = internal.getJsonToken(token);
-            const trackerToken = internal.getUpdateToken(token);
-            socket.emit(
-              `init:${family.key}`,
-              json.parseJson(((_a2 = jsonToken.family) == null ? void 0 : _a2.subKey) || `null`),
-              internal.getFromStore(jsonToken, store)
-            );
-            const unsubFromUpdates = internal.subscribeToState(
-              trackerToken,
-              ({ newValue }) => {
-                var _a3;
-                socket.emit(
-                  `next:${token.key}`,
-                  json.parseJson(((_a3 = jsonToken.family) == null ? void 0 : _a3.subKey) || `null`),
-                  newValue
-                );
-              },
-              `expose-family:${family.key}:${socket.id}`,
-              store
-            );
-            unsubFamilyCallbacksByKey.set(token.key, unsubFromUpdates);
-          }
-        );
-        unsubFamilyCallbacksByKey.set(family.key, unsubscribeFromTokenCreation);
-        socket.on(`unsub:${family.key}`, fillFamilyUnsubRequest);
-      } else {
-        const token = family(subKey);
-        const jsonToken = internal.getJsonToken(token);
-        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
-        );
-        unsubSingleCallbacksByKey.set(token.key, unsubscribe);
-        socket.on(`unsub:${token.key}`, () => {
-          fillSingleUnsubRequest(token.key);
-        });
       }
     };
     socket.on(`sub:${family.key}`, fillSubRequest);
     return () => {
       socket.off(`sub:${family.key}`, fillSubRequest);
-      for (const [, unsub] of unsubFamilyCallbacksByKey) {
-        unsub();
-      }
-      for (const [, unsub] of unsubSingleCallbacksByKey) {
+      for (const [, unsub] of unsubCallbacksByKey) {
         unsub();
       }
-      unsubFamilyCallbacksByKey.clear();
-      unsubSingleCallbacksByKey.clear();
+      unsubCallbacksByKey.clear();
     };
   };
 }
@@ -462,7 +969,7 @@ function realtimeActionReceiver({
       const performanceKeyStart = `${performanceKey}:start`;
       const performanceKeyEnd = `${performanceKey}:end`;
       performance.mark(performanceKeyStart);
-      AtomIO__namespace.runTransaction(tx, update.id, store)(...update.params);
+      internal.actUponStore(tx, update.id, store)(...update.params);
       performance.mark(performanceKeyEnd);
       const metric = performance.measure(
         performanceKey,
@@ -475,140 +982,31 @@ function realtimeActionReceiver({
     return () => socket.off(`tx-run:${tx.key}`, fillTransactionRequest);
   };
 }
-function realtimeActionSynchronizer({
-  socket,
-  store = internal.IMPLICIT.STORE
-}) {
-  return function actionSynchronizer(tx, filter) {
-    const userKeyState = internal.findInStore(
-      usersOfSockets.states.userKeyOfSocket,
-      socket.id,
-      store
-    );
-    const userKey = internal.getFromStore(userKeyState, store);
-    const socketUnacknowledgedUpdatesState = internal.findInStore(
-      socketUnacknowledgedUpdatesSelectors,
-      socket.id,
-      store
-    );
-    const socketUnacknowledgedUpdates = internal.getFromStore(
-      socketUnacknowledgedUpdatesState,
-      store
-    );
-    if (filter) {
-      const redactorState = internal.findInStore(transactionRedactorAtoms, tx.key, store);
-      internal.setIntoStore(redactorState, { filter }, store);
-    }
-    const fillTransactionRequest = (update) => {
-      const performanceKey = `tx-run:${tx.key}:${update.id}`;
-      const performanceKeyStart = `${performanceKey}:start`;
-      const performanceKeyEnd = `${performanceKey}:end`;
-      performance.mark(performanceKeyStart);
-      AtomIO__namespace.runTransaction(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.off(`tx-run:${tx.key}`, fillTransactionRequest);
-    socket.on(`tx-run:${tx.key}`, fillTransactionRequest);
-    let unsubscribeFromTransaction;
-    const fillTransactionSubscriptionRequest = () => {
-      unsubscribeFromTransaction = internal.subscribeToTransaction(
-        tx,
-        (update) => {
-          const updateState = internal.findInStore(completeUpdateAtoms, update.id, store);
-          internal.setIntoStore(updateState, update, store);
-          const toEmit = filter ? internal.getFromStore(
-            internal.findInStore(redactedUpdateSelectors, [tx.key, update.id], store),
-            store
-          ) : update;
-          internal.setIntoStore(
-            socketUnacknowledgedUpdatesState,
-            (updates) => {
-              if (toEmit) {
-                updates.push(toEmit);
-                updates.sort((a, b) => a.epoch - b.epoch);
-              }
-              return updates;
-            },
-            store
-          );
-          socket.emit(`tx-new:${tx.key}`, toEmit);
-        },
-        `tx-sub:${tx.key}:${socket.id}`,
-        store
-      );
-      socket.on(`tx-unsub:${tx.key}`, unsubscribeFromTransaction);
-    };
-    socket.on(`tx-sub:${tx.key}`, fillTransactionSubscriptionRequest);
-    let i = 1;
-    let next = 1;
-    const retry = setInterval(() => {
-      const toEmit = socketUnacknowledgedUpdates[0];
-      console.log(userKey, socketUnacknowledgedUpdates);
-      if (toEmit && i === next) {
-        socket.emit(`tx-new:${tx.key}`, toEmit);
-        next *= 2;
-      }
-      i++;
-    }, 250);
-    const trackClientAcknowledgement = (epoch) => {
-      var _a;
-      i = 1;
-      next = 1;
-      const socketEpochState = internal.findInStore(
-        socketEpochSelectors,
-        socket.id,
-        store
-      );
-      internal.setIntoStore(socketEpochState, epoch, store);
-      if (((_a = socketUnacknowledgedUpdates[0]) == null ? void 0 : _a.epoch) === epoch) {
-        internal.setIntoStore(
-          socketUnacknowledgedUpdatesState,
-          (updates) => {
-            updates.shift();
-            return updates;
-          },
-          store
-        );
-      }
-    };
-    socket.on(`tx-ack:${tx.key}`, trackClientAcknowledgement);
-    return () => {
-      if (unsubscribeFromTransaction) {
-        unsubscribeFromTransaction();
-        unsubscribeFromTransaction = void 0;
-      }
-      clearInterval(retry);
-      socket.off(`tx-run:${tx.key}`, fillTransactionRequest);
-      socket.off(`tx-sub:${tx.key}`, fillTransactionSubscriptionRequest);
-    };
-  };
-}
 
-exports.DEFAULT_USER_IN_ROOM_META = DEFAULT_USER_IN_ROOM_META;
-exports.completeUpdateAtoms = completeUpdateAtoms;
+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.realtimeActionSynchronizer = realtimeActionSynchronizer;
-exports.realtimeFamilyProvider = realtimeFamilyProvider;
+exports.realtimeAtomFamilyProvider = realtimeAtomFamilyProvider;
+exports.realtimeContinuitySynchronizer = realtimeContinuitySynchronizer;
 exports.realtimeMutableFamilyProvider = realtimeMutableFamilyProvider;
 exports.realtimeMutableProvider = realtimeMutableProvider;
 exports.realtimeStateProvider = realtimeStateProvider;
 exports.realtimeStateReceiver = realtimeStateReceiver;
 exports.realtimeStateSynchronizer = realtimeStateSynchronizer;
-exports.redactedUpdateSelectors = redactedUpdateSelectors;
-exports.roomIndex = roomIndex;
-exports.socketEpochSelectors = socketEpochSelectors;
-exports.socketUnacknowledgedUpdatesSelectors = socketUnacknowledgedUpdatesSelectors;
-exports.transactionRedactorAtoms = transactionRedactorAtoms;
-exports.userEpochAtoms = userEpochAtoms;
+exports.redactTransactionUpdateContent = redactTransactionUpdateContent;
+exports.roomArgumentsAtoms = roomArgumentsAtoms;
+exports.roomSelectors = roomSelectors;
+exports.socketAtoms = socketAtoms;
+exports.socketIndex = socketIndex;
 exports.userIndex = userIndex;
-exports.userUnacknowledgedUpdatesAtoms = userUnacknowledgedUpdatesAtoms;
-exports.usersInRooms = usersInRooms;
+exports.userUnacknowledgedQueues = userUnacknowledgedQueues;
 exports.usersOfSockets = usersOfSockets;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.cjs.map