atom.io 0.23.5 → 0.24.1

package/realtime-react/dist/index.cjs

@@ -169,335 +169,10 @@ function useServerAction(token) {
   );
   return internal.actUponStore(token, internal.arbitrary(), store);
 }
-function syncContinuity(continuity, socket, store) {
-  const continuityKey = continuity.key;
-  const optimisticUpdates = internal.getFromStore(RTC.optimisticUpdateQueue, store);
-  const confirmedUpdates = internal.getFromStore(RTC.confirmedUpdateQueue, store);
-  const initializeContinuity = (epoch, payload) => {
-    socket.off(`continuity-init:${continuityKey}`, initializeContinuity);
-    let i = 0;
-    let k = ``;
-    let v = null;
-    for (const x of payload) {
-      if (i % 2 === 0) {
-        k = x;
-      } else {
-        v = x;
-        if (`type` in k && k.type === `mutable_atom`) {
-          k = internal.getJsonToken(k, store);
-        }
-        internal.setIntoStore(k, v, store);
-      }
-      i++;
-    }
-    internal.setEpochNumberOfContinuity(continuityKey, epoch, store);
-  };
-  socket.off(`continuity-init:${continuityKey}`);
-  socket.on(`continuity-init:${continuityKey}`, initializeContinuity);
-  const registerAndAttemptConfirmedUpdate = (confirmed) => {
-    function reconcileEpoch(optimisticUpdate, confirmedUpdate) {
-      store.logger.info(
-        `\u{1F9D1}\u200D\u2696\uFE0F`,
-        `continuity`,
-        continuityKey,
-        `reconciling updates`
-      );
-      internal.setIntoStore(
-        RTC.optimisticUpdateQueue,
-        (queue) => {
-          queue.shift();
-          return queue;
-        },
-        store
-      );
-      if (optimisticUpdate.id === confirmedUpdate.id) {
-        const clientResult = JSON.stringify(optimisticUpdate.updates);
-        const serverResult = JSON.stringify(confirmedUpdate.updates);
-        if (clientResult === serverResult) {
-          store.logger.info(
-            `\u2705`,
-            `continuity`,
-            continuityKey,
-            `results for ${optimisticUpdate.id} match between client and server`
-          );
-          socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch);
-          return;
-        }
-      } else {
-        store.logger.info(
-          `\u274C`,
-          `continuity`,
-          continuityKey,
-          `thought update #${confirmedUpdate.epoch} was ${optimisticUpdate.key}:${optimisticUpdate.id}, but it was actually ${confirmedUpdate.key}:${confirmedUpdate.id}`
-        );
-      }
-      store.logger.info(
-        `\u{1F9D1}\u200D\u2696\uFE0F`,
-        `continuity`,
-        continuityKey,
-        `updates do not match`,
-        optimisticUpdate,
-        confirmedUpdate
-      );
-      const reversedOptimisticUpdates = optimisticUpdates.toReversed();
-      for (const subsequentOptimistic of reversedOptimisticUpdates) {
-        internal.ingestTransactionUpdate(`oldValue`, subsequentOptimistic, store);
-      }
-      store.logger.info(
-        `\u23EA`,
-        `continuity`,
-        continuityKey,
-        `undid optimistic updates:`,
-        reversedOptimisticUpdates
-      );
-      internal.ingestTransactionUpdate(`oldValue`, optimisticUpdate, store);
-      store.logger.info(
-        `\u23EA`,
-        `continuity`,
-        continuityKey,
-        `undid zeroth optimistic update`,
-        optimisticUpdate
-      );
-      internal.ingestTransactionUpdate(`newValue`, confirmedUpdate, store);
-      store.logger.info(
-        `\u23E9`,
-        `continuity`,
-        continuityKey,
-        `applied confirmed update`,
-        confirmedUpdate
-      );
-      socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch);
-      for (const subsequentOptimistic of optimisticUpdates) {
-        const token = {
-          type: `transaction`,
-          key: subsequentOptimistic.key
-        };
-        const { id, params } = subsequentOptimistic;
-        internal.actUponStore(token, id, store)(...params);
-      }
-      store.logger.info(
-        `\u23E9`,
-        `continuity`,
-        continuityKey,
-        `reapplied subsequent optimistic updates:`,
-        optimisticUpdates
-      );
-    }
-    store.logger.info(
-      `\u{1F9D1}\u200D\u2696\uFE0F`,
-      `continuity`,
-      continuityKey,
-      `integrating confirmed update`,
-      { confirmedUpdate: confirmed, confirmedUpdates, optimisticUpdates }
-    );
-    const zerothOptimisticUpdate = optimisticUpdates[0];
-    if (zerothOptimisticUpdate) {
-      store.logger.info(
-        `\u{1F9D1}\u200D\u2696\uFE0F`,
-        `continuity`,
-        continuityKey,
-        `has optimistic updates to reconcile`
-      );
-      if (confirmed.epoch === zerothOptimisticUpdate.epoch) {
-        store.logger.info(
-          `\u{1F9D1}\u200D\u2696\uFE0F`,
-          `continuity`,
-          continuityKey,
-          `epoch of confirmed update #${confirmed.epoch} matches zeroth optimistic update`
-        );
-        reconcileEpoch(zerothOptimisticUpdate, confirmed);
-        for (const nextConfirmed of confirmedUpdates) {
-          const nextOptimistic = optimisticUpdates[0];
-          if (nextConfirmed.epoch === (nextOptimistic == null ? void 0 : nextOptimistic.epoch)) {
-            reconcileEpoch(nextOptimistic, nextConfirmed);
-          } else {
-            break;
-          }
-        }
-      } else {
-        store.logger.info(
-          `\u{1F9D1}\u200D\u2696\uFE0F`,
-          `continuity`,
-          continuityKey,
-          `epoch of confirmed update #${confirmed.epoch} does not match zeroth optimistic update #${zerothOptimisticUpdate.epoch}`
-        );
-        const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
-          (update) => update.epoch === confirmed.epoch
-        );
-        if (!confirmedUpdateIsAlreadyEnqueued) {
-          store.logger.info(
-            `\u{1F448}`,
-            `continuity`,
-            continuityKey,
-            `pushing confirmed update to queue`,
-            confirmed
-          );
-          internal.setIntoStore(
-            RTC.confirmedUpdateQueue,
-            (queue) => {
-              queue.push(confirmed);
-              queue.sort((a, b) => a.epoch - b.epoch);
-              return queue;
-            },
-            store
-          );
-        }
-      }
-    } else {
-      store.logger.info(
-        `\u{1F9D1}\u200D\u2696\uFE0F`,
-        `continuity`,
-        continuityKey,
-        `has no optimistic updates to deal with`
-      );
-      const continuityEpoch = internal.getEpochNumberOfContinuity(continuityKey, store);
-      const isRoot = internal.isRootStore(store);
-      if (isRoot && continuityEpoch === confirmed.epoch - 1) {
-        store.logger.info(
-          `\u2705`,
-          `continuity`,
-          continuityKey,
-          `integrating update #${confirmed.epoch} (${confirmed.key} ${confirmed.id})`
-        );
-        internal.ingestTransactionUpdate(`newValue`, confirmed, store);
-        socket.emit(`ack:${continuityKey}`, confirmed.epoch);
-        internal.setEpochNumberOfContinuity(continuityKey, confirmed.epoch, store);
-      } else if (isRoot && continuityEpoch !== void 0) {
-        store.logger.info(
-          `\u{1F9D1}\u200D\u2696\uFE0F`,
-          `continuity`,
-          continuityKey,
-          `received update #${confirmed.epoch} but still waiting for update #${continuityEpoch + 1}`,
-          {
-            clientEpoch: continuityEpoch,
-            serverEpoch: confirmed.epoch
-          }
-        );
-        const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
-          (update) => update.epoch === confirmed.epoch
-        );
-        if (confirmedUpdateIsAlreadyEnqueued) {
-          store.logger.info(
-            `\u{1F44D}`,
-            `continuity`,
-            continuityKey,
-            `confirmed update #${confirmed.epoch} is already enqueued`
-          );
-        } else {
-          store.logger.info(
-            `\u{1F448}`,
-            `continuity`,
-            continuityKey,
-            `pushing confirmed update #${confirmed.epoch} to queue`
-          );
-          internal.setIntoStore(
-            RTC.confirmedUpdateQueue,
-            (queue) => {
-              queue.push(confirmed);
-              queue.sort((a, b) => a.epoch - b.epoch);
-              return queue;
-            },
-            store
-          );
-        }
-      }
-    }
-  };
-  socket.off(`tx-new:${continuityKey}`);
-  socket.on(`tx-new:${continuityKey}`, registerAndAttemptConfirmedUpdate);
-  const unsubscribeFunctions = continuity.actions.map((transaction) => {
-    internal.assignTransactionToContinuity(continuityKey, transaction.key, store);
-    const unsubscribeFromTransactionUpdates = internal.subscribeToTransaction(
-      transaction,
-      (clientUpdate) => {
-        store.logger.info(
-          `\u{1F91E}`,
-          `continuity`,
-          continuityKey,
-          `enqueuing optimistic update`
-        );
-        const optimisticUpdateIndex = optimisticUpdates.findIndex(
-          (update) => update.id === clientUpdate.id
-        );
-        if (optimisticUpdateIndex === -1) {
-          store.logger.info(
-            `\u{1F91E}`,
-            `continuity`,
-            continuityKey,
-            `enqueuing new optimistic update`
-          );
-          internal.setIntoStore(
-            RTC.optimisticUpdateQueue,
-            (queue) => {
-              queue.push(clientUpdate);
-              queue.sort((a, b) => a.epoch - b.epoch);
-              return queue;
-            },
-            store
-          );
-        } else {
-          store.logger.info(
-            `\u{1F91E}`,
-            `continuity`,
-            continuityKey,
-            `replacing existing optimistic update at index ${optimisticUpdateIndex}`
-          );
-          internal.setIntoStore(
-            RTC.optimisticUpdateQueue,
-            (queue) => {
-              queue[optimisticUpdateIndex] = clientUpdate;
-              return queue;
-            },
-            store
-          );
-        }
-        socket.emit(`tx-run:${continuityKey}`, {
-          id: clientUpdate.id,
-          key: transaction.key,
-          params: clientUpdate.params
-        });
-      },
-      `tx-run:${continuityKey}`,
-      store
-    );
-    return unsubscribeFromTransactionUpdates;
-  });
-  socket.on(`reveal:${continuityKey}`, (revealed) => {
-    let i = 0;
-    let k = ``;
-    let v = null;
-    for (const x of revealed) {
-      if (i % 2 === 0) {
-        k = x;
-      } else {
-        v = x;
-        internal.setIntoStore(k, v, store);
-      }
-      i++;
-    }
-  });
-  socket.on(
-    `conceal:${continuityKey}`,
-    (concealed) => {
-      for (const token of concealed) {
-        internal.disposeAtom(token, store);
-      }
-    }
-  );
-  socket.emit(`get:${continuityKey}`);
-  return () => {
-    socket.off(`continuity-init:${continuityKey}`);
-    socket.off(`tx-new:${continuityKey}`);
-    for (const unsubscribe of unsubscribeFunctions)
-      unsubscribe();
-  };
-}
-
-// realtime-react/src/use-sync-continuity.ts
 function useSyncContinuity(token) {
   const store = React__namespace.useContext(react.StoreContext);
   useRealtimeService(`tx-sync:${token.key}`, (socket) => {
-    return syncContinuity(token, socket, store);
+    return RTC.syncContinuity(token, socket, store);
   });
 }
 

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

