atom.io 0.18.0 → 0.18.1

package/realtime-server/dist/index.cjs

@@ -1,13 +1,12 @@
 'use strict';
 
-var internal = require('atom.io/internal');
 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 realtimeServer = require('atom.io/realtime-server');
 var child_process = require('child_process');
 var data = require('atom.io/data');
-var setRtx = require('atom.io/transceivers/set-rtx');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -48,6 +47,8 @@ var __spreadValues = (a, b) => {
   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;
@@ -82,7 +83,11 @@ var CustomSocket = class {
   off(event, listener) {
     const listeners = this.listeners.get(event);
     if (listeners) {
-      listeners.delete(listener);
+      if (listener) {
+        listeners.delete(listener);
+      } else {
+        this.listeners.delete(event);
+      }
     }
     return this;
   }
@@ -91,28 +96,109 @@ var CustomSocket = class {
     return this;
   }
 };
+
+// realtime-server/src/ipc-sockets/child-socket.ts
 var ChildSocket = class extends CustomSocket {
-  constructor(process2) {
+  constructor(process2, key, logger = console) {
     super((event, ...args) => {
-      const stringifiedEvent = JSON.stringify([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.id = `no_id_retrieved`;
+    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 stringifiedEvent = buffer.toString();
-        const parsedEvent = json.parseJson(stringifiedEvent);
-        this.handleEvent(...parsedEvent);
+        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) {
@@ -121,6 +207,7 @@ var SubjectSocket = class extends CustomSocket {
       return this;
     });
     this.id = `no_id_retrieved`;
+    this.disposalFunctions = [];
     this.id = id;
     this.in = new internal.Subject();
     this.out = new internal.Subject();
@@ -128,69 +215,130 @@ var SubjectSocket = class extends CustomSocket {
       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);
+      this.process.stdout.write(stringifiedEvent + ``);
       return this;
     });
-    this.id = `no_id_retrieved`;
+    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.queue = [];
     this.relays = /* @__PURE__ */ new Map();
     this.relayServices = [];
     this.process.stdin.on(
       `data`,
-      (chunk) => {
-        const buffer = chunk.toString();
-        this.queue.push(...buffer.split(`
-`));
-        while (this.queue.length > 0) {
-          try {
-            const event = this.queue.shift();
-            if (event === ``)
-              continue;
-            const parsedEvent = json.parseJson(event);
-            this.handleEvent(...parsedEvent);
-          } catch (error) {
-            this.process.stderr.write(`\u274C ${error}
-`);
-            break;
+      (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);
           }
         }
       }
     );
-    process.on(`SIGINT`, () => process.exit(0));
+    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(`setup-relay`, (id) => {
-      const relay = new SubjectSocket(`relay:${id}`);
-      this.relays.set(id, relay);
+    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) {
-        attachServices(relay);
+        const cleanup = attachServices(relay);
+        if (cleanup) {
+          relay.disposalFunctions.push(cleanup);
+        }
       }
-      this.on(`relay:${id}`, (...data) => {
+      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);
-    const relays = this.relays.values();
-    for (const relay of relays) {
-      attachServices(relay);
-    }
   }
 };
-var redactorAtoms = AtomIO.selectorFamily({
+AtomIO.selectorFamily({
   key: `perspectiveRedactor`,
   get: ({ userId, syncGroupKey }) => ({ get, find }) => {
     const syncGroup = realtime.SyncGroup.existing.get(syncGroupKey);
@@ -200,17 +348,31 @@ var redactorAtoms = AtomIO.selectorFamily({
       );
     }
     const userPerspectiveTokens = syncGroup.perspectives.flatMap(
-      ({ perspectiveAtoms, resourceAtoms }) => {
-        const userPerspectiveToken = find(perspectiveAtoms, userId);
+      ({ viewAtoms }) => {
+        const userPerspectiveToken = find(viewAtoms, userId);
         const userPerspective = get(userPerspectiveToken);
-        const visibleTokens = [...userPerspective].map((subKey) => {
-          const resourceToken = find(resourceAtoms, subKey);
-          return resourceToken.key;
+        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);
@@ -229,7 +391,7 @@ var redactorAtoms = AtomIO.selectorFamily({
     };
     const filter = (update) => {
       const visibleKeys = syncGroup.globals.map(
-        (atomToken) => atomToken.key
+        (atomToken) => atomToken.type === `mutable_atom` ? internal.getUpdateToken(atomToken).key : atomToken.key
       );
       visibleKeys.push(...userPerspectiveTokens);
       return filterTransactionUpdate(visibleKeys, update);
@@ -237,67 +399,40 @@ var redactorAtoms = AtomIO.selectorFamily({
     return filter;
   }
 });
-var redactedPerspectiveUpdateSelectors = AtomIO.selectorFamily({
-  key: `redactedPerspectiveUpdate`,
-  get: ({ userId, syncGroupKey, updateId }) => ({ get, find }) => {
-    const updateState = find(realtimeServer.completeUpdateAtoms, updateId);
-    const update = get(updateState);
-    const redactorKey = { userId, syncGroupKey };
-    const redactorState = find(redactorAtoms, redactorKey);
-    const redact = get(redactorState);
-    if (update) {
-      return redact(update);
-    }
-    return null;
-  }
-});
-var roomIndex = AtomIO__namespace.atom({
-  key: `roomIndex`,
-  default: () => new setRtx.SetRTX(),
-  mutable: true,
-  toJson: (set) => set.toJSON(),
-  fromJson: (json) => setRtx.SetRTX.fromJSON(json)
-});
-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 roomArgumentsAtoms = AtomIO__namespace.atomFamily({
+var roomArgumentsAtoms = AtomIO.atomFamily({
   key: `roomArguments`,
-  default: [`echo Hello World!`]
+  default: [`echo`, [`Hello World!`]]
 });
-var roomSelectors = AtomIO__namespace.selectorFamily({
+var roomSelectors = AtomIO.selectorFamily({
   key: `room`,
-  get: (roomId) => ({ get, find }) => {
+  get: (roomId) => async ({ get, find }) => {
     const argumentsState = find(roomArgumentsAtoms, roomId);
     const args = get(argumentsState);
     const [script, options] = args;
-    return 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);
-    });
+    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(roomIndex, (s) => s.add(roomId));
+    set(realtime.roomIndex, (s) => s.add(roomId));
     const roomState = find(roomSelectors, roomId);
     const room = get(roomState);
     return room;
@@ -307,30 +442,49 @@ var joinRoomTX = AtomIO__namespace.transaction({
   key: `joinRoom`,
   do: (transactors, roomId, userId, enteredAtEpoch) => {
     const meta = { enteredAtEpoch };
-    usersInRooms.transact(transactors, ({ relations }) => {
+    realtime.usersInRooms.transact(transactors, ({ relations }) => {
       relations.set(roomId, userId, meta);
     });
     return meta;
   }
 });
-var completeUpdateAtoms2 = AtomIO.atomFamily({
-  key: `completeUpdate`,
-  default: null
+var leaveRoomTX = AtomIO__namespace.transaction({
+  key: `leaveRoom`,
+  do: (transactors, roomId, userId) => {
+    realtime.usersInRooms.transact(transactors, ({ relations }) => {
+      relations.delete({ room: roomId, user: userId });
+    });
+  }
 });
-var transactionRedactorAtoms = AtomIO.atomFamily({
-  key: `transactionRedactor`,
-  default: { filter: (updates) => updates }
+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 redactedUpdateSelectors = AtomIO.selectorFamily({
-  key: `redactedUpdate`,
-  get: ([transactionKey, updateId]) => ({ get, find }) => {
-    const update = get(find(completeUpdateAtoms2, updateId));
-    const { filter } = get(find(transactionRedactorAtoms, transactionKey));
-    if (update && filter) {
-      return __spreadProps(__spreadValues({}, update), { updates: filter(update.updates) });
+function redactTransactionUpdateContent(visibleStateKeys, updates) {
+  return updates.map((update) => {
+    if (`newValue` in update) {
+      return update;
     }
-    return null;
-  }
+    const redacted = redactTransactionUpdateContent(
+      visibleStateKeys,
+      update.updates
+    );
+    return __spreadProps(__spreadValues({}, update), { updates: redacted });
+  }).filter((update) => {
+    if (`newValue` in update) {
+      return visibleStateKeys.includes(update.key);
+    }
+    return true;
+  });
+}
+var actionOcclusionAtoms = AtomIO.atomFamily({
+  key: `transactionRedactor`,
+  default: { occlude: (updates) => updates }
 });
 var userUnacknowledgedQueues = AtomIO.atomFamily({
   key: `unacknowledgedUpdates`,
@@ -419,27 +573,74 @@ function realtimeContinuitySynchronizer({
       userKey,
       store
     );
-    const userUnacknowledgedUpdates = internal.getFromStore(
+    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 atom3 of continuity.globals) {
-        initialPayload.push(atom3, internal.getFromStore(atom3, store));
+      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 { perspectiveAtoms } of continuity.perspectives) {
-        const perspectiveTokensState = internal.findInStore(
-          perspectiveAtoms,
-          userKey,
-          store
-        );
-        const perspectiveTokens = internal.getFromStore(perspectiveTokensState, store);
-        for (const perspectiveToken of perspectiveTokens) {
-          const resource = internal.getFromStore(perspectiveToken, store);
-          initialPayload.push(perspectiveToken, resource);
+      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;
@@ -448,38 +649,47 @@ function realtimeContinuitySynchronizer({
         const unsubscribeFromTransaction = internal.subscribeToTransaction(
           transaction2,
           (update) => {
-            const updateState = internal.findInStore(
-              completeUpdateAtoms2,
-              update.id,
-              store
-            );
-            internal.setIntoStore(updateState, update, store);
-            const redactedUpdateKey = {
-              userId: userKey,
-              syncGroupKey: continuityKey,
-              updateId: update.id
-            };
-            const redactedUpdateState = internal.findInStore(
-              redactedPerspectiveUpdateSelectors,
-              redactedUpdateKey,
-              store
-            );
-            const redactedUpdate = internal.getFromStore(redactedUpdateState, store);
-            internal.setIntoStore(
-              userUnacknowledgedQueue,
-              (updates) => {
-                if (redactedUpdate) {
-                  updates.push(redactedUpdate);
-                  updates.sort((a, b) => a.epoch - b.epoch);
-                }
-                return updates;
-              },
-              store
-            );
-            socket == null ? void 0 : socket.emit(
-              `tx-new:${continuityKey}`,
-              redactedUpdate
-            );
+            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
@@ -490,17 +700,30 @@ function realtimeContinuitySynchronizer({
     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);
-      internal.actUponStore(
-        { type: `transaction`, key: transactionKey },
-        updateId,
-        store
-      )(...update.params);
+      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,
@@ -514,56 +737,27 @@ function realtimeContinuitySynchronizer({
         updateId,
         metric.duration
       );
-    };
-    socket.off(`tx-run:${continuityKey}`, fillTransactionRequest);
-    socket.on(`tx-run:${continuityKey}`, fillTransactionRequest);
-    let i = 1;
-    let next = 1;
-    const retry = setInterval(() => {
-      const toEmit = userUnacknowledgedUpdates[0];
+      const valuesOfCardsViewKey = `valuesOfCardsView("${userKey}")`;
+      const rootsOfCardValueView = store.selectorAtoms.getRelatedKeys(valuesOfCardsViewKey);
+      const myCardValueView = store.valueMap.get(valuesOfCardsViewKey);
       store.logger.info(
-        `\u{1F504}`,
+        `\u{1F441}`,
         `continuity`,
         continuityKey,
-        `${store.config.name} retrying ${userKey} (${i}/${next})`,
-        socket == null ? void 0 : socket.id,
-        userUnacknowledgedUpdates
-      );
-      if (toEmit && i === next) {
-        socket == null ? void 0 : socket.emit(`tx-new:${continuityKey}`, toEmit);
-        next *= 2;
-      }
-      i++;
-    }, 250);
-    const trackClientAcknowledgement = (epoch) => {
-      var _a;
-      store.logger.info(
-        `\u{1F44D}`,
-        `continuity`,
-        continuityKey,
-        `${userKey} acknowledged epoch ${epoch}`
+        `seeing ${userKey} card values`,
+        {
+          valuesOfCardsViewKey,
+          rootsOfCardValueView,
+          myCardValueView
+        }
       );
-      i = 1;
-      next = 1;
-      const isUnacknowledged = ((_a = userUnacknowledgedUpdates[0]) == null ? void 0 : _a.epoch) === epoch;
-      if (isUnacknowledged) {
-        internal.setIntoStore(
-          userUnacknowledgedQueue,
-          (updates) => {
-            updates.shift();
-            return updates;
-          },
-          store
-        );
-      }
     };
-    socket.off(`ack:${continuityKey}`, trackClientAcknowledgement);
-    socket.on(`ack:${continuityKey}`, trackClientAcknowledgement);
+    socket.off(`tx-run:${continuityKey}`, fillTransactionRequest);
+    socket.on(`tx-run:${continuityKey}`, fillTransactionRequest);
     return () => {
-      clearInterval(retry);
       for (const unsubscribe of unsubscribeFunctions)
         unsubscribe();
-      socket == null ? void 0 : socket.off(`ack:${continuityKey}`, trackClientAcknowledgement);
+      unsubscribeFromPerspectives();
       socket == null ? void 0 : socket.off(`get:${continuityKey}`, sendInitialPayload);
       socket == null ? void 0 : socket.off(`tx-run:${continuityKey}`, fillTransactionRequest);
     };
@@ -788,135 +982,17 @@ function realtimeActionReceiver({
     return () => socket.off(`tx-run:${tx.key}`, fillTransactionRequest);
   };
 }
-function realtimeActionSynchronizer({
-  socket,
-  store = internal.IMPLICIT.STORE
-}) {
-  return function actionSynchronizer(tx, filter) {
-    internal.assignTransactionToContinuity(`default`, tx.key, store);
-    const userKeyState = internal.findInStore(
-      usersOfSockets.states.userKeyOfSocket,
-      socket.id,
-      store
-    );
-    const userKey = internal.getFromStore(userKeyState, store);
-    if (!userKey) {
-      store.logger.error(
-        `\u274C`,
-        `transaction`,
-        tx.key,
-        `Tried to create a synchronizer for a socket (${socket.id}) that is not connected to a user.`
-      );
-      return () => {
-      };
-    }
-    const userUnacknowledgedQueue = internal.findInStore(
-      userUnacknowledgedQueues,
-      userKey,
-      store
-    );
-    const userUnacknowledgedUpdates = internal.getFromStore(
-      userUnacknowledgedQueue,
-      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);
-      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.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(completeUpdateAtoms2, 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(
-            userUnacknowledgedQueue,
-            (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 = userUnacknowledgedUpdates[0];
-      if (toEmit && i === next) {
-        socket.emit(`tx-new:${tx.key}`, toEmit);
-        next *= 2;
-      }
-      i++;
-    }, 250);
-    const trackClientAcknowledgement = (epoch) => {
-      var _a;
-      i = 1;
-      next = 1;
-      if (((_a = userUnacknowledgedUpdates[0]) == null ? void 0 : _a.epoch) === epoch) {
-        internal.setIntoStore(
-          userUnacknowledgedQueue,
-          (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.ChildSocket = ChildSocket;
 exports.CustomSocket = CustomSocket;
-exports.DEFAULT_USER_IN_ROOM_META = DEFAULT_USER_IN_ROOM_META;
 exports.ParentSocket = ParentSocket;
 exports.SubjectSocket = SubjectSocket;
-exports.completeUpdateAtoms = completeUpdateAtoms2;
+exports.actionOcclusionAtoms = actionOcclusionAtoms;
 exports.createRoomTX = createRoomTX;
+exports.destroyRoomTX = destroyRoomTX;
 exports.joinRoomTX = joinRoomTX;
+exports.leaveRoomTX = leaveRoomTX;
 exports.realtimeActionReceiver = realtimeActionReceiver;
-exports.realtimeActionSynchronizer = realtimeActionSynchronizer;
 exports.realtimeAtomFamilyProvider = realtimeAtomFamilyProvider;
 exports.realtimeContinuitySynchronizer = realtimeContinuitySynchronizer;
 exports.realtimeMutableFamilyProvider = realtimeMutableFamilyProvider;
@@ -924,17 +1000,13 @@ exports.realtimeMutableProvider = realtimeMutableProvider;
 exports.realtimeStateProvider = realtimeStateProvider;
 exports.realtimeStateReceiver = realtimeStateReceiver;
 exports.realtimeStateSynchronizer = realtimeStateSynchronizer;
-exports.redactedPerspectiveUpdateSelectors = redactedPerspectiveUpdateSelectors;
-exports.redactedUpdateSelectors = redactedUpdateSelectors;
+exports.redactTransactionUpdateContent = redactTransactionUpdateContent;
 exports.roomArgumentsAtoms = roomArgumentsAtoms;
-exports.roomIndex = roomIndex;
 exports.roomSelectors = roomSelectors;
 exports.socketAtoms = socketAtoms;
 exports.socketIndex = socketIndex;
-exports.transactionRedactorAtoms = transactionRedactorAtoms;
 exports.userIndex = userIndex;
 exports.userUnacknowledgedQueues = userUnacknowledgedQueues;
-exports.usersInRooms = usersInRooms;
 exports.usersOfSockets = usersOfSockets;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.cjs.map