atom.io 0.30.1 → 0.30.3

package/realtime-server/dist/index.js

@@ -1,12 +1,12 @@
 import '../../dist/chunk-XWL6SNVU.js';
-import { parseJson, stringifyJson } from 'atom.io/json';
-import { Subject, IMPLICIT, getFromStore, subscribeToState, findInStore, getJsonToken, getUpdateToken, actUponStore, isRootStore, subscribeToTransaction, setIntoStore } from 'atom.io/internal';
-import { SetRTX } from 'atom.io/transceivers/set-rtx';
 import { editRelationsInStore, join, findRelationsInStore } from 'atom.io/data';
+import { Subject, getFromStore, subscribeToState, findInStore, IMPLICIT, getJsonToken, getUpdateToken, isRootStore, actUponStore, setIntoStore, subscribeToTransaction } from 'atom.io/internal';
 import * as AtomIO from 'atom.io';
 import { atomFamily, selectorFamily, atom } from 'atom.io';
 import { roomIndex, usersInRooms } from 'atom.io/realtime';
 import { spawn } from 'node:child_process';
+import { parseJson, stringifyJson } from 'atom.io/json';
+import { SetRTX } from 'atom.io/transceivers/set-rtx';
 
 // realtime-server/src/ipc-sockets/custom-socket.ts
 var CustomSocket = class {
@@ -309,31 +309,8 @@ var ParentSocket = class extends CustomSocket {
     this.relayServices.push(attachServices);
   }
 };
-function realtimeActionReceiver({
-  socket,
-  store = IMPLICIT.STORE
-}) {
-  return function actionReceiver(tx) {
-    const fillTransactionRequest = (update) => {
-      const performanceKey = `tx-run:${tx.key}:${update.id}`;
-      const performanceKeyStart = `${performanceKey}:start`;
-      const performanceKeyEnd = `${performanceKey}:end`;
-      performance.mark(performanceKeyStart);
-      actUponStore(tx, update.id, store)(...update.params);
-      performance.mark(performanceKeyEnd);
-      const metric = performance.measure(
-        performanceKey,
-        performanceKeyStart,
-        performanceKeyEnd
-      );
-      store?.logger.info(`\u{1F680}`, `transaction`, tx.key, update.id, metric.duration);
-    };
-    socket.on(`tx-run:${tx.key}`, fillTransactionRequest);
-    return () => {
-      socket.off(`tx-run:${tx.key}`, fillTransactionRequest);
-    };
-  };
-}
+
+// realtime-server/src/realtime-server-stores/server-room-external-store.ts
 var roomArgumentsAtoms = atomFamily({
   key: `roomArguments`,
   default: [`echo`, [`Hello World!`]]
@@ -439,8 +416,8 @@ function redactTransactionUpdateContent(visibleStateKeys, updates) {
     }
   });
 }
