atom.io 0.16.1 → 0.16.3

package/realtime-server/dist/index.d.ts

@@ -1,26 +1,164 @@
 import { Transceiver, Store } from 'atom.io/internal';
 import * as SocketIO from 'socket.io';
-import * as AtomIO from 'atom.io';
-import { WritableToken } from 'atom.io';
+import * as atom_io_data from 'atom.io/data';
+import * as atom_io from 'atom.io';
+import { TransactionUpdate, TransactionUpdateContent, WritableToken } from 'atom.io';
+import * as atom_io_transceivers_set_rtx from 'atom.io/transceivers/set-rtx';
+import { SetRTX } from 'atom.io/transceivers/set-rtx';
 import { Json } from 'atom.io/json';
 
-declare function realtimeStateProvider({ socket, store, }: ServerConfig): <J extends Json.Serializable>(token: AtomIO.WritableToken<J>) => () => void;
+type primitive = boolean | number | string | null;
 
-declare function realtimeFamilyProvider({ socket, store, }: ServerConfig): <J extends Json.Serializable>(family: AtomIO.RegularAtomFamily<J, Json.Serializable>, index: AtomIO.ReadableToken<Iterable<string>>) => () => void;
+type Serializable = primitive | Readonly<{
+    [key: string]: Serializable;
+}> | ReadonlyArray<Serializable>;
+type Object$1<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
 
-declare function realtimeMutableProvider({ socket, store, }: ServerConfig): <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable>(token: AtomIO.MutableAtomToken<Core, SerializableCore>) => () => void;
+type Refinement<Unrefined, Refined extends Unrefined> = (value: Unrefined) => value is Refined;
+type Cardinality = `1:1` | `1:n` | `n:n`;
 
