atom.io 0.29.5 → 0.30.1

package/internal/src/timeline/create-timeline.ts

@@ -25,6 +25,7 @@ import { newest } from "../lineage"
 import { getUpdateToken } from "../mutable"
 import { type Store, withdraw } from "../store"
 import { Subject } from "../subject"
+import { isChildStore } from "../transaction"
 import type { Flat, Func } from "../utility-types"
 
 export type TimelineAtomUpdate<ManagedAtom extends TimelineManageable> = Flat<
@@ -371,74 +372,81 @@ function addMoleculeFamilyToTimeline(
 					`got a molecule creation or disposal`,
 					creationOrDisposal,
 				)
-				switch (creationOrDisposal.type) {
-					case `molecule_creation`:
-						{
-							store.timelineTopics.set(
-								{
-									topicKey: creationOrDisposal.token.key,
-									timelineKey: tl.key,
-								},
-								{ topicType: `molecule` },
-							)
-							const txUpdateInProgress =
-								newest(store).on.transactionApplying.state?.update
-							if (txUpdateInProgress) {
-								joinTransaction(tl, txUpdateInProgress, store)
-							} else if (tl.timeTraveling === null) {
-								const event = Object.assign(creationOrDisposal, {
-									timestamp: Date.now(),
-								})
-								tl.history.push(event)
-								tl.at = tl.history.length
-								tl.subject.next(event)
-							}
-							const molecule = withdraw(creationOrDisposal.token, store)
+				if (creationOrDisposal.subType === `classic`) {
+					switch (creationOrDisposal.type) {
+						case `molecule_creation`:
+							{
+								store.timelineTopics.set(
+									{
+										topicKey: creationOrDisposal.token.key,
+										timelineKey: tl.key,
+									},
+									{ topicType: `molecule` },
+								)
+								const txUpdateInProgress =
+									newest(store).on.transactionApplying.state?.update
+								if (txUpdateInProgress) {
+									joinTransaction(tl, txUpdateInProgress, store)
+								} else if (tl.timeTraveling === null) {
+									const event = Object.assign(creationOrDisposal, {
+										timestamp: Date.now(),
+									})
+									tl.history.push(event)
+									tl.at = tl.history.length
+									tl.subject.next(event)
+								}
+								const molecule = withdraw(creationOrDisposal.token, store)
 
-							for (const token of molecule.tokens.values()) {
-								switch (token.type) {
-									case `atom`:
-									case `mutable_atom`:
-										addAtomToTimeline(token, tl, store)
-										break
+								for (const token of molecule.tokens.values()) {
+									switch (token.type) {
+										case `atom`:
+										case `mutable_atom`:
+											addAtomToTimeline(token, tl, store)
+											break
+									}
 								}
+								tl.subscriptions.set(
+									molecule.key,
+									molecule.subject.subscribe(
+										`timeline:${tl.key}`,
+										(stateCreationOrDisposal) => {
+											handleStateLifecycleEvent(
+												stateCreationOrDisposal,
+												tl,
+												store,
+											)
+										},
+									),
+								)
 							}
-							tl.subscriptions.set(
-								molecule.key,
-								molecule.subject.subscribe(
-									`timeline:${tl.key}`,
-									(stateCreationOrDisposal) => {
-										handleStateLifecycleEvent(stateCreationOrDisposal, tl, store)
-									},
-								),
-							)
-						}
-						break
-					case `molecule_disposal`:
-						{
-							const txUpdateInProgress =
-								newest(store).on.transactionApplying.state?.update
-							if (txUpdateInProgress) {
-								joinTransaction(tl, txUpdateInProgress, store)
-							} else if (tl.timeTraveling === null) {
-								const event = Object.assign(creationOrDisposal, {
-									timestamp: Date.now(),
-								})
-								tl.history.push(event)
-								tl.at = tl.history.length
-								tl.subject.next(event)
-							}
-							const moleculeKey = creationOrDisposal.token.key
-							tl.subscriptions.get(moleculeKey)?.()
-							tl.subscriptions.delete(moleculeKey)
-							for (const [familyKey] of creationOrDisposal.values) {
-								const stateKey = `${familyKey}(${stringifyJson(moleculeKey)})`
-								tl.subscriptions.get(stateKey)?.()
-								tl.subscriptions.delete(stateKey)
-								store.timelineTopics.delete(stateKey)
+							break
+						case `molecule_disposal`:
+							{
+								const txUpdateInProgress =
+									newest(store).on.transactionApplying.state?.update
+								if (txUpdateInProgress) {
+									joinTransaction(tl, txUpdateInProgress, store)
+								} else if (tl.timeTraveling === null) {
+									const event = Object.assign(creationOrDisposal, {
+										timestamp: Date.now(),
+									})
+									tl.history.push(event)
+									tl.at = tl.history.length
+									tl.subject.next(event)
+								}
+								const moleculeKey = stringifyJson(creationOrDisposal.token.key)
+
+								tl.subscriptions.get(moleculeKey)?.()
+								tl.subscriptions.delete(moleculeKey)
+								for (const [familyKey] of creationOrDisposal.values) {
+									const stateKey = `${familyKey}(${stringifyJson(moleculeKey)})`
+									tl.subscriptions.get(stateKey)?.()
+									tl.subscriptions.delete(stateKey)
+									store.timelineTopics.delete(stateKey)
+								}
 							}
-						}
-						break
+							break
+					}
 				}
 			}),
 		)
@@ -506,17 +514,32 @@ function filterTransactionUpdates(
 			}
 
 			let key: string
+			let familyKey: string | undefined
 			switch (updateFromTx.type) {
 				case `state_creation`:
 				case `state_disposal`:
+					key = updateFromTx.token.key
+					familyKey = updateFromTx.token.family?.key
+					break
 				case `molecule_creation`:
 				case `molecule_disposal`:
-					key = updateFromTx.token.key
+					switch (updateFromTx.subType) {
+						case `classic`:
+							key = updateFromTx.token.key
+							break
+						case `modern`:
+							return true // always include
+					}
 					break
 				default:
 					key = updateFromTx.key
+					familyKey = updateFromTx.family?.key
 					break
 			}
+			timelineTopics.has(key)
+			if (familyKey && timelineTopics.has(familyKey)) {
+				return true
+			}
 			return timelineTopics.has(key)
 		})
 		.map((updateFromTx) => {
@@ -543,13 +566,18 @@ function handleStateLifecycleEvent(
 		timestamp,
 	}) as TimelineUpdate<any>
 	if (!tl.timeTraveling) {
-		const txUpdateInProgress = newest(store).on.transactionApplying.state?.update
-		if (txUpdateInProgress) {
-			joinTransaction(tl, txUpdateInProgress, store)
+		const target = newest(store)
+		if (isChildStore(target)) {
+			// we don't want to update the true timeline while we are in a transaction
 		} else {
-			tl.history.push(timelineEvent)
-			tl.at = tl.history.length
-			tl.subject.next(timelineEvent)
+			const txUpdateInProgress = target.on.transactionApplying.state
+			if (txUpdateInProgress) {
+				joinTransaction(tl, txUpdateInProgress.update, store)
+			} else {
+				tl.history.push(timelineEvent)
+				tl.at = tl.history.length
+				tl.subject.next(timelineEvent)
+			}
 		}
 	}
 	switch (event.type) {

package/internal/src/transaction/index.ts

@@ -24,5 +24,5 @@ export type TransactionProgress<F extends Func> = {
 
 export type TransactionEpoch = {
 	epoch: Map<string, number>
-	actionContinuities: Junction<`continuity`, `action`>
+	actionContinuities: Junction<`continuity`, string, `action`, string>
 }

package/internal/src/utility-types.ts

@@ -4,6 +4,13 @@ export type Flat<R extends { [K in PropertyKey]: any }> = {
 	[K in keyof R]: R[K]
 }
 
-export type Range<N extends number, A extends any[] = []> = A[`length`] extends N
+export type Count<N extends number, A extends any[] = []> = [
+	...A,
+	any,
+][`length`] extends N
 	? A[`length`]
-	: A[`length`] | Range<N, [...A, any]>
+	: A[`length`] | Count<N, [...A, any]>
+
+export type Each<E extends any[]> = {
+	[P in Count<E[`length`]>]: E[P]
+}

package/json/dist/index.d.ts

@@ -1,11 +1,11 @@
-import { Range, Flat, Store, Transceiver } from 'atom.io/internal';
+import { Count, Flat, Store, Transceiver } from 'atom.io/internal';
 import * as AtomIO from 'atom.io';
 
 type Entries<K extends PropertyKey = keyof any, V = any> = [K, V][];
 type KeyOfEntries<E extends Entries> = E extends [infer K, any][] ? K : never;
 type ValueOfEntry<E extends Entries, K extends KeyOfEntries<E>> = {
-    [P in Range<E[`length`]>]: E[P] extends [K, infer V] ? V : never;
-}[Range<E[`length`]>];
+    [P in Count<E[`length`]>]: E[P] extends [K, infer V] ? V : never;
+}[Count<E[`length`]>];
 type FromEntries<E extends Entries> = Flat<{
     [K in KeyOfEntries<E>]: ValueOfEntry<E, K>;
 }>;

package/json/dist/index.js

@@ -1,4 +1,5 @@
-import { createWritableSelectorFamily } from '../../dist/chunk-TCINPEYE.js';
+import { createWritableSelectorFamily } from '../../dist/chunk-SMKF3ZNG.js';
+import '../../dist/chunk-ADMEAXYU.js';
 import '../../dist/chunk-XWL6SNVU.js';
 import { createStandaloneSelector, IMPLICIT, growMoleculeInStore, initFamilyMemberInStore, withdraw, seekInStore } from 'atom.io/internal';
 

package/json/src/entries.ts

@@ -1,4 +1,4 @@
-import type { Flat, Range } from "atom.io/internal"
+import type { Count, Flat } from "atom.io/internal"
 
 export type Entries<K extends PropertyKey = keyof any, V = any> = [K, V][]
 
@@ -7,8 +7,8 @@ export type KeyOfEntries<E extends Entries> = E extends [infer K, any][]
 	: never
 
 export type ValueOfEntry<E extends Entries, K extends KeyOfEntries<E>> = {
-	[P in Range<E[`length`]>]: E[P] extends [K, infer V] ? V : never
-}[Range<E[`length`]>]
+	[P in Count<E[`length`]>]: E[P] extends [K, infer V] ? V : never
+}[Count<E[`length`]>]
 
 export type FromEntries<E extends Entries> = Flat<{
 	[K in KeyOfEntries<E>]: ValueOfEntry<E, K>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.29.5",
+  "version": "0.30.1",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -57,34 +57,34 @@
     "@types/estree": "1.0.6",
     "@types/http-proxy": "1.17.15",
     "@types/npmlog": "7.0.0",
-    "@types/react": "18.3.8",
+    "@types/react": "18.3.12",
     "@types/tmp": "0.2.6",
-    "@typescript-eslint/parser": "8.6.0",
-    "@typescript-eslint/rule-tester": "8.6.0",
-    "@vitest/coverage-v8": "2.1.1",
-    "@vitest/ui": "2.1.1",
+    "@typescript-eslint/parser": "8.10.0",
+    "@typescript-eslint/rule-tester": "8.10.0",
+    "@vitest/coverage-v8": "2.1.3",
+    "@vitest/ui": "2.1.3",
     "concurrently": "9.0.1",
-    "drizzle-kit": "0.24.2",
-    "drizzle-orm": "0.33.0",
-    "eslint": "9.11.0",
-    "framer-motion": "11.5.6",
+    "drizzle-kit": "0.26.2",
+    "drizzle-orm": "0.35.3",
+    "eslint": "9.13.0",
+    "framer-motion": "11.11.9",
     "happy-dom": "15.7.4",
     "http-proxy": "1.18.1",
     "npmlog": "7.0.1",
     "postgres": "3.4.4",
-    "preact": "10.24.0",
+    "preact": "10.24.3",
     "react": "18.3.1",
     "react-dom": "18.3.1",
-    "react-router-dom": "6.26.2",
+    "react-router-dom": "6.27.0",
     "socket.io": "4.8.0",
     "socket.io-client": "4.8.0",
     "tmp": "0.2.3",
     "tsup": "8.3.0",
     "tsx": "4.19.1",
-    "typescript": "5.6.2",
-    "vite": "5.4.7",
+    "typescript": "5.6.3",
+    "vite": "5.4.10",
     "vite-tsconfig-paths": "5.0.1",
-    "vitest": "2.1.1",
+    "vitest": "2.1.3",
     "zod": "3.23.8"
   },
   "main": "dist/index.js",

package/react-devtools/dist/index.js

@@ -6,7 +6,7 @@ import { undo, redo, getState } from 'atom.io';
 import { IMPLICIT, createStandaloneAtom, createAtomFamily, findInStore, become } from 'atom.io/internal';
 import { jsonRefinery, attachIntrospectionStates, primitiveRefinery, prettyJson, discoverType } from 'atom.io/introspection';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
-import { isJson, fromEntries, toEntries, JSON_DEFAULTS } from 'atom.io/json';
+import { isJson, fromEntries, toEntries, JSON_DEFAULTS, stringifyJson } from 'atom.io/json';
 import { persistSync } from 'atom.io/web';
 
 var OpenClose = ({ isOpen, setIsOpen, disabled, testid }) => {
@@ -1131,7 +1131,9 @@ var TransactionUpdateFC = ({ serialNumber, transactionUpdate }) => {
           ] }),
           /* @__PURE__ */ jsxs("section", { className: "transaction_impact", children: [
             /* @__PURE__ */ jsx("span", { className: "detail", children: "impact: " }),
-            transactionUpdate.updates.filter((token) => `key` in token && !token.key.startsWith(`\u{1F441}\u200D\u{1F5E8}`)).map((update, index) => {
+            transactionUpdate.updates.filter(
+              (token) => token.type !== `molecule_creation` && token.type !== `molecule_disposal` && token.type !== `state_creation` && token.type !== `state_disposal` && !token.key.startsWith(`\u{1F441}\u200D\u{1F5E8}`)
+            ).map((update, index) => {
               switch (update.type) {
                 case `atom_update`:
                 case `selector_update`:
@@ -1165,7 +1167,7 @@ var TimelineUpdateFC = ({ timelineUpdate, serialNumber }) => {
     "article",
     {
       className: "node timeline_update",
-      "data-testid": `timeline-update-${timelineUpdate.key}-${serialNumber}`,
+      "data-testid": `timeline-update-${typeof timelineUpdate.key === `string` ? timelineUpdate.key : stringifyJson(timelineUpdate.key)}-${serialNumber}`,
       children: [
         /* @__PURE__ */ jsx("header", { children: /* @__PURE__ */ jsxs("h4", { children: [
           timelineUpdate.timestamp,
@@ -1175,7 +1177,9 @@ var TimelineUpdateFC = ({ timelineUpdate, serialNumber }) => {
           timelineUpdate.key,
           ")"
         ] }) }),
-        /* @__PURE__ */ jsx("main", { children: timelineUpdate.type === `transaction_update` ? timelineUpdate.updates.filter((token) => `key` in token && !token.key.startsWith(`\u{1F441}\u200D\u{1F5E8}`)).map((update, index) => {
+        /* @__PURE__ */ jsx("main", { children: timelineUpdate.type === `transaction_update` ? timelineUpdate.updates.filter(
+          (token) => token.type !== `molecule_creation` && token.type !== `molecule_disposal` && token.type !== `state_creation` && token.type !== `state_disposal` && !token.key.startsWith(`\u{1F441}\u200D\u{1F5E8}`)
+        ).map((update, index) => {
           switch (update.type) {
             case `atom_update`:
             case `selector_update`:
@@ -1276,7 +1280,7 @@ var TimelineLog = ({ token, isOpenState, timelineState }) => {
       ] })
     ] }),
     isOpen ? /* @__PURE__ */ jsx("main", { children: timeline.history.map(
-      (update, index) => `key` in update ? /* @__PURE__ */ jsxs(Fragment$1, { children: [
+      (update, index) => update.type !== `molecule_creation` && update.type !== `molecule_disposal` && update.type !== `state_creation` && update.type !== `state_disposal` ? /* @__PURE__ */ jsxs(Fragment$1, { children: [
         index === timeline.at ? /* @__PURE__ */ jsx(YouAreHere, {}) : null,
         /* @__PURE__ */ jsx(
           article.TimelineUpdate,

package/react-devtools/src/TimelineIndex.tsx

@@ -64,7 +64,10 @@ export const TimelineLog: FC<{
 			{isOpen ? (
 				<main>
 					{timeline.history.map((update, index) =>
-						`key` in update ? (
+						update.type !== `molecule_creation` &&
+						update.type !== `molecule_disposal` &&
+						update.type !== `state_creation` &&
+						update.type !== `state_disposal` ? (
 							<Fragment key={update.key + index + timeline.at}>
 								{index === timeline.at ? <YouAreHere /> : null}
 								<article.TimelineUpdate

package/react-devtools/src/Updates.tsx

@@ -5,6 +5,7 @@ import type {
 } from "atom.io"
 import type { Func } from "atom.io/internal"
 import { discoverType, prettyJson } from "atom.io/introspection"
+import { stringifyJson } from "atom.io/json"
 import * as React from "react"
 
 /* eslint-disable no-console */
@@ -90,7 +91,14 @@ const TransactionUpdateFC: React.FC<{
 				<section className="transaction_impact">
 					<span className="detail">impact: </span>
 					{transactionUpdate.updates
-						.filter((token) => `key` in token && !token.key.startsWith(`👁‍🗨`))
+						.filter(
+							(token) =>
+								token.type !== `molecule_creation` &&
+								token.type !== `molecule_disposal` &&
+								token.type !== `state_creation` &&
+								token.type !== `state_disposal` &&
+								!token.key.startsWith(`👁‍🗨`),
+						)
 						.map((update, index) => {
 							switch (update.type) {
 								case `atom_update`:
@@ -125,7 +133,7 @@ export const TimelineUpdateFC: React.FC<{
 	return `key` in timelineUpdate ? (
 		<article
 			className="node timeline_update"
-			data-testid={`timeline-update-${timelineUpdate.key}-${serialNumber}`}
+			data-testid={`timeline-update-${typeof timelineUpdate.key === `string` ? timelineUpdate.key : stringifyJson(timelineUpdate.key)}-${serialNumber}`}
 		>
 			<header>
 				<h4>
@@ -136,7 +144,14 @@ export const TimelineUpdateFC: React.FC<{
 			<main>
 				{timelineUpdate.type === `transaction_update` ? (
 					timelineUpdate.updates
-						.filter((token) => `key` in token && !token.key.startsWith(`👁‍🗨`))
+						.filter(
+							(token) =>
+								token.type !== `molecule_creation` &&
+								token.type !== `molecule_disposal` &&
+								token.type !== `state_creation` &&
+								token.type !== `state_disposal` &&
+								!token.key.startsWith(`👁‍🗨`),
+						)
 						.map((update, index) => {
 							switch (update.type) {
 								case `atom_update`:

package/realtime/dist/index.d.ts

@@ -45,7 +45,7 @@ type UserInRoomMeta = {
     enteredAtEpoch: number;
 };
 declare const DEFAULT_USER_IN_ROOM_META: UserInRoomMeta;
-declare const usersInRooms: atom_io_data.JoinToken<"room", "user", "1:n", UserInRoomMeta>;
+declare const usersInRooms: atom_io_data.JoinToken<"room", string, "user", string, "1:n", UserInRoomMeta>;
 declare const usersInMyRoomView: atom_io.ReadonlySelectorFamilyToken<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

@@ -90,7 +90,9 @@ var usersInRooms = join(
   {
     key: `usersInRooms`,
     between: [`room`, `user`],
-    cardinality: `1:n`
+    cardinality: `1:n`,
+    isAType: (input) => typeof input === `string`,
+    isBType: (input) => typeof input === `string`
   },
   DEFAULT_USER_IN_ROOM_META
 );

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

@@ -31,6 +31,8 @@ export const usersInRooms = join(
 		key: `usersInRooms`,
 		between: [`room`, `user`],
 		cardinality: `1:n`,
+		isAType: (input): input is string => typeof input === `string`,
+		isBType: (input): input is string => typeof input === `string`,
 	},
 	DEFAULT_USER_IN_ROOM_META,
 )

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

@@ -2,7 +2,7 @@ import { Subject, Transceiver, Store } from 'atom.io/internal';
 import { Json, stringified, JsonIO, Canonical } from 'atom.io/json';
 import { ChildProcessWithoutNullStreams } from 'node:child_process';
 import * as AtomIO from 'atom.io';
-import { TransactionUpdateContent, TransactionUpdate, WritableToken } from 'atom.io';
+import { TransactionUpdateContent, TransactionUpdate, Hierarchy, 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';
@@ -112,10 +112,19 @@ declare const actionOcclusionAtoms: AtomIO.RegularAtomFamilyToken<{
 }, string>;
 declare const userUnacknowledgedQueues: AtomIO.RegularAtomFamilyToken<Pick<TransactionUpdate<any>, "key" | "epoch" | "id" | "updates" | "output">[], string>;
 
-declare const socketAtoms: AtomIO.RegularAtomFamilyToken<Socket | null, string>;
+type SocketKey = `socket::${string}`;
+type UserKey = `user::${string}`;
+type RoomKey = `room::${string}`;
+type SocketSystemHierarchy = Hierarchy<[
+    {
+        above: `root`;
+        below: [UserKey, SocketKey, RoomKey];
+    }
+]>;
+declare const socketAtoms: AtomIO.RegularAtomFamilyToken<Socket | null, `socket::${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>;
+declare const usersOfSockets: atom_io_data.JoinToken<"user", `user::${string}`, "socket", `socket::${string}`, "1:1", null>;
 
 type StateProvider = ReturnType<typeof realtimeStateProvider>;
 declare function realtimeStateProvider({ socket, store, }: ServerConfig): <J extends Json.Serializable>(token: AtomIO.WritableToken<J>) => () => void;
@@ -136,4 +145,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, 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 RoomKey, type ServerConfig, type Socket, type SocketKey, type SocketSystemHierarchy, type StateProvider, type StateReceiver, type StringifiedEvent, SubjectSocket, type UserKey, 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

@@ -468,7 +468,9 @@ var userIndex = atom({
 var usersOfSockets = join({
   key: `usersOfSockets`,
   between: [`user`, `socket`],
-  cardinality: `1:1`
+  cardinality: `1:1`,
+  isAType: (s) => s.startsWith(`user::`),
+  isBType: (s) => s.startsWith(`socket::`)
 });
 
 // realtime-server/src/realtime-continuity-synchronizer.ts
@@ -481,7 +483,7 @@ function realtimeContinuitySynchronizer({
     const continuityKey = continuity.key;
     const userKeyState = findRelationsInStore(
       usersOfSockets,
-      socket.id,
+      `socket::${socket.id}`,
       store
     ).userKeyOfSocket;
     const userKey = getFromStore(store, userKeyState);

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

@@ -15,7 +15,7 @@ import {
 import type { Json, JsonIO } from "atom.io/json"
 import type { ContinuityToken } from "atom.io/realtime"
 
-import type { ServerConfig, Socket } from "."
+import type { ServerConfig, Socket, SocketKey } from "."
 import { socketAtoms, usersOfSockets } from "."
 import {
 	redactTransactionUpdateContent,
@@ -35,7 +35,7 @@ export function realtimeContinuitySynchronizer({
 		const continuityKey = continuity.key
 		const userKeyState = findRelationsInStore(
 			usersOfSockets,
-			socket.id,
+			`socket::${socket.id}`,
 			store,
 		).userKeyOfSocket
 		const userKey = getFromStore(store, userKeyState)

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

@@ -1,3 +1,4 @@
+import type { Hierarchy } from "atom.io"
 import { atom, atomFamily } from "atom.io"
 import { join } from "atom.io/data"
 import type { SetRTXJson } from "atom.io/transceivers/set-rtx"
@@ -5,7 +6,20 @@ import { SetRTX } from "atom.io/transceivers/set-rtx"
 
 import type { Socket } from ".."
 
-export const socketAtoms = atomFamily<Socket | null, string>({
+export type SocketKey = `socket::${string}`
+export type UserKey = `user::${string}`
+export type RoomKey = `room::${string}`
+
+export type SocketSystemHierarchy = Hierarchy<
+	[
+		{
+			above: `root`
+			below: [UserKey, SocketKey, RoomKey]
+		},
+	]
+>
+
+export const socketAtoms = atomFamily<Socket | null, SocketKey>({
 	key: `sockets`,
 	default: null,
 })
@@ -28,4 +42,6 @@ export const usersOfSockets = join({
 	key: `usersOfSockets`,
 	between: [`user`, `socket`],
 	cardinality: `1:1`,
+	isAType: (s): s is UserKey => s.startsWith(`user::`),
+	isBType: (s): s is SocketKey => s.startsWith(`socket::`),
 })

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

@@ -6,6 +6,9 @@ import { Socket } from 'socket.io-client';
 
 type TestSetupOptions = {
     port: number;
+    immortal?: {
+        server?: boolean;
+    };
     server: (tools: {
         socket: SocketIO.Socket;
         silo: AtomIO.Silo;

package/realtime-testing/dist/index.js

@@ -2,6 +2,7 @@ import '../../dist/chunk-XWL6SNVU.js';
 import * as http from 'node:http';
 import { render, prettyDOM } from '@testing-library/react';
 import * as AtomIO from 'atom.io';
+import { realm } from 'atom.io';
 import { editRelationsInStore, findRelationsInStore } from 'atom.io/data';
 import { IMPLICIT, findInStore, setIntoStore, getFromStore, clearStore } from 'atom.io/internal';
 import { toEntries } from 'atom.io/json';
@@ -32,9 +33,13 @@ function prefixLogger(store, prefix) {
 var setupRealtimeTestServer = (options) => {
   ++testNumber;
   const silo = new AtomIO.Silo(
-    { name: `SERVER-${testNumber}`, lifespan: `ephemeral` },
+    {
+      name: `SERVER-${testNumber}`,
+      lifespan: options.immortal?.server ? `immortal` : `ephemeral`
+    },
     IMPLICIT.STORE
   );
+  const socketRealm = realm(silo.store);
   const httpServer = http.createServer((_, res) => res.end(`Hello World!`));
   const address = httpServer.listen(options.port).address();
   const port = typeof address === `string` ? null : address === null ? null : address.port;
@@ -42,12 +47,14 @@ var setupRealtimeTestServer = (options) => {
   const server = new SocketIO.Server(httpServer).use((socket, next) => {
     const { token, username } = socket.handshake.auth;
     if (token === `test` && socket.id) {
-      const socketState = findInStore(silo.store, RTS.socketAtoms, socket.id);
+      const userClaim = socketRealm.allocate(`root`, `user::${username}`);
+      const socketClaim = socketRealm.allocate(`root`, `socket::${socket.id}`);
+      const socketState = findInStore(silo.store, RTS.socketAtoms, socketClaim);
       setIntoStore(silo.store, socketState, socket);
       editRelationsInStore(
         RTS.usersOfSockets,
         (relations) => {
-          relations.set(socket.id, username);
+          relations.set(userClaim, socketClaim);
         },
         silo.store
       );
@@ -64,7 +71,7 @@ var setupRealtimeTestServer = (options) => {
     function enableLogging() {
       const userKeyState = findRelationsInStore(
         RTS.usersOfSockets,
-        socket.id,
+        `socket::${socket.id}`,
         silo.store
       ).userKeyOfSocket;
       userKey = getFromStore(silo.store, userKeyState);