atom.io 0.40.6 → 0.40.8

package/dist/realtime-server/index.js

@@ -1,19 +1,234 @@
-import { IMPLICIT, Subject, actUponStore, editRelationsInStore, findInStore, findRelationsInStore, getFromStore, getJsonToken, getUpdateToken, isRootStore, setIntoStore, subscribeToState, subscribeToTransaction } from "atom.io/internal";
+import { OWN_OP, operateOnStore } from "../has-role-CMlaUlaf.js";
+import "../is-fn-DY1wZ-md.js";
+import { mutexAtoms } from "../mutex-store-CSvxY9i3.js";
+import { roomIndex, usersInRooms } from "../shared-room-store-BfW3nWif.js";
+import { employSocket } from "../employ-socket-D6wgByWh.js";
+import { IMPLICIT, Subject, actUponStore, editRelationsInStore, findInStore, 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/continuity/continuity-store.ts
+function redactTransactionUpdateContent(visibleStateKeys, updates) {
+	return updates.map((update) => {
+		switch (update.type) {
+			case `transaction_outcome`: {
+				const redacted = redactTransactionUpdateContent(visibleStateKeys, update.subEvents);
+				return {
+					...update,
+					subEvents: redacted
+				};
+			}
+			case `atom_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 `state_creation`:
+			case `state_disposal`: return visibleStateKeys.includes(update.token.key);
+			case `molecule_creation`:
+			case `transaction_outcome`:
+			case `molecule_disposal`:
+			case `molecule_transfer`: return true;
+		}
+	});
+}
+const redactorAtoms = atomFamily({
+	key: `redactor`,
+	default: { occlude: (updates) => updates }
+});
+const unacknowledgedUpdatesAtoms = atomFamily({
+	key: `unacknowledgedUpdates`,
+	default: () => []
+});
+
+//#endregion
+//#region src/realtime-server/continuity/provide-outcomes.ts
+function provideOutcomes(store, socket, continuity, userKey) {
+	const continuityKey = continuity.key;
+	const unsubscribeFunctions = /* @__PURE__ */ new Set();
+	for (const transaction$1 of continuity.actions) {
+		const unsubscribeFromTransaction = subscribeToTransaction(store, transaction$1, `sync-continuity:${continuityKey}:${userKey}`, (outcomes) => {
+			try {
+				const visibleKeys = continuity.globals.map((atom) => {
+					if (atom.type === `atom`) return atom.key;
+					return getUpdateToken(atom).key;
+				}).concat(continuity.perspectives.flatMap((perspective) => {
+					const { viewAtoms } = perspective;
+					const userPerspectiveTokenState = findInStore(store, viewAtoms, userKey);
+					return getFromStore(store, userPerspectiveTokenState).map((token) => {
+						return token.type === `mutable_atom` ? `*` + token.key : token.key;
+					});
+				}));
+				const redactedUpdates = redactTransactionUpdateContent(visibleKeys, outcomes.subEvents);
+				const redactedUpdate = {
+					...outcomes,
+					updates: redactedUpdates
+				};
+				setIntoStore(store, unacknowledgedUpdatesAtoms, 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$1.key} to ${userKey}`, thrown.message);
+			}
+		});
+		unsubscribeFunctions.add(unsubscribeFromTransaction);
+	}
+	return () => {
+		for (const unsubscribe of unsubscribeFunctions) unsubscribe();
+	};
+}
+
+//#endregion
+//#region src/realtime-server/continuity/provide-perspectives.ts
+function providePerspectives(store, socket, continuity, userKey) {
+	const continuityKey = continuity.key;
+	const unsubFns = /* @__PURE__ */ new Set();
+	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 && concealed.length > 0) socket.emit(`conceal:${continuityKey}`, concealed);
+		});
+		unsubFns.add(unsubscribeFromUserView);
+	}
+	return () => {
+		for (const unsubscribe of unsubFns) unsubscribe();
+	};
+}
+
+//#endregion
+//#region src/realtime-server/continuity/provide-startup-payloads.ts
+function provideStartupPayloads(store, socket, continuity, userKey) {
+	const continuityKey = continuity.key;
+	function sendInitialPayload() {
+		const initialPayload = [];
+		for (const atom of continuity.globals) {
+			const resourceToken = atom.type === `mutable_atom` ? getJsonToken(store, atom) : atom;
+			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);
+	}
+	return employSocket(socket, `get:${continuityKey}`, sendInitialPayload);
+}
+
+//#endregion
+//#region src/realtime-server/continuity/receive-action-requests.ts
+function receiveActionRequests(store, socket, continuity, userKey) {
+	const continuityKey = continuity.key;
+	return employSocket(socket, `tx-run:${continuityKey}`, function serveTransactionRequest(txOutcome) {
+		store.logger.info(`🛎️`, `continuity`, continuityKey, `received`, txOutcome);
+		const transactionKey = txOutcome.token.key;
+		const updateId = txOutcome.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)(...txOutcome.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/track-acknowledgements.ts
+function trackAcknowledgements(store, socket, continuity, userKey) {
+	const continuityKey = continuity.key;
+	const userUnacknowledgedUpdates = getFromStore(store, unacknowledgedUpdatesAtoms, userKey);
+	function trackClientAcknowledgement(epoch) {
+		store.logger.info(`👍`, `continuity`, continuityKey, `${userKey} acknowledged epoch ${epoch}`);
+		if (userUnacknowledgedUpdates[0]?.epoch === epoch) setIntoStore(store, unacknowledgedUpdatesAtoms, userKey, (updates) => {
+			updates.shift();
+			store.logger.info(`👍`, `continuity`, continuityKey, `${userKey} unacknowledged update queue now has`, updates.length, `items`);
+			return updates;
+		});
+	}
+	return employSocket(socket, `ack:${continuityKey}`, trackClientAcknowledgement);
+}
+
+//#endregion
+//#region src/realtime-server/continuity/provide-continuity.ts
+function prepareToProvideContinuity({ socket, store = IMPLICIT.STORE }) {
+	return function syncRealtimeContinuity(continuity, userKey) {
+		const continuityKey = continuity.key;
+		const unacknowledgedUpdates = getFromStore(store, unacknowledgedUpdatesAtoms, userKey);
+		for (const unacknowledgedUpdate of unacknowledgedUpdates) socket.emit(`tx-new:${continuityKey}`, unacknowledgedUpdate);
+		const subscriptions = /* @__PURE__ */ new Set();
+		const clearSubscriptions = () => {
+			for (const unsubscribe of subscriptions) unsubscribe();
+			subscriptions.clear();
+		};
+		subscriptions.add(providePerspectives(store, socket, continuity, userKey));
+		subscriptions.add(provideOutcomes(store, socket, continuity, userKey));
+		subscriptions.add(provideStartupPayloads(store, socket, continuity, userKey));
+		subscriptions.add(receiveActionRequests(store, socket, continuity, userKey));
+		subscriptions.add(trackAcknowledgements(store, socket, continuity, userKey));
+		return clearSubscriptions;
+	};
+}
+
+//#endregion
 //#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);
+	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(...args);
+		if (listeners) for (const listener of listeners) listener(...rest);
 	}
 	id = `no_id_retrieved`;
 	emit;
@@ -52,12 +267,12 @@ var ChildSocket = class extends CustomSocket {
 	incompleteLog = ``;
 	unprocessedLogs = [];
 	id = `#####`;
-	process;
+	proc;
 	key;
 	logger;
-	handleLog(arg) {
-		if (Array.isArray(arg)) {
-			const [level, ...rest] = arg;
+	handleLog(log) {
+		if (Array.isArray(log)) {
+			const [level, ...rest] = log;
 			switch (level) {
 				case `i`:
 					this.logger.info(...rest);
@@ -68,22 +283,21 @@ var ChildSocket = class extends CustomSocket {
 				case `e`:
 					this.logger.error(...rest);
 					break;
-				default: return;
 			}
 		}
 	}
-	constructor(process$1, key, logger) {
+	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.process.stdin);
-				this.process.stdin.removeListener(`error`, errorHandler);
+				if (err.code === `EPIPE`) console.error(`EPIPE error during write`, this.proc.stdin);
+				this.proc.stdin.removeListener(`error`, errorHandler);
 			};
-			this.process.stdin.once(`error`, errorHandler);
-			this.process.stdin.write(stringifiedEvent);
+			this.proc.stdin.once(`error`, errorHandler);
+			this.proc.stdin.write(stringifiedEvent);
 			return this;
 		});
-		this.process = process$1;
+		this.proc = proc;
 		this.key = key;
 		this.logger = logger ?? {
 			info: (...args) => {
@@ -96,55 +310,90 @@ var ChildSocket = class extends CustomSocket {
 				console.error(this.id, this.key, ...args);
 			}
 		};
-		this.process.stdout.on(`data`, (buffer) => {
+		this.proc.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);
+			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`));
 					}
 				}
-				this.incompleteData = ``;
-			} catch (error) {
-				console.warn(`⚠️----------------⚠️`);
-				console.warn(this.incompleteData);
-				console.warn(`⚠️----------------⚠️`);
-				console.error(error);
+				++idx;
 			}
 		});
-		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);
+		this.proc.stderr.on(`data`, (buffer) => {
+			const pieces = buffer.toString().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`));
 					}
 				}
-			} catch (error) {
-				console.error(`❌❌❌`);
-				console.error(this.incompleteLog);
-				console.error(error);
-				console.error(`❌❌❌️`);
+				++idx;
 			}
 		});