-declare const realtimeMutableFamilyProvider: ({ socket, store, }: ServerConfig) => <Family extends AtomIO.MutableAtomFamily<Transceiver<Json.Serializable>, Json.Serializable, Json.Serializable>>(family: Family, index: AtomIO.ReadableToken<Iterable<string>>) => () => void;
+interface JunctionEntries<Content extends Object$1 | null> extends Object$1 {
+    readonly relations: [string, string[]][];
+    readonly contents: [string, Content][];
+}
+interface JunctionSchema<ASide extends string, BSide extends string> extends Object$1 {
+    readonly between: [a: ASide, b: BSide];
+    readonly cardinality: Cardinality;
+}
+type BaseExternalStoreConfiguration = {
+    addRelation: (a: string, b: string) => void;
+    deleteRelation: (a: string, b: string) => void;
+    replaceRelationsSafely: (a: string, bs: string[]) => void;
+    replaceRelationsUnsafely: (a: string, bs: string[]) => void;
+    getRelatedKeys: (key: string) => Set<string> | undefined;
+    has: (a: string, b?: string) => boolean;
+};
+type ExternalStoreWithContentConfiguration<Content extends Object$1> = {
+    getContent: (contentKey: string) => Content | undefined;
+    setContent: (contentKey: string, content: Content) => void;
+    deleteContent: (contentKey: string) => void;
+};
+type Empty<Obj extends object> = {
+    [Key in keyof Obj]?: undefined;
+};
+type ExternalStoreConfiguration<Content extends Object$1 | null> = Content extends Object$1 ? BaseExternalStoreConfiguration & ExternalStoreWithContentConfiguration<Content> : BaseExternalStoreConfiguration & Empty<ExternalStoreWithContentConfiguration<Object$1>>;
+type JunctionAdvancedConfiguration<Content extends Object$1 | null> = {
+    externalStore?: ExternalStoreConfiguration<Content>;
+    isContent?: Refinement<unknown, Content>;
+    makeContentKey?: (a: string, b: string) => string;
+};
+type JunctionJSON<ASide extends string, BSide extends string, Content extends Object$1 | null> = JunctionEntries<Content> & JunctionSchema<ASide, BSide>;
+declare class Junction<const ASide extends string, const BSide extends string, const Content extends Object$1 | null = null> {
+    readonly a: ASide;
+    readonly b: BSide;
+    readonly cardinality: Cardinality;
+    readonly relations: Map<string, Set<string>>;
+    readonly contents: Map<string, Content>;
+    isContent: Refinement<unknown, Content> | null;
+    makeContentKey: (a: string, b: string) => string;
+    getRelatedKeys(key: string): Set<string> | undefined;
+    protected addRelation(a: string, b: string): void;
+    protected deleteRelation(a: string, b: string): void;
+    protected replaceRelationsUnsafely(a: string, bs: string[]): void;
+    protected replaceRelationsSafely(a: string, bs: string[]): void;
+    protected getContentInternal(contentKey: string): Content | undefined;
+    protected setContent(contentKey: string, content: Content): void;
+    protected deleteContent(contentKey: string): void;
+    constructor(data: JunctionSchema<ASide, BSide> & Partial<JunctionEntries<Content>>, config?: JunctionAdvancedConfiguration<Content>);
+    toJSON(): JunctionJSON<ASide, BSide, Content>;
+    set(a: string, ...rest: Content extends null ? [b: string] : [b: string, content: Content]): this;
+    set(relation: {
+        [Key in ASide | BSide]: string;
+    }, ...rest: Content extends null ? [] | [b?: undefined] : [content: Content]): this;
+    delete(a: string, b?: string): this;
+    delete(relation: Record<ASide | BSide, string> | Record<ASide, string> | Record<BSide, string>, b?: undefined): this;
+    getRelatedKey(key: string): string | undefined;
+    replaceRelations(a: string, relations: Content extends null ? string[] : Record<string, Content>, config?: {
+        reckless: boolean;
+    }): this;
+    getContent(a: string, b: string): Content | undefined;
+    getRelationEntries(input: Record<ASide, string> | Record<BSide, string>): [string, Content][];
+    has(a: string, b?: string): boolean;
+}
+
+declare const userIndex: atom_io.MutableAtomToken<SetRTX<string>, atom_io_transceivers_set_rtx.SetRTXJson<string>>;
+declare const usersOfSockets: {
+    readonly relations: Junction<"user", "socket", null>;
+    readonly states: {
+        readonly userKeyOfSocket: atom_io.ReadonlySelectorFamily<string | null, string>;
+        readonly socketKeyOfUser: atom_io.ReadonlySelectorFamily<string | null, string>;
+    };
+    readonly transact: (transactors: Readonly<{
+        get: <S>(state: atom_io.ReadonlySelectorToken<S> | atom_io.WritableToken<S>) => S;
+        set: <S_1, New extends S_1>(state: atom_io.WritableToken<S_1>, newValue: New | ((oldValue: S_1) => New)) => void;
+        find: typeof atom_io.findState;
+    }>, run: (join: atom_io_data.Join<"user", "socket", "1:1", null>) => void) => void;
+    readonly core: {
+        readonly findRelatedKeysState: atom_io.MutableAtomFamily<SetRTX<string>, atom_io_transceivers_set_rtx.SetRTXJson<string>, string>;
+    };
+};
+declare const roomIndex: atom_io.MutableAtomToken<SetRTX<string>, atom_io_transceivers_set_rtx.SetRTXJson<string>>;
+type UserInRoomMeta = {
+    enteredAtEpoch: number;
+};
+declare const DEFAULT_USER_IN_ROOM_META: UserInRoomMeta;
+declare const usersInRooms: {
+    readonly relations: Junction<"room", "user", UserInRoomMeta>;
+    readonly states: {
+        readonly roomEntryOfUser: atom_io.ReadonlySelectorFamily<[string, UserInRoomMeta] | null, string>;
+    } & {
+        readonly userEntriesOfRoom: atom_io.ReadonlySelectorFamily<[string, UserInRoomMeta][], string>;
+    } & {
+        readonly roomKeyOfUser: atom_io.ReadonlySelectorFamily<string | null, string>;
+    } & {
+        readonly userKeysOfRoom: atom_io.ReadonlySelectorFamily<string[], string>;
+    };
+    readonly transact: (transactors: Readonly<{
+        get: <S>(state: atom_io.ReadonlySelectorToken<S> | atom_io.WritableToken<S>) => S;
+        set: <S_1, New extends S_1>(state: atom_io.WritableToken<S_1>, newValue: New | ((oldValue: S_1) => New)) => void;
+        find: typeof atom_io.findState;
+    }>, run: (join: atom_io_data.Join<"room", "user", "1:n", UserInRoomMeta>) => void) => void;
+    readonly core: {
+        readonly findRelatedKeysState: atom_io.MutableAtomFamily<SetRTX<string>, atom_io_transceivers_set_rtx.SetRTXJson<string>, string>;
+    };
+};
+
+declare const completeUpdateAtoms: atom_io.RegularAtomFamily<TransactionUpdate<any> | null, string>;
+declare const transactionRedactorAtoms: atom_io.RegularAtomFamily<{
+    filter: (updates: TransactionUpdateContent[]) => TransactionUpdateContent[];
+}, string>;
+declare const redactedUpdateSelectors: atom_io.ReadonlySelectorFamily<TransactionUpdate<any> | null, [transactionKey: string, updateId: string]>;
+declare const userUnacknowledgedUpdatesAtoms: atom_io.RegularAtomFamily<TransactionUpdate<any>[], string>;
+declare const socketUnacknowledgedUpdatesSelectors: atom_io.WritableSelectorFamily<TransactionUpdate<any>[], string>;
+declare const userEpochAtoms: atom_io.RegularAtomFamily<number | null, string>;
+declare const socketEpochSelectors: atom_io.WritableSelectorFamily<number | null, string>;
+
+type StateProvider = ReturnType<typeof realtimeStateProvider>;
+declare function realtimeStateProvider({ socket, store, }: ServerConfig): <J extends Json.Serializable>(token: atom_io.WritableToken<J>) => () => void;
+
+declare function realtimeStateSynchronizer({ socket, store, }: ServerConfig): <J extends Json.Serializable>(token: atom_io.WritableToken<J>) => () => void;
+
+type FamilyProvider = ReturnType<typeof realtimeFamilyProvider>;
+declare function realtimeFamilyProvider({ socket, store, }: ServerConfig): <J extends Json.Serializable, K extends Json.Serializable>(family: atom_io.RegularAtomFamily<J, K>, index: atom_io.ReadableToken<Iterable<K>>) => () => void;
+
+type MutableProvider = ReturnType<typeof realtimeMutableProvider>;
+declare function realtimeMutableProvider({ socket, store, }: ServerConfig): <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable>(token: atom_io.MutableAtomToken<Core, SerializableCore>) => () => void;
+
+type MutableFamilyProvider = ReturnType<typeof realtimeMutableFamilyProvider>;
+declare function realtimeMutableFamilyProvider({ socket, store, }: ServerConfig): <T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(family: atom_io.MutableAtomFamily<T, J, K>, index: atom_io.ReadableToken<Iterable<K>>) => () => void;
 
