atom.io 0.18.2 → 0.19.0

package/react-devtools/dist/index.cjs

@@ -2852,5 +2852,3 @@ exports.primitiveRefinery = primitiveRefinery;
 exports.selectorIndex = selectorIndex;
 exports.timelineIndex = timelineIndex;
 exports.transactionIndex = transactionIndex;
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.cjs.map

package/react-devtools/dist/index.css

@@ -326,4 +326,3 @@ main.atom_io_devtools {
     }
   }
 }
-/*# sourceMappingURL=index.css.map */

package/react-devtools/dist/index.js

@@ -1,7 +1,7 @@
-import { treeShake, isEmptyArray, pipe, ifDefined, isArray, isRecord, doesExtend, isModifier, isPlainObject, raiseError, sprawl, recordToEntries, fallback, hasExactProperties, isEmptyObject, doNothing, isOneOf, map, entriesToRecord, comprises, addTo, become, mapObject, delve } from '../../dist/chunk-NYCVSXQB.js';
-import { lazyLocalStorageEffect } from '../../dist/chunk-A4ZCNKWQ.js';
-import { JSON_TYPE_NAMES, isString, isNumber, isBoolean, stringifyJson, JSON_DEFAULTS } from '../../dist/chunk-XACXFU3B.js';
-import { __spreadProps, __spreadValues, __objRest, __restKey } from '../../dist/chunk-PZLG2HP3.js';
+import { treeShake, isEmptyArray, pipe, ifDefined, isArray, isRecord, doesExtend, isModifier, isPlainObject, raiseError, sprawl, recordToEntries, fallback, hasExactProperties, isEmptyObject, doNothing, isOneOf, map, entriesToRecord, comprises, addTo, become, mapObject, delve } from '../../dist/chunk-CVBEVTM5.js';
+import { lazyLocalStorageEffect } from '../../dist/chunk-BWWVY5O5.js';
+import { JSON_TYPE_NAMES, isString, isNumber, isBoolean, stringifyJson, JSON_DEFAULTS } from '../../dist/chunk-VAE5OCKN.js';
+import { __spreadProps, __spreadValues, __objRest, __restKey } from '../../dist/chunk-U2IICNHQ.js';
 import { selectorFamily, atom, atomFamily, findState, undo, redo, getState } from 'atom.io';
 import { attachIntrospectionStates } from 'atom.io/introspection';
 import { useI, useO } from 'atom.io/react';
@@ -2566,5 +2566,3 @@ var prettyJson = new Differ(primitiveRefinery, jsonTreeRefinery, {
 });
 
 export { AtomIODevtools, atomIndex, devtoolsAreOpenState, devtoolsViewOptionsState, devtoolsViewSelectionState, findTimelineState, findTransactionLogState, findViewIsOpenState, jsonTreeRefinery, prettyJson, primitiveRefinery, selectorIndex, timelineIndex, transactionIndex };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.js.map

package/realtime/dist/index.cjs

