atom.io 0.40.6 → 0.40.7

package/dist/realtime-server/index.js

@@ -1,357 +1,15 @@
+import { OWN_OP, operateOnStore } from "../has-role-hv4-hJMw.js";
+import "../is-fn-DY1wZ-md.js";
+import { mutexAtoms } from "../mutex-store-CSvxY9i3.js";
+import { roomIndex, usersInRooms } from "../shared-room-store-COGGKqes.js";
+import { employSocket } from "../employ-socket-D6wgByWh.js";
 import { IMPLICIT, Subject, actUponStore, editRelationsInStore, findInStore, findRelationsInStore, getFromStore, getJsonToken, getUpdateToken, isRootStore, setIntoStore, subscribeToState, subscribeToTransaction } from "atom.io/internal";
+import { atomFamily, join, mutableAtom, selectorFamily, transaction } from "atom.io";
 import { parseJson, stringifyJson } from "atom.io/json";
-import * as AtomIO from "atom.io";
-import { atomFamily, join, mutableAtom, selectorFamily } from "atom.io";
 import { SetRTX } from "atom.io/transceivers/set-rtx";
-import { roomIndex, usersInRooms } from "atom.io/realtime";
 import { spawn } from "node:child_process";
 
-//#region src/realtime-server/ipc-sockets/custom-socket.ts
-var CustomSocket = class {
-	listeners;
-	globalListeners;
-	handleEvent(event, ...args) {
-		for (const listener of this.globalListeners) listener(event, ...args);
-		const listeners = this.listeners.get(event);
-		if (listeners) for (const listener of listeners) listener(...args);
-	}
-	id = `no_id_retrieved`;
-	emit;
-	constructor(emit) {
-		this.emit = emit;
-		this.listeners = /* @__PURE__ */ new Map();
-		this.globalListeners = /* @__PURE__ */ new Set();
-	}
-	on(event, listener) {
-		const listeners = this.listeners.get(event);
-		if (listeners) listeners.add(listener);
-		else this.listeners.set(event, new Set([listener]));
-		return this;
-	}
-	onAny(listener) {
-		this.globalListeners.add(listener);
-		return this;
-	}
-	off(event, listener) {
-		const listeners = this.listeners.get(event);
-		if (listeners) if (listener) listeners.delete(listener);
-		else this.listeners.delete(event);
-		return this;
-	}
-	offAny(listener) {
-		this.globalListeners.delete(listener);
-		return this;
-	}
-};
-
-//#endregion
-//#region src/realtime-server/ipc-sockets/child-socket.ts
-var ChildSocket = class extends CustomSocket {
-	incompleteData = ``;
-	unprocessedEvents = [];
-	incompleteLog = ``;
-	unprocessedLogs = [];
-	id = `#####`;
-	process;
-	key;
-	logger;
-	handleLog(arg) {
-		if (Array.isArray(arg)) {
-			const [level, ...rest] = arg;
-			switch (level) {
-				case `i`:
-					this.logger.info(...rest);
-					break;
-				case `w`:
-					this.logger.warn(...rest);
-					break;
-				case `e`:
-					this.logger.error(...rest);
-					break;
-				default: return;
-			}
-		}
-	}
-	constructor(process$1, key, logger) {
-		super((event, ...args) => {
-			const stringifiedEvent = JSON.stringify([event, ...args]) + `\x03`;
-			const errorHandler = (err) => {
-				if (err.code === `EPIPE`) console.error(`EPIPE error during write`, this.process.stdin);
-				this.process.stdin.removeListener(`error`, errorHandler);
-			};
-			this.process.stdin.once(`error`, errorHandler);
-			this.process.stdin.write(stringifiedEvent);
-			return this;
-		});
-		this.process = process$1;
-		this.key = key;
-		this.logger = logger ?? {
-			info: (...args) => {
-				console.info(this.id, this.key, ...args);
-			},
-			warn: (...args) => {
-				console.warn(this.id, this.key, ...args);
-			},
-			error: (...args) => {
-				console.error(this.id, this.key, ...args);
-			}
-		};
-		this.process.stdout.on(`data`, (buffer) => {
-			const chunk = buffer.toString();
-			if (chunk === `ALIVE`) return;
-			this.unprocessedEvents.push(...chunk.split(`\x03`));
-			const newInput = this.unprocessedEvents.shift();
-			this.incompleteData += newInput ?? ``;
-			try {
-				if (this.incompleteData.startsWith(`error`)) console.log(`❗`, this.incompleteData);
-				let parsedEvent = parseJson(this.incompleteData);
-				this.handleEvent(...parsedEvent);
-				while (this.unprocessedEvents.length > 0) {
-					const event = this.unprocessedEvents.shift();
-					if (event) {
-						if (this.unprocessedEvents.length === 0) this.incompleteData = event;
-						parsedEvent = parseJson(event);
-						this.handleEvent(...parsedEvent);
-					}
-				}
-				this.incompleteData = ``;
-			} catch (error) {
-				console.warn(`⚠️----------------⚠️`);
-				console.warn(this.incompleteData);
-				console.warn(`⚠️----------------⚠️`);
-				console.error(error);
-			}
-		});
-		this.process.stderr.on(`data`, (buf) => {
-			const chunk = buf.toString();
-			this.unprocessedLogs.push(...chunk.split(`\x03`));
-			const newInput = this.unprocessedLogs.shift();
-			this.incompleteLog += newInput ?? ``;
-			try {
-				let parsedLog = parseJson(this.incompleteLog);
-				this.handleLog(parsedLog);
-				while (this.unprocessedLogs.length > 0) {
-					this.incompleteLog = this.unprocessedLogs.shift() ?? ``;
-					if (this.incompleteLog) {
-						parsedLog = parseJson(this.incompleteLog);
-						this.handleLog(parsedLog);
-					}
-				}
-			} catch (error) {
-				console.error(`❌❌❌`);
-				console.error(this.incompleteLog);
-				console.error(error);
-				console.error(`❌❌❌️`);
-			}
-		});
-		if (process$1.pid) this.id = process$1.pid.toString();
-	}
-};
-
-//#endregion
-//#region src/realtime-server/ipc-sockets/parent-socket.ts
-var SubjectSocket = class extends CustomSocket {
-	in;
-	out;
-	id = `no_id_retrieved`;
-	disposalFunctions = [];
-	constructor(id) {
-		super((...args) => {
-			this.out.next(args);
-			return this;
-		});
-		this.id = id;
-		this.in = new Subject();
-		this.out = new Subject();
-		this.in.subscribe(`socket`, (event) => {
-			this.handleEvent(...event);
-		});
-	}
-	dispose() {
-		for (const dispose of this.disposalFunctions) dispose();
-	}
-};
-var ParentSocket = class extends CustomSocket {
-	incompleteData = ``;
-	unprocessedEvents = [];
-	relays;
-	relayServices;
-	process;
-	id = `#####`;
-	log(...args) {
-		this.process.stderr.write(stringifyJson(args.map((arg) => arg instanceof SetRTX ? `{ ${arg.toJSON().members.join(` | `)} }` : arg)) + `\x03`);
-	}
-	logger = {
-		info: (...args) => {
-			this.log(`i`, ...args);
-		},
-		warn: (...args) => {
-			this.log(`w`, ...args);
-		},
-		error: (...args) => {
-			this.log(`e`, ...args);
-		}
-	};
-	constructor() {
-		super((event, ...args) => {
-			const stringifiedEvent = JSON.stringify([event, ...args]);
-			this.process.stdout.write(stringifiedEvent + `\x03`);
-			return this;
-		});
-		this.process = process;
-		this.process.stdin.resume();
-		this.relays = /* @__PURE__ */ new Map();
-		this.relayServices = [];
-		this.process.stdin.on(`data`, (buffer) => {
-			const chunk = buffer.toString();
-			this.unprocessedEvents.push(...chunk.split(`\x03`));
-			const newInput = this.unprocessedEvents.shift();
-			this.incompleteData += newInput ?? ``;
-			try {
-				const parsedData = parseJson(this.incompleteData);
-				this.logger.info(`🎰`, `received`, parsedData);
-				this.handleEvent(...parsedData);
-				while (this.unprocessedEvents.length > 0) {
-					const event = this.unprocessedEvents.shift();
-					if (event) {
-						if (this.unprocessedEvents.length === 0) this.incompleteData = event;
-						const parsedEvent = parseJson(event);
-						this.handleEvent(...parsedEvent);
-					}
-				}
-				this.incompleteData = ``;
-			} catch (thrown) {
-				if (thrown instanceof Error) this.logger.error(`❗`, thrown.message, thrown.cause, thrown.stack);
-			}
-		});
-		this.on(`exit`, () => {
-			this.logger.info(`🔥`, this.id, `received "exit"`);
-			process.exit(0);
-		});
-		process.on(`exit`, (code) => {
-			this.logger.info(`🔥`, this.id, `exited with code ${code}`);
-		});
-		process.on(`end`, () => {
-			this.logger.info(`🔥`, this.id, `ended`);
-			process.exit(0);
-		});
-		process.on(`SIGTERM`, () => {
-			this.logger.error(`🔥`, this.id, `terminated`);
-			process.exit(0);
-		});
-		process.on(`SIGINT`, () => {
-			this.logger.error(`🔥`, this.id, `interrupted`);
-			process.exit(0);
-		});
-		if (process.pid) this.id = process.pid?.toString();
-		this.on(`user-joins`, (username) => {
-			this.logger.info(`👤`, `user`, username, `joined`);
-			const relay = new SubjectSocket(`user:${username}`);
-			this.relays.set(username, relay);
-			this.logger.info(`🔗`, `attaching services:`, `[${[...this.relayServices.keys()].join(`, `)}]`);
-			for (const attachServices of this.relayServices) {
-				const cleanup = attachServices(relay);
-				if (cleanup) relay.disposalFunctions.push(cleanup);
-			}
-			this.on(`user:${username}`, (...data) => {
-				relay.in.next(data);
-			});
-			relay.out.subscribe(`socket`, (data) => {
-				this.emit(...data);
-			});
-		});
-		this.on(`user-leaves`, (username) => {
-			const relay = this.relays.get(username);
-			this.off(`relay:${username}`);
-			if (relay) {
-				relay.dispose();
-				this.relays.delete(username);
-			}
-		});
-		process.stdout.write(`ALIVE`);
-	}
-	relay(attachServices) {
-		this.logger.info(`🔗`, `running relay method`);
-		this.relayServices.push(attachServices);
-	}
-};
-
-//#endregion
-//#region src/realtime-server/realtime-server-stores/server-room-external-store.ts
-const roomArgumentsAtoms = atomFamily({
-	key: `roomArguments`,
-	default: [`echo`, [`Hello World!`]]
-});
-const roomSelectors = selectorFamily({
-	key: `room`,
-	get: (roomId) => async ({ get, find }) => {
-		const argumentsState = find(roomArgumentsAtoms, roomId);
-		const args = get(argumentsState);
-		const [script, options] = args;
-		const child = await new Promise((resolve) => {
-			const room = spawn(script, options, { env: process.env });
-			const resolver = (data) => {
-				if (data.toString() === `ALIVE`) {
-					room.stdout.off(`data`, resolver);
-					resolve(room);
-				}
-			};
-			room.stdout.on(`data`, resolver);
-		});
-		return new ChildSocket(child, roomId);
-	}
-});
-
-//#endregion
-//#region src/realtime-server/realtime-server-stores/server-room-external-actions.ts
-const createRoomTX = AtomIO.transaction({
-	key: `createRoom`,
-	do: ({ get, set, find }, roomId, script, options) => {
-		const args = options ? [script, options] : [script];
-		const roomArgumentsState = find(roomArgumentsAtoms, roomId);
-		set(roomArgumentsState, args);
-		set(roomIndex, (s) => s.add(roomId));
-		const roomState = find(roomSelectors, roomId);
-		const room = get(roomState);
-		return room;
-	}
-});
-const joinRoomTX = AtomIO.transaction({
-	key: `joinRoom`,
-	do: (tools, roomId, userId, enteredAtEpoch) => {
-		const meta = { enteredAtEpoch };
-		editRelationsInStore(usersInRooms, (relations) => {
-			relations.set({
-				room: roomId,
-				user: userId
-			}, meta);
-		}, tools.env().store);
-		return meta;
-	}
-});
-const leaveRoomTX = AtomIO.transaction({
-	key: `leaveRoom`,
-	do: (tools, roomId, userId) => {
-		editRelationsInStore(usersInRooms, (relations) => {
-			relations.delete({
-				room: roomId,
-				user: userId
-			});
-		}, tools.env().store);
-	}
-});
-const destroyRoomTX = AtomIO.transaction({
-	key: `destroyRoom`,
-	do: (tools, roomKey) => {
-		editRelationsInStore(usersInRooms, (relations) => {
-			relations.delete({ room: roomKey });
-		}, tools.env().store);
-		tools.set(roomIndex, (s) => (s.delete(roomKey), s));
-	}
-});
-
-//#endregion
-//#region src/realtime-server/realtime-server-stores/server-sync-store.ts
+//#region src/realtime-server/continuity/continuity-store.ts
 function redactTransactionUpdateContent(visibleStateKeys, updates) {
 	return updates.map((update) => {
 		switch (update.type) {
@@ -390,28 +48,6 @@ const userUnacknowledgedQueues = atomFamily({
 	default: () => []
 });
 
-//#endregion
-//#region src/realtime-server/realtime-server-stores/server-user-store.ts
-const socketAtoms = atomFamily({
-	key: `sockets`,
-	default: null
-});
-const socketIndex = mutableAtom({
-	key: `socketsIndex`,
-	class: SetRTX
-});
-const userIndex = mutableAtom({
-	key: `usersIndex`,
-	class: SetRTX
-});
-const usersOfSockets = join({
-	key: `usersOfSockets`,
-	between: [`user`, `socket`],
-	cardinality: `1:1`,
-	isAType: (s) => s.startsWith(`user::`),
-	isBType: (s) => s.startsWith(`socket::`)
-});
-
 //#endregion
 //#region src/realtime-server/continuity/prepare-to-send-initial-payload.ts
 function prepareToSendInitialPayload(store, continuity, userKey, socket) {
@@ -489,8 +125,8 @@ function prepareToTrackClientAcknowledgement(store, continuity, userKey, userUna
 function subscribeToContinuityActions(store, continuity, userKey, socket) {
 	const continuityKey = continuity.key;
 	const unsubscribeFunctions = [];
-	for (const transaction of continuity.actions) {
-		const unsubscribeFromTransaction = subscribeToTransaction(store, transaction, `sync-continuity:${continuityKey}:${userKey}`, (update) => {
+	for (const transaction$1 of continuity.actions) {
+		const unsubscribeFromTransaction = subscribeToTransaction(store, transaction$1, `sync-continuity:${continuityKey}:${userKey}`, (update) => {
 			try {
 				const visibleKeys = continuity.globals.map((atom) => {
 					if (atom.type === `atom`) return atom.key;
@@ -519,7 +155,7 @@ function subscribeToContinuityActions(store, continuity, userKey, socket) {
 				});
 				socket?.emit(`tx-new:${continuityKey}`, redactedUpdate);
 			} catch (thrown) {
-				if (thrown instanceof Error) store.logger.error(`❌`, `continuity`, continuityKey, `${userKey} failed to send update from transaction ${transaction.key} to ${userKey}`, thrown.message);
+				if (thrown instanceof Error) store.logger.error(`❌`, `continuity`, continuityKey, `${userKey} failed to send update from transaction ${transaction$1.key} to ${userKey}`, thrown.message);
 			}
 		});
 		unsubscribeFunctions.push(unsubscribeFromTransaction);
@@ -605,17 +241,329 @@ function prepareToExposeRealtimeContinuity({ socket: initialSocket, store = IMPL
 }
 
 //#endregion
-//#region src/realtime-server/realtime-action-receiver.ts
-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(store, tx, update.id)(...update.params);
-			performance.mark(performanceKeyEnd);
-			const metric = performance.measure(performanceKey, performanceKeyStart, performanceKeyEnd);
+//#region src/realtime-server/ipc-sockets/custom-socket.ts
+var CustomSocket = class {
+	listeners;
+	globalListeners;
+	handleEvent(...args) {
+		const [event, ...rest] = args;
+		for (const listener of this.globalListeners) listener(event, ...rest);
+		const listeners = this.listeners.get(event);
+		if (listeners) for (const listener of listeners) listener(...rest);
+	}
+	id = `no_id_retrieved`;
+	emit;
+	constructor(emit) {
+		this.emit = emit;
+		this.listeners = /* @__PURE__ */ new Map();
+		this.globalListeners = /* @__PURE__ */ new Set();
+	}
+	on(event, listener) {
+		const listeners = this.listeners.get(event);
+		if (listeners) listeners.add(listener);
+		else this.listeners.set(event, new Set([listener]));
+		return this;
+	}
+	onAny(listener) {
+		this.globalListeners.add(listener);
+		return this;
+	}
+	off(event, listener) {
+		const listeners = this.listeners.get(event);
+		if (listeners) if (listener) listeners.delete(listener);
+		else this.listeners.delete(event);
+		return this;
+	}
+	offAny(listener) {
+		this.globalListeners.delete(listener);
+		return this;
+	}
+};
+
+//#endregion
+//#region src/realtime-server/ipc-sockets/child-socket.ts
+var ChildSocket = class extends CustomSocket {
+	incompleteData = ``;
+	unprocessedEvents = [];
+	incompleteLog = ``;
+	unprocessedLogs = [];
+	id = `#####`;
+	proc;
+	key;
+	logger;
+	handleLog(log) {
+		if (Array.isArray(log)) {
+			const [level, ...rest] = log;
+			switch (level) {
+				case `i`:
+					this.logger.info(...rest);
+					break;
+				case `w`:
+					this.logger.warn(...rest);
+					break;
+				case `e`:
+					this.logger.error(...rest);
+					break;
+			}
+		}
+	}
+	constructor(proc, key, logger) {
+		super((event, ...args) => {
+			const stringifiedEvent = JSON.stringify([event, ...args]) + `\x03`;
+			const errorHandler = (err) => {
+				if (err.code === `EPIPE`) console.error(`EPIPE error during write`, this.proc.stdin);
+				this.proc.stdin.removeListener(`error`, errorHandler);
+			};
+			this.proc.stdin.once(`error`, errorHandler);
+			this.proc.stdin.write(stringifiedEvent);
+			return this;
+		});
+		this.proc = proc;
+		this.key = key;
+		this.logger = logger ?? {
+			info: (...args) => {
+				console.info(this.id, this.key, ...args);
+			},
+			warn: (...args) => {
+				console.warn(this.id, this.key, ...args);
+			},
+			error: (...args) => {
+				console.error(this.id, this.key, ...args);
+			}
+		};
+		this.proc.stdout.on(`data`, (buffer) => {
+			const chunk = buffer.toString();
+			if (chunk === `ALIVE`) {
+				this.logger.info(chunk);
+				return;
+			}
+			const pieces = chunk.split(`\x03`);
+			const initialMaybeWellFormed = pieces[0];
+			pieces[0] = this.incompleteData + initialMaybeWellFormed;
+			let idx = 0;
+			for (const piece of pieces) {
+				if (piece === ``) continue;
+				try {
+					const jsonPiece = parseJson(piece);
+					this.handleEvent(...jsonPiece);
+					this.incompleteData = ``;
+				} catch (thrown0) {
+					if (thrown0 instanceof Error) console.error([
+						`❌ Malformed data received from child process`,
+						``,
+						piece,
+						``,
+						thrown0.message
+					].join(`\n❌\t`));
+					try {
+						if (idx === 0) {
+							this.incompleteData = piece;
+							const maybeActualJsonPiece = parseJson(initialMaybeWellFormed);
+							this.handleEvent(...maybeActualJsonPiece);
+							this.incompleteData = ``;
+						} else this.incompleteData += piece;
+					} catch (thrown1) {
+						if (thrown1 instanceof Error) console.error([
+							`❌ Malformed data received from child process`,
+							``,
+							initialMaybeWellFormed,
+							``,
+							thrown1.message
+						].join(`\n❌\t`));
+					}
+				}
+				++idx;
+			}
+		});
+		this.proc.stderr.on(`data`, (buffer) => {
+			const chunk = buffer.toString();
+			const pieces = chunk.split(`\x03`);
+			const initialMaybeWellFormed = pieces[0];
+			pieces[0] = this.incompleteData + initialMaybeWellFormed;
+			let idx = 0;
+			for (const piece of pieces) {
+				if (piece === ``) continue;
+				try {
+					const jsonPiece = parseJson(piece);
+					this.handleLog(jsonPiece);
+					this.incompleteData = ``;
+				} catch (thrown0) {
+					if (thrown0 instanceof Error) console.error([
+						`❌ Malformed log received from child process`,
+						``,
+						piece,
+						``,
+						thrown0.message
+					].join(`\n❌\t`));
+					try {
+						if (idx === 0) {
+							this.incompleteData = piece;
+							const maybeActualJsonPiece = parseJson(initialMaybeWellFormed);
+							this.handleLog(maybeActualJsonPiece);
+							this.incompleteData = ``;
+						} else this.incompleteData += piece;
+					} catch (thrown1) {
+						if (thrown1 instanceof Error) console.error([
+							`❌ Malformed log received from child process...`,
+							``,
+							initialMaybeWellFormed,
+							``,
+							thrown1.message
+						].join(`\n❌\t`));
+					}
+				}
+				++idx;
+			}
+		});
+		if (proc.pid) this.id = proc.pid.toString();
+	}
+};
+
+//#endregion
+//#region src/realtime-server/ipc-sockets/parent-socket.ts
+var SubjectSocket = class extends CustomSocket {
+	in;
+	out;
+	id = `no_id_retrieved`;
+	disposalFunctions = [];
+	constructor(id) {
+		super((...args) => {
+			this.out.next(args);
+			return this;
+		});
+		this.id = id;
+		this.in = new Subject();
+		this.out = new Subject();
+		this.in.subscribe(`socket`, (event) => {
+			this.handleEvent(...event);
+		});
+	}
+	dispose() {
+		for (const dispose of this.disposalFunctions) dispose();
+	}
+};
+var ParentSocket = class extends CustomSocket {
+	incompleteData = ``;
+	unprocessedEvents = [];
+	relays;
+	relayServices;
+	proc;
+	id = `#####`;
+	log(...args) {
+		this.proc.stderr.write(stringifyJson(args.map((arg) => arg instanceof SetRTX ? `{ ${arg.toJSON().members.join(` | `)} }` : arg)) + `\x03`);
+	}
+	logger = {
+		info: (...args) => {
+			this.log(`i`, ...args);
+		},
+		warn: (...args) => {
+			this.log(`w`, ...args);
+		},
+		error: (...args) => {
+			this.log(`e`, ...args);
+		}
+	};
+	constructor(proc) {
+		super((event, ...args) => {
+			const stringifiedEvent = JSON.stringify([event, ...args]);
+			this.proc.stdout.write(stringifiedEvent + `\x03`);
+			return this;
+		});
+		this.proc = proc;
+		this.proc.stdin.resume();
+		this.relays = /* @__PURE__ */ new Map();
+		this.relayServices = [];
+		this.proc.stdin.on(`data`, (buffer) => {
+			const chunk = buffer.toString();
+			const pieces = chunk.split(`\x03`);
+			const initialMaybeWellFormed = pieces[0];
+			pieces[0] = this.incompleteData + initialMaybeWellFormed;
+			let idx = 0;
+			for (const piece of pieces) {
+				if (piece === ``) continue;
+				try {
+					const jsonPiece = parseJson(piece);
+					this.logger.info(`🎰`, `received`, jsonPiece);
+					this.handleEvent(...jsonPiece);
+					this.incompleteData = ``;
+				} catch (thrown0) {
+					if (thrown0 instanceof Error) this.logger.error([
+						`received malformed data from parent process:`,
+						``,
+						piece,
+						``,
+						thrown0.message
+					].join(`\n❌\t`));
+					try {
+						if (idx === 0) {
+							this.incompleteData = piece;
+							const maybeActualJsonPiece = parseJson(initialMaybeWellFormed);
+							this.logger.info(`🎰`, `received`, maybeActualJsonPiece);
+							this.handleEvent(...maybeActualJsonPiece);
+							this.incompleteData = ``;
+						} else this.incompleteData += piece;
+					} catch (thrown1) {
+						if (thrown1 instanceof Error) this.logger.error([
+							`received malformed data from parent process:`,
+							``,
+							initialMaybeWellFormed,
+							``,
+							thrown1.message
+						].join(`\n❌\t`));
+					}
+				}
+				++idx;
+			}
+		});
+		this.on(`exit`, () => {
+			this.logger.info(`🔥`, this.id, `received "exit"`);
+			this.proc.exit(0);
+		});
+		if (this.proc.pid) this.id = this.proc.pid?.toString();
+		this.on(`user-joins`, (username) => {
+			this.logger.info(`👤`, `user`, username, `joined`);
+			const relay = new SubjectSocket(`user:${username}`);
+			this.relays.set(username, relay);
+			this.logger.info(`🔗`, `attaching services:`, `[${[...this.relayServices.keys()].join(`, `)}]`);
+			for (const attachServices of this.relayServices) {
+				const cleanup = attachServices(relay);
+				if (cleanup) relay.disposalFunctions.push(cleanup);
+			}
+			this.on(`user:${username}`, (...data) => {
+				relay.in.next(data);
+			});
+			relay.out.subscribe(`socket`, (data) => {
+				this.emit(...data);
+			});
+		});
+		this.on(`user-leaves`, (username) => {
+			const relay = this.relays.get(username);
+			this.off(`relay:${username}`);
+			if (relay) {
+				relay.dispose();
+				this.relays.delete(username);
+			}
+		});
+		this.proc.stdout.write(`ALIVE`);
+	}
+	relay(attachServices) {
+		this.logger.info(`🔗`, `running relay method`);
+		this.relayServices.push(attachServices);
+	}
+};
+
+//#endregion
+//#region src/realtime-server/realtime-action-receiver.ts
+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(store, tx, update.id)(...update.params);
+			performance.mark(performanceKeyEnd);
+			const metric = performance.measure(performanceKey, performanceKeyStart, performanceKeyEnd);
 			store?.logger.info(`🚀`, `transaction`, tx.key, update.id, metric.duration);
 		};
 		socket.on(`tx-run:${tx.key}`, fillTransactionRequest);
@@ -629,35 +577,62 @@ function realtimeActionReceiver({ socket, store = IMPLICIT.STORE }) {
 //#region src/realtime-server/realtime-family-provider.ts
 function realtimeAtomFamilyProvider({ socket, store = IMPLICIT.STORE }) {
 	return function familyProvider(family, index) {
-		const unsubCallbacksByKey = /* @__PURE__ */ new Map();
+		const coreSubscriptions = /* @__PURE__ */ new Set();
+		const clearCoreSubscriptions = () => {
+			for (const unsub of coreSubscriptions) unsub();
+			coreSubscriptions.clear();
+		};
+		const familyMemberSubscriptionsWanted = /* @__PURE__ */ new Set();
+		const familyMemberSubscriptions = /* @__PURE__ */ new Map();
+		const clearFamilySubscriptions = () => {
+			for (const unsub of familyMemberSubscriptions.values()) unsub();
+			familyMemberSubscriptions.clear();
+		};
 		const fillUnsubRequest = (key) => {
-			socket.off(`unsub:${key}`, fillUnsubRequest);
-			const unsub = unsubCallbacksByKey.get(key);
+			const unsubUnsub = familyMemberSubscriptions.get(`${key}:unsub`);
+			if (unsubUnsub) {
+				unsubUnsub();
+				familyMemberSubscriptions.delete(`${key}:unsub`);
+			}
+			const unsub = familyMemberSubscriptions.get(key);
 			if (unsub) {
 				unsub();
-				unsubCallbacksByKey.delete(key);
+				familyMemberSubscriptions.delete(key);
 			}
 		};
-		const fillSubRequest = (subKey) => {
-			const exposedSubKeys = getFromStore(store, index);
-			for (const exposedSubKey of exposedSubKeys) if (stringifyJson(exposedSubKey) === stringifyJson(subKey)) {
-				const token = findInStore(store, family, subKey);
-				socket.emit(`serve:${token.key}`, getFromStore(store, token));
-				const unsubscribe = subscribeToState(store, token, `expose-family:${family.key}:${socket.id}`, ({ newValue }) => {
-					socket.emit(`serve:${token.key}`, newValue);
-				});
-				unsubCallbacksByKey.set(token.key, unsubscribe);
-				socket.on(`unsub:${token.key}`, () => {
-					fillUnsubRequest(token.key);
-				});
-				break;
-			}
+		const exposeFamilyMembers = (subKey) => {
+			const token = findInStore(store, family, subKey);
+			getFromStore(store, token);
+			socket.emit(`serve:${token.key}`, getFromStore(store, token));
+			familyMemberSubscriptions.set(token.key, subscribeToState(store, token, `expose-family:${family.key}:${socket.id}`, ({ newValue }) => {
+				socket.emit(`serve:${token.key}`, newValue);
+			}));
+			familyMemberSubscriptions.set(`${token.key}:unsub`, employSocket(socket, `unsub:${token.key}`, () => {
+				fillUnsubRequest(token.key);
+			}));
+		};
+		const isAvailable = (exposedSubKeys, subKey) => {
+			for (const exposedSubKey of exposedSubKeys) if (stringifyJson(exposedSubKey) === stringifyJson(subKey)) return true;
+			return false;
 		};
-		socket.on(`sub:${family.key}`, fillSubRequest);
+		const start = () => {
+			coreSubscriptions.add(employSocket(socket, `sub:${family.key}`, (subKey) => {
+				const exposedSubKeys = getFromStore(store, index);
+				const shouldExpose = isAvailable(exposedSubKeys, subKey);
+				if (shouldExpose) exposeFamilyMembers(subKey);
+				else {
+					familyMemberSubscriptionsWanted.add(stringifyJson(subKey));
+					socket.emit(`unavailable:${family.key}`, subKey);
+				}
+			}));
+			coreSubscriptions.add(subscribeToState(store, index, `expose-family:${family.key}:${socket.id}`, ({ newValue: newExposedSubKeys }) => {
+				for (const subKey of newExposedSubKeys) if (familyMemberSubscriptionsWanted.has(stringifyJson(subKey))) exposeFamilyMembers(subKey);
+			}));
+		};
+		start();
 		return () => {
-			socket.off(`sub:${family.key}`, fillSubRequest);
-			for (const [, unsub] of unsubCallbacksByKey) unsub();
-			unsubCallbacksByKey.clear();
+			clearCoreSubscriptions();
+			clearFamilySubscriptions();
 		};
 	};
 }
@@ -666,38 +641,64 @@ function realtimeAtomFamilyProvider({ socket, store = IMPLICIT.STORE }) {
 //#region src/realtime-server/realtime-mutable-family-provider.ts
 function realtimeMutableFamilyProvider({ socket, store = IMPLICIT.STORE }) {
 	return function mutableFamilyProvider(family, index) {
-		const unsubCallbacksByKey = /* @__PURE__ */ new Map();
+		const coreSubscriptions = /* @__PURE__ */ new Set();
+		const clearCoreSubscriptions = () => {
+			for (const unsub of coreSubscriptions) unsub();
+			coreSubscriptions.clear();
+		};
+		const familyMemberSubscriptionsWanted = /* @__PURE__ */ new Set();
+		const familyMemberSubscriptions = /* @__PURE__ */ new Map();
+		const clearFamilySubscriptions = () => {
+			for (const unsub of familyMemberSubscriptions.values()) unsub();
+			familyMemberSubscriptions.clear();
+		};
 		const fillUnsubRequest = (key) => {
-			socket.off(`unsub:${key}`, fillUnsubRequest);
-			const unsub = unsubCallbacksByKey.get(key);
+			const unsubUnsub = familyMemberSubscriptions.get(`${key}:unsub`);
+			if (unsubUnsub) {
+				unsubUnsub();
+				familyMemberSubscriptions.delete(`${key}:unsub`);
+			}
+			const unsub = familyMemberSubscriptions.get(key);
 			if (unsub) {
 				unsub();
-				unsubCallbacksByKey.delete(key);
+				familyMemberSubscriptions.delete(key);
 			}
 		};
-		const fillSubRequest = (subKey) => {
-			const exposedSubKeys = getFromStore(store, index);
-			for (const exposedSubKey of exposedSubKeys) if (stringifyJson(exposedSubKey) === stringifyJson(subKey)) {
-				const token = findInStore(store, family, subKey);
-				getFromStore(store, token);
-				const jsonToken = getJsonToken(store, token);
-				const updateToken = getUpdateToken(token);
-				socket.emit(`init:${token.key}`, getFromStore(store, jsonToken));
-				const unsubscribe = subscribeToState(store, updateToken, `expose-family:${family.key}:${socket.id}`, ({ newValue }) => {
-					socket.emit(`next:${token.key}`, newValue);
-				});
-				unsubCallbacksByKey.set(token.key, unsubscribe);
-				socket.on(`unsub:${token.key}`, () => {
-					fillUnsubRequest(token.key);
-				});
-				break;
-			}
+		const exposeFamilyMembers = (subKey) => {
+			const token = findInStore(store, family, subKey);
+			getFromStore(store, token);
+			const jsonToken = getJsonToken(store, token);
+			const updateToken = getUpdateToken(token);
+			socket.emit(`init:${token.key}`, getFromStore(store, jsonToken));
+			familyMemberSubscriptions.set(token.key, subscribeToState(store, updateToken, `expose-family:${family.key}:${socket.id}`, ({ newValue }) => {
+				socket.emit(`next:${token.key}`, newValue);
+			}));
+			familyMemberSubscriptions.set(`${token.key}:unsub`, employSocket(socket, `unsub:${token.key}`, () => {
+				fillUnsubRequest(token.key);
+			}));
+		};
+		const isAvailable = (exposedSubKeys, subKey) => {
+			for (const exposedSubKey of exposedSubKeys) if (stringifyJson(exposedSubKey) === stringifyJson(subKey)) return true;
+			return false;
 		};
-		socket.on(`sub:${family.key}`, fillSubRequest);
+		const start = () => {
+			coreSubscriptions.add(employSocket(socket, `sub:${family.key}`, (subKey) => {
+				const exposedSubKeys = getFromStore(store, index);
+				const shouldExpose = isAvailable(exposedSubKeys, subKey);
+				if (shouldExpose) exposeFamilyMembers(subKey);
+				else {
+					familyMemberSubscriptionsWanted.add(stringifyJson(subKey));
+					socket.emit(`unavailable:${family.key}`, subKey);
+				}
+			}));
+			coreSubscriptions.add(subscribeToState(store, index, `expose-family:${family.key}:${socket.id}`, ({ newValue: newExposedSubKeys }) => {
+				for (const subKey of newExposedSubKeys) if (familyMemberSubscriptionsWanted.has(stringifyJson(subKey))) exposeFamilyMembers(subKey);
+			}));
+		};
+		start();
 		return () => {
-			socket.off(`sub:${family.key}`, fillSubRequest);
-			for (const [, unsub] of unsubCallbacksByKey) unsub();
-			unsubCallbacksByKey.clear();
+			clearCoreSubscriptions();
+			clearFamilySubscriptions();
 		};
 	};
 }
@@ -706,82 +707,188 @@ function realtimeMutableFamilyProvider({ socket, store = IMPLICIT.STORE }) {
 //#region src/realtime-server/realtime-mutable-provider.ts
 function realtimeMutableProvider({ socket, store = IMPLICIT.STORE }) {
 	return function mutableProvider(token) {
-		let unsubscribeFromStateUpdates = null;
+		const subscriptions = /* @__PURE__ */ new Set();
+		const clearSubscriptions = () => {
+			for (const unsub of subscriptions) unsub();
+			subscriptions.clear();
+		};
 		const jsonToken = getJsonToken(store, token);
 		const trackerToken = getUpdateToken(token);
-		const fillUnsubRequest = () => {
-			socket.off(`unsub:${token.key}`, fillUnsubRequest);
-			unsubscribeFromStateUpdates?.();
-			unsubscribeFromStateUpdates = null;
-		};
-		const fillSubRequest = () => {
-			socket.emit(`init:${token.key}`, getFromStore(store, jsonToken));
-			unsubscribeFromStateUpdates = subscribeToState(store, trackerToken, `expose-single:${socket.id}`, ({ newValue }) => {
-				socket.emit(`next:${token.key}`, newValue);
-			});
-			socket.on(`unsub:${token.key}`, fillUnsubRequest);
-		};
-		socket.on(`sub:${token.key}`, fillSubRequest);
-		return () => {
-			socket.off(`sub:${token.key}`, fillSubRequest);
-			unsubscribeFromStateUpdates?.();
+		const start = () => {
+			subscriptions.add(employSocket(socket, `sub:${token.key}`, () => {
+				clearSubscriptions();
+				socket.emit(`init:${token.key}`, getFromStore(store, jsonToken));
+				subscriptions.add(subscribeToState(store, trackerToken, `expose-single:${socket.id}`, ({ newValue }) => {
+					socket.emit(`next:${token.key}`, newValue);
+				}));
+				subscriptions.add(employSocket(socket, `unsub:${token.key}`, () => {
+					clearSubscriptions();
+					start();
+				}));
+			}));
 		};
+		start();
+		return clearSubscriptions;
 	};
 }
 
+//#endregion
+//#region src/realtime-server/realtime-server-stores/server-room-external-store.ts
+const ROOMS = /* @__PURE__ */ new Map();
+async function spawnRoom(roomId, script, options) {
+	const child = await new Promise((resolve) => {
+		const room = spawn(script, options, { env: process.env });
+		const resolver = (data) => {
+			if (data.toString() === `ALIVE`) {
+				room.stdout.off(`data`, resolver);
+				resolve(room);
+			}
+		};
+		room.stdout.on(`data`, resolver);
+	});
+	ROOMS.set(roomId, new ChildSocket(child, roomId));
+	return new ChildSocket(child, roomId);
+}
+const joinRoomTX = transaction({
+	key: `joinRoom`,
+	do: (tools, roomId, userId, enteredAtEpoch) => {
+		const meta = { enteredAtEpoch };
+		editRelationsInStore(usersInRooms, (relations) => {
+			relations.set({
+				room: roomId,
+				user: userId
+			}, meta);
+		}, tools.env().store);
+		return meta;
+	}
+});
+const leaveRoomTX = transaction({
+	key: `leaveRoom`,
+	do: ({ env }, roomId, userId) => {
+		editRelationsInStore(usersInRooms, (relations) => {
+			relations.delete({
+				room: roomId,
+				user: userId
+			});
+		}, env().store);
+	}
+});
+const destroyRoomTX = transaction({
+	key: `destroyRoom`,
+	do: ({ set, env }, roomId) => {
+		editRelationsInStore(usersInRooms, (relations) => {
+			relations.delete({ room: roomId });
+		}, env().store);
+		set(roomIndex, (s) => (s.delete(roomId), s));
+		const room = ROOMS.get(roomId);
+		if (room) {
+			room.emit(`exit`);
+			ROOMS.delete(roomId);
+		}
+	}
+});
+
+//#endregion
+//#region src/realtime-server/realtime-server-stores/server-user-store.ts
+const socketAtoms = atomFamily({
+	key: `sockets`,
+	default: null
+});
+const socketIndex = mutableAtom({
+	key: `socketsIndex`,
+	class: SetRTX
+});
+const userIndex = mutableAtom({
+	key: `usersIndex`,
+	class: SetRTX
+});
+const usersOfSockets = join({
+	key: `usersOfSockets`,
+	between: [`user`, `socket`],
+	cardinality: `1:1`,
+	isAType: (s) => s.startsWith(`user::`),
+	isBType: (s) => s.startsWith(`socket::`)
+});
+const userMutualSituationalAwarenessIndexes = selectorFamily({
+	key: `userMutualSituationalAwarenessIndexes`,
+	get: (userId) => () => {
+		return [userId];
+	}
+});
+
 //#endregion
 //#region src/realtime-server/realtime-state-provider.ts
 function realtimeStateProvider({ socket, store = IMPLICIT.STORE }) {
 	return function stateProvider(token) {
-		let unsubscribeFromStateUpdates;
-		const fillSubRequest = () => {
-			socket.emit(`serve:${token.key}`, getFromStore(store, token));
-			unsubscribeFromStateUpdates = subscribeToState(store, token, `expose-single:${socket.id}`, ({ newValue }) => {
-				socket.emit(`serve:${token.key}`, newValue);
-			});
-			const fillUnsubRequest = () => {
-				socket.off(`unsub:${token.key}`, fillUnsubRequest);
-				if (unsubscribeFromStateUpdates) {
-					unsubscribeFromStateUpdates();
-					unsubscribeFromStateUpdates = void 0;
-				}
-			};
-			socket.on(`unsub:${token.key}`, fillUnsubRequest);
+		const subscriptions = /* @__PURE__ */ new Set();
+		const clearSubscriptions = () => {
+			for (const unsub of subscriptions) unsub();
+			subscriptions.clear();
 		};
-		socket.on(`sub:${token.key}`, fillSubRequest);
-		return () => {
-			socket.off(`sub:${token.key}`, fillSubRequest);
-			if (unsubscribeFromStateUpdates) {
-				unsubscribeFromStateUpdates();
-				unsubscribeFromStateUpdates = void 0;
-			}
+		const start = () => {
+			subscriptions.add(employSocket(socket, `sub:${token.key}`, () => {
+				clearSubscriptions();
+				socket.emit(`serve:${token.key}`, getFromStore(store, token));
+				subscriptions.add(subscribeToState(store, token, `expose-single:${socket.id}`, ({ newValue }) => {
+					socket.emit(`serve:${token.key}`, newValue);
+				}));
+				subscriptions.add(employSocket(socket, `unsub:${token.key}`, () => {
+					clearSubscriptions();
+					start();
+				}));
+			}));
 		};
+		start();
+		return clearSubscriptions;
 	};
 }
 
 //#endregion
 //#region src/realtime-server/realtime-state-receiver.ts
 function realtimeStateReceiver({ socket, store = IMPLICIT.STORE }) {
-	return function stateReceiver(token) {
-		const publish = (newValue) => {
-			setIntoStore(store, token, newValue);
-		};
-		const fillPubUnclaim = () => {
-			socket.off(`pub:${token.key}`, publish);
-			socket.off(`unclaim:${token.key}`, fillPubUnclaim);
+	return function stateReceiver(clientToken, serverToken = clientToken) {
+		const mutexAtom = findInStore(store, mutexAtoms, serverToken.key);
+		const subscriptions = /* @__PURE__ */ new Set();
+		const clearSubscriptions = () => {
+			for (const unsub of subscriptions) unsub();
+			subscriptions.clear();
 		};
-		const fillPubClaim = () => {
-			socket.on(`pub:${token.key}`, publish);
-			socket.on(`unclaim:${token.key}`, fillPubUnclaim);
+		const permitPublish = () => {
+			clearSubscriptions();
+			subscriptions.add(employSocket(socket, `pub:${clientToken.key}`, (newValue) => {
+				setIntoStore(store, serverToken, newValue);
+			}));
+			subscriptions.add(employSocket(socket, `unclaim:${clientToken.key}`, () => {
+				setIntoStore(store, mutexAtom, false);
+				clearSubscriptions();
+				start();
+			}));
 		};
-		socket.on(`claim:${token.key}`, fillPubClaim);
-		return () => {
-			socket.off(`claim:${token.key}`, fillPubClaim);
-			socket.off(`pub:${token.key}`, publish);
+		const start = () => {
+			subscriptions.add(employSocket(socket, `claim:${clientToken.key}`, () => {
+				if (getFromStore(store, mutexAtom)) {
+					clearSubscriptions();
+					subscriptions.add(subscribeToState(store, mutexAtom, socket.id, () => {
+						const currentValue = getFromStore(store, mutexAtom);
+						if (currentValue === false) {
+							operateOnStore(OWN_OP, store, mutexAtom, true);
+							permitPublish();
+							socket.emit(`claim-result:${clientToken.key}`, true);
+						}
+					}));
+					socket.emit(`claim-result:${clientToken.key}`, false);
+					return;
+				}
+				setIntoStore(store, mutexAtom, true);
+				permitPublish();
+				socket.emit(`claim-result:${clientToken.key}`, true);
+			}));
 		};
+		start();
+		return clearSubscriptions;
 	};
 }
 
 //#endregion
-export { ChildSocket, CustomSocket, ParentSocket, SubjectSocket, createRoomTX, destroyRoomTX, joinRoomTX, leaveRoomTX, prepareToExposeRealtimeContinuity, realtimeActionReceiver, realtimeAtomFamilyProvider, realtimeMutableFamilyProvider, realtimeMutableProvider, realtimeStateProvider, realtimeStateReceiver, redactTransactionUpdateContent, redactorAtoms, roomArgumentsAtoms, roomSelectors, socketAtoms, socketIndex, userIndex, userUnacknowledgedQueues, usersOfSockets };
+export { ChildSocket, CustomSocket, ParentSocket, ROOMS, SubjectSocket, destroyRoomTX, joinRoomTX, leaveRoomTX, prepareToExposeRealtimeContinuity, realtimeActionReceiver, realtimeAtomFamilyProvider, realtimeMutableFamilyProvider, realtimeMutableProvider, realtimeStateProvider, realtimeStateReceiver, socketAtoms, socketIndex, spawnRoom, userIndex, userMutualSituationalAwarenessIndexes, usersOfSockets };
 //# sourceMappingURL=index.js.map