-		if (process$1.pid) this.id = process$1.pid.toString();
+		if (proc.pid) this.id = proc.pid.toString();
 	}
 };
 
@@ -176,10 +425,10 @@ var ParentSocket = class extends CustomSocket {
 	unprocessedEvents = [];
 	relays;
 	relayServices;
-	process;
+	proc;
 	id = `#####`;
 	log(...args) {
-		this.process.stderr.write(stringifyJson(args.map((arg) => arg instanceof SetRTX ? `{ ${arg.toJSON().members.join(` | `)} }` : arg)) + `\x03`);
+		this.proc.stderr.write(stringifyJson(args.map((arg) => arg instanceof SetRTX ? `{ ${arg.toJSON().members.join(` | `)} }` : arg)) + `\x03`);
 	}
 	logger = {
 		info: (...args) => {
@@ -192,68 +441,73 @@ var ParentSocket = class extends CustomSocket {
 			this.log(`e`, ...args);
 		}
 	};
-	constructor() {
+	constructor(proc) {
 		super((event, ...args) => {
 			const stringifiedEvent = JSON.stringify([event, ...args]);
-			this.process.stdout.write(stringifiedEvent + `\x03`);
+			this.proc.stdout.write(stringifiedEvent + `\x03`);
 			return this;
 		});
-		this.process = process;
-		this.process.stdin.resume();
+		this.proc = proc;
+		this.proc.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.proc.stdin.on(`data`, (buffer) => {
+			const pieces = buffer.toString().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`));
 					}
 				}
-				this.incompleteData = ``;
-			} catch (thrown) {
-				if (thrown instanceof Error) this.logger.error(`❗`, thrown.message, thrown.cause, thrown.stack);
+				++idx;
 			}
 		});
 		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);
+			this.proc.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();
+		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}`);
+			const userKey = `user::${username}`;
+			const relay = new SubjectSocket(userKey);
 			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);
+			for (const attachRelay of this.relayServices) {
+				const cleanupRelay = attachRelay(relay, userKey);
+				if (cleanupRelay) relay.disposalFunctions.push(cleanupRelay);
 			}
-			this.on(`user:${username}`, (...data) => {
+			this.on(userKey, (...data) => {
 				relay.in.next(data);
 			});
 			relay.out.subscribe(`socket`, (data) => {
@@ -268,55 +522,189 @@ var ParentSocket = class extends CustomSocket {
 				this.relays.delete(username);
 			}
 		});
-		process.stdout.write(`ALIVE`);
+		this.proc.stdout.write(`ALIVE`);
 	}
-	relay(attachServices) {
+	receiveRelay(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);
+//#region src/realtime-server/realtime-family-provider.ts
+function realtimeAtomFamilyProvider({ socket, store = IMPLICIT.STORE }) {
+	return function familyProvider(family, index) {
+		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) => {
+			const unsubUnsub = familyMemberSubscriptions.get(`${key}:unsub`);
+			if (unsubUnsub) {
+				unsubUnsub();
+				familyMemberSubscriptions.delete(`${key}:unsub`);
+			}
+			const unsub = familyMemberSubscriptions.get(key);
+			if (unsub) {
+				unsub();
+				familyMemberSubscriptions.delete(key);
+			}
+		};
+		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;
+		};
+		const start = () => {
+			coreSubscriptions.add(employSocket(socket, `sub:${family.key}`, (subKey) => {
+				const exposedSubKeys = getFromStore(store, index);
+				if (isAvailable(exposedSubKeys, subKey)) exposeFamilyMembers(subKey);
+				else {
+					familyMemberSubscriptionsWanted.add(stringifyJson(subKey));
+					socket.emit(`unavailable:${family.key}`, subKey);
 				}
-			};
-			room.stdout.on(`data`, resolver);
-		});
-		return new ChildSocket(child, roomId);
-	}
-});
+			}));
+			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 () => {
+			clearCoreSubscriptions();
+			clearFamilySubscriptions();
+		};
+	};
+}
 
 //#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({