@@ -103,8 +103,10 @@ var usersInRooms = data.join(
 );
 var usersInMyRoomView = atom_io.selectorFamily({
   key: `usersInMyRoomView`,
-  get: (username) => ({ find }) => {
-    return [find(usersInRooms.core.findRelatedKeysState, username)];
+  get: (myUsername) => ({ find }) => {
+    const usersInRoomsAtoms = data.getInternalRelations(usersInRooms);
+    const myRoomIndex = find(usersInRoomsAtoms, myUsername);
+    return [myRoomIndex];
   }
 });
 
@@ -116,5 +118,3 @@ exports.roomIndex = roomIndex;
 exports.usersInMyRoomView = usersInMyRoomView;
 exports.usersInRooms = usersInRooms;
 exports.usersInThisRoomIndex = usersInThisRoomIndex;
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.cjs.map

package/realtime/dist/index.d.ts

@@ -2,7 +2,6 @@ import * as atom_io from 'atom.io';
 import { AtomFamilyToken, ReadableFamilyToken, ReadableToken, AtomToken, TransactionToken, MutableAtomToken } from 'atom.io';
 import { Json } from 'atom.io/json';
 import * as atom_io_data from 'atom.io/data';
-import * as atom_io_internal from 'atom.io/internal';
 import { SetRTX, SetRTXJson } from 'atom.io/transceivers/set-rtx';
 
 declare class InvariantMap<K, V> extends Map<K, V> {
@@ -40,107 +39,13 @@ type ContinuityOptions = {
 };
 declare function continuity(options: ContinuityOptions): ContinuityToken;
 
-type primitive = boolean | number | string | null;
-
-type Serializable = primitive | Readonly<{
-    [key: string]: Serializable;
-}> | ReadonlyArray<Serializable>;
-type Object$1<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
-
-type Refinement<Unrefined, Refined extends Unrefined> = (value: Unrefined) => value is Refined;
-type Cardinality = `1:1` | `1:n` | `n:n`;
-
-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 usersInThisRoomIndex: MutableAtomToken<SetRTX<string>, SetRTXJson<string>>;
 declare const roomIndex: MutableAtomToken<SetRTX<string>, 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 in: (store: atom_io_internal.Store) => atom_io_data.Join<"room", "user", "1:n", UserInRoomMeta>;
-    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>, SetRTXJson<string>, string>;
-    };
-};
+declare const usersInRooms: atom_io_data.JoinToken<"room", "user", "1:n", UserInRoomMeta>;
 declare const usersInMyRoomView: atom_io.ReadonlySelectorFamilyTokenWithCall<MutableAtomToken<SetRTX<string>, SetRTXJson<string>>[], string>;
 
 export { type ContinuityOptions, type ContinuityToken, DEFAULT_USER_IN_ROOM_META, InvariantMap, type PerspectiveToken, SyncGroup, type UserInRoomMeta, continuity, roomIndex, usersInMyRoomView, usersInRooms, usersInThisRoomIndex };

package/realtime/dist/index.js

@@ -1,7 +1,7 @@
-import '../../dist/chunk-PZLG2HP3.js';
+import '../../dist/chunk-U2IICNHQ.js';
 import { assignTransactionToContinuity, IMPLICIT, setEpochNumberOfContinuity, getUpdateToken } from 'atom.io/internal';
 import { atom, selectorFamily } from 'atom.io';