-var actionOcclusionAtoms = atomFamily({
-  key: `transactionRedactor`,
+var redactorAtoms = atomFamily({
+  key: `redactor`,
   default: { occlude: (updates) => updates }
 });
 var userUnacknowledgedQueues = atomFamily({
@@ -472,13 +449,227 @@ var usersOfSockets = join({
   isAType: (s) => s.startsWith(`user::`),
   isBType: (s) => s.startsWith(`socket::`)
 });
+function prepareToSendInitialPayload(store, continuity, userKey, socket) {
+  const continuityKey = continuity.key;
+  return function sendInitialPayload() {
+    const initialPayload = [];
+    for (const atom2 of continuity.globals) {
+      const resourceToken = atom2.type === `mutable_atom` ? getJsonToken(store, atom2) : atom2;
+      const resource = getFromStore(store, resourceToken);
+      initialPayload.push(resourceToken, resource);
+    }
+    for (const perspective of continuity.perspectives) {
+      const { viewAtoms, resourceAtoms } = perspective;
+      const userViewState = findInStore(store, viewAtoms, userKey);
+      const userView = getFromStore(store, userViewState);
+      store.logger.info(`\u{1F441}`, `atom`, resourceAtoms.key, `${userKey} can see`, {
+        viewAtoms,
+        resourceAtoms,
+        userView
+      });
+      for (const visibleToken of userView) {
+        const resourceToken = visibleToken.type === `mutable_atom` ? getJsonToken(store, visibleToken) : visibleToken;
+        const resource = getFromStore(store, resourceToken);
+        initialPayload.push(resourceToken, resource);
+      }
+    }
+    const epoch = isRootStore(store) ? store.transactionMeta.epoch.get(continuityKey) ?? null : null;
+    socket?.emit(`continuity-init:${continuityKey}`, epoch, initialPayload);
+  };
+}
+function prepareToServeTransactionRequest(store, continuity, userKey) {
+  const continuityKey = continuity.key;
+  return function serveTransactionRequest(update) {
+    store.logger.info(`\u{1F6CE}\uFE0F`, `continuity`, continuityKey, `received`, update);
+    const transactionKey = update.key;
+    const updateId = update.id;
+    const performanceKey = `tx-run:${transactionKey}:${updateId}`;
+    const performanceKeyStart = `${performanceKey}:start`;
+    const performanceKeyEnd = `${performanceKey}:end`;
+    performance.mark(performanceKeyStart);
+    try {
+      actUponStore(
+        { type: `transaction`, key: transactionKey },
+        updateId,
+        store
+      )(...update.params);
+    } catch (thrown) {
+      if (thrown instanceof Error) {
+        store.logger.error(
+          `\u274C`,
+          `continuity`,
+          continuityKey,
+          `failed to run transaction ${transactionKey} from ${userKey} with update ${updateId}`,
+          thrown.message
+        );
+      }
+    }
+    performance.mark(performanceKeyEnd);
+    const metric = performance.measure(
+      performanceKey,
+      performanceKeyStart,
+      performanceKeyEnd
+    );
+    store?.logger.info(
+      `\u{1F680}`,
+      `transaction`,
+      transactionKey,
+      updateId,
+      userKey,
+      metric.duration
+    );
+  };
+}
+function prepareToTrackClientAcknowledgement(store, continuity, userKey, userUnacknowledgedUpdates) {
+  const continuityKey = continuity.key;
+  return function trackClientAcknowledgement(epoch) {
+    store.logger.info(
+      `\u{1F44D}`,
+      `continuity`,
+      continuityKey,
+      `${userKey} acknowledged epoch ${epoch}`
+    );
+    const isUnacknowledged = userUnacknowledgedUpdates[0]?.epoch === epoch;
+    if (isUnacknowledged) {
+      setIntoStore(store, userUnacknowledgedQueues, userKey, (updates) => {
+        updates.shift();
+        store.logger.info(
+          `\u{1F44D}`,
+          `continuity`,
+          continuityKey,
+          `${userKey} unacknowledged update queue now has`,
+          updates.length,
+          `items`
+        );
+        return updates;
+      });
+    }
+  };
+}
+function subscribeToContinuityActions(store, continuity, userKey, socket) {
+  const continuityKey = continuity.key;
+  const unsubscribeFunctions = [];
+  for (const transaction2 of continuity.actions) {
+    const unsubscribeFromTransaction = subscribeToTransaction(
+      transaction2,
+      (update) => {
+        try {
+          const visibleKeys = continuity.globals.map((atom2) => {
+            if (atom2.type === `atom`) {
+              return atom2.key;
+            }
+            return getUpdateToken(atom2).key;
+          }).concat(
+            continuity.perspectives.flatMap((perspective) => {
+              const { viewAtoms } = perspective;
+              const userPerspectiveTokenState = findInStore(
+                store,
+                viewAtoms,
+                userKey
+              );
+              const visibleTokens = getFromStore(
+                store,
+                userPerspectiveTokenState
+              );
+              return visibleTokens.map((token) => {
+                const key = token.type === `mutable_atom` ? `*` + token.key : token.key;
+                return key;
+              });
+            })
+          );
+          const redactedUpdates = redactTransactionUpdateContent(
+            visibleKeys,
+            update.updates
+          );
+          const redactedUpdate = {
+            ...update,
+            updates: redactedUpdates
+          };
+          setIntoStore(store, userUnacknowledgedQueues, userKey, (updates) => {
+            if (redactedUpdate) {
+              updates.push(redactedUpdate);
+              updates.sort((a, b) => a.epoch - b.epoch);
+              store.logger.info(
+                `\u{1F44D}`,
+                `continuity`,
+                continuityKey,
+                `${userKey} unacknowledged update queue now has`,
+                updates.length,
+                `items`
+              );
+            }
+            return updates;
+          });
+          socket?.emit(
+            `tx-new:${continuityKey}`,
+            redactedUpdate
+          );
+        } catch (thrown) {
+          if (thrown instanceof Error) {
+            store.logger.error(
+              `\u274C`,
+              `continuity`,
+              continuityKey,
+              `${userKey} failed to send update from transaction ${transaction2.key} to ${userKey}`,
+              thrown.message
+            );
+          }
+        }
+      },
+      `sync-continuity:${continuityKey}:${userKey}`,
+      store
+    );
+    unsubscribeFunctions.push(unsubscribeFromTransaction);
+  }
+  return unsubscribeFunctions;
+}
+function subscribeToContinuityPerspectives(store, continuity, userKey, socket) {
+  const continuityKey = continuity.key;
+  const unsubFns = [];
+  for (const perspective of continuity.perspectives) {
+    const { viewAtoms } = perspective;
+    const userViewState = findInStore(store, viewAtoms, userKey);
+    const unsubscribeFromUserView = subscribeToState(
+      userViewState,
+      ({ oldValue, newValue }) => {
+        const oldKeys = oldValue.map((token) => token.key);
+        const newKeys = newValue.map((token) => token.key);
+        const concealed = oldValue.filter(
+          (token) => !newKeys.includes(token.key)
+        );
+        const revealed = newValue.filter((token) => !oldKeys.includes(token.key)).flatMap((token) => {
+          const resourceToken = token.type === `mutable_atom` ? getJsonToken(store, token) : token;
+          const resource = getFromStore(store, resourceToken);
+          return [resourceToken, resource];
+        });
+        store.logger.info(
+          `\u{1F441}`,
+          `atom`,
+          perspective.resourceAtoms.key,
+          `${userKey} has a new perspective`,
+          { oldKeys, newKeys, revealed, concealed }
+        );
+        if (revealed.length > 0) {
+          socket?.emit(`reveal:${continuityKey}`, revealed);
+        }
+        if (concealed.length > 0) {
+          socket?.emit(`conceal:${continuityKey}`, concealed);
+        }
+      },
+      `sync-continuity:${continuityKey}:${userKey}:perspective:${perspective.resourceAtoms.key}`,
+      store
+    );
+    unsubFns.push(unsubscribeFromUserView);
+  }
+  return unsubFns;
+}
 
-// realtime-server/src/realtime-continuity-synchronizer.ts
-function realtimeContinuitySynchronizer({
+// realtime-server/src/continuity/prepare-to-sync-realtime-continuity.ts
+function prepareToExposeRealtimeContinuity({
   socket: initialSocket,
   store = IMPLICIT.STORE
 }) {
-  return function synchronizer(continuity) {
+  return function syncRealtimeContinuity(continuity) {
     let socket = initialSocket;
     const continuityKey = continuity.key;
     const userKeyState = findRelationsInStore(
@@ -533,226 +724,80 @@ function realtimeContinuitySynchronizer({
       `sync-continuity:${continuityKey}:${userKey}`,
       store
     );
-    const userUnacknowledgedQueue = findInStore(
+    const userUnacknowledgedUpdates = getFromStore(
       store,
       userUnacknowledgedQueues,
       userKey
     );
-    const userUnacknowledgedUpdates = getFromStore(
+    const unsubscribeFunctions = [];
+    const unsubscribeFromPerspectives = subscribeToContinuityPerspectives(
       store,
-      userUnacknowledgedQueue
+      continuity,
+      userKey,
+      socket
+    );
+    const unsubscribeFromTransactions = subscribeToContinuityActions(
+      store,
+      continuity,
+      userKey,
+      socket
+    );
+    unsubscribeFunctions.push(
+      ...unsubscribeFromPerspectives,
+      ...unsubscribeFromTransactions
+    );
+    const sendInitialPayload = prepareToSendInitialPayload(
+      store,
+      continuity,
+      userKey,
+      initialSocket
     );
-    const unsubscribeFunctions = [];
-    const revealPerspectives = () => {
-      const unsubFns = [];
-      for (const perspective of continuity.perspectives) {
-        const { viewAtoms } = perspective;
-        const userViewState = findInStore(store, viewAtoms, userKey);
-        const unsubscribe = subscribeToState(
-          userViewState,
-          ({ oldValue, newValue }) => {
-            const oldKeys = oldValue.map((token) => token.key);
-            const newKeys = newValue.map((token) => token.key);
-            const concealed = oldValue.filter(
-              (token) => !newKeys.includes(token.key)
-            );
-            const revealed = newValue.filter((token) => !oldKeys.includes(token.key)).flatMap((token) => {
-              const resourceToken = token.type === `mutable_atom` ? getJsonToken(store, token) : token;
-              const resource = getFromStore(store, resourceToken);
-              return [resourceToken, resource];
-            });
-            store.logger.info(
-              `\u{1F441}`,
-              `atom`,
-              perspective.resourceAtoms.key,
-              `${userKey} has a new perspective`,
-              { oldKeys, newKeys, revealed, concealed }
-            );
-            if (revealed.length > 0) {
-              socket?.emit(`reveal:${continuityKey}`, revealed);
-            }
-            if (concealed.length > 0) {
-              socket?.emit(`conceal:${continuityKey}`, concealed);
-            }
-          },
-          `sync-continuity:${continuityKey}:${userKey}:perspective:${perspective.resourceAtoms.key}`,
-          store
-        );
-        unsubFns.push(unsubscribe);
-      }
-      return () => {
-        for (const unsubscribe of unsubFns) unsubscribe();
-      };
-    };
-    const unsubscribeFromPerspectives = revealPerspectives();
-    const 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);
-      for (const transaction2 of continuity.actions) {
-        const unsubscribeFromTransaction = subscribeToTransaction(
-          transaction2,
-          (update) => {
-            try {
-              const visibleKeys = continuity.globals.map((atom2) => {
-                if (atom2.type === `atom`) {
-                  return atom2.key;
-                }
-                return getUpdateToken(atom2).key;
-              }).concat(
-                continuity.perspectives.flatMap((perspective) => {
-                  const { viewAtoms } = perspective;
-                  const userPerspectiveTokenState = findInStore(
-                    store,
-                    viewAtoms,
-                    userKey
-                  );
-                  const visibleTokens = getFromStore(
-                    store,
-                    userPerspectiveTokenState
-                  );
-                  return visibleTokens.map((token) => {
-                    const key = token.type === `mutable_atom` ? `*` + token.key : token.key;
-                    return key;
-                  });
-                })
-              );
-              const redactedUpdates = redactTransactionUpdateContent(
-                visibleKeys,
-                update.updates
-              );
-              const redactedUpdate = {
-                ...update,
-                updates: redactedUpdates
-              };
-              setIntoStore(store, userUnacknowledgedQueue, (updates) => {
-                if (redactedUpdate) {
-                  updates.push(redactedUpdate);
-                  updates.sort((a, b) => a.epoch - b.epoch);
-                }
-                return updates;
-              });
-              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 = prepareToServeTransactionRequest(
+      store,
+      continuity,
+      userKey
+    );
+    socket.off(`tx-run:${continuityKey}`, fillTransactionRequest);
+    socket.on(`tx-run:${continuityKey}`, fillTransactionRequest);
+    const trackClientAcknowledgement = prepareToTrackClientAcknowledgement(
+      store,
+      continuity,
+      userKey,
+      userUnacknowledgedUpdates
+    );
+    socket?.on(`ack:${continuityKey}`, trackClientAcknowledgement);
+    return () => {
+      for (const unsubscribe of unsubscribeFunctions) unsubscribe();
+      socket?.off(`ack:${continuityKey}`, trackClientAcknowledgement);
+      socket?.off(`get:${continuityKey}`, sendInitialPayload);
+      socket?.off(`tx-run:${continuityKey}`, fillTransactionRequest);
+    };
+  };
+}
+function realtimeActionReceiver({
+  socket,
+  store = IMPLICIT.STORE
+}) {
+  return function actionReceiver(tx) {
     const fillTransactionRequest = (update) => {
-      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 performanceKey = `tx-run:${tx.key}:${update.id}`;
       const performanceKeyStart = `${performanceKey}:start`;
       const performanceKeyEnd = `${performanceKey}:end`;
       performance.mark(performanceKeyStart);
-      try {
-        actUponStore(
-          { type: `transaction`, key: transactionKey },
-          updateId,
-          store
-        )(...update.params);
-      } catch (thrown) {
-        if (thrown instanceof Error) {
-          store.logger.error(
-            `\u274C`,
-            `continuity`,
-            continuityKey,
-            `failed to run transaction ${transactionKey} with update ${updateId}`,
-            thrown.message
-          );
-        }
-      }
+      actUponStore(tx, update.id, store)(...update.params);
       performance.mark(performanceKeyEnd);
       const metric = performance.measure(
         performanceKey,
         performanceKeyStart,
         performanceKeyEnd
       );
-      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);
-    const trackClientAcknowledgement = (epoch) => {
-      store.logger.info(
-        `\u{1F44D}`,
-        `continuity`,
-        continuityKey,
-        `${userKey} acknowledged epoch ${epoch}`
-      );
-      const isUnacknowledged = userUnacknowledgedUpdates[0]?.epoch === epoch;
-      if (isUnacknowledged) {
-        setIntoStore(store, userUnacknowledgedQueue, (updates) => {
-          updates.shift();
-          return updates;
-        });
-      }
+      store?.logger.info(`\u{1F680}`, `transaction`, tx.key, update.id, metric.duration);
     };
-    socket?.on(`ack:${continuityKey}`, trackClientAcknowledgement);
+    socket.on(`tx-run:${tx.key}`, fillTransactionRequest);
     return () => {
-      for (const unsubscribe of unsubscribeFunctions) unsubscribe();
-      socket?.off(`ack:${continuityKey}`, trackClientAcknowledgement);
-      unsubscribeFromPerspectives();
-      socket?.off(`get:${continuityKey}`, sendInitialPayload);
-      socket?.off(`tx-run:${continuityKey}`, fillTransactionRequest);
+      socket.off(`tx-run:${tx.key}`, fillTransactionRequest);
     };
   };
 }
@@ -942,4 +987,4 @@ function realtimeStateReceiver({
   };
 }
 
-export { ChildSocket, CustomSocket, ParentSocket, SubjectSocket, actionOcclusionAtoms, createRoomTX, destroyRoomTX, joinRoomTX, leaveRoomTX, realtimeActionReceiver, realtimeAtomFamilyProvider, realtimeContinuitySynchronizer, realtimeMutableFamilyProvider, realtimeMutableProvider, realtimeStateProvider, realtimeStateReceiver, redactTransactionUpdateContent, roomArgumentsAtoms, roomSelectors, socketAtoms, socketIndex, userIndex, userUnacknowledgedQueues, usersOfSockets };
+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 };

package/realtime-server/src/continuity/prepare-to-send-initial-payload.ts

@@ -0,0 +1,54 @@
+import type { Store } from "atom.io/internal"
+import {
+	findInStore,
+	getFromStore,
+	getJsonToken,
+	isRootStore,
+} from "atom.io/internal"
+import type { Json } from "atom.io/json"
+import type { ContinuityToken } from "atom.io/realtime"
+
+import type { Socket, UserKey } from ".."
+
+export function prepareToSendInitialPayload(
+	store: Store,
+	continuity: ContinuityToken,
+	userKey: UserKey,
+	socket: Socket | null,
+): () => void {
+	const continuityKey = continuity.key
+	return function sendInitialPayload(): void {
+		const initialPayload: Json.Serializable[] = []
+		for (const atom of continuity.globals) {
+			const resourceToken =
+				atom.type === `mutable_atom` ? getJsonToken(store, atom) : atom
+			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(`👁`, `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)
+	}
+}

package/realtime-server/src/continuity/prepare-to-serve-transaction-request.ts

@@ -0,0 +1,53 @@
+import type { TransactionUpdate } from "atom.io"
+import type { Store } from "atom.io/internal"
+import { actUponStore } from "atom.io/internal"
+import type { JsonIO } from "atom.io/json"
+import type { ContinuityToken } from "atom.io/realtime"
+
+export function prepareToServeTransactionRequest(
+	store: Store,
+	continuity: ContinuityToken,
+	userKey: string,
+): (update: Pick<TransactionUpdate<JsonIO>, `id` | `key` | `params`>) => void {
+	const continuityKey = continuity.key
+	return function serveTransactionRequest(update) {
+		store.logger.info(`🛎️`, `continuity`, continuityKey, `received`, update)
+		const transactionKey = update.key
+		const updateId = update.id
+		const performanceKey = `tx-run:${transactionKey}:${updateId}`
+		const performanceKeyStart = `${performanceKey}:start`
+		const performanceKeyEnd = `${performanceKey}:end`
+		performance.mark(performanceKeyStart)
+		try {
+			actUponStore(
+				{ type: `transaction`, key: transactionKey },
+				updateId,
+				store,
+			)(...update.params)
+		} catch (thrown) {
+			if (thrown instanceof Error) {
+				store.logger.error(
+					`❌`,
+					`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(
+			`🚀`,
+			`transaction`,
+			transactionKey,
+			updateId,
+			userKey,
+			metric.duration,
+		)
+	}
+}