atom.io 0.32.3 → 0.33.0

package/dist/realtime-server/index.js

@@ -0,0 +1,795 @@
+import { IMPLICIT, Subject, actUponStore, editRelationsInStore, findInStore, findRelationsInStore, getFromStore, getJsonToken, getUpdateToken, isRootStore, setIntoStore, subscribeToState, subscribeToTransaction } from "atom.io/internal";
+import { parseJson, stringifyJson } from "atom.io/json";
+import * as AtomIO from "atom.io";
+import { atom, atomFamily, join, 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 = new Map();
+		this.globalListeners = 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 = 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, roomId) => {
+		editRelationsInStore(usersInRooms, (relations) => {
+			relations.delete({ room: roomId });
+		}, tools.env().store);
+		tools.set(roomIndex, (s) => (s.delete(roomId), s));
+	}
+});
+
+//#endregion
+//#region src/realtime-server/realtime-server-stores/server-sync-store.ts
+function redactTransactionUpdateContent(visibleStateKeys, updates) {
+	return updates.map((update) => {
+		switch (update.type) {
+			case `transaction_update`: {
+				const redacted = redactTransactionUpdateContent(visibleStateKeys, update.updates);
+				return {
+					...update,
+					updates: redacted
+				};
+			}
+			case `atom_update`:
+			case `selector_update`:
+			case `molecule_creation`:
+			case `molecule_disposal`:
+			case `molecule_transfer`:
+			case `state_creation`:
+			case `state_disposal`: return update;
+		}
+	}).filter((update) => {
+		switch (update.type) {
+			case `atom_update`:
+			case `selector_update`: return visibleStateKeys.includes(update.key);
+			case `state_creation`:
+			case `state_disposal`: return visibleStateKeys.includes(update.token.key);
+			case `molecule_creation`:
+			case `transaction_update`:
+			case `molecule_disposal`:
+			case `molecule_transfer`: return true;
+		}
+	});
+}
+const redactorAtoms = atomFamily({
+	key: `redactor`,
+	default: { occlude: (updates) => updates }
+});
+const userUnacknowledgedQueues = atomFamily({
+	key: `unacknowledgedUpdates`,
+	default: () => []
+});
+
+//#endregion
+//#region src/realtime-server/realtime-server-stores/server-user-store.ts
+const socketAtoms = atomFamily({
+	key: `sockets`,
+	default: null
+});
+const socketIndex = atom({
+	key: `socketsIndex`,
+	mutable: true,
+	default: () => new SetRTX(),
+	toJson: (set) => set.toJSON(),
+	fromJson: (json) => SetRTX.fromJSON(json)
+});
+const userIndex = atom({
+	key: `usersIndex`,
+	mutable: true,
+	default: () => new SetRTX(),
+	toJson: (set) => set.toJSON(),
+	fromJson: (json) => SetRTX.fromJSON(json)
+});
+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) {
+	const continuityKey = continuity.key;
+	return function sendInitialPayload() {
+		const initialPayload = [];
+		for (const atom$1 of continuity.globals) {
+			const resourceToken = atom$1.type === `mutable_atom` ? getJsonToken(store, atom$1) : atom$1;
+			const resource = getFromStore(store, resourceToken);
+			initialPayload.push(resourceToken, resource);
+		}
+		for (const perspective of continuity.perspectives) {
+			const { viewAtoms, resourceAtoms } = perspective;
+			const userViewState = findInStore(store, viewAtoms, userKey);
+			const userView = getFromStore(store, userViewState);
+			store.logger.info(`👁`, `atom`, resourceAtoms.key, `${userKey} can see`, {
+				viewAtoms,
+				resourceAtoms,
+				userView
+			});
+			for (const visibleToken of userView) {
+				const resourceToken = visibleToken.type === `mutable_atom` ? getJsonToken(store, visibleToken) : visibleToken;
+				const resource = getFromStore(store, resourceToken);
+				initialPayload.push(resourceToken, resource);
+			}
+		}
+		const epoch = isRootStore(store) ? store.transactionMeta.epoch.get(continuityKey) ?? null : null;
+		socket?.emit(`continuity-init:${continuityKey}`, epoch, initialPayload);
+	};
+}
+
+//#endregion
+//#region src/realtime-server/continuity/prepare-to-serve-transaction-request.ts
+function prepareToServeTransactionRequest(store, continuity, userKey) {
+	const continuityKey = continuity.key;
+	return function serveTransactionRequest(update) {
+		store.logger.info(`🛎️`, `continuity`, continuityKey, `received`, update);
+		const transactionKey = update.key;
+		const updateId = update.id;
+		const performanceKey = `tx-run:${transactionKey}:${updateId}`;
+		const performanceKeyStart = `${performanceKey}:start`;
+		const performanceKeyEnd = `${performanceKey}:end`;
+		performance.mark(performanceKeyStart);
+		try {
+			actUponStore(store, {
+				type: `transaction`,
+				key: transactionKey
+			}, updateId)(...update.params);
+		} catch (thrown) {
+			if (thrown instanceof Error) store.logger.error(`❌`, `continuity`, continuityKey, `failed to run transaction ${transactionKey} from ${userKey} with update ${updateId}`, thrown.message);
+		}
+		performance.mark(performanceKeyEnd);
+		const metric = performance.measure(performanceKey, performanceKeyStart, performanceKeyEnd);
+		store?.logger.info(`🚀`, `transaction`, transactionKey, updateId, userKey, metric.duration);
+	};
+}
+
+//#endregion
+//#region src/realtime-server/continuity/prepare-to-track-client-acknowledgement.ts
+function prepareToTrackClientAcknowledgement(store, continuity, userKey, userUnacknowledgedUpdates) {
+	const continuityKey = continuity.key;
+	return function trackClientAcknowledgement(epoch) {
+		store.logger.info(`👍`, `continuity`, continuityKey, `${userKey} acknowledged epoch ${epoch}`);
+		const isUnacknowledged = userUnacknowledgedUpdates[0]?.epoch === epoch;
+		if (isUnacknowledged) setIntoStore(store, userUnacknowledgedQueues, userKey, (updates) => {
+			updates.shift();
+			store.logger.info(`👍`, `continuity`, continuityKey, `${userKey} unacknowledged update queue now has`, updates.length, `items`);
+			return updates;
+		});
+	};
+}
+
+//#endregion
+//#region src/realtime-server/continuity/subscribe-to-continuity-actions.ts
+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) => {
+			try {
+				const visibleKeys = continuity.globals.map((atom$1) => {
+					if (atom$1.type === `atom`) return atom$1.key;
+					return getUpdateToken(atom$1).key;
+				}).concat(continuity.perspectives.flatMap((perspective) => {
+					const { viewAtoms } = perspective;
+					const userPerspectiveTokenState = findInStore(store, viewAtoms, userKey);
+					const visibleTokens = getFromStore(store, userPerspectiveTokenState);
+					return visibleTokens.map((token) => {
+						const key = token.type === `mutable_atom` ? `*` + token.key : token.key;
+						return key;
+					});
+				}));
+				const redactedUpdates = redactTransactionUpdateContent(visibleKeys, update.updates);
+				const redactedUpdate = {
+					...update,
+					updates: redactedUpdates
+				};
+				setIntoStore(store, userUnacknowledgedQueues, userKey, (updates) => {
+					if (redactedUpdate) {
+						updates.push(redactedUpdate);
+						updates.sort((a, b) => a.epoch - b.epoch);
+						store.logger.info(`👍`, `continuity`, continuityKey, `${userKey} unacknowledged update queue now has`, updates.length, `items`);
+					}
+					return updates;
+				});
+				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);
+			}
+		});
+		unsubscribeFunctions.push(unsubscribeFromTransaction);
+	}
+	return unsubscribeFunctions;
+}
+
+//#endregion
+//#region src/realtime-server/continuity/subscribe-to-continuity-perpectives.ts
+function subscribeToContinuityPerspectives(store, continuity, userKey, socket) {
+	const continuityKey = continuity.key;
+	const unsubFns = [];
+	for (const perspective of continuity.perspectives) {
+		const { viewAtoms } = perspective;
+		const userViewState = findInStore(store, viewAtoms, userKey);
+		const unsubscribeFromUserView = subscribeToState(store, userViewState, `sync-continuity:${continuityKey}:${userKey}:perspective:${perspective.resourceAtoms.key}`, ({ oldValue, newValue }) => {
+			const oldKeys = oldValue.map((token) => token.key);
+			const newKeys = newValue.map((token) => token.key);
+			const concealed = oldValue.filter((token) => !newKeys.includes(token.key));
+			const revealed = newValue.filter((token) => !oldKeys.includes(token.key)).flatMap((token) => {
+				const resourceToken = token.type === `mutable_atom` ? getJsonToken(store, token) : token;
+				const resource = getFromStore(store, resourceToken);
+				return [resourceToken, resource];
+			});
+			store.logger.info(`👁`, `atom`, perspective.resourceAtoms.key, `${userKey} has a new perspective`, {
+				oldKeys,
+				newKeys,
+				revealed,
+				concealed
+			});
+			if (revealed.length > 0) socket?.emit(`reveal:${continuityKey}`, revealed);
+			if (concealed.length > 0) socket?.emit(`conceal:${continuityKey}`, concealed);
+		});
+		unsubFns.push(unsubscribeFromUserView);
+	}
+	return unsubFns;
+}
+
+//#endregion
+//#region src/realtime-server/continuity/prepare-to-sync-realtime-continuity.ts
+function prepareToExposeRealtimeContinuity({ socket: initialSocket, store = IMPLICIT.STORE }) {
+	return function syncRealtimeContinuity(continuity) {
+		let socket = initialSocket;
+		const continuityKey = continuity.key;
+		const userKeyState = findRelationsInStore(usersOfSockets, `socket::${socket.id}`, store).userKeyOfSocket;
+		const userKey = getFromStore(store, userKeyState);
+		if (!userKey) {
+			store.logger.error(`❌`, `continuity`, continuityKey, `Tried to create a synchronizer for a socket (${socket.id}) that is not connected to a user.`);
+			return () => {};
+		}
+		const socketKeyState = findRelationsInStore(usersOfSockets, userKey, store).socketKeyOfUser;
+		const unsubscribeFromSocketTracking = subscribeToState(store, socketKeyState, `sync-continuity:${continuityKey}:${userKey}`, ({ newValue: newSocketKey }) => {
+			store.logger.info(`👋`, `continuity`, continuityKey, `seeing ${userKey} on new socket ${newSocketKey}`);
+			if (newSocketKey === null) {
+				store.logger.warn(`❌`, `continuity`, continuityKey, `User (${userKey}) is not connected to a socket, waiting for them to reappear.`);
+				return;
+			}
+			const newSocketState = findInStore(store, socketAtoms, newSocketKey);
+			const newSocket = getFromStore(store, newSocketState);
+			socket = newSocket;
+			for (const unacknowledgedUpdate of userUnacknowledgedUpdates) socket?.emit(`tx-new:${continuityKey}`, unacknowledgedUpdate);
+		});
+		const userUnacknowledgedUpdates = getFromStore(store, userUnacknowledgedQueues, userKey);
+		const unsubscribeFunctions = [];
+		const unsubscribeFromPerspectives = subscribeToContinuityPerspectives(store, continuity, userKey, socket);
+		const unsubscribeFromTransactions = subscribeToContinuityActions(store, continuity, userKey, socket);
+		unsubscribeFunctions.push(...unsubscribeFromPerspectives, ...unsubscribeFromTransactions);
+		const sendInitialPayload = prepareToSendInitialPayload(store, continuity, userKey, initialSocket);
+		socket.off(`get:${continuityKey}`, sendInitialPayload);
+		socket.on(`get:${continuityKey}`, sendInitialPayload);
+		const fillTransactionRequest = prepareToServeTransactionRequest(store, continuity, userKey);
+		socket.off(`tx-run:${continuityKey}`, fillTransactionRequest);
+		socket.on(`tx-run:${continuityKey}`, fillTransactionRequest);
+		const trackClientAcknowledgement = prepareToTrackClientAcknowledgement(store, continuity, userKey, userUnacknowledgedUpdates);
+		socket?.on(`ack:${continuityKey}`, trackClientAcknowledgement);
+		return () => {
+			for (const unsubscribe of unsubscribeFunctions) unsubscribe();
+			socket?.off(`ack:${continuityKey}`, trackClientAcknowledgement);
+			socket?.off(`get:${continuityKey}`, sendInitialPayload);
+			socket?.off(`tx-run:${continuityKey}`, fillTransactionRequest);
+		};
+	};
+}
+
+//#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);
+		return () => {
+			socket.off(`tx-run:${tx.key}`, fillTransactionRequest);
+		};
+	};
+}
+
+//#endregion
+//#region src/realtime-server/realtime-family-provider.ts
+function realtimeAtomFamilyProvider({ socket, store = IMPLICIT.STORE }) {
+	return function familyProvider(family, index) {
+		const unsubCallbacksByKey = new Map();
+		const fillUnsubRequest = (key) => {
+			socket.off(`unsub:${key}`, fillUnsubRequest);
+			const unsub = unsubCallbacksByKey.get(key);
+			if (unsub) {
+				unsub();
+				unsubCallbacksByKey.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;
+			}
+		};
+		socket.on(`sub:${family.key}`, fillSubRequest);
+		return () => {
+			socket.off(`sub:${family.key}`, fillSubRequest);
+			for (const [, unsub] of unsubCallbacksByKey) unsub();
+			unsubCallbacksByKey.clear();
+		};
+	};
+}
+
+//#endregion
+//#region src/realtime-server/realtime-mutable-family-provider.ts
+function realtimeMutableFamilyProvider({ socket, store = IMPLICIT.STORE }) {
+	return function mutableFamilyProvider(family, index) {
+		const unsubCallbacksByKey = new Map();
+		const fillUnsubRequest = (key) => {
+			socket.off(`unsub:${key}`, fillUnsubRequest);
+			const unsub = unsubCallbacksByKey.get(key);
+			if (unsub) {
+				unsub();
+				unsubCallbacksByKey.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;
+			}
+		};
+		socket.on(`sub:${family.key}`, fillSubRequest);
+		return () => {
+			socket.off(`sub:${family.key}`, fillSubRequest);
+			for (const [, unsub] of unsubCallbacksByKey) unsub();
+			unsubCallbacksByKey.clear();
+		};
+	};
+}
+
+//#endregion
+//#region src/realtime-server/realtime-mutable-provider.ts
+function realtimeMutableProvider({ socket, store = IMPLICIT.STORE }) {
+	return function mutableProvider(token) {
+		let unsubscribeFromStateUpdates = null;
+		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?.();
+		};
+	};
+}
+
+//#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);
+		};
+		socket.on(`sub:${token.key}`, fillSubRequest);
+		return () => {
+			socket.off(`sub:${token.key}`, fillSubRequest);
+			if (unsubscribeFromStateUpdates) {
+				unsubscribeFromStateUpdates();
+				unsubscribeFromStateUpdates = void 0;
+			}
+		};
+	};
+}
+
+//#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);
+		};
+		const fillPubClaim = () => {
+			socket.on(`pub:${token.key}`, publish);
+			socket.on(`unclaim:${token.key}`, fillPubUnclaim);
+		};
+		socket.on(`claim:${token.key}`, fillPubClaim);
+		return () => {
+			socket.off(`claim:${token.key}`, fillPubClaim);
+			socket.off(`pub:${token.key}`, publish);
+		};
+	};
+}
+
+//#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 };
+//# sourceMappingURL=index.js.map