-import { join } from 'atom.io/data';
+import { join, getInternalRelations } from 'atom.io/data';
 import { SetRTX } from 'atom.io/transceivers/set-rtx';
 
 var InvariantMap = class extends Map {
@@ -101,11 +101,11 @@ var usersInRooms = join(
 );
 var usersInMyRoomView = selectorFamily({
   key: `usersInMyRoomView`,
-  get: (username) => ({ find }) => {
-    return [find(usersInRooms.core.findRelatedKeysState, username)];
+  get: (myUsername) => ({ find }) => {
+    const usersInRoomsAtoms = getInternalRelations(usersInRooms);
+    const myRoomIndex = find(usersInRoomsAtoms, myUsername);
+    return [myRoomIndex];
   }
 });
 
 export { DEFAULT_USER_IN_ROOM_META, InvariantMap, SyncGroup, continuity, roomIndex, usersInMyRoomView, usersInRooms, usersInThisRoomIndex };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.js.map

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

@@ -1,6 +1,6 @@
 import type { MutableAtomToken } from "atom.io"
 import { atom, selectorFamily } from "atom.io"
-import { join } from "atom.io/data"
+import { getInternalRelations, join } from "atom.io/data"
 import type { SetRTXJson } from "atom.io/transceivers/set-rtx"
 import { SetRTX } from "atom.io/transceivers/set-rtx"
 
@@ -41,8 +41,10 @@ export const usersInMyRoomView = selectorFamily<
 >({
 	key: `usersInMyRoomView`,
 	get:
-		(username) =>
+		(myUsername) =>
 		({ find }) => {
-			return [find(usersInRooms.core.findRelatedKeysState, username)]
+			const usersInRoomsAtoms = getInternalRelations(usersInRooms)
+			const myRoomIndex = find(usersInRoomsAtoms, myUsername)
+			return [myRoomIndex]
 		},
 })

package/realtime-client/dist/index.cjs

@@ -569,5 +569,3 @@ exports.pullSelectorFamilyMember = pullSelectorFamilyMember;
 exports.pushState = pushState;
 exports.serverAction = serverAction;
 exports.syncContinuity = syncContinuity;
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.cjs.map

package/realtime-client/dist/index.js

@@ -1,7 +1,7 @@
-export { syncContinuity } from '../../dist/chunk-IZHOMSXA.js';
-export { confirmedUpdateQueue, myIdState, myIdState__INTERNAL, myUsernameState, optimisticUpdateQueue } from '../../dist/chunk-3J2EGSBE.js';
-import '../../dist/chunk-A4ZCNKWQ.js';
-import '../../dist/chunk-PZLG2HP3.js';
+export { syncContinuity } from '../../dist/chunk-YDOGCZ53.js';
+export { confirmedUpdateQueue, myIdState, myIdState__INTERNAL, myUsernameState, optimisticUpdateQueue } from '../../dist/chunk-O47EQUM6.js';
+import '../../dist/chunk-BWWVY5O5.js';
+import '../../dist/chunk-U2IICNHQ.js';
 import * as Internal from 'atom.io/internal';
 import { setIntoStore, getJsonToken, getUpdateToken } from 'atom.io/internal';
 import { parseJson } from 'atom.io/json';
@@ -171,5 +171,3 @@ function serverAction(token, socket, store) {
 }
 
 export { pullAtom, pullAtomFamilyMember, pullMutableAtom, pullMutableAtomFamilyMember, pullSelector, pullSelectorFamilyMember, pushState, serverAction };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.js.map

package/realtime-react/dist/index.cjs

@@ -512,5 +512,3 @@ exports.usePullSelectorFamilyMember = usePullSelectorFamilyMember;
 exports.usePush = usePush;
 exports.useServerAction = useServerAction;
 exports.useSyncContinuity = useSyncContinuity;
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.cjs.map

package/realtime-react/dist/index.js

@@ -1,5 +1,5 @@
-import { syncContinuity } from '../../dist/chunk-IZHOMSXA.js';
-import '../../dist/chunk-PZLG2HP3.js';
+import { syncContinuity } from '../../dist/chunk-YDOGCZ53.js';
+import '../../dist/chunk-U2IICNHQ.js';
 import { useI, StoreContext, useO } from 'atom.io/react';
 import * as RTC from 'atom.io/realtime-client';
 import * as React from 'react';
@@ -155,5 +155,3 @@ function useSyncContinuity(token) {
 }
 
 export { RealtimeContext, RealtimeProvider, usePullAtom, usePullAtomFamilyMember, usePullMutable, usePullMutableAtomFamilyMember, usePullSelector, usePullSelectorFamilyMember, usePush, useServerAction, useSyncContinuity };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.js.map

package/realtime-server/dist/index.cjs

@@ -5,8 +5,8 @@ var internal = require('atom.io/internal');
 var setRtx = require('atom.io/transceivers/set-rtx');
 var AtomIO = require('atom.io');
 var realtime = require('atom.io/realtime');
-var child_process = require('child_process');
 var data = require('atom.io/data');
+var child_process = require('child_process');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -216,8 +216,8 @@ var SubjectSocket = class extends CustomSocket {
     });
   }
   dispose() {
-    for (const dispose of this.disposalFunctions) {
-      dispose();
+    for (const dispose2 of this.disposalFunctions) {
+      dispose2();
     }
   }
 };
@@ -338,6 +338,138 @@ var ParentSocket = class extends CustomSocket {
     this.relayServices.push(attachServices);
   }
 };