@@ -1,9 +1,9 @@
 import * as React from 'react';
 import { Socket } from 'socket.io-client';
 import * as AtomIO from 'atom.io';
-import { AtomToken, TransactionToken, AtomFamilyToken, ReadableFamilyToken, ReadableToken } from 'atom.io';
 import { Json } from 'atom.io/json';
 import { Transceiver } from 'atom.io/internal';
+import { ContinuityToken } from 'atom.io/realtime';
 
 type RealtimeReactStore = {
     socket: Socket | null;
@@ -34,19 +34,6 @@ declare function usePush<J extends Json.Serializable>(token: AtomIO.WritableToke
 
 declare function useServerAction<F extends AtomIO.Func>(token: AtomIO.TransactionToken<F>): (...parameters: Parameters<F>) => ReturnType<F>;
 
-type PerspectiveToken<F extends AtomFamilyToken<any>, T extends F extends AtomFamilyToken<infer U, any> ? U : never> = {
-    type: `realtime_perspective`;
-    resourceAtoms: F;
-    viewAtoms: ReadableFamilyToken<ReadableToken<T>[], string>;
-};
-type ContinuityToken = {
-    readonly type: `continuity`;
-    readonly key: string;
-    readonly globals: AtomToken<any>[];
-    readonly actions: TransactionToken<any>[];
-    readonly perspectives: PerspectiveToken<AtomFamilyToken<any, Json.Serializable>, Json.Serializable>[];
-};
-
 declare function useSyncContinuity(token: ContinuityToken): void;
 
 export { RealtimeContext, RealtimeProvider, type RealtimeReactStore, usePullAtom, usePullAtomFamilyMember, usePullMutable, usePullMutableAtomFamilyMember, usePullSelector, usePullSelectorFamilyMember, usePush, useServerAction, useSyncContinuity };

package/realtime-react/dist/index.js

@@ -1,7 +1,7 @@
-import { syncContinuity } from '../../dist/chunk-GVHKIJ3G.js';
 import '../../dist/chunk-F2X4B4VY.js';
 import { useI, StoreContext, useO } from 'atom.io/react';
 import * as RTC from 'atom.io/realtime-client';
+import { syncContinuity } from 'atom.io/realtime-client';
 import * as React from 'react';
 import { jsx } from 'react/jsx-runtime';
 import { findInStore, actUponStore, arbitrary } from 'atom.io/internal';

package/realtime-react/src/use-sync-continuity.ts

@@ -1,8 +1,8 @@
 import { StoreContext } from "atom.io/react"
+import type { ContinuityToken } from "atom.io/realtime"
+import { syncContinuity } from "atom.io/realtime-client"
 import * as React from "react"
 
-import type { ContinuityToken } from "../../realtime/src/realtime-continuity"
-import { syncContinuity } from "../../realtime-client/src/sync-continuity"
 import { useRealtimeService } from "./use-realtime-service"
 
 export function useSyncContinuity(token: ContinuityToken): void {

package/realtime-server/dist/index.cjs

@@ -3,10 +3,9 @@
 var json = require('atom.io/json');
 var internal = require('atom.io/internal');
 var setRtx = require('atom.io/transceivers/set-rtx');
+var data = require('atom.io/data');
 var AtomIO = require('atom.io');
-require('atom.io/immortal');
 var realtime = require('atom.io/realtime');
-var data = require('atom.io/data');
 var child_process = require('child_process');
 
 function _interopNamespace(e) {
@@ -370,138 +369,6 @@ function realtimeActionReceiver({
     };
   };
 }
-function capitalize(string) {
-  return string[0].toUpperCase() + string.slice(1);
-}
-function getJoinMap(store) {
-  if (`joins` in store && store.joins instanceof Map) {
-    return store.joins;
-  }
-  const joins = /* @__PURE__ */ new Map();
-  store.joins = joins;
-  return joins;
-}
-function getJoin(token, store) {
-  var _a;
-  const joinMap = getJoinMap(store);
-  let myJoin = joinMap.get(token.key);
-  if (myJoin === void 0) {
-    const rootJoinMap = getJoinMap(internal.IMPLICIT.STORE);
-    myJoin = (_a = rootJoinMap.get(token.key)) == null ? void 0 : _a.in(store);
-    if (myJoin === void 0) {
-      throw new Error(
-        `Join "${token.key}" not found in store "${store.config.name}"`
-      );
-    }
-    joinMap.set(token.key, myJoin);
-  }
-  return myJoin;
-}
-function findRelationsInStore(token, key, store) {
-  const myJoin = getJoin(token, store);
-  let relations;
-  switch (token.cardinality) {
-    case `1:1`: {
-      const keyAB = `${token.a}KeyOf${capitalize(token.b)}`;
-      const keyBA = `${token.b}KeyOf${capitalize(token.a)}`;
-      relations = {
-        get [keyAB]() {
-          const familyAB = myJoin.states[keyAB];
-          const state = myJoin.retrieve(familyAB, key);
-          return state;
-        },
-        get [keyBA]() {
-          const familyBA = myJoin.states[keyBA];
-          const state = myJoin.retrieve(familyBA, key);
-          return state;
-        }
-      };
-      const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
-      if (entryAB in myJoin.states) {
-        const entryBA = `${token.b}EntryOf${capitalize(token.a)}`;
-        Object.assign(relations, {
-          get [entryAB]() {
-            const familyAB = myJoin.states[entryAB];
-            const state = myJoin.retrieve(familyAB, key);
-            return state;
-          },
-          get [entryBA]() {
-            const familyBA = myJoin.states[entryBA];
-            const state = myJoin.retrieve(familyBA, key);
-            return state;
-          }
-        });
-      }
-      break;
-    }
-    case `1:n`: {
-      const keyAB = `${token.a}KeyOf${capitalize(token.b)}`;
-      const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
-      relations = {
-        get [keyAB]() {
-          const familyAB = myJoin.states[keyAB];
-          const state = myJoin.retrieve(familyAB, key);
-          return state;
-        },
-        get [keysBA]() {
-          const familyBA = myJoin.states[keysBA];
-          const state = myJoin.retrieve(familyBA, key);
-          return state;
-        }
-      };
-      const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
-      if (entryAB in myJoin.states) {
-        const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
-        Object.assign(relations, {
-          get [entryAB]() {
-            const familyAB = myJoin.states[entryAB];
-            const state = myJoin.retrieve(familyAB, key);
-            return state;
-          },
-          get [entriesBA]() {
-            const familyBA = myJoin.states[entriesBA];
-            const state = myJoin.retrieve(familyBA, key);
-            return state;
-          }
-        });
-      }
-      break;
-    }
-    case `n:n`: {
-      const keysAB = `${token.a}KeysOf${capitalize(token.b)}`;
-      const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
-      relations = {
-        get [keysAB]() {
-          const familyAB = myJoin.states[keysAB];
-          const state = myJoin.retrieve(familyAB, key);
-          return state;
-        },
-        get [keysBA]() {
-          const familyBA = myJoin.states[keysBA];
-          const state = myJoin.retrieve(familyBA, key);
-          return state;
-        }
-      };
-      const entriesAB = `${token.a}EntriesOf${capitalize(token.b)}`;
-      if (entriesAB in myJoin.states) {
-        const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
-        Object.assign(relations, {
-          get [entriesAB]() {
-            const familyAB = myJoin.states[entriesAB];
-            const state = myJoin.retrieve(familyAB, key);
-            return state;
-          },
-          get [entriesBA]() {
-            const familyBA = myJoin.states[entriesBA];
-            const state = myJoin.retrieve(familyBA, key);
-            return state;
-          }
-        });
-      }
-    }
-  }
-  return relations;
-}
 AtomIO.selectorFamily({
   key: `perspectiveRedactor`,
   get: ({ userId, syncGroupKey }) => ({ get, find }) => {
@@ -708,7 +575,7 @@ function realtimeContinuitySynchronizer({
   return function synchronizer(continuity) {
     let socket = initialSocket;
     const continuityKey = continuity.key;
-    const userKeyState = findRelationsInStore(
+    const userKeyState = data.findRelationsInStore(
       usersOfSockets,
       socket.id,
       store
@@ -724,7 +591,7 @@ function realtimeContinuitySynchronizer({
       return () => {
       };
     }
-    const socketKeyState = findRelationsInStore(
+    const socketKeyState = data.findRelationsInStore(
       usersOfSockets,
       userKey,
       store
@@ -1134,20 +1001,6 @@ function realtimeStateReceiver({
     };
   };
 }
-function realtimeStateSynchronizer({
-  socket,
-  store = internal.IMPLICIT.STORE
-}) {
-  return function stateSynchronizer(token) {
-    const fillGetRequest = () => {
-      socket.emit(`value:${token.key}`, internal.getFromStore(token, store));
-    };
-    socket.on(`get:${token.key}`, fillGetRequest);
-    return () => {
-      socket.off(`get:${token.key}`, fillGetRequest);
-    };
-  };
-}
 
 exports.ChildSocket = ChildSocket;
 exports.CustomSocket = CustomSocket;
@@ -1165,7 +1018,6 @@ exports.realtimeMutableFamilyProvider = realtimeMutableFamilyProvider;
 exports.realtimeMutableProvider = realtimeMutableProvider;
 exports.realtimeStateProvider = realtimeStateProvider;
 exports.realtimeStateReceiver = realtimeStateReceiver;
-exports.realtimeStateSynchronizer = realtimeStateSynchronizer;
 exports.redactTransactionUpdateContent = redactTransactionUpdateContent;
 exports.roomArgumentsAtoms = roomArgumentsAtoms;
 exports.roomSelectors = roomSelectors;

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

@@ -125,8 +125,6 @@ declare function realtimeStateProvider({ socket, store, }: ServerConfig): <J ext
 type StateReceiver = ReturnType<typeof realtimeStateReceiver>;
 declare function realtimeStateReceiver({ socket, store, }: ServerConfig): <J extends Json.Serializable>(token: WritableToken<J>) => () => void;
 
-declare function realtimeStateSynchronizer({ socket, store, }: ServerConfig): <J extends Json.Serializable>(token: AtomIO.WritableToken<J>) => () => void;
-
 type Socket = {
     id: string;
     on: (event: string, listener: (...args: Json.Serializable[]) => void) => void;
@@ -140,4 +138,4 @@ type ServerConfig = {
     store?: Store;
 };
 
-export { type ActionReceiver, ChildSocket, type CreateRoomIO, CustomSocket, type EventBuffer, type Events, type FamilyProvider, type JoinRoomIO, type LeaveRoomIO, type MutableFamilyProvider, type MutableProvider, ParentSocket, type RealtimeContinuitySynchronizer, type RoomArguments, type ServerConfig, type Socket, type StateProvider, type StateReceiver, type StringifiedEvent, SubjectSocket, actionOcclusionAtoms, createRoomTX, destroyRoomTX, joinRoomTX, leaveRoomTX, realtimeActionReceiver, realtimeAtomFamilyProvider, realtimeContinuitySynchronizer, realtimeMutableFamilyProvider, realtimeMutableProvider, realtimeStateProvider, realtimeStateReceiver, realtimeStateSynchronizer, redactTransactionUpdateContent, roomArgumentsAtoms, roomSelectors, socketAtoms, socketIndex, userIndex, userUnacknowledgedQueues, usersOfSockets };
+export { type ActionReceiver, ChildSocket, type CreateRoomIO, CustomSocket, type EventBuffer, type Events, type FamilyProvider, type JoinRoomIO, type LeaveRoomIO, type MutableFamilyProvider, type MutableProvider, ParentSocket, type RealtimeContinuitySynchronizer, type RoomArguments, type ServerConfig, type Socket, type StateProvider, type StateReceiver, type StringifiedEvent, SubjectSocket, actionOcclusionAtoms, createRoomTX, destroyRoomTX, joinRoomTX, leaveRoomTX, realtimeActionReceiver, realtimeAtomFamilyProvider, realtimeContinuitySynchronizer, realtimeMutableFamilyProvider, realtimeMutableProvider, realtimeStateProvider, realtimeStateReceiver, redactTransactionUpdateContent, roomArgumentsAtoms, roomSelectors, socketAtoms, socketIndex, userIndex, userUnacknowledgedQueues, usersOfSockets };

package/realtime-server/dist/index.js

@@ -1,13 +1,11 @@
-import { findRelationsInStore } from '../../dist/chunk-7DT3PVS3.js';
-import '../../dist/chunk-FTONNX2R.js';
 import { __spreadProps, __spreadValues } from '../../dist/chunk-F2X4B4VY.js';
 import { parseJson, stringifyJson } from 'atom.io/json';
 import { getUpdateToken, IMPLICIT, Subject, getFromStore, subscribeToState, findInStore, getJsonToken, 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 * as AtomIO from 'atom.io';
 import { selectorFamily, atomFamily, atom } from 'atom.io';
 import { SyncGroup, roomIndex, usersInRooms } from 'atom.io/realtime';
-import { editRelationsInStore, join } from 'atom.io/data';
 import { spawn } from 'child_process';
 
 // realtime-server/src/ipc-sockets/custom-socket.ts
@@ -963,19 +961,5 @@ function realtimeStateReceiver({
     };
   };
 }
-function realtimeStateSynchronizer({
-  socket,
-  store = IMPLICIT.STORE
-}) {
-  return function stateSynchronizer(token) {
-    const fillGetRequest = () => {
-      socket.emit(`value:${token.key}`, getFromStore(token, store));
-    };
-    socket.on(`get:${token.key}`, fillGetRequest);
-    return () => {
-      socket.off(`get:${token.key}`, fillGetRequest);
-    };
-  };
-}
 
-export { ChildSocket, CustomSocket, ParentSocket, SubjectSocket, actionOcclusionAtoms, createRoomTX, destroyRoomTX, joinRoomTX, leaveRoomTX, realtimeActionReceiver, realtimeAtomFamilyProvider, realtimeContinuitySynchronizer, realtimeMutableFamilyProvider, realtimeMutableProvider, realtimeStateProvider, realtimeStateReceiver, realtimeStateSynchronizer, redactTransactionUpdateContent, roomArgumentsAtoms, roomSelectors, socketAtoms, socketIndex, userIndex, userUnacknowledgedQueues, usersOfSockets };
+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 };

package/realtime-server/src/index.ts

@@ -10,8 +10,6 @@ export * from "./realtime-mutable-provider"
 export * from "./realtime-server-stores"
 export * from "./realtime-state-provider"
 export * from "./realtime-state-receiver"
-export * from "./realtime-state-synchronizer"
-// export * from "./realtime-action-synchronizer.txt"
 
 export type Socket = {
 	id: string

package/realtime-server/src/realtime-continuity-synchronizer.ts

@@ -1,4 +1,5 @@
 import type * as AtomIO from "atom.io"
+import { findRelationsInStore } from "atom.io/data"
 import {
 	actUponStore,
 	findInStore,
@@ -12,7 +13,6 @@ import {
 import type { Json, JsonIO } from "atom.io/json"
 import type { ContinuityToken } from "atom.io/realtime"
 
-import { findRelationsInStore } from "../../data/src/join"
 import type { ServerConfig, Socket } from "."
 import { socketAtoms, usersOfSockets } from "."
 import {