+type StateReceiver = ReturnType<typeof realtimeStateReceiver>;
 declare function realtimeStateReceiver({ socket, store, }: ServerConfig): <J extends Json.Serializable>(token: WritableToken<J>) => () => void;
 
-declare const realtimeActionReceiver: ({ socket, store, }: ServerConfig) => <ƒ extends AtomIO.ƒn>(tx: AtomIO.TransactionToken<ƒ>) => () => void;
+type ActionReceiver = ReturnType<typeof realtimeActionReceiver>;
+declare function realtimeActionReceiver({ socket, store, }: ServerConfig): <ƒ extends atom_io.ƒn>(tx: atom_io.TransactionToken<ƒ>) => () => void;
 
-declare function realtimeActionSynchronizer({ socket, store, }: ServerConfig): <ƒ extends AtomIO.ƒn>(tx: AtomIO.TransactionToken<ƒ>, filter?: ((update: AtomIO.TransactionUpdateContent[]) => AtomIO.TransactionUpdateContent[]) | undefined) => () => void;
+type ActionSynchronizer = ReturnType<typeof realtimeActionSynchronizer>;
+declare function realtimeActionSynchronizer({ socket, store, }: ServerConfig): <ƒ extends atom_io.ƒn>(tx: atom_io.TransactionToken<ƒ>, filter?: ((update: atom_io.TransactionUpdateContent[]) => atom_io.TransactionUpdateContent[]) | undefined) => () => void;
 
 type ServerConfig = {
     socket: SocketIO.Socket;
     store?: Store;
 };
 