+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 join2 = joinMap.get(token.key);
+  if (join2 === void 0) {
+    const rootJoinMap = getJoinMap(internal.IMPLICIT.STORE);
+    join2 = (_a = rootJoinMap.get(token.key)) == null ? void 0 : _a.in(store);
+    if (join2 === void 0) {
+      throw new Error(
+        `Join "${token.key}" not found in store "${store.config.name}"`
+      );
+    }
+    joinMap.set(token.key, join2);
+  }
+  return join2;
+}
+function findRelationsInStore(token, key, store) {
+  const join2 = 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 = join2.states[keyAB];
+          const state = internal.findInStore(familyAB, key, store);
+          return state;
+        },
+        get [keyBA]() {
+          const familyBA = join2.states[keyBA];
+          const state = internal.findInStore(familyBA, key, store);
+          return state;
+        }
+      };
+      const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
+      if (entryAB in join2.states) {
+        const entryBA = `${token.b}EntryOf${capitalize(token.a)}`;
+        Object.assign(relations, {
+          get [entryAB]() {
+            const familyAB = join2.states[entryAB];
+            const state = internal.findInStore(familyAB, key, store);
+            return state;
+          },
+          get [entryBA]() {
+            const familyBA = join2.states[entryBA];
+            const state = internal.findInStore(familyBA, key, store);
+            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 = join2.states[keyAB];
+          const state = internal.findInStore(familyAB, key, store);
+          return state;
+        },
+        get [keysBA]() {
+          const familyBA = join2.states[keysBA];
+          const state = internal.findInStore(familyBA, key, store);
+          return state;
+        }
+      };
+      const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
+      if (entryAB in join2.states) {
+        const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
+        Object.assign(relations, {
+          get [entryAB]() {
+            const familyAB = join2.states[entryAB];
+            const state = internal.findInStore(familyAB, key, store);
+            return state;
+          },
+          get [entriesBA]() {
+            const familyBA = join2.states[entriesBA];
+            const state = internal.findInStore(familyBA, key, store);
+            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 = join2.states[keysAB];
+          const state = internal.findInStore(familyAB, key, store);
+          return state;
+        },
+        get [keysBA]() {
+          const familyBA = join2.states[keysBA];
+          const state = internal.findInStore(familyBA, key, store);
+          return state;
+        }
+      };
+      const entriesAB = `${token.a}EntriesOf${capitalize(token.b)}`;
+      if (entriesAB in join2.states) {
+        const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
+        Object.assign(relations, {
+          get [entriesAB]() {
+            const familyAB = join2.states[entriesAB];
+            const state = internal.findInStore(familyAB, key, store);
+            return state;
+          },
+          get [entriesBA]() {
+            const familyBA = join2.states[entriesBA];
+            const state = internal.findInStore(familyBA, key, store);
+            return state;
+          }
+        });
+      }
+    }
+  }
+  return relations;
+}
 AtomIO.selectorFamily({
   key: `perspectiveRedactor`,
   get: ({ userId, syncGroupKey }) => ({ get, find }) => {
@@ -442,26 +574,38 @@ var joinRoomTX = AtomIO__namespace.transaction({
   key: `joinRoom`,
   do: (transactors, roomId, userId, enteredAtEpoch) => {
     const meta = { enteredAtEpoch };
-    realtime.usersInRooms.transact(transactors, ({ relations }) => {
-      relations.set(roomId, userId, meta);
-    });
+    data.editRelationsInStore(
+      realtime.usersInRooms,
+      (relations) => {
+        relations.set({ room: roomId, user: userId }, meta);
+      },
+      transactors.env().store
+    );
     return meta;
   }
 });
 var leaveRoomTX = AtomIO__namespace.transaction({
   key: `leaveRoom`,
   do: (transactors, roomId, userId) => {
-    realtime.usersInRooms.transact(transactors, ({ relations }) => {
-      relations.delete({ room: roomId, user: userId });
-    });
+    data.editRelationsInStore(
+      realtime.usersInRooms,
+      (relations) => {
+        relations.delete({ room: roomId, user: userId });
+      },
+      transactors.env().store
+    );
   }
 });
 var destroyRoomTX = AtomIO__namespace.transaction({
   key: `destroyRoom`,
   do: (transactors, roomId) => {
-    realtime.usersInRooms.transact(transactors, ({ relations }) => {
-      relations.delete({ room: roomId });
-    });
+    data.editRelationsInStore(
+      realtime.usersInRooms,
+      (relations) => {
+        relations.delete({ room: roomId });
+      },
+      transactors.env().store
+    );
     transactors.set(realtime.roomIndex, (s) => (s.delete(roomId), s));
   }
 });
@@ -522,11 +666,11 @@ function realtimeContinuitySynchronizer({
   return function synchronizer(continuity) {
     let socket = initialSocket;
     const continuityKey = continuity.key;
-    const userKeyState = internal.findInStore(
-      usersOfSockets.states.userKeyOfSocket,
+    const userKeyState = findRelationsInStore(
+      usersOfSockets,
       socket.id,
       store
-    );
+    ).userKeyOfSocket;
     const userKey = internal.getFromStore(userKeyState, store);
     if (!userKey) {
       store.logger.error(
@@ -538,11 +682,11 @@ function realtimeContinuitySynchronizer({
       return () => {
       };
     }
-    const socketKeyState = internal.findInStore(
-      usersOfSockets.states.socketKeyOfUser,
+    const socketKeyState = findRelationsInStore(
+      usersOfSockets,
       userKey,
       store
-    );
+    ).socketKeyOfUser;
     internal.subscribeToState(
       socketKeyState,
       ({ newValue: newSocketKey }) => {
@@ -1008,5 +1152,3 @@ exports.socketIndex = socketIndex;
 exports.userIndex = userIndex;
 exports.userUnacknowledgedQueues = userUnacknowledgedQueues;
 exports.usersOfSockets = usersOfSockets;
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.cjs.map

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

@@ -1,4 +1,3 @@
-import * as atom_io_internal from 'atom.io/internal';
 import { Subject, Transceiver, Store } from 'atom.io/internal';
 import { Json, Stringified, JsonIO } from 'atom.io/json';
 import { ChildProcessWithoutNullStreams } from 'child_process';
@@ -104,99 +103,10 @@ declare const actionOcclusionAtoms: AtomIO.RegularAtomFamilyTokenWithCall<{
 }, string>;
 declare const userUnacknowledgedQueues: AtomIO.RegularAtomFamilyTokenWithCall<Pick<TransactionUpdate<any>, "key" | "epoch" | "id" | "updates" | "output">[], string>;
 
-type primitive = boolean | number | string | null;
-
-type Serializable = primitive | Readonly<{
-    [key: string]: Serializable;
-}> | ReadonlyArray<Serializable>;
-type Object$1<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
-
-type Refinement<Unrefined, Refined extends Unrefined> = (value: Unrefined) => value is Refined;
-type Cardinality = `1:1` | `1:n` | `n:n`;
-
-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 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 usersOfSockets: {
-    readonly relations: Junction<"user", "socket", null>;
-    readonly states: {
-        readonly socketKeyOfUser: AtomIO.ReadonlySelectorFamily<string | null, string>;
-        readonly userKeyOfSocket: AtomIO.ReadonlySelectorFamily<string | null, string>;
-    };
-    readonly in: (store: atom_io_internal.Store) => atom_io_data.Join<"user", "socket", "1:1", null>;
-    readonly transact: (transactors: Readonly<{
-        get: <S>(state: AtomIO.ReadonlySelectorToken<S> | AtomIO.WritableToken<S>) => S;
-        set: <S_1, New extends S_1>(state: AtomIO.WritableToken<S_1>, newValue: New | ((oldValue: S_1) => New)) => void;
-        find: typeof AtomIO.findState;
-    }>, run: (join: atom_io_data.Join<"user", "socket", "1:1", null>) => void) => void;
-    readonly core: {
-        readonly findRelatedKeysState: AtomIO.MutableAtomFamily<SetRTX<string>, atom_io_transceivers_set_rtx.SetRTXJson<string>, 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;