atom.io 0.19.3 → 0.20.0

package/react-devtools/dist/index.js

@@ -1,4 +1,4 @@
-import { pipe, ifDefined, isArray, isRecord, doesExtend, isPlainObject, raiseError, sprawl, recordToEntries, fallback, doNothing, become, mapObject, delve } from '../../dist/chunk-CC7IF7QF.js';
+import { pipe, ifDefined, isArray, isRecord, doesExtend, isPlainObject, raiseError, sprawl, recordToEntries, fallback, doNothing, become, mapObject, delve } from '../../dist/chunk-3V3VWQ7X.js';
 import { lazyLocalStorageEffect } from '../../dist/chunk-BWWVY5O5.js';
 import { JSON_TYPE_NAMES, isString, isNumber, isBoolean, stringifyJson, JSON_DEFAULTS } from '../../dist/chunk-BF4MVQF6.js';
 import { __spreadProps, __spreadValues, __objRest, __restKey } from '../../dist/chunk-F2X4B4VY.js';
@@ -9,6 +9,82 @@ import { motion, spring, LayoutGroup } from 'framer-motion';
 import { forwardRef, useRef, useState, useImperativeHandle, useLayoutEffect, Fragment as Fragment$1, Component, useId } from 'react';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 
+// ../anvl/src/refinement/can-exist.ts
+var canExist = (_) => true;
+
+// ../anvl/src/refinement/cannot-exist.ts
+var cannotExist = (_) => false;
+
+// ../anvl/src/refinement/is-intersection.ts
+function mustSatisfyAllOfTheFollowing(isTypeA, logging = false, refinements = [isTypeA]) {
+  const name = `(${refinements.map((r) => (r == null ? void 0 : r.name) || `anon`).join(` & `)})`;
+  const _ = {
+    [name]: (input) => refinements.every(
+      (refinement) => (logging && console.log(
+        refinements.map((r) => r.name || `anon`).join(` & `),
+        `>`,
+        refinement.name || `anon`,
+        `:`,
+        refinement(input)
+      ), refinement(input))
+    )
+  };
+  const checkTypes = Object.assign(_[name], {
+    and: (isTypeB) => mustSatisfyAllOfTheFollowing(isTypeB, logging, [
+      ...refinements,
+      isTypeB
+    ])
+  });
+  return checkTypes;
+}
+var isIntersection = mustSatisfyAllOfTheFollowing(canExist);
+
+// ../anvl/src/refinement/is-union.ts
+var mustSatisfyOneOfTheFollowing = (isTypeA, logging = false, refinements = [isTypeA]) => {
+  const name = `(${refinements.map((r) => (r == null ? void 0 : r.name) || `anon`).join(` | `)})`;
+  const _ = {
+    [name]: (input) => refinements.some(
+      (refinement) => {
+        var _a;
+        return logging && console.log(
+          refinements.map((r) => r.name || `anon`).join(` | `),
+          `>`,
+          (_a = refinement.name) != null ? _a : `anon`,
+          `:`,
+          refinement(input)
+        ), refinement(input);
+      }
+    )
+  };
+  const checkTypes = Object.assign(_[name], {
+    or: (isTypeB) => mustSatisfyOneOfTheFollowing(isTypeB, logging, [...refinements, isTypeB])
+  });
+  return checkTypes;
+};
+var isUnion = mustSatisfyOneOfTheFollowing(cannotExist);
+
+// ../anvl/src/refinement/refine-json.ts
+var JSON_PROTOTYPES = [
+  `Array`,
+  `Boolean`,
+  `Number`,
+  `Object`,
+  `String`
+];
+var refineJsonType = (data) => data === null ? { type: `null`, data: null } : isBoolean(data) ? { type: `boolean`, data } : isNumber(data) ? { type: `number`, data } : isString(data) ? { type: `string`, data } : Array.isArray(data) ? { type: `array`, data } : isPlainObject(data) ? { type: `object`, data } : raiseError(
+  data === void 0 ? `undefined passed to refineJsonType. This is not valid JSON.` : `${stringifyJson(data)} with prototype "${Object.getPrototypeOf(data).constructor.name}" passed to refineJsonType. This is not valid JSON.`
+);
+var isJson = (input) => {
+  var _a;
+  if (input === null)
+    return true;
+  if (input === void 0)
+    return false;
+  const prototype = (_a = Object.getPrototypeOf(input)) == null ? void 0 : _a.constructor.name;
+  const refine = JSON_PROTOTYPES.includes(prototype);
+  return refine;
+};
+
 // ../anvl/src/refinement/refinery.ts
 var Refinery = class {
   constructor(supported) {
@@ -54,82 +130,6 @@ var discoverType = (input) => {
   return Object.getPrototypeOf(input).constructor.name;
 };
 
-// ../anvl/src/refinement/refine-json.ts
-var JSON_PROTOTYPES = [
-  `Array`,
-  `Boolean`,
-  `Number`,
-  `Object`,
-  `String`
-];
-var refineJsonType = (data) => data === null ? { type: `null`, data: null } : isBoolean(data) ? { type: `boolean`, data } : isNumber(data) ? { type: `number`, data } : isString(data) ? { type: `string`, data } : Array.isArray(data) ? { type: `array`, data } : isPlainObject(data) ? { type: `object`, data } : raiseError(
-  data === void 0 ? `undefined passed to refineJsonType. This is not valid JSON.` : `${stringifyJson(data)} with prototype "${Object.getPrototypeOf(data).constructor.name}" passed to refineJsonType. This is not valid JSON.`
-);
-var isJson = (input) => {
-  var _a;
-  if (input === null)
-    return true;
-  if (input === void 0)
-    return false;
-  const prototype = (_a = Object.getPrototypeOf(input)) == null ? void 0 : _a.constructor.name;
-  const refine = JSON_PROTOTYPES.includes(prototype);
-  return refine;
-};
-
-// ../anvl/src/refinement/can-exist.ts
-var canExist = (_) => true;
-
-// ../anvl/src/refinement/cannot-exist.ts
-var cannotExist = (_) => false;
-
-// ../anvl/src/refinement/is-union.ts
-var mustSatisfyOneOfTheFollowing = (isTypeA, logging = false, refinements = [isTypeA]) => {
-  const name = `(${refinements.map((r) => (r == null ? void 0 : r.name) || `anon`).join(` | `)})`;
-  const _ = {
-    [name]: (input) => refinements.some(
-      (refinement) => {
-        var _a;
-        return logging && console.log(
-          refinements.map((r) => r.name || `anon`).join(` | `),
-          `>`,
-          (_a = refinement.name) != null ? _a : `anon`,
-          `:`,
-          refinement(input)
-        ), refinement(input);
-      }
-    )
-  };
-  const checkTypes = Object.assign(_[name], {
-    or: (isTypeB) => mustSatisfyOneOfTheFollowing(isTypeB, logging, [...refinements, isTypeB])
-  });
-  return checkTypes;
-};
-var isUnion = mustSatisfyOneOfTheFollowing(cannotExist);
-
-// ../anvl/src/refinement/is-intersection.ts
-function mustSatisfyAllOfTheFollowing(isTypeA, logging = false, refinements = [isTypeA]) {
-  const name = `(${refinements.map((r) => (r == null ? void 0 : r.name) || `anon`).join(` & `)})`;
-  const _ = {
-    [name]: (input) => refinements.every(
-      (refinement) => (logging && console.log(
-        refinements.map((r) => r.name || `anon`).join(` & `),
-        `>`,
-        refinement.name || `anon`,
-        `:`,
-        refinement(input)
-      ), refinement(input))
-    )
-  };
-  const checkTypes = Object.assign(_[name], {
-    and: (isTypeB) => mustSatisfyAllOfTheFollowing(isTypeB, logging, [
-      ...refinements,
-      isTypeB
-    ])
-  });
-  return checkTypes;
-}
-var isIntersection = mustSatisfyAllOfTheFollowing(canExist);
-
 // ../anvl/src/refinement/index.ts
 var isLiteral = (value) => (input) => input === value;
 var isWithin = (args) => (input) => args.includes(input);

package/react-devtools/src/AtomIODevtools.tsx

@@ -1,3 +1,5 @@
+import "./devtools.scss"
+
 import { useI, useO } from "atom.io/react"
 import { LayoutGroup, motion, spring } from "framer-motion"
 import { useRef } from "react"
@@ -13,8 +15,6 @@ import { StateIndex } from "./StateIndex"
 import { TimelineIndex } from "./TimelineIndex"
 import { TransactionIndex } from "./TransactionIndex"
 
-import "./devtools.scss"
-
 export const AtomIODevtools = (): JSX.Element => {
 	const constraintsRef = useRef(null)
 

package/react-devtools/src/TransactionIndex.tsx

@@ -1,10 +1,10 @@
 import {
+	findState,
+	type Func,
 	type ReadonlySelectorToken,
 	type RegularAtomToken,
 	type TransactionToken,
 	type TransactionUpdate,
-	findState,
-	type Func,
 } from "atom.io"
 import { useI, useO } from "atom.io/react"
 import type { FC } from "react"

package/react-devtools/src/Updates.tsx

@@ -1,8 +1,8 @@
 import type {
+	Func,
 	KeyedStateUpdate,
 	TimelineUpdate,
 	TransactionUpdate,
-	Func,
 } from "atom.io"
 import * as React from "react"
 

package/react-devtools/src/devtools.scss

@@ -130,9 +130,6 @@ main.atom_io_devtools {
       }
       section.transaction_log {
         margin-top: 0;
-        header: {
-          padding: 5px;
-        }
         main {
           display: flex;
           flex-flow: row wrap;

package/react-devtools/src/index.ts

@@ -4,9 +4,9 @@ import { attachIntrospectionStates } from "atom.io/introspection"
 import { isPlainObject } from "~/packages/anvl/src/object"
 import { Refinery } from "~/packages/anvl/src/refinement"
 import {
-	Differ,
 	diffArray,
 	diffBoolean,
+	Differ,
 	diffNumber,
 	diffObject,
 	diffString,

package/realtime/src/realtime-continuity.ts

@@ -6,9 +6,9 @@ import type {
 	TransactionToken,
 } from "atom.io"
 import {
-	IMPLICIT,
 	assignTransactionToContinuity,
 	getUpdateToken,
+	IMPLICIT,
 	setEpochNumberOfContinuity,
 } from "atom.io/internal"
 import type { Json } from "atom.io/json"

package/realtime/src/shared-room-store.ts

@@ -12,7 +12,7 @@ export const usersInThisRoomIndex = atom<SetRTX<string>, SetRTXJson<string>>({
 	fromJson: (json) => SetRTX.fromJSON(json),
 })
 
-export const roomIndex = atom({
+export const roomIndex = atom<SetRTX<string>, SetRTXJson<string>>({
 	key: `roomIndex`,
 	default: () => new SetRTX<string>(),
 	mutable: true,

package/realtime-client/dist/index.js

@@ -1,4 +1,4 @@
-export { syncContinuity } from '../../dist/chunk-ATKDGVTV.js';
+export { syncContinuity } from '../../dist/chunk-2AIFLP2B.js';
 export { confirmedUpdateQueue, myIdState, myIdState__INTERNAL, myUsernameState, optimisticUpdateQueue } from '../../dist/chunk-O47EQUM6.js';
 import '../../dist/chunk-BWWVY5O5.js';
 import '../../dist/chunk-F2X4B4VY.js';

package/realtime-client/src/pull-atom-family-member.ts

@@ -1,5 +1,5 @@
 import type * as AtomIO from "atom.io"
-import { type Store, setIntoStore } from "atom.io/internal"
+import { setIntoStore, type Store } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 import { parseJson } from "atom.io/json"
 import type { Socket } from "socket.io-client"

package/realtime-client/src/pull-atom.ts

@@ -1,5 +1,5 @@
 import type * as AtomIO from "atom.io"
-import { type Store, setIntoStore } from "atom.io/internal"
+import { setIntoStore, type Store } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 import type { Socket } from "socket.io-client"
 

package/realtime-client/src/pull-mutable-atom-family-member.ts

@@ -1,8 +1,8 @@
 import type * as AtomIO from "atom.io"
-import { getJsonToken, getUpdateToken, setIntoStore } from "atom.io/internal"
 import type { Store, Transceiver } from "atom.io/internal"
-import { parseJson } from "atom.io/json"
+import { getJsonToken, getUpdateToken, setIntoStore } from "atom.io/internal"
 import type { Json } from "atom.io/json"
+import { parseJson } from "atom.io/json"
 import type { Socket } from "socket.io-client"
 
 export function pullMutableAtomFamilyMember<

package/realtime-client/src/sync-continuity.ts

@@ -1,9 +1,9 @@
 import type * as AtomIO from "atom.io"
 import type { Store } from "atom.io/internal"
-import { deleteAtom } from "atom.io/internal"
 import {
 	actUponStore,
 	assignTransactionToContinuity,
+	deleteAtom,
 	getEpochNumberOfContinuity,
 	getFromStore,
 	getJsonToken,

package/realtime-react/dist/index.js

@@ -1,4 +1,4 @@
-import { syncContinuity } from '../../dist/chunk-ATKDGVTV.js';
+import { syncContinuity } from '../../dist/chunk-2AIFLP2B.js';
 import '../../dist/chunk-F2X4B4VY.js';
 import { useI, StoreContext, useO } from 'atom.io/react';
 import * as RTC from 'atom.io/realtime-client';

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,13 +1,12 @@
 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 * as atom_io_transceivers_set_rtx from 'atom.io/transceivers/set-rtx';
-import { SetRTX } from 'atom.io/transceivers/set-rtx';
+import { SetRTX, SetRTXJson } from 'atom.io/transceivers/set-rtx';
 
 type Events = Json.Object<string, Json.Serializable[]>;
 type StringifiedEvent<Key extends string, Params extends Json.Serializable[]> = Stringified<[Key, ...Params]>;
@@ -82,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>;
@@ -104,29 +115,17 @@ declare const actionOcclusionAtoms: AtomIO.RegularAtomFamilyTokenWithCall<{
 declare const userUnacknowledgedQueues: AtomIO.RegularAtomFamilyTokenWithCall<Pick<TransactionUpdate<any>, "key" | "epoch" | "id" | "updates" | "output">[], string>;
 
 declare const socketAtoms: AtomIO.RegularAtomFamilyTokenWithCall<Socket | null, string>;
-declare const socketIndex: AtomIO.MutableAtomToken<SetRTX<string>, atom_io_transceivers_set_rtx.SetRTXJson<string>>;
-declare const userIndex: AtomIO.MutableAtomToken<SetRTX<string>, atom_io_transceivers_set_rtx.SetRTXJson<string>>;
+declare const socketIndex: AtomIO.MutableAtomToken<SetRTX<string>, SetRTXJson<string>>;
+declare const userIndex: AtomIO.MutableAtomToken<SetRTX<string>, SetRTXJson<string>>;
 declare const usersOfSockets: atom_io_data.JoinToken<"user", "socket", "1:1", null>;
 
 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;