-export { type ServerConfig, realtimeActionReceiver, realtimeActionSynchronizer, realtimeFamilyProvider, realtimeMutableFamilyProvider, realtimeMutableProvider, realtimeStateProvider, realtimeStateReceiver };
+export { type ActionReceiver, type ActionSynchronizer, DEFAULT_USER_IN_ROOM_META, type FamilyProvider, type MutableFamilyProvider, type MutableProvider, type ServerConfig, type StateProvider, type StateReceiver, type UserInRoomMeta, completeUpdateAtoms, realtimeActionReceiver, realtimeActionSynchronizer, realtimeFamilyProvider, realtimeMutableFamilyProvider, realtimeMutableProvider, realtimeStateProvider, realtimeStateReceiver, realtimeStateSynchronizer, redactedUpdateSelectors, roomIndex, socketEpochSelectors, socketUnacknowledgedUpdatesSelectors, transactionRedactorAtoms, userEpochAtoms, userIndex, userUnacknowledgedUpdatesAtoms, usersInRooms, usersOfSockets };

package/realtime-server/dist/index.js

@@ -1,20 +1,124 @@
 import { __spreadProps, __spreadValues } from '../../dist/chunk-PZLG2HP3.js';
 import * as AtomIO7 from 'atom.io';
-import { setState } from 'atom.io';
-import { IMPLICIT, getJsonToken, getUpdateToken, subscribeToState, subscribeToTransaction } from 'atom.io/internal';
+import { atom, atomFamily, selectorFamily, setState } from 'atom.io';
+import { join } from 'atom.io/data';
+import { SetRTX } from 'atom.io/transceivers/set-rtx';
+import { IMPLICIT, getJsonToken, getUpdateToken, findInStore, subscribeToState, subscribeToTransaction } from 'atom.io/internal';
 import { parseJson } from 'atom.io/json';
 
