atom.io 0.19.4 → 0.20.1

package/realtime-react/src/use-realtime-service.ts

@@ -1,5 +1,6 @@
 import * as React from "react"
 import type { Socket } from "socket.io-client"
+
 import { onMount } from "./on-mount"
 import { RealtimeContext } from "./realtime-context"
 

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

@@ -1,7 +1,8 @@
 import { StoreContext } from "atom.io/react"
 import * as React from "react"
-import { syncContinuity } from "../../realtime-client/src/sync-continuity"
+
 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

@@ -344,6 +344,31 @@ var ParentSocket = class extends CustomSocket {
     this.relayServices.push(attachServices);
   }
 };
+function realtimeActionReceiver({
+  socket,
+  store = internal.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);
+      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.on(`tx-run:${tx.key}`, fillTransactionRequest);
+    return () => {
+      socket.off(`tx-run:${tx.key}`, fillTransactionRequest);
+    };
+  };
+}
 function capitalize(string) {
   return string[0].toUpperCase() + string.slice(1);
 }
@@ -913,55 +938,6 @@ function realtimeContinuitySynchronizer({
     };
   };
 }
-function realtimeStateProvider({
-  socket,
-  store = internal.IMPLICIT.STORE
-}) {
-  return function stateProvider(token) {
-    let unsubscribeFromStateUpdates;
-    const fillSubRequest = () => {
-      socket.emit(`serve:${token.key}`, internal.getFromStore(token, store));
-      unsubscribeFromStateUpdates = internal.subscribeToState(
-        token,
-        ({ newValue }) => {
-          socket.emit(`serve:${token.key}`, newValue);
-        },
-        `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);
-      if (unsubscribeFromStateUpdates) {
-        unsubscribeFromStateUpdates();
-        unsubscribeFromStateUpdates = void 0;
-      }
-    };
-  };
-}
-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);
-    };
-  };
-}
 function realtimeAtomFamilyProvider({
   socket,
   store = internal.IMPLICIT.STORE
@@ -1008,38 +984,6 @@ function realtimeAtomFamilyProvider({
     };
   };
 }
-function realtimeMutableProvider({
-  socket,
-  store = internal.IMPLICIT.STORE
-}) {
-  return function mutableProvider(token) {
-    let unsubscribeFromStateUpdates = null;
-    const jsonToken = internal.getJsonToken(token);
-    const trackerToken = internal.getUpdateToken(token);
-    const fillUnsubRequest = () => {
-      socket.off(`unsub:${token.key}`, fillUnsubRequest);
-      unsubscribeFromStateUpdates == null ? void 0 : unsubscribeFromStateUpdates();
-      unsubscribeFromStateUpdates = null;
-    };
-    const fillSubRequest = () => {
-      socket.emit(`init:${token.key}`, internal.getFromStore(jsonToken, store));
-      unsubscribeFromStateUpdates = internal.subscribeToState(
-        trackerToken,
-        ({ newValue }) => {
-          socket.emit(`next:${token.key}`, newValue);
-        },
-        `expose-single:${socket.id}`,
-        store
-      );
-      socket.on(`unsub:${token.key}`, fillUnsubRequest);
-    };
-    socket.on(`sub:${token.key}`, fillSubRequest);
-    return () => {
-      socket.off(`sub:${token.key}`, fillSubRequest);
-      unsubscribeFromStateUpdates == null ? void 0 : unsubscribeFromStateUpdates();
-    };
-  };
-}
 function realtimeMutableFamilyProvider({
   socket,
   store = internal.IMPLICIT.STORE
@@ -1088,6 +1032,73 @@ function realtimeMutableFamilyProvider({
     };
   };
 }
+function realtimeMutableProvider({
+  socket,
+  store = internal.IMPLICIT.STORE
+}) {
+  return function mutableProvider(token) {
+    let unsubscribeFromStateUpdates = null;
+    const jsonToken = internal.getJsonToken(token);
+    const trackerToken = internal.getUpdateToken(token);
+    const fillUnsubRequest = () => {
+      socket.off(`unsub:${token.key}`, fillUnsubRequest);
+      unsubscribeFromStateUpdates == null ? void 0 : unsubscribeFromStateUpdates();
+      unsubscribeFromStateUpdates = null;
+    };
+    const fillSubRequest = () => {
+      socket.emit(`init:${token.key}`, internal.getFromStore(jsonToken, store));
+      unsubscribeFromStateUpdates = internal.subscribeToState(
+        trackerToken,
+        ({ newValue }) => {
+          socket.emit(`next:${token.key}`, newValue);
+        },
+        `expose-single:${socket.id}`,
+        store
+      );
+      socket.on(`unsub:${token.key}`, fillUnsubRequest);
+    };
+    socket.on(`sub:${token.key}`, fillSubRequest);
+    return () => {
+      socket.off(`sub:${token.key}`, fillSubRequest);
+      unsubscribeFromStateUpdates == null ? void 0 : unsubscribeFromStateUpdates();
+    };
+  };
+}
+function realtimeStateProvider({
+  socket,
+  store = internal.IMPLICIT.STORE
+}) {
+  return function stateProvider(token) {
+    let unsubscribeFromStateUpdates;
+    const fillSubRequest = () => {
+      socket.emit(`serve:${token.key}`, internal.getFromStore(token, store));
+      unsubscribeFromStateUpdates = internal.subscribeToState(
+        token,
+        ({ newValue }) => {
+          socket.emit(`serve:${token.key}`, newValue);
+        },
+        `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);
+      if (unsubscribeFromStateUpdates) {
+        unsubscribeFromStateUpdates();
+        unsubscribeFromStateUpdates = void 0;
+      }
+    };
+  };
+}
 function realtimeStateReceiver({
   socket,
   store = internal.IMPLICIT.STORE
@@ -1111,28 +1122,17 @@ function realtimeStateReceiver({
     };
   };
 }
-function realtimeActionReceiver({
+function realtimeStateSynchronizer({
   socket,
   store = internal.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);
-      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);
+  return function stateSynchronizer(token) {
+    const fillGetRequest = () => {
+      socket.emit(`value:${token.key}`, internal.getFromStore(token, store));
     };
-    socket.on(`tx-run:${tx.key}`, fillTransactionRequest);
+    socket.on(`get:${token.key}`, fillGetRequest);
     return () => {
-      socket.off(`tx-run:${tx.key}`, fillTransactionRequest);
+      socket.off(`get:${token.key}`, fillGetRequest);
     };
   };
 }

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

@@ -1,9 +1,9 @@
 import { Subject, Transceiver, Store } from 'atom.io/internal';
 import { Json, Stringified, JsonIO } from 'atom.io/json';
 import { ChildProcessWithoutNullStreams } from 'node:child_process';
-import { ContinuityToken, UserInRoomMeta } from 'atom.io/realtime';
 import * as AtomIO from 'atom.io';
 import { TransactionUpdateContent, TransactionUpdate, WritableToken } from 'atom.io';
+import { ContinuityToken, UserInRoomMeta } from 'atom.io/realtime';
 import * as atom_io_data from 'atom.io/data';
 import { Loadable } from 'atom.io/data';
 import { SetRTX, SetRTXJson } from 'atom.io/transceivers/set-rtx';
@@ -81,9 +81,21 @@ declare class ParentSocket<I extends Events & {
     relay(attachServices: (socket: SubjectSocket<any, any>) => (() => void) | void): void;
 }
 
+type ActionReceiver = ReturnType<typeof realtimeActionReceiver>;
+declare function realtimeActionReceiver({ socket, store, }: ServerConfig): <F extends JsonIO>(tx: AtomIO.TransactionToken<F>) => () => void;
+
 type RealtimeContinuitySynchronizer = ReturnType<typeof realtimeContinuitySynchronizer>;
 declare function realtimeContinuitySynchronizer({ socket: initialSocket, store, }: ServerConfig): (continuity: ContinuityToken) => () => void;
 
+type FamilyProvider = ReturnType<typeof realtimeAtomFamilyProvider>;
+declare function realtimeAtomFamilyProvider({ socket, store, }: ServerConfig): <J extends Json.Serializable, K extends Json.Serializable>(family: AtomIO.RegularAtomFamilyToken<J, K>, index: AtomIO.ReadableToken<Iterable<K>>) => () => 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: AtomIO.MutableAtomFamilyToken<T, J, K>, index: AtomIO.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: AtomIO.MutableAtomToken<Core, SerializableCore>) => () => void;
+
 declare const createRoomTX: AtomIO.TransactionToken<(roomId: string, script: string, options?: string[]) => Loadable<ChildSocket<any, any>>>;
 type CreateRoomIO = AtomIO.TransactionIO<typeof createRoomTX>;
 declare const joinRoomTX: AtomIO.TransactionToken<(roomId: string, userId: string, enteredAtEpoch: number) => UserInRoomMeta>;
@@ -110,22 +122,10 @@ declare const usersOfSockets: atom_io_data.JoinToken<"user", "socket", "1:1", nu
 type StateProvider = ReturnType<typeof realtimeStateProvider>;
 declare function realtimeStateProvider({ socket, store, }: ServerConfig): <J extends Json.Serializable>(token: AtomIO.WritableToken<J>) => () => void;
 
-declare function realtimeStateSynchronizer({ socket, store, }: ServerConfig): <J extends Json.Serializable>(token: AtomIO.WritableToken<J>) => () => void;
-
-type FamilyProvider = ReturnType<typeof realtimeAtomFamilyProvider>;
-declare function realtimeAtomFamilyProvider({ socket, store, }: ServerConfig): <J extends Json.Serializable, K extends Json.Serializable>(family: AtomIO.RegularAtomFamilyToken<J, K>, index: AtomIO.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: AtomIO.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: AtomIO.MutableAtomFamilyToken<T, J, K>, index: AtomIO.ReadableToken<Iterable<K>>) => () => void;
-
 type StateReceiver = ReturnType<typeof realtimeStateReceiver>;
 declare function realtimeStateReceiver({ socket, store, }: ServerConfig): <J extends Json.Serializable>(token: WritableToken<J>) => () => void;
 
-type ActionReceiver = ReturnType<typeof realtimeActionReceiver>;
-declare function realtimeActionReceiver({ socket, store, }: ServerConfig): <F extends JsonIO>(tx: AtomIO.TransactionToken<F>) => () => void;
+declare function realtimeStateSynchronizer({ socket, store, }: ServerConfig): <J extends Json.Serializable>(token: AtomIO.WritableToken<J>) => () => void;
 
 type Socket = {
     id: string;

package/realtime-server/dist/index.js

@@ -1,8 +1,8 @@
-import { findRelationsInStore } from '../../dist/chunk-MSCJWACE.js';
+import { findRelationsInStore } from '../../dist/chunk-SMZRGPN6.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, isRootStore, subscribeToTransaction, actUponStore, setIntoStore } from 'atom.io/internal';
+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 * as AtomIO from 'atom.io';
 import { selectorFamily, atomFamily, atom } from 'atom.io';
@@ -306,6 +306,31 @@ 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 == null ? void 0 : 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);
+    };
+  };
+}
 selectorFamily({
   key: `perspectiveRedactor`,
   get: ({ userId, syncGroupKey }) => ({ get, find }) => {
@@ -743,55 +768,6 @@ function realtimeContinuitySynchronizer({
     };
   };
 }
-function realtimeStateProvider({
-  socket,
-  store = IMPLICIT.STORE
-}) {
-  return function stateProvider(token) {
-    let unsubscribeFromStateUpdates;
-    const fillSubRequest = () => {
-      socket.emit(`serve:${token.key}`, getFromStore(token, store));
-      unsubscribeFromStateUpdates = subscribeToState(
-        token,
-        ({ newValue }) => {
-          socket.emit(`serve:${token.key}`, newValue);
-        },
-        `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);
-      if (unsubscribeFromStateUpdates) {
-        unsubscribeFromStateUpdates();
-        unsubscribeFromStateUpdates = void 0;
-      }
-    };
-  };
-}
-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);
-    };
-  };
-}
 function realtimeAtomFamilyProvider({
   socket,
   store = IMPLICIT.STORE
@@ -838,38 +814,6 @@ function realtimeAtomFamilyProvider({
     };
   };
 }
-function realtimeMutableProvider({
-  socket,
-  store = IMPLICIT.STORE
-}) {
-  return function mutableProvider(token) {
-    let unsubscribeFromStateUpdates = null;
-    const jsonToken = getJsonToken(token);
-    const trackerToken = getUpdateToken(token);
-    const fillUnsubRequest = () => {
-      socket.off(`unsub:${token.key}`, fillUnsubRequest);
-      unsubscribeFromStateUpdates == null ? void 0 : unsubscribeFromStateUpdates();
-      unsubscribeFromStateUpdates = null;
-    };
-    const fillSubRequest = () => {
-      socket.emit(`init:${token.key}`, getFromStore(jsonToken, store));
-      unsubscribeFromStateUpdates = subscribeToState(
-        trackerToken,
-        ({ newValue }) => {
-          socket.emit(`next:${token.key}`, newValue);
-        },
-        `expose-single:${socket.id}`,
-        store
-      );
-      socket.on(`unsub:${token.key}`, fillUnsubRequest);
-    };
-    socket.on(`sub:${token.key}`, fillSubRequest);
-    return () => {
-      socket.off(`sub:${token.key}`, fillSubRequest);
-      unsubscribeFromStateUpdates == null ? void 0 : unsubscribeFromStateUpdates();
-    };
-  };
-}
 function realtimeMutableFamilyProvider({
   socket,
   store = IMPLICIT.STORE
@@ -918,6 +862,73 @@ function realtimeMutableFamilyProvider({
     };
   };
 }
+function realtimeMutableProvider({
+  socket,
+  store = IMPLICIT.STORE
+}) {
+  return function mutableProvider(token) {
+    let unsubscribeFromStateUpdates = null;
+    const jsonToken = getJsonToken(token);
+    const trackerToken = getUpdateToken(token);
+    const fillUnsubRequest = () => {
+      socket.off(`unsub:${token.key}`, fillUnsubRequest);
+      unsubscribeFromStateUpdates == null ? void 0 : unsubscribeFromStateUpdates();
+      unsubscribeFromStateUpdates = null;
+    };
+    const fillSubRequest = () => {
+      socket.emit(`init:${token.key}`, getFromStore(jsonToken, store));
+      unsubscribeFromStateUpdates = subscribeToState(
+        trackerToken,
+        ({ newValue }) => {
+          socket.emit(`next:${token.key}`, newValue);
+        },
+        `expose-single:${socket.id}`,
+        store
+      );
+      socket.on(`unsub:${token.key}`, fillUnsubRequest);
+    };
+    socket.on(`sub:${token.key}`, fillSubRequest);
+    return () => {
+      socket.off(`sub:${token.key}`, fillSubRequest);
+      unsubscribeFromStateUpdates == null ? void 0 : unsubscribeFromStateUpdates();
+    };
+  };
+}
+function realtimeStateProvider({
+  socket,
+  store = IMPLICIT.STORE
+}) {
+  return function stateProvider(token) {
+    let unsubscribeFromStateUpdates;
+    const fillSubRequest = () => {
+      socket.emit(`serve:${token.key}`, getFromStore(token, store));
+      unsubscribeFromStateUpdates = subscribeToState(
+        token,
+        ({ newValue }) => {
+          socket.emit(`serve:${token.key}`, newValue);
+        },
+        `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);
+      if (unsubscribeFromStateUpdates) {
+        unsubscribeFromStateUpdates();
+        unsubscribeFromStateUpdates = void 0;
+      }
+    };
+  };
+}
 function realtimeStateReceiver({
   socket,
   store = IMPLICIT.STORE
@@ -941,28 +952,17 @@ function realtimeStateReceiver({
     };
   };
 }
-function realtimeActionReceiver({
+function realtimeStateSynchronizer({
   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 == null ? void 0 : store.logger.info(`\u{1F680}`, `transaction`, tx.key, update.id, metric.duration);
+  return function stateSynchronizer(token) {
+    const fillGetRequest = () => {
+      socket.emit(`value:${token.key}`, getFromStore(token, store));
     };
-    socket.on(`tx-run:${tx.key}`, fillTransactionRequest);
+    socket.on(`get:${token.key}`, fillGetRequest);
     return () => {
-      socket.off(`tx-run:${tx.key}`, fillTransactionRequest);
+      socket.off(`get:${token.key}`, fillGetRequest);
     };
   };
 }

package/realtime-server/src/index.ts

@@ -2,15 +2,15 @@ import type { Store } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 
 export * from "./ipc-sockets"
+export * from "./realtime-action-receiver"
 export * from "./realtime-continuity-synchronizer"
-export * from "./realtime-server-stores"
-export * from "./realtime-state-provider"
-export * from "./realtime-state-synchronizer"
 export * from "./realtime-family-provider"
-export * from "./realtime-mutable-provider"
 export * from "./realtime-mutable-family-provider"
+export * from "./realtime-mutable-provider"
+export * from "./realtime-server-stores"
+export * from "./realtime-state-provider"
 export * from "./realtime-state-receiver"
-export * from "./realtime-action-receiver"
+export * from "./realtime-state-synchronizer"
 // export * from "./realtime-action-synchronizer.txt"
 
 export type Socket = {

package/realtime-server/src/ipc-sockets/parent-socket.ts

@@ -1,10 +1,10 @@
 import { IMPLICIT, Subject } from "atom.io/internal"
-import { parseJson, stringifyJson } from "atom.io/json"
 import type { Json } from "atom.io/json"
-
+import { parseJson, stringifyJson } from "atom.io/json"
 import { SetRTX } from "atom.io/transceivers/set-rtx"
-import { CustomSocket } from "./custom-socket"
+
 import type { EventBuffer, Events } from "./custom-socket"
+import { CustomSocket } from "./custom-socket"
 
 export class SubjectSocket<
 	I extends Events,

package/realtime-server/src/realtime-action-receiver.ts

@@ -1,5 +1,5 @@
 import type * as AtomIO from "atom.io"
-import { IMPLICIT, actUponStore } from "atom.io/internal"
+import { actUponStore, IMPLICIT } from "atom.io/internal"
 import type { JsonIO } from "atom.io/json"
 
 import type { ServerConfig } from "."

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

@@ -1,10 +1,10 @@
 import type * as AtomIO from "atom.io"
 import {
-	IMPLICIT,
 	actUponStore,
 	findInStore,
 	getFromStore,
 	getJsonToken,
+	IMPLICIT,
 	isRootStore,
 	subscribeToState,
 	subscribeToTransaction,
@@ -12,10 +12,9 @@ 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 { findRelationsInStore } from "../../data/src/join"
 import {
 	redactTransactionUpdateContent,
 	userUnacknowledgedQueues,

package/realtime-server/src/realtime-family-provider.ts

@@ -1,8 +1,8 @@
 import type * as AtomIO from "atom.io"
 import {
-	IMPLICIT,
 	findInStore,
 	getFromStore,
+	IMPLICIT,
 	subscribeToState,
 } from "atom.io/internal"
 import { type Json, stringifyJson } from "atom.io/json"

package/realtime-server/src/realtime-mutable-family-provider.ts

@@ -1,11 +1,11 @@
 import type * as AtomIO from "atom.io"
 import type { Transceiver } from "atom.io/internal"
 import {
-	IMPLICIT,
 	findInStore,
 	getFromStore,
 	getJsonToken,
 	getUpdateToken,
+	IMPLICIT,
 	subscribeToState,
 } from "atom.io/internal"
 import type { Json } from "atom.io/json"

package/realtime-server/src/realtime-mutable-provider.ts

@@ -1,12 +1,12 @@
 import type * as AtomIO from "atom.io"
+import type { Transceiver } from "atom.io/internal"
 import {
-	IMPLICIT,
 	getFromStore,
 	getJsonToken,
 	getUpdateToken,
+	IMPLICIT,
 	subscribeToState,
 } from "atom.io/internal"
-import type { Transceiver } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 
 import type { ServerConfig } from "."

package/realtime-server/src/realtime-server-stores/realtime-continuity-store.ts

@@ -1,6 +1,6 @@
-import { selectorFamily } from "atom.io"
 import type { TransactionUpdate } from "atom.io"
-import { IMPLICIT, getJsonToken, getUpdateToken } from "atom.io/internal"
+import { selectorFamily } from "atom.io"
+import { getJsonToken, getUpdateToken, IMPLICIT } from "atom.io/internal"
 import type { JsonIO } from "atom.io/json"
 import { SyncGroup } from "atom.io/realtime"
 // import { completeUpdateAtoms } from "atom.io/realtime-server"

package/realtime-server/src/realtime-server-stores/server-room-external-actions.ts

@@ -1,5 +1,5 @@
 import * as AtomIO from "atom.io"
-import { type Loadable, editRelations, editRelationsInStore } from "atom.io/data"
+import { editRelations, editRelationsInStore, type Loadable } from "atom.io/data"
 import type { UserInRoomMeta } from "atom.io/realtime"
 import { roomIndex, usersInRooms } from "atom.io/realtime"