+//#region src/realtime-server/realtime-mutable-family-provider.ts
+function realtimeMutableFamilyProvider({ socket, store = IMPLICIT.STORE }) {
+	return function mutableFamilyProvider(family, index) {
+		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) => {
+			const unsubUnsub = familyMemberSubscriptions.get(`${key}:unsub`);
+			if (unsubUnsub) {
+				unsubUnsub();
+				familyMemberSubscriptions.delete(`${key}:unsub`);
+			}
+			const unsub = familyMemberSubscriptions.get(key);
+			if (unsub) {
+				unsub();
+				familyMemberSubscriptions.delete(key);
+			}
+		};
+		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;
+		};
+		const start = () => {
+			coreSubscriptions.add(employSocket(socket, `sub:${family.key}`, (subKey) => {
+				const exposedSubKeys = getFromStore(store, index);
+				if (isAvailable(exposedSubKeys, subKey)) 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 () => {
+			clearCoreSubscriptions();
+			clearFamilySubscriptions();
+		};
+	};
+}
+
+//#endregion
+//#region src/realtime-server/realtime-mutable-provider.ts
+function realtimeMutableProvider({ socket, store = IMPLICIT.STORE }) {
+	return function mutableProvider(token) {
+		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 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 };
@@ -329,65 +717,30 @@ const joinRoomTX = AtomIO.transaction({
 		return meta;
 	}
 });
-const leaveRoomTX = AtomIO.transaction({
+const leaveRoomTX = transaction({
 	key: `leaveRoom`,
-	do: (tools, roomId, userId) => {
+	do: ({ env }, roomId, userId) => {
 		editRelationsInStore(usersInRooms, (relations) => {
 			relations.delete({
 				room: roomId,
 				user: userId
 			});
-		}, tools.env().store);
+		}, env().store);
 	}
 });
-const destroyRoomTX = AtomIO.transaction({
+const destroyRoomTX = transaction({
 	key: `destroyRoom`,
-	do: (tools, roomKey) => {
+	do: ({ set, env }, roomId) => {
 		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
-function redactTransactionUpdateContent(visibleStateKeys, updates) {
-	return updates.map((update) => {
-		switch (update.type) {
-			case `transaction_outcome`: {
-				const redacted = redactTransactionUpdateContent(visibleStateKeys, update.subEvents);
-				return {
-					...update,
-					subEvents: redacted
-				};
-			}
-			case `atom_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 `state_creation`:
-			case `state_disposal`: return visibleStateKeys.includes(update.token.key);
-			case `molecule_creation`:
-			case `transaction_outcome`:
-			case `molecule_disposal`:
-			case `molecule_transfer`: return true;
+			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);
 		}
-	});
-}
-const redactorAtoms = atomFamily({
-	key: `redactor`,
-	default: { occlude: (updates) => updates }
-});
-const userUnacknowledgedQueues = atomFamily({
-	key: `unacknowledgedUpdates`,
-	default: () => []
+	}
 });
 
 //#endregion
@@ -411,377 +764,85 @@ const usersOfSockets = join({
 	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 of continuity.globals) {
-			const resourceToken = atom.type === `mutable_atom` ? getJsonToken(store, atom) : atom;
-			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(txOutcome) {
-		store.logger.info(`🛎️`, `continuity`, continuityKey, `received`, txOutcome);
-		const transactionKey = txOutcome.token.key;
-		const updateId = txOutcome.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)(...txOutcome.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) => {
-					if (atom.type === `atom`) return atom.key;
-					return getUpdateToken(atom).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.subEvents);
-				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 && concealed.length > 0) socket?.emit(`conceal:${continuityKey}`, concealed);
-		});
-		unsubFns.push(unsubscribeFromUserView);
+const userMutualSituationalAwarenessIndexes = selectorFamily({
+	key: `userMutualSituationalAwarenessIndexes`,
+	get: (userId) => () => {
+		return [userId];
 	}
-	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;
-		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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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);
+		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);
+	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 fillPubUnclaim = () => {
-			socket.off(`pub:${token.key}`, publish);
-			socket.off(`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();
+			}));
 		};
-		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);
+		const start = () => {
+			subscriptions.add(employSocket(socket, `claim:${clientToken.key}`, () => {
+				if (getFromStore(store, mutexAtom)) {
+					clearSubscriptions();
+					subscriptions.add(subscribeToState(store, mutexAtom, socket.id, () => {
+						if (getFromStore(store, mutexAtom) === 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, prepareToProvideContinuity, realtimeAtomFamilyProvider, realtimeMutableFamilyProvider, realtimeMutableProvider, realtimeStateProvider, realtimeStateReceiver, socketAtoms, socketIndex, spawnRoom, userIndex, userMutualSituationalAwarenessIndexes, usersOfSockets };
 //# sourceMappingURL=index.js.map