+var userIndex = atom({
+  key: `usersIndex`,
+  mutable: true,
+  default: () => new SetRTX(),
+  toJson: (set) => set.toJSON(),
+  fromJson: (json) => SetRTX.fromJSON(json)
+});
+var usersOfSockets = join({
+  key: `usersOfSockets`,
+  between: [`user`, `socket`],
+  cardinality: `1:1`
+});
+var roomIndex = atom({
+  key: `conclaveIndex`,
+  default: () => new SetRTX(),
+  mutable: true,
+  toJson: (set) => set.toJSON(),
+  fromJson: (json) => SetRTX.fromJSON(json)
+});
+var DEFAULT_USER_IN_ROOM_META = {
+  enteredAtEpoch: 0
+};
+var usersInRooms = join(
+  {
+    key: `usersInRooms`,
+    between: [`room`, `user`],
+    cardinality: `1:n`
+  },
+  DEFAULT_USER_IN_ROOM_META
+);
+var completeUpdateAtoms = atomFamily({
+  key: `completeUpdate`,
+  default: null
+});
+var transactionRedactorAtoms = atomFamily({
+  key: `transactionRedactor`,
+  default: { filter: (updates) => updates }
+});
+var redactedUpdateSelectors = 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 userUnacknowledgedUpdatesAtoms = atomFamily({
+  key: `unacknowledgedUpdates`,
+  default: () => []
+});
+var socketUnacknowledgedUpdatesSelectors = selectorFamily({
+  key: `socketUnacknowledgedUpdates`,
+  get: (socketId) => ({ get, find }) => {
+    const userKeyState = find(usersOfSockets.states.userKeyOfSocket, socketId);
+    const userKey = get(userKeyState);
+    if (!userKey) {
+      return [];
+    }
+    const unacknowledgedUpdatesState = find(
+      userUnacknowledgedUpdatesAtoms,
+      userKey
+    );
+    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;
+    }
+    const unacknowledgedUpdatesState = find(
+      userUnacknowledgedUpdatesAtoms,
+      userKey
+    );
+    set(unacknowledgedUpdatesState, newUpdates);
+  }
+});
+var userEpochAtoms = atomFamily({
+  key: `clientEpoch`,
+  default: null
+});
+var socketEpochSelectors = 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);
+    if (!userKey) {
+      return;
+    }
+    const userEpochState = find(userEpochAtoms, userKey);
+    set(userEpochState, newEpoch);
+  }
+});
 function realtimeStateProvider({
   socket,
   store = IMPLICIT.STORE
 }) {
   return function stateProvider(token) {
-    let unsubscribeFromStateUpdates = null;
-    const fillUnsubRequest = () => {
-      socket.off(`unsub:${token.key}`, fillUnsubRequest);
-      unsubscribeFromStateUpdates == null ? void 0 : unsubscribeFromStateUpdates();
-      unsubscribeFromStateUpdates = null;
-    };
+    let unsubscribeFromStateUpdates;
     const fillSubRequest = () => {
       socket.emit(`serve:${token.key}`, AtomIO7.getState(token, store));
       unsubscribeFromStateUpdates = subscribeToState(
@@ -25,12 +129,36 @@ function realtimeStateProvider({
         `expose-single:${socket.id}`,
         store
       );
+      const fillUnsubRequest = () => {
+        socket.off(`unsub:${token.key}`, fillUnsubRequest);
+        if (unsubscribeFromStateUpdates) {
+          unsubscribeFromStateUpdates();
+          unsubscribeFromStateUpdates = void 0;
+        }
+      };
       socket.on(`unsub:${token.key}`, fillUnsubRequest);
     };
     socket.on(`sub:${token.key}`, fillSubRequest);
     return () => {
       socket.off(`sub:${token.key}`, fillSubRequest);
-      unsubscribeFromStateUpdates == null ? void 0 : unsubscribeFromStateUpdates();
+      if (unsubscribeFromStateUpdates) {
+        unsubscribeFromStateUpdates();
+        unsubscribeFromStateUpdates = void 0;
+      }
+    };
+  };
+}
+function realtimeStateSynchronizer({
+  socket,
+  store = IMPLICIT.STORE
+}) {
+  return function stateSynchronizer(token) {
+    const fillGetRequest = () => {
+      socket.emit(`value:${token.key}`, AtomIO7.getState(token, store));
+    };
+    socket.on(`get:${token.key}`, fillGetRequest);
+    return () => {
+      socket.off(`get:${token.key}`, fillGetRequest);
     };
   };
 }
@@ -61,7 +189,7 @@ function realtimeFamilyProvider({
       if (subKey === void 0) {
         const keys = AtomIO7.getState(index, store);
         for (const key of keys) {
-          const token = AtomIO7.findInStore(family, key, store);
+          const token = findInStore(family, key, store);
           socket.emit(
             `serve:${family.key}`,
             parseJson(((_a = token.family) == null ? void 0 : _a.subKey) || `null`),
@@ -152,10 +280,10 @@ function realtimeMutableProvider({
     };
   };
 }
-var realtimeMutableFamilyProvider = ({
+function realtimeMutableFamilyProvider({
   socket,
   store = IMPLICIT.STORE
-}) => {
+}) {
   return function mutableFamilyProvider(family, index) {
     const unsubSingleCallbacksByKey = /* @__PURE__ */ new Map();
     const unsubFamilyCallbacksByKey = /* @__PURE__ */ new Map();
@@ -179,7 +307,7 @@ var realtimeMutableFamilyProvider = ({
       if (subKey === void 0) {
         const keys = AtomIO7.getState(index, store);
         for (const key of keys) {
-          const token = family(key);
+          const token = findInStore(family, key, store);
           const jsonToken = getJsonToken(token);
           const trackerToken = getUpdateToken(token);
           socket.emit(
@@ -263,7 +391,7 @@ var realtimeMutableFamilyProvider = ({
       unsubSingleCallbacksByKey.clear();
     };
   };
-};
+}
 function realtimeStateReceiver({
   socket,
   store = IMPLICIT.STORE
@@ -285,17 +413,17 @@ function realtimeStateReceiver({
     };
   };
 }
-var realtimeActionReceiver = ({
+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);
-      AtomIO7.runTransaction(tx, store)(...update.params);
+      AtomIO7.runTransaction(tx, update.id, store)(...update.params);
       performance.mark(performanceKeyEnd);
       const metric = performance.measure(
         performanceKey,
@@ -307,69 +435,122 @@ var realtimeActionReceiver = ({
     socket.on(`tx-run:${tx.key}`, fillTransactionRequest);
     return () => socket.off(`tx-run:${tx.key}`, fillTransactionRequest);
   };
-};
-var completeUpdateAtoms = AtomIO7.atomFamily({
-  key: `completeUpdate`,
-  default: null
-});
-var transactionRedactorAtoms = AtomIO7.atomFamily({
-  key: `transactionRedactor`,
-  default: { filter: (updates) => updates }
-});
-var redactedUpdateSelectors = AtomIO7.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;
-  }
-});
-
-// realtime-server/src/realtime-action-synchronizer.ts
+}
 function realtimeActionSynchronizer({
   socket,
   store = IMPLICIT.STORE
 }) {
   return function actionSynchronizer(tx, filter) {
+    const userKeyState = findInStore(
+      usersOfSockets.states.userKeyOfSocket,
+      socket.id,
+      store
+    );
+    const userKey = AtomIO7.getState(userKeyState, store);
+    const socketUnacknowledgedUpdatesState = findInStore(
+      socketUnacknowledgedUpdatesSelectors,
+      socket.id,
+      store
+    );
+    const socketUnacknowledgedUpdates = AtomIO7.getState(
+      socketUnacknowledgedUpdatesState,
+      store
+    );
     if (filter) {
-      AtomIO7.setState(
-        AtomIO7.findState(transactionRedactorAtoms, tx.key),
-        { filter },
-        store
-      );
+      const redactorState = findInStore(transactionRedactorAtoms, tx.key, store);
+      AtomIO7.setState(redactorState, { filter }, store);
     }
     const fillTransactionRequest = (update) => {
-      AtomIO7.runTransaction(tx, store, update.id)(...update.params);
+      const performanceKey = `tx-run:${tx.key}:${update.id}`;
+      const performanceKeyStart = `${performanceKey}:start`;
+      const performanceKeyEnd = `${performanceKey}:end`;
+      performance.mark(performanceKeyStart);
+      AtomIO7.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 = () => {
-      const unsubscribe = subscribeToTransaction(
+      unsubscribeFromTransaction = subscribeToTransaction(
         tx,
         (update) => {
-          unsubscribe();
-          const updateState = AtomIO7.findState(completeUpdateAtoms, update.id);
+          const updateState = findInStore(completeUpdateAtoms, update.id, store);
           AtomIO7.setState(updateState, update, store);
           const toEmit = filter ? AtomIO7.getState(
-            AtomIO7.findState(redactedUpdateSelectors, [tx.key, update.id]),
+            findInStore(redactedUpdateSelectors, [tx.key, update.id], store),
             store
           ) : update;
+          AtomIO7.setState(
+            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}`, unsubscribe);
+      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 = findInStore(
+        socketEpochSelectors,
+        socket.id,
+        store
+      );
+      AtomIO7.setState(socketEpochState, epoch, store);
+      if (((_a = socketUnacknowledgedUpdates[0]) == null ? void 0 : _a.epoch) === epoch) {
+        AtomIO7.setState(
+          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);
     };
   };
 }
 
-export { realtimeActionReceiver, realtimeActionSynchronizer, realtimeFamilyProvider, realtimeMutableFamilyProvider, realtimeMutableProvider, realtimeStateProvider, realtimeStateReceiver };
+export { DEFAULT_USER_IN_ROOM_META, completeUpdateAtoms, realtimeActionReceiver, realtimeActionSynchronizer, realtimeFamilyProvider, realtimeMutableFamilyProvider, realtimeMutableProvider, realtimeStateProvider, realtimeStateReceiver, realtimeStateSynchronizer, redactedUpdateSelectors, roomIndex, socketEpochSelectors, socketUnacknowledgedUpdatesSelectors, transactionRedactorAtoms, userEpochAtoms, userIndex, userUnacknowledgedUpdatesAtoms, usersInRooms, usersOfSockets };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map