atom.io 0.32.3 → 0.33.0

package/dist/internal/index.js

@@ -0,0 +1,3213 @@
+import { arbitrary as arbitrary$1, subscribeToState as subscribeToState$1, subscribeToTimeline as subscribeToTimeline$1, subscribeToTransaction as subscribeToTransaction$1 } from "atom.io/internal";
+import { parseJson, selectJson, selectJsonFamily, stringifyJson } from "atom.io/json";
+import { Anarchy, AtomIOLogger } from "atom.io";
+import { SetRTX } from "atom.io/transceivers/set-rtx";
+
+//#region src/internal/arbitrary.ts
+function arbitrary(random = Math.random) {
+	return random().toString(36).slice(2);
+}
+
+//#endregion
+//#region src/internal/future.ts
+/**
+* A Promise whose incoming value can be hot swapped.
+* @internal
+* @private
+* @typeParam T The type of the value that the promise will resolve to.
+*
+* @remarks
+* Can be constructed like a Promise, or from an existing Promise.
+*/
+var Future = class extends Promise {
+	fate;
+	resolve;
+	reject;
+	done = false;
+	constructor(executor) {
+		let superResolve;
+		let superReject;
+		super((resolve, reject) => {
+			superResolve = resolve;
+			superReject = reject;
+		});
+		this.resolve = superResolve;
+		this.reject = superReject;
+		this.use(executor instanceof Promise ? executor : new Promise(executor));
+	}
+	pass(promise, value) {
+		if (promise === this.fate) {
+			this.resolve(value);
+			this.done = true;
+		}
+	}
+	fail(promise, reason) {
+		if (promise === this.fate) {
+			this.reject(reason);
+			this.done = true;
+		}
+	}
+	use(value) {
+		if (value instanceof Promise) {
+			const promise = value;
+			this.fate = promise;
+			promise.then((resolved) => {
+				this.pass(promise, resolved);
+			}, (reason) => {
+				this.fail(promise, reason);
+			});
+		} else {
+			this.resolve(value);
+			this.fate = void 0;
+		}
+	}
+};
+
+//#endregion
+//#region src/internal/lineage.ts
+function newest(scion) {
+	while (scion.child !== null) scion = scion.child;
+	return scion;
+}
+
+//#endregion
+//#region src/internal/store/circular-buffer.ts
+var CircularBuffer = class CircularBuffer {
+	_buffer;
+	_index = 0;
+	constructor(lengthOrArray) {
+		let length;
+		if (typeof lengthOrArray === `number`) length = lengthOrArray;
+		else length = lengthOrArray.length;
+		this._buffer = Array.from({ length });
+	}
+	get buffer() {
+		return this._buffer;
+	}
+	get index() {
+		return this._index;
+	}
+	add(item) {
+		this._buffer[this._index] = item;
+		this._index = (this._index + 1) % this._buffer.length;
+	}
+	copy() {
+		const copy = new CircularBuffer([...this._buffer]);
+		copy._index = this._index;
+		return copy;
+	}
+};
+
+//#endregion
+//#region src/internal/store/counterfeit.ts
+const FAMILY_MEMBER_TOKEN_TYPES = {
+	atom_family: `atom`,
+	mutable_atom_family: `mutable_atom`,
+	selector_family: `selector`,
+	readonly_selector_family: `readonly_selector`,
+	molecule_family: `molecule`
+};
+function counterfeit(token, key) {
+	const subKey = stringifyJson(key);
+	const fullKey = `${token.key}(${subKey})`;
+	const type = FAMILY_MEMBER_TOKEN_TYPES[token.type];
+	const stateToken = {
+		key: fullKey,
+		type
+	};
+	Object.assign(stateToken, { family: {
+		key: token.key,
+		subKey
+	} });
+	Object.assign(stateToken, { counterfeit: true });
+	return stateToken;
+}
+
+//#endregion
+//#region src/internal/store/deposit.ts
+function deposit(state) {
+	const token = {
+		key: state.key,
+		type: state.type
+	};
+	if (`family` in state) token.family = state.family;
+	return token;
+}
+
+//#endregion
+//#region src/internal/junction.ts
+var Junction = class {
+	a;
+	b;
+	cardinality;
+	relations = new Map();
+	contents = new Map();
+	isAType;
+	isBType;
+	isContent;
+	makeContentKey = (a, b) => `${a}:${b}`;
+	warn;
+	getRelatedKeys(key) {
+		return this.relations.get(key);
+	}
+	addRelation(a, b) {
+		let aRelations = this.relations.get(a);
+		let bRelations = this.relations.get(b);
+		if (aRelations) aRelations.add(b);
+		else {
+			aRelations = new Set([b]);
+			this.relations.set(a, aRelations);
+		}
+		if (bRelations) bRelations.add(a);
+		else {
+			bRelations = new Set([a]);
+			this.relations.set(b, bRelations);
+		}
+	}
+	deleteRelation(a, b) {
+		const aRelations = this.relations.get(a);
+		if (aRelations) {
+			aRelations.delete(b);
+			if (aRelations.size === 0) this.relations.delete(a);
+			const bRelations = this.relations.get(b);
+			if (bRelations) {
+				bRelations.delete(a);
+				if (bRelations.size === 0) this.relations.delete(b);
+			}
+		}
+	}
+	replaceRelationsUnsafely(x, ys) {
+		this.relations.set(x, new Set(ys));
+		for (const y of ys) {
+			const yRelations = new Set().add(x);
+			this.relations.set(y, yRelations);
+		}
+	}
+	replaceRelationsSafely(x, ys) {
+		const xRelationsPrev = this.relations.get(x);
+		let a = this.isAType?.(x) ? x : void 0;
+		let b = a === void 0 ? x : void 0;
+		if (xRelationsPrev) for (const y of xRelationsPrev) {
+			a ??= y;
+			b ??= y;
+			const yRelations = this.relations.get(y);
+			if (yRelations) {
+				if (yRelations.size === 1) this.relations.delete(y);
+				else yRelations.delete(x);
+				this.contents.delete(this.makeContentKey(a, b));
+			}
+		}
+		this.relations.set(x, new Set(ys));
+		for (const y of ys) {
+			let yRelations = this.relations.get(y);
+			if (yRelations) yRelations.add(x);
+			else {
+				yRelations = new Set().add(x);
+				this.relations.set(y, yRelations);
+			}
+		}
+	}
+	getContentInternal(contentKey) {
+		return this.contents.get(contentKey);
+	}
+	setContent(contentKey, content) {
+		this.contents.set(contentKey, content);
+	}
+	deleteContent(contentKey) {
+		this.contents.delete(contentKey);
+	}
+	constructor(data, config) {
+		this.a = data.between[0];
+		this.b = data.between[1];
+		this.cardinality = data.cardinality;
+		if (!config?.externalStore) {
+			this.relations = new Map(data.relations?.map(([x, ys]) => [x, new Set(ys)]));
+			this.contents = new Map(data.contents);
+		}
+		this.isAType = config?.isAType ?? null;
+		this.isBType = config?.isBType ?? null;
+		this.isContent = config?.isContent ?? null;
+		if (config?.makeContentKey) this.makeContentKey = config.makeContentKey;
+		if (config?.externalStore) {
+			const externalStore = config.externalStore;
+			this.has = (a, b) => externalStore.has(a, b);
+			this.addRelation = (a, b) => {
+				externalStore.addRelation(a, b);
+			};
+			this.deleteRelation = (a, b) => {
+				externalStore.deleteRelation(a, b);
+			};
+			this.replaceRelationsSafely = (a, bs) => {
+				externalStore.replaceRelationsSafely(a, bs);
+			};
+			this.replaceRelationsUnsafely = (a, bs) => {
+				externalStore.replaceRelationsUnsafely(a, bs);
+			};
+			this.getRelatedKeys = (key) => externalStore.getRelatedKeys(key);
+			if (externalStore.getContent) {
+				this.getContentInternal = (contentKey) => {
+					return externalStore.getContent(contentKey);
+				};
+				this.setContent = (contentKey, content) => {
+					externalStore.setContent(contentKey, content);
+				};
+				this.deleteContent = (contentKey) => {
+					externalStore.deleteContent(contentKey);
+				};
+			}
+			for (const [x, ys] of data.relations ?? []) {
+				let a = this.isAType?.(x) ? x : void 0;
+				let b = a === void 0 ? x : void 0;
+				for (const y of ys) {
+					a ??= y;
+					b ??= y;
+					this.addRelation(a, b);
+				}
+			}
+			for (const [contentKey, content] of data.contents ?? []) this.setContent(contentKey, content);
+		}
+		if (config?.warn) this.warn = config.warn;
+	}
+	toJSON() {
+		return {
+			between: [this.a, this.b],
+			cardinality: this.cardinality,
+			relations: [...this.relations.entries()].map(([a, b]) => [a, [...b]]),
+			contents: [...this.contents.entries()]
+		};
+	}
+	set(...params) {
+		let a;
+		let b;
+		let content;
+		switch (params.length) {
+			case 1: {
+				const relation = params[0];
+				a = relation[this.a];
+				b = relation[this.b];
+				content = void 0;
+				break;
+			}
+			case 2: {
+				const zeroth = params[0];
+				if (typeof zeroth === `string`) [a, b] = params;
+				else {
+					a = zeroth[this.a];
+					b = zeroth[this.b];
+					content = params[1];
+				}
+				break;
+			}
+			default: {
+				a = params[0];
+				b = params[1];
+				content = params[2];
+				break;
+			}
+		}
+		switch (this.cardinality) {
+			case `1:1`: {
+				const bPrev = this.getRelatedKey(a);
+				if (bPrev && bPrev !== b) this.delete(a, bPrev);
+			}
+			case `1:n`:
+				{
+					const aPrev = this.getRelatedKey(b);
+					if (aPrev && aPrev !== a) this.delete(aPrev, b);
+				}
+				break;
+			case `n:n`:
+		}
+		if (content) {
+			const contentKey = this.makeContentKey(a, b);
+			this.setContent(contentKey, content);
+		}
+		this.addRelation(a, b);
+		return this;
+	}
+	delete(x, b) {
+		b = typeof b === `string` ? b : x[this.b];
+		const a = typeof x === `string` ? x : x[this.a];
+		if (a === void 0 && typeof b === `string`) {
+			const bRelations = this.getRelatedKeys(b);
+			if (bRelations) for (const bRelation of bRelations) this.delete(bRelation, b);
+		}
+		if (typeof a === `string` && b === void 0) {
+			const aRelations = this.getRelatedKeys(a);
+			if (aRelations) for (const aRelation of aRelations) this.delete(a, aRelation);
+		}
+		if (typeof a === `string` && typeof b === `string`) {
+			this.deleteRelation(a, b);
+			const contentKey = this.makeContentKey(a, b);
+			this.deleteContent(contentKey);
+		}
+		return this;
+	}
+	getRelatedKey(key) {
+		const relations = this.getRelatedKeys(key);
+		if (relations) {
+			if (relations.size > 1) this.warn?.(`${relations.size} related keys were found for key "${key}": (${[...relations].map((k) => `"${k}"`).join(`, `)}). Only one related key was expected.`);
+			let singleRelation;
+			for (const relation of relations) {
+				singleRelation = relation;
+				break;
+			}
+			return singleRelation;
+		}
+	}
+	replaceRelations(x, relations, config) {
+		const hasContent = !Array.isArray(relations);
+		const ys = hasContent ? Object.keys(relations) : relations;
+		if (config?.reckless) this.replaceRelationsUnsafely(x, ys);
+		else this.replaceRelationsSafely(x, ys);
+		if (hasContent) for (const y of ys) {
+			const contentKey = this.makeContentKey(x, y);
+			const content = relations[y];
+			this.setContent(contentKey, content);
+		}
+		return this;
+	}
+	getContent(a, b) {
+		const contentKey = this.makeContentKey(a, b);
+		return this.getContentInternal(contentKey);
+	}
+	getRelationEntries(input) {
+		const a = input[this.a];
+		const b = input[this.b];
+		if (a !== void 0 && b === void 0) {
+			const aRelations = this.getRelatedKeys(a);
+			if (aRelations) return [...aRelations].map((aRelation) => {
+				return [aRelation, this.getContent(a, aRelation)];
+			});
+		}
+		if (a === void 0 && b !== void 0) {
+			const bRelations = this.getRelatedKeys(b);
+			if (bRelations) return [...bRelations].map((bRelation) => {
+				return [bRelation, this.getContent(bRelation, b)];
+			});
+		}
+		return [];
+	}
+	has(a, b) {
+		if (b) {
+			const setA = this.getRelatedKeys(a);
+			return setA?.has(b) ?? false;
+		}
+		return this.relations.has(a);
+	}
+};
+
+//#endregion
+//#region src/internal/subject.ts
+var Subject = class {
+	Subscriber;
+	subscribers = new Map();
+	subscribe(key, subscriber) {
+		this.subscribers.set(key, subscriber);
+		const unsubscribe = () => {
+			this.unsubscribe(key);
+		};
+		return unsubscribe;
+	}
+	unsubscribe(key) {
+		this.subscribers.delete(key);
+	}
+	next(value) {
+		const subscribers = this.subscribers.values();
+		for (const subscriber of subscribers) subscriber(value);
+	}
+};
+var StatefulSubject = class extends Subject {
+	state;
+	constructor(initialState) {
+		super();
+		this.state = initialState;
+	}
+	next(value) {
+		this.state = value;
+		super.next(value);
+	}
+};
+
+//#endregion
+//#region src/internal/transaction/is-root-store.ts
+function isRootStore(store) {
+	return `epoch` in store.transactionMeta;
+}
+function isChildStore(store) {
+	return `phase` in store.transactionMeta;
+}
+
+//#endregion
+//#region src/internal/transaction/abort-transaction.ts
+const abortTransaction = (store) => {
+	const target = newest(store);
+	if (!isChildStore(target)) {
+		store.logger.warn(`🐞`, `transaction`, `???`, `abortTransaction called outside of a transaction. This is probably a bug in AtomIO.`);
+		return;
+	}
+	store.logger.info(`🪂`, `transaction`, target.transactionMeta.update.key, `Aborting transaction`);
+	target.parent.child = null;
+};
+
+//#endregion
+//#region src/internal/capitalize.ts
+function capitalize(string) {
+	return string[0].toUpperCase() + string.slice(1);
+}
+
+//#endregion
+//#region src/internal/pretty-print.ts
+function prettyPrintTokenType(token) {
+	return token.type.split(`_`).map(capitalize).join(` `);
+}
+
+//#endregion
+//#region src/internal/not-found-error.ts
+var NotFoundError = class extends Error {
+	constructor(token, store) {
+		super(`${prettyPrintTokenType(token)} ${stringifyJson(token.key)} not found in store "${store.config.name}".`);
+	}
+};
+
+//#endregion
+//#region src/internal/transaction/act-upon-store.ts
+function actUponStore(store, token, id) {
+	return (...parameters) => {
+		const tx = withdraw(store, token);
+		if (tx) return tx.run(parameters, id);
+		throw new NotFoundError(token, store);
+	};
+}
+
+//#endregion
+//#region src/internal/set-state/become.ts
+const become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(originalThing) : nextVersionOfThing;
+
+//#endregion
+//#region src/internal/get-state/read-or-compute-value.ts
+const readOrComputeValue = (target, state) => {
+	if (target.valueMap.has(state.key)) {
+		target.logger.info(`📖`, state.type, state.key, `reading cached value`);
+		return readCachedValue(state, target);
+	}
+	switch (state.type) {
+		case `selector`:
+		case `readonly_selector`:
+			target.logger.info(`🧮`, state.type, state.key, `computing value`);
+			return state.get();
+		case `atom`:
+		case `mutable_atom`: {
+			const def = state.default;
+			let fallback;
+			if (def instanceof Function) fallback = def();
+			else fallback = def;
+			target.logger.info(`💁`, `atom`, state.key, `could not find cached value; using default`, fallback);
+			return fallback;
+		}
+	}
+};
+
+//#endregion
+//#region src/internal/operation.ts
+const openOperation = (store, token) => {
+	if (store.operation.open) {
+		const rejectionTime = performance.now();
+		store.logger.info(`❗`, token.type, token.key, `deferring setState at T-${rejectionTime} until setState for "${store.operation.token.key}" is done`);
+		return rejectionTime;
+	}
+	store.operation = {
+		open: true,
+		done: new Set(),
+		prev: new Map(),
+		time: Date.now(),
+		token
+	};
+	store.logger.info(`⭕`, token.type, token.key, `operation start in store "${store.config.name}"${!isChildStore(store) ? `` : ` ${store.transactionMeta.phase} "${store.transactionMeta.update.key}"`}`);
+};
+const closeOperation = (store) => {
+	if (store.operation.open) store.logger.info(`🔴`, store.operation.token.type, store.operation.token.key, `operation done in store "${store.config.name}"`);
+	store.operation = { open: false };
+	store.on.operationClose.next(store.operation);
+};
+const isDone = (store, key) => {
+	if (!store.operation.open) {
+		store.logger.error(`🐞`, `unknown`, key, `isDone called outside of an operation. This is probably a bug in AtomIO.`);
+		return true;
+	}
+	return store.operation.done.has(key);
+};
+const markDone = (store, key) => {
+	if (!store.operation.open) {
+		store.logger.error(`🐞`, `unknown`, key, `markDone called outside of an operation. This is probably a bug in AtomIO.`);
+		return;
+	}
+	store.operation.done.add(key);
+};
+
+//#endregion
+//#region src/internal/set-state/emit-update.ts
+const emitUpdate = (store, state, update) => {
+	switch (state.type) {
+		case `mutable_atom`:
+			store.logger.info(`📢`, state.type, state.key, `is now (`, update.newValue, `) subscribers:`, state.subject.subscribers);
+			break;
+		case `atom`:
+		case `selector`:
+		case `readonly_selector`: store.logger.info(`📢`, state.type, state.key, `went (`, update.oldValue, `->`, update.newValue, `) subscribers:`, state.subject.subscribers);
+	}
+	state.subject.next(update);
+};
+
+//#endregion
+//#region src/internal/set-state/evict-downstream.ts
+const evictDownStream = (store, atom$1) => {
+	const target = newest(store);
+	const downstreamKeys = target.selectorAtoms.getRelatedKeys(atom$1.key);
+	target.logger.info(`🧹`, atom$1.type, atom$1.key, downstreamKeys ? `evicting ${downstreamKeys.size} states downstream:` : `no downstream states`, downstreamKeys ?? `to evict`);
+	if (downstreamKeys) {
+		if (target.operation.open) target.logger.info(`🧹`, atom$1.type, atom$1.key, `[ ${[...target.operation.done].join(`, `)} ] already done`);
+		for (const key of downstreamKeys) {
+			if (isDone(target, key)) continue;
+			evictCachedValue(key, target);
+			markDone(target, key);
+		}
+	}
+};
+
+//#endregion
+//#region src/internal/set-state/set-atom.ts
+const setAtom = (target, atom$1, next) => {
+	const oldValue = readOrComputeValue(target, atom$1);
+	let newValue = oldValue;
+	if (atom$1.type === `mutable_atom` && isChildStore(target)) {
+		const { parent } = target;
+		const copiedValue = copyMutableIfNeeded(target, atom$1, parent);
+		newValue = copiedValue;
+	}
+	newValue = become(next)(newValue);
+	target.logger.info(`📝`, `atom`, atom$1.key, `set to`, newValue);
+	newValue = cacheValue(target, atom$1.key, newValue, atom$1.subject);
+	if (isAtomDefault(target, atom$1.key)) markAtomAsNotDefault(target, atom$1.key);
+	markDone(target, atom$1.key);
+	evictDownStream(target, atom$1);
+	const update = {
+		oldValue,
+		newValue
+	};
+	if (!isChildStore(target)) {
+		emitUpdate(target, atom$1, update);
+		return;
+	}
+	if (target.on.transactionApplying.state === null) {
+		const { key } = atom$1;
+		if (isTransceiver(update.newValue)) return;
+		const atomUpdate = {
+			type: `atom_update`,
+			key,
+			...update
+		};
+		if (atom$1.family) atomUpdate.family = atom$1.family;
+		target.transactionMeta.update.updates.push(atomUpdate);
+		target.logger.info(`📁`, `atom`, key, `stowed (`, update.oldValue, `->`, update.newValue, `)`);
+	} else if (atom$1.key.startsWith(`*`)) {
+		const mutableKey = atom$1.key.slice(1);
+		const mutableAtom = target.atoms.get(mutableKey);
+		let transceiver = target.valueMap.get(mutableKey);
+		if (mutableAtom.type === `mutable_atom` && isChildStore(target)) {
+			const { parent } = target;
+			const copiedValue = copyMutableIfNeeded(target, mutableAtom, parent);
+			transceiver = copiedValue;
+		}
+		const accepted = transceiver.do(update.newValue) === null;
+		if (accepted) evictDownStream(target, mutableAtom);
+	}
+};
+
+//#endregion
+//#region src/internal/set-state/set-atom-or-selector.ts
+const setAtomOrSelector = (store, state, value) => {
+	switch (state.type) {
+		case `atom`:
+		case `mutable_atom`:
+			setAtom(store, state, value);
+			break;
+		case `selector`:
+			state.set(value);
+			break;
+	}
+};
+
+//#endregion
+//#region src/internal/families/create-regular-atom-family.ts
+function createRegularAtomFamily(store, options, internalRoles) {
+	const familyToken = {
+		key: options.key,
+		type: `atom_family`
+	};
+	const existing = store.families.get(options.key);
+	if (existing) store.logger.error(`❗`, `atom_family`, options.key, `Overwriting an existing ${prettyPrintTokenType(existing)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);
+	const subject = new Subject();
+	const familyFunction = (key) => {
+		const subKey = stringifyJson(key);
+		const family = {
+			key: options.key,
+			subKey
+		};
+		const fullKey = `${options.key}(${subKey})`;
+		const target = newest(store);
+		const def = options.default;
+		const individualOptions = {
+			key: fullKey,
+			default: def instanceof Function ? def(key) : def
+		};
+		if (options.effects) individualOptions.effects = options.effects(key);
+		const token = createRegularAtom(target, individualOptions, family);
+		subject.next({
+			type: `state_creation`,
+			token
+		});
+		return token;
+	};
+	const atomFamily$1 = Object.assign(familyFunction, familyToken, {
+		subject,
+		install: (s) => createRegularAtomFamily(s, options),
+		internalRoles
+	});
+	store.families.set(options.key, atomFamily$1);
+	store.defaults.set(options.key, options.default);
+	return familyToken;
+}
+
+//#endregion
+//#region src/internal/families/create-atom-family.ts
+function createAtomFamily(store, options) {
+	const isMutable = `mutable` in options;
+	if (isMutable) return createMutableAtomFamily(store, options);
+	return createRegularAtomFamily(store, options);
+}
+
+//#endregion
+//#region src/internal/keys.ts
+const isAtomKey = (store, key) => newest(store).atoms.has(key);
+const isSelectorKey = (store, key) => newest(store).selectors.has(key);
+const isReadonlySelectorKey = (store, key) => newest(store).readonlySelectors.has(key);
+const isStateKey = (store, key) => isAtomKey(store, key) || isSelectorKey(store, key) || isReadonlySelectorKey(store, key);
+
+//#endregion
+//#region src/internal/selector/get-selector-dependency-keys.ts
+const getSelectorDependencyKeys = (key, store) => {
+	const sources = newest(store).selectorGraph.getRelationEntries({ downstreamSelectorKey: key }).filter(([_, { source }]) => source !== key).map(([_, { source }]) => source).filter((source) => isStateKey(store, source));
+	return sources;
+};
+
+//#endregion
+//#region src/internal/selector/trace-selector-atoms.ts
+const traceSelectorAtoms = (directDependencyKey, covered, store) => {
+	const rootKeys = [];
+	const indirectDependencyKeys = getSelectorDependencyKeys(directDependencyKey, store);
+	while (indirectDependencyKeys.length > 0) {
+		const indirectDependencyKey = indirectDependencyKeys.shift();
+		if (covered.has(indirectDependencyKey)) continue;
+		covered.add(indirectDependencyKey);
+		if (!isAtomKey(store, indirectDependencyKey)) indirectDependencyKeys.push(...getSelectorDependencyKeys(indirectDependencyKey, store));
+		else if (!rootKeys.includes(indirectDependencyKey)) rootKeys.push(indirectDependencyKey);
+	}
+	return rootKeys;
+};
+const traceAllSelectorAtoms = (selector, store) => {
+	const selectorKey = selector.key;
+	const directDependencyKeys = getSelectorDependencyKeys(selectorKey, store);
+	const covered = new Set();
+	return directDependencyKeys.flatMap((depKey) => isAtomKey(store, depKey) ? depKey : traceSelectorAtoms(depKey, covered, store));
+};
+
+//#endregion
+//#region src/internal/selector/update-selector-atoms.ts
+const updateSelectorAtoms = (selectorKey, dependency, covered, store) => {
+	const target = newest(store);
+	if (dependency.type === `atom` || dependency.type === `mutable_atom`) {
+		target.selectorAtoms.set({
+			selectorKey,
+			atomKey: dependency.key
+		});
+		store.logger.info(`🔍`, `selector`, selectorKey, `discovers root atom "${dependency.key}"`);
+	} else {
+		const rootKeys = traceSelectorAtoms(dependency.key, covered, store);
+		store.logger.info(`🔍`, `selector`, selectorKey, `discovers root atoms: [ ${rootKeys.map((key) => `"${key}"`).join(`, `)} ]`);
+		for (const atomKey of rootKeys) target.selectorAtoms = target.selectorAtoms.set({
+			selectorKey,
+			atomKey
+		});
+	}
+	covered.add(dependency.key);
+};
+
+//#endregion
+//#region src/internal/selector/register-selector.ts
+const registerSelector = (selectorKey, covered, store) => ({
+	get: (...params) => {
+		const target = newest(store);
+		let dependency;
+		if (params.length === 2) {
+			const [family, key] = params;
+			dependency = findInStore(store, family, key);
+		} else [dependency] = params;
+		const dependencyState = withdraw(store, dependency);
+		const dependencyValue = readOrComputeValue(store, dependencyState);
+		store.logger.info(`🔌`, `selector`, selectorKey, `registers dependency ( "${dependency.key}" =`, dependencyValue, `)`);
+		target.selectorGraph.set({
+			upstreamSelectorKey: dependency.key,
+			downstreamSelectorKey: selectorKey
+		}, { source: dependency.key });
+		updateSelectorAtoms(selectorKey, dependency, covered, store);
+		return dependencyValue;
+	},
+	set: (...params) => {
+		let token;
+		let value;
+		if (params.length === 2) {
+			token = params[0];
+			value = params[1];
+		} else {
+			const family = params[0];
+			const key = params[1];
+			value = params[2];
+			token = findInStore(store, family, key);
+		}
+		const target = newest(store);
+		const state = withdraw(target, token);
+		setAtomOrSelector(target, state, value);
+	},
+	find: (...args) => findInStore(store, ...args),
+	json: (token) => getJsonToken(store, token)
+});
+
+//#endregion
+//#region src/internal/selector/create-readonly-selector.ts
+const createReadonlySelector = (store, options, family) => {
+	const target = newest(store);
+	const subject = new Subject();
+	const covered = new Set();
+	const { get, find, json } = registerSelector(options.key, covered, target);
+	const getSelf = () => {
+		const value = options.get({
+			get,
+			find,
+			json
+		});
+		cacheValue(newest(store), options.key, value, subject);
+		covered.clear();
+		return value;
+	};
+	const readonlySelector = {
+		...options,
+		subject,
+		install: (s) => createReadonlySelector(s, options, family),
+		get: getSelf,
+		type: `readonly_selector`,
+		...family && { family }
+	};
+	target.readonlySelectors.set(options.key, readonlySelector);
+	const initialValue = getSelf();
+	store.logger.info(`✨`, readonlySelector.type, readonlySelector.key, `=`, initialValue);
+	const token = {
+		key: options.key,
+		type: `readonly_selector`
+	};
+	if (family) token.family = family;
+	return token;
+};
+
+//#endregion
+//#region src/internal/selector/create-writable-selector.ts
+const createWritableSelector = (store, options, family) => {
+	const target = newest(store);
+	const subject = new Subject();
+	const covered = new Set();
+	const setterToolkit = registerSelector(options.key, covered, target);
+	const { find, get, json } = setterToolkit;
+	const getterToolkit = {
+		find,
+		get,
+		json
+	};
+	const getSelf = (getFn = options.get, innerTarget = newest(store)) => {
+		const value = getFn(getterToolkit);
+		cacheValue(innerTarget, options.key, value, subject);
+		covered.clear();
+		return value;
+	};
+	const setSelf = (next) => {
+		const innerTarget = newest(store);
+		const oldValue = getSelf(options.get, innerTarget);
+		const newValue = become(next)(oldValue);
+		store.logger.info(`📝`, `selector`, options.key, `set (`, oldValue, `->`, newValue, `)`);
+		cacheValue(innerTarget, options.key, newValue, subject);
+		markDone(innerTarget, options.key);
+		if (isRootStore(innerTarget)) subject.next({
+			newValue,
+			oldValue
+		});
+		options.set(setterToolkit, newValue);
+	};
+	const mySelector = {
+		...options,
+		subject,
+		install: (s) => createWritableSelector(s, options, family),
+		get: getSelf,
+		set: setSelf,
+		type: `selector`,
+		...family && { family }
+	};
+	target.selectors.set(options.key, mySelector);
+	const initialValue = getSelf();
+	store.logger.info(`✨`, mySelector.type, mySelector.key, `=`, initialValue);
+	const token = {
+		key: options.key,
+		type: `selector`
+	};
+	if (family) token.family = family;
+	return token;
+};
+
+//#endregion
+//#region src/internal/selector/create-standalone-selector.ts
+function createStandaloneSelector(store, options) {
+	const isWritable = `set` in options;
+	if (isWritable) {
+		const state$1 = createWritableSelector(store, options, void 0);
+		store.on.selectorCreation.next(state$1);
+		return state$1;
+	}
+	const state = createReadonlySelector(store, options, void 0);
+	store.on.selectorCreation.next(state);
+	return state;
+}
+
+//#endregion
+//#region src/internal/selector/dispose-selector.ts
+function disposeSelector(store, selectorToken) {
+	const target = newest(store);
+	const { key } = selectorToken;
+	const selector = withdraw(target, selectorToken);
+	if (!selector.family) store.logger.error(`❌`, `selector`, key, `Standalone selectors cannot be disposed.`);
+	else {
+		const molecule = target.molecules.get(selector.family.subKey);
+		if (molecule) target.moleculeData.delete(selector.family.subKey, selector.family.key);
+		let familyToken;
+		switch (selectorToken.type) {
+			case `selector`:
+				{
+					target.selectors.delete(key);
+					familyToken = {
+						key: selector.family.key,
+						type: `selector_family`
+					};
+					const family = withdraw(store, familyToken);
+					family.subject.next({
+						type: `state_disposal`,
+						subType: `selector`,
+						token: selectorToken
+					});
+				}
+				break;
+			case `readonly_selector`:
+				{
+					target.readonlySelectors.delete(key);
+					familyToken = {
+						key: selector.family.key,
+						type: `readonly_selector_family`
+					};
+					const family = withdraw(store, familyToken);
+					family.subject.next({
+						type: `state_disposal`,
+						subType: `selector`,
+						token: selectorToken
+					});
+				}
+				break;
+		}
+		target.valueMap.delete(key);
+		target.selectorAtoms.delete(key);
+		target.selectorGraph.delete(key);
+		store.logger.info(`🔥`, selectorToken.type, key, `deleted`);
+		if (isChildStore(target) && target.transactionMeta.phase === `building`) target.transactionMeta.update.updates.push({
+			type: `state_disposal`,
+			subType: `selector`,
+			token: selectorToken
+		});
+		else store.on.selectorDisposal.next(selectorToken);
+	}
+}
+
+//#endregion
+//#region src/internal/families/create-readonly-selector-family.ts
+function createReadonlySelectorFamily(store, options, internalRoles) {
+	const familyToken = {
+		key: options.key,
+		type: `readonly_selector_family`
+	};
+	const existing = store.families.get(options.key);
+	if (existing) store.logger.error(`❗`, `readonly_selector_family`, options.key, `Overwriting an existing ${prettyPrintTokenType(existing)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);
+	const subject = new Subject();
+	const familyFunction = (key) => {
+		const subKey = stringifyJson(key);
+		const family = {
+			key: options.key,
+			subKey
+		};
+		const fullKey = `${options.key}(${subKey})`;
+		const target = newest(store);
+		const token = createReadonlySelector(target, {
+			key: fullKey,
+			get: options.get(key)
+		}, family);
+		subject.next({
+			type: `state_creation`,
+			token
+		});
+		return token;
+	};
+	const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
+		internalRoles,
+		subject,
+		install: (s) => createReadonlySelectorFamily(s, options),
+		default: (key) => {
+			const getFn = options.get(key);
+			return getFn({
+				get: (...args) => getFromStore(store, ...args),
+				find: (...args) => findInStore(store, ...args),
+				json: (token) => getJsonToken(store, token)
+			});
+		}
+	});
+	store.families.set(options.key, readonlySelectorFamily);
+	return familyToken;
+}
+
+//#endregion
+//#region src/internal/families/create-writable-selector-family.ts
+function createWritableSelectorFamily(store, options, internalRoles) {
+	const familyToken = {
+		key: options.key,
+		type: `selector_family`
+	};
+	const existing = store.families.get(options.key);
+	if (existing) store.logger.error(`❗`, `selector_family`, options.key, `Overwriting an existing ${prettyPrintTokenType(existing)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);
+	const subject = new Subject();
+	const familyFunction = (key) => {
+		const subKey = stringifyJson(key);
+		const family = {
+			key: options.key,
+			subKey
+		};
+		const fullKey = `${options.key}(${subKey})`;
+		const target = newest(store);
+		const token = createWritableSelector(target, {
+			key: fullKey,
+			get: options.get(key),
+			set: options.set(key)
+		}, family);
+		subject.next({
+			type: `state_creation`,
+			token
+		});
+		return token;
+	};
+	const selectorFamily$1 = Object.assign(familyFunction, familyToken, {
+		internalRoles,
+		subject,
+		install: (s) => createWritableSelectorFamily(s, options),
+		default: (key) => {
+			const getFn = options.get(key);
+			return getFn({
+				get: (...args) => getFromStore(store, ...args),
+				find: (...args) => findInStore(store, ...args),
+				json: (token) => getJsonToken(store, token)
+			});
+		}
+	});
+	store.families.set(options.key, selectorFamily$1);
+	return familyToken;
+}
+
+//#endregion
+//#region src/internal/families/create-selector-family.ts
+function createSelectorFamily(store, options) {
+	const isWritable = `set` in options;
+	if (isWritable) return createWritableSelectorFamily(store, options);
+	return createReadonlySelectorFamily(store, options);
+}
+
+//#endregion
+//#region src/internal/families/init-family-member.ts
+function initFamilyMemberInStore(store, token, key) {
+	const family = store.families.get(token.key);
+	if (family === void 0) throw new NotFoundError(token, store);
+	const state = family(key);
+	const target = newest(store);
+	if (state.family) {
+		if (isRootStore(target)) switch (state.type) {
+			case `atom`:
+			case `mutable_atom`:
+				store.on.atomCreation.next(state);
+				break;
+			case `selector`:
+			case `readonly_selector`:
+				store.on.selectorCreation.next(state);
+				break;
+		}
+		else if (isChildStore(target) && target.on.transactionApplying.state === null) target.transactionMeta.update.updates.push({
+			type: `state_creation`,
+			token: state
+		});
+	}
+	return state;
+}
+
+//#endregion
+//#region src/internal/families/seek-in-store.ts
+function seekInStore(store, token, key) {
+	const subKey = stringifyJson(key);
+	const fullKey = `${token.key}(${subKey})`;
+	const target = newest(store);
+	let state;
+	switch (token.type) {
+		case `atom_family`:
+		case `mutable_atom_family`:
+			state = target.atoms.get(fullKey);
+			break;
+		case `selector_family`:
+			state = target.selectors.get(fullKey);
+			break;
+		case `readonly_selector_family`:
+			state = target.readonlySelectors.get(fullKey);
+			break;
+	}
+	if (state) return deposit(state);
+	return state;
+}
+
+//#endregion
+//#region src/internal/families/find-in-store.ts
+function findInStore(store, token, key) {
+	let state = seekInStore(store, token, key);
+	if (state) return state;
+	const stringKey = stringifyJson(key);
+	const molecule = store.molecules.get(stringKey);
+	if (!molecule && store.config.lifespan === `immortal`) {
+		const fakeToken = counterfeit(token, key);
+		store.logger.error(`❌`, fakeToken.type, fakeToken.key, `was not found in store "${store.config.name}"; returned a counterfeit token.`);
+		return fakeToken;
+	}
+	state = initFamilyMemberInStore(store, token, key);
+	if (molecule) {
+		const target = newest(store);
+		target.moleculeData.set(stringKey, token.key);
+	}
+	return state;
+}
+
+//#endregion
+//#region src/internal/families/dispose-from-store.ts
+function disposeFromStore(store, ...params) {
+	let token;
+	if (params.length === 1) token = params[0];
+	else {
+		const family = params[0];
+		const key = params[1];
+		const maybeToken = findInStore(store, family, key);
+		token = maybeToken;
+	}
+	try {
+		withdraw(store, token);
+	} catch (thrown) {
+		store.logger.error(`❌`, token.type, token.key, `could not be disposed because it was not found in the store "${store.config.name}".`);
+		return;
+	}
+	switch (token.type) {
+		case `atom`:
+		case `mutable_atom`:
+			disposeAtom(store, token);
+			break;
+		case `selector`:
+		case `readonly_selector`:
+			disposeSelector(store, token);
+			break;
+	}
+}
+
+//#endregion
+//#region src/internal/families/get-family-of-token.ts
+function getFamilyOfToken(store, token) {
+	if (token.family) {
+		const family = store.families.get(token.family.key);
+		if (family) return family;
+	}
+}
+
+//#endregion
+//#region src/internal/set-state/set-into-store.ts
+function setIntoStore(store, ...params) {
+	let token;
+	let family;
+	let key;
+	let value;
+	if (params.length === 2) {
+		token = params[0];
+		value = params[1];
+		family = getFamilyOfToken(store, token) ?? null;
+		if (family) {
+			key = token.family ? parseJson(token.family.subKey) : null;
+			token = findInStore(store, family, key);
+		}
+	} else {
+		family = params[0];
+		key = params[1];
+		value = params[2];
+		token = findInStore(store, family, key);
+	}
+	if (`counterfeit` in token && `family` in token) {
+		const subKey = token.family.subKey;
+		const disposal = store.disposalTraces.buffer.find((item) => item?.key === subKey);
+		store.logger.error(`❌`, token.type, token.key, `could not be set because it was not found in the store "${store.config.name}".`, disposal ? `This state was previously disposed:\n${disposal.trace}` : `No previous disposal trace was found.`);
+		return;
+	}
+	const rejectionTime = openOperation(store, token);
+	if (rejectionTime) {
+		const unsubscribe = store.on.operationClose.subscribe(`waiting to set "${token.key}" at T-${rejectionTime}`, () => {
+			unsubscribe();
+			store.logger.info(`🟢`, token.type, token.key, `resuming deferred setState from T-${rejectionTime}`);
+			setIntoStore(store, token, value);
+		});
+		return;
+	}
+	const state = withdraw(store, token);
+	setAtomOrSelector(store, state, value);
+	closeOperation(store);
+}
+
+//#endregion
+//#region src/internal/ingest-updates/ingest-atom-update.ts
+function ingestAtomUpdate(applying, atomUpdate, store) {
+	const { key, newValue, oldValue } = atomUpdate;
+	const value = applying === `newValue` ? newValue : oldValue;
+	const token = {
+		key,
+		type: `atom`
+	};
+	if (atomUpdate.family) Object.assign(token, { family: atomUpdate.family });
+	setIntoStore(store, token, value);
+}
+
+//#endregion
+//#region src/internal/get-trace.ts
+function getTrace(error) {
+	const { stack } = error;
+	if (stack) return `\n` + stack.split(`\n`)?.slice(1)?.join(`\n`);
+	return ``;
+}
+
+//#endregion
+//#region src/internal/molecule.ts
+function makeRootMoleculeInStore(key, store = IMPLICIT.STORE) {
+	const molecule = {
+		key,
+		stringKey: stringifyJson(key),
+		dependsOn: `any`
+	};
+	store.molecules.set(stringifyJson(key), molecule);
+	return key;
+}
+function allocateIntoStore(store, provenance, key, dependsOn = `any`) {
+	const origin = provenance;
+	const stringKey = stringifyJson(key);
+	const invalidKeys = [];
+	const target = newest(store);
+	if (Array.isArray(origin)) for (const formerClaim of origin) {
+		const claimString = stringifyJson(formerClaim);
+		const claim = target.molecules.get(claimString);
+		if (claim) store.moleculeGraph.set(claimString, stringKey, { source: claimString });
+		else invalidKeys.push(claimString);
+	}
+	else {
+		const claimString = stringifyJson(origin);
+		const claim = target.molecules.get(claimString);
+		if (claim) store.moleculeGraph.set(claimString, stringKey, { source: claimString });
+		else invalidKeys.push(claimString);
+	}
+	if (invalidKeys.length === 0) target.molecules.set(stringKey, {
+		key,
+		stringKey,
+		dependsOn
+	});
+	const creationEvent = {
+		type: `molecule_creation`,
+		key,
+		provenance: origin
+	};
+	const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
+	if (isTransaction) target.transactionMeta.update.updates.push(creationEvent);
+	else target.on.moleculeCreation.next(creationEvent);
+	for (const claim of invalidKeys) {
+		const disposal = store.disposalTraces.buffer.find((item) => item?.key === claim);
+		store.logger.error(`❌`, `molecule`, key, `allocation failed:`, `Could not allocate to ${claim} in store "${store.config.name}".`, disposal ? `\n   ${claim} was most recently disposed\n${disposal.trace}` : `No previous disposal trace for ${claim} was found.`);
+	}
+	return key;
+}
+function fuseWithinStore(store, type, sideA, sideB) {
+	const compoundKey = `T$--${type}==${sideA}++${sideB}`;
+	const above = [sideA, sideB];
+	allocateIntoStore(store, above, compoundKey, `all`);
+	return compoundKey;
+}
+function deallocateFromStore(store, claim) {
+	const stringKey = stringifyJson(claim);
+	const molecule = store.molecules.get(stringKey);
+	if (!molecule) {
+		const disposal = store.disposalTraces.buffer.find((item) => item?.key === stringKey);
+		store.logger.error(`❌`, `molecule`, claim, `deallocation failed:`, `Could not find allocation for ${stringKey} in store "${store.config.name}".`, disposal ? `\n   This state was most recently deallocated\n${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`);
+		return;
+	}
+	const joinKeys = store.moleculeJoins.getRelatedKeys(molecule.key);
+	if (joinKeys) for (const joinKey of joinKeys) {
+		const join$1 = store.joins.get(joinKey);
+		if (join$1) {
+			join$1.relations.delete(molecule.key);
+			join$1.molecules.delete(molecule.stringKey);
+		}
+	}
+	store.moleculeJoins.delete(molecule.stringKey);
+	const provenance = [];
+	const values = [];
+	const disposalEvent = {
+		type: `molecule_disposal`,
+		key: molecule.key,
+		values,
+		provenance
+	};
+	const target = newest(store);
+	target.molecules.delete(stringKey);
+	const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
+	if (isTransaction) target.transactionMeta.update.updates.push(disposalEvent);
+	const relatedMolecules = store.moleculeGraph.getRelationEntries({ downstreamMoleculeKey: molecule.stringKey });
+	if (relatedMolecules) for (const [relatedStringKey, { source }] of relatedMolecules) if (source === molecule.stringKey) {
+		const relatedKey = parseJson(relatedStringKey);
+		deallocateFromStore(store, relatedKey);
+	} else provenance.push(source);
+	const familyKeys = target.moleculeData.getRelatedKeys(molecule.stringKey);
+	if (familyKeys) for (const familyKey of familyKeys) {
+		const family = target.families.get(familyKey);
+		const token = findInStore(store, family, molecule.key);
+		values.push([family.key, token]);
+		disposeFromStore(store, token);
+	}
+	target.moleculeGraph.delete(molecule.stringKey);
+	target.moleculeJoins.delete(molecule.stringKey);
+	target.moleculeData.delete(molecule.stringKey);
+	if (!isTransaction) target.on.moleculeDisposal.next(disposalEvent);
+	target.molecules.delete(molecule.stringKey);
+	const trace = getTrace(new Error());
+	store.disposalTraces.add({
+		key: stringKey,
+		trace
+	});
+}
+function claimWithinStore(store, newProvenance, claim, exclusive) {
+	const stringKey = stringifyJson(claim);
+	const target = newest(store);
+	const molecule = target.molecules.get(stringKey);
+	if (!molecule) {
+		const disposal = store.disposalTraces.buffer.find((item) => item?.key === stringKey);
+		store.logger.error(`❌`, `molecule`, claim, `claim failed:`, `Could not allocate to ${stringKey} in store "${store.config.name}".`, disposal ? `\n   ${stringKey} was most recently disposed\n${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`);
+		return claim;
+	}
+	const newProvenanceKey = stringifyJson(newProvenance);
+	const newProvenanceMolecule = target.molecules.get(newProvenanceKey);
+	if (!newProvenanceMolecule) {
+		const disposal = store.disposalTraces.buffer.find((item) => item?.key === newProvenanceKey);
+		store.logger.error(`❌`, `molecule`, claim, `claim failed:`, `Could not allocate to ${newProvenanceKey} in store "${store.config.name}".`, disposal ? `\n   ${newProvenanceKey} was most recently disposed\n${disposal.trace}` : `No previous disposal trace for ${newProvenanceKey} was found.`);
+		return claim;
+	}
+	const priorProvenance = store.moleculeGraph.getRelationEntries({ downstreamMoleculeKey: molecule.stringKey }).filter(([, { source }]) => source !== stringKey).map(([key]) => parseJson(key));
+	if (exclusive) target.moleculeGraph.delete(stringKey);
+	target.moleculeGraph.set({
+		upstreamMoleculeKey: newProvenanceMolecule.stringKey,
+		downstreamMoleculeKey: molecule.stringKey
+	}, { source: newProvenanceMolecule.stringKey });
+	const transferEvent = {
+		type: `molecule_transfer`,
+		key: molecule.key,
+		from: priorProvenance,
+		to: [newProvenanceMolecule.key]
+	};
+	const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
+	if (isTransaction) target.transactionMeta.update.updates.push(transferEvent);
+	return claim;
+}
+
+//#endregion
+//#region src/internal/ingest-updates/ingest-creation-disposal.ts
+function ingestCreationEvent(update, applying, store) {
+	switch (applying) {
+		case `newValue`: {
+			createInStore(update, store);
+			break;
+		}
+		case `oldValue`: {
+			disposeFromStore(store, update.token);
+			break;
+		}
+	}
+}
+function ingestDisposalEvent(update, applying, store) {
+	switch (applying) {
+		case `newValue`: {
+			disposeFromStore(store, update.token);
+			break;
+		}
+		case `oldValue`: {
+			createInStore(update, store);
+			if (update.subType === `atom`) store.valueMap.set(update.token.key, update.value);
+			break;
+		}
+	}
+}
+function createInStore(update, store) {
+	const { family: familyMeta } = update.token;
+	if (familyMeta) {
+		const family = store.families.get(familyMeta.key);
+		if (family) findInStore(store, family, parseJson(familyMeta.subKey));
+	}
+}
+function ingestMoleculeCreationEvent(update, applying, store) {
+	switch (applying) {
+		case `newValue`:
+			allocateIntoStore(store, update.provenance, update.key);
+			break;
+		case `oldValue`:
+			deallocateFromStore(store, update.key);
+			break;
+	}
+}
+function ingestMoleculeDisposalEvent(update, applying, store) {
+	switch (applying) {
+		case `newValue`:
+			deallocateFromStore(store, update.key);
+			break;
+		case `oldValue`:
+			{
+				const provenanceJson = update.provenance.map(parseJson);
+				allocateIntoStore(store, provenanceJson, update.key);
+				for (const [familyKey, value] of update.values) {
+					const family = store.families.get(familyKey);
+					if (family) {
+						findInStore(store, family, update.key);
+						const memberKey = `${familyKey}(${stringifyJson(update.key)})`;
+						store.valueMap.set(memberKey, value);
+					}
+				}
+			}
+			break;
+	}
+}
+function ingestMoleculeTransferEvent(update, applying, store) {
+	switch (applying) {
+		case `newValue`:
+			{
+				const provenance = update.to.length === 1 ? update.to[0] : update.to;
+				claimWithinStore(store, provenance, update.key, `exclusive`);
+			}
+			break;
+		case `oldValue`:
+			{
+				const provenance = update.from.length === 1 ? update.from[0] : update.from;
+				claimWithinStore(store, provenance, update.key, `exclusive`);
+			}
+			break;
+	}
+}
+
+//#endregion
+//#region src/internal/ingest-updates/ingest-selector-update.ts
+function ingestSelectorUpdate(applying, selectorUpdate, store) {
+	const updates = applying === `newValue` ? selectorUpdate.atomUpdates : selectorUpdate.atomUpdates.toReversed();
+	for (const atomUpdate of updates) ingestAtomUpdate(applying, atomUpdate, store);
+}
+
+//#endregion
+//#region src/internal/ingest-updates/ingest-transaction-update.ts
+function ingestTransactionUpdate(applying, transactionUpdate, store) {
+	const updates = applying === `newValue` ? transactionUpdate.updates : [...transactionUpdate.updates].reverse();
+	for (const updateFromTransaction of updates) switch (updateFromTransaction.type) {
+		case `atom_update`:
+		case `selector_update`:
+			ingestAtomUpdate(applying, updateFromTransaction, store);
+			break;
+		case `state_creation`:
+			ingestCreationEvent(updateFromTransaction, applying, store);
+			break;
+		case `state_disposal`:
+			ingestDisposalEvent(updateFromTransaction, applying, store);
+			break;
+		case `molecule_creation`:
+			ingestMoleculeCreationEvent(updateFromTransaction, applying, store);
+			break;
+		case `molecule_disposal`:
+			ingestMoleculeDisposalEvent(updateFromTransaction, applying, store);
+			break;
+		case `molecule_transfer`:
+			ingestMoleculeTransferEvent(updateFromTransaction, applying, store);
+			break;
+		case `transaction_update`:
+			ingestTransactionUpdate(applying, updateFromTransaction, store);
+			break;
+	}
+}
+
+//#endregion
+//#region src/internal/transaction/get-epoch-number.ts
+function getContinuityKey(store, transactionKey) {
+	const continuity = store.transactionMeta.actionContinuities.getRelatedKey(transactionKey);
+	return continuity;
+}
+function getEpochNumberOfContinuity(store, continuityKey) {
+	const epoch = store.transactionMeta.epoch.get(continuityKey);
+	return epoch;
+}
+function getEpochNumberOfAction(store, transactionKey) {
+	const isRoot = isRootStore(store);
+	if (!isRoot) return void 0;
+	const continuityKey = getContinuityKey(store, transactionKey);
+	if (continuityKey === void 0) return void 0;
+	return getEpochNumberOfContinuity(store, continuityKey);
+}
+
+//#endregion
+//#region src/internal/transaction/set-epoch-number.ts
+function setEpochNumberOfContinuity(store, continuityKey, newEpoch) {
+	const isRoot = isRootStore(store);
+	if (isRoot && continuityKey) store.transactionMeta.epoch.set(continuityKey, newEpoch);
+}
+function setEpochNumberOfAction(store, transactionKey, newEpoch) {
+	const isRoot = isRootStore(store);
+	if (!isRoot) return;
+	const continuityKey = getContinuityKey(store, transactionKey);
+	if (continuityKey !== void 0) store.transactionMeta.epoch.set(continuityKey, newEpoch);
+}
+
+//#endregion
+//#region src/internal/transaction/apply-transaction.ts
+const applyTransaction = (output, store) => {
+	const child = newest(store);
+	const { parent } = child;
+	if (parent === null || !isChildStore(child) || child.transactionMeta?.phase !== `building`) {
+		store.logger.warn(`🐞`, `transaction`, `???`, `applyTransaction called outside of a transaction. This is probably a bug in AtomIO.`);
+		return;
+	}
+	child.transactionMeta.phase = `applying`;
+	child.transactionMeta.update.output = output;
+	parent.child = null;
+	parent.on.transactionApplying.next(child.transactionMeta);
+	const { updates } = child.transactionMeta.update;
+	store.logger.info(`🛄`, `transaction`, child.transactionMeta.update.key, `Applying transaction with ${updates.length} updates:`, updates);
+	ingestTransactionUpdate(`newValue`, child.transactionMeta.update, parent);
+	if (isRootStore(parent)) {
+		setEpochNumberOfAction(parent, child.transactionMeta.update.key, child.transactionMeta.update.epoch);
+		const myTransaction = withdraw(store, {
+			key: child.transactionMeta.update.key,
+			type: `transaction`
+		});
+		myTransaction?.subject.next(child.transactionMeta.update);
+		store.logger.info(`🛬`, `transaction`, child.transactionMeta.update.key, `Finished applying transaction.`);
+	} else if (isChildStore(parent)) parent.transactionMeta.update.updates.push(child.transactionMeta.update);
+	parent.on.transactionApplying.next(null);
+};
+
+//#endregion
+//#region src/internal/transaction/assign-transaction-to-continuity.ts
+function assignTransactionToContinuity(store, continuityKey, transactionKey) {
+	const isRoot = isRootStore(store);
+	if (!isRoot) return;
+	const { epoch, actionContinuities } = store.transactionMeta;
+	actionContinuities.set(continuityKey, transactionKey);
+	if (!epoch.has(continuityKey)) epoch.set(continuityKey, -1);
+}
+
+//#endregion
+//#region src/internal/get-environment-data.ts
+function getEnvironmentData(store) {
+	return { store };
+}
+
+//#endregion
+//#region src/internal/get-state/get-from-store.ts
+function getFromStore(store, ...params) {
+	let token;
+	let family;
+	let key;
+	if (params.length === 1) token = params[0];
+	else {
+		family = params[0];
+		key = params[1];
+		token = findInStore(store, family, key);
+	}
+	if (`counterfeit` in token && `family` in token) {
+		family = store.families.get(token.family.key);
+		const subKey = token.family.subKey;
+		const disposal = store.disposalTraces.buffer.find((item) => item?.key === subKey);
+		store.logger.error(`❌`, token.type, token.key, `could not be retrieved because it was not found in the store "${store.config.name}".`, disposal ? `This state was previously disposed:\n${disposal.trace}` : `No previous disposal trace was found.`);
+		switch (family.type) {
+			case `atom_family`:
+			case `mutable_atom_family`: return store.defaults.get(family.key);
+			case `selector_family`:
+			case `readonly_selector_family`: {
+				if (store.defaults.has(family.key)) return store.defaults.get(token.family.key);
+				const defaultValue = withdraw(store, family).default(subKey);
+				store.defaults.set(family.key, defaultValue);
+				return defaultValue;
+			}
+		}
+	}
+	return readOrComputeValue(store, withdraw(store, token));
+}
+
+//#endregion
+//#region src/internal/lazy-map.ts
+var LazyMap = class extends Map {
+	deleted = new Set();
+	source;
+	constructor(source) {
+		super();
+		this.source = source;
+	}
+	get(key) {
+		const has = super.has(key);
+		if (has) return super.get(key);
+		if (!this.deleted.has(key) && this.source.has(key)) {
+			const value = this.source.get(key);
+			return value;
+		}
+		return void 0;
+	}
+	set(key, value) {
+		this.deleted.delete(key);
+		return super.set(key, value);
+	}
+	hasOwn(key) {
+		return super.has(key);
+	}
+	has(key) {
+		return !this.deleted.has(key) && (super.has(key) || this.source.has(key));
+	}
+	delete(key) {
+		this.deleted.add(key);
+		return super.delete(key);
+	}
+};
+
+//#endregion
+//#region src/internal/transaction/build-transaction.ts
+const buildTransaction = (store, key, params, id) => {
+	const parent = newest(store);
+	const childBase = {
+		parent,
+		child: null,
+		on: parent.on,
+		loggers: parent.loggers,
+		logger: parent.logger,
+		config: parent.config,
+		atoms: new LazyMap(parent.atoms),
+		atomsThatAreDefault: new Set(parent.atomsThatAreDefault),
+		families: new LazyMap(parent.families),
+		joins: new LazyMap(parent.joins),
+		operation: { open: false },
+		readonlySelectors: new LazyMap(parent.readonlySelectors),
+		timelines: new LazyMap(parent.timelines),
+		timelineTopics: new Junction(parent.timelineTopics.toJSON()),
+		trackers: new Map(),
+		transactions: new LazyMap(parent.transactions),
+		selectorAtoms: new Junction(parent.selectorAtoms.toJSON()),
+		selectorGraph: new Junction(parent.selectorGraph.toJSON(), { makeContentKey: (...keys) => keys.sort().join(`:`) }),
+		selectors: new LazyMap(parent.selectors),
+		valueMap: new LazyMap(parent.valueMap),
+		defaults: parent.defaults,
+		disposalTraces: store.disposalTraces.copy(),
+		molecules: new LazyMap(parent.molecules),
+		moleculeGraph: new Junction(parent.moleculeGraph.toJSON(), { makeContentKey: parent.moleculeGraph.makeContentKey }),
+		moleculeData: new Junction(parent.moleculeData.toJSON(), { makeContentKey: parent.moleculeData.makeContentKey }),
+		moleculeJoins: new Junction(parent.moleculeJoins.toJSON(), { makeContentKey: parent.moleculeJoins.makeContentKey }),
+		miscResources: new LazyMap(parent.miscResources)
+	};
+	const epoch = getEpochNumberOfAction(store, key);
+	const transactionMeta = {
+		phase: `building`,
+		update: {
+			type: `transaction_update`,
+			key,
+			id,
+			epoch: epoch === void 0 ? Number.NaN : epoch + 1,
+			updates: [],
+			params,
+			output: void 0
+		},
+		toolkit: {
+			get: (...ps) => getFromStore(child, ...ps),
+			set: (...ps) => {
+				setIntoStore(child, ...ps);
+			},
+			run: (token, identifier = arbitrary()) => actUponStore(child, token, identifier),
+			find: (...ps) => findInStore(store, ...ps),
+			json: (token) => getJsonToken(child, token),
+			dispose: (...ps) => {
+				disposeFromStore(child, ...ps);
+			},
+			env: () => getEnvironmentData(child)
+		}
+	};
+	const child = Object.assign(childBase, { transactionMeta });
+	parent.child = child;
+	store.logger.info(`🛫`, `transaction`, key, `Building transaction with params:`, params);
+	return child;
+};
+
+//#endregion
+//#region src/internal/transaction/create-transaction.ts
+function createTransaction(store, options) {
+	const newTransaction = {
+		key: options.key,
+		type: `transaction`,
+		run: (params, id) => {
+			const childStore = buildTransaction(store, options.key, params, id);
+			try {
+				const target$1 = newest(store);
+				const { toolkit } = childStore.transactionMeta;
+				const output = options.do(toolkit, ...params);
+				applyTransaction(output, target$1);
+				return output;
+			} catch (thrown) {
+				abortTransaction(target);
+				store.logger.warn(`💥`, `transaction`, options.key, `caught:`, thrown);
+				throw thrown;
+			}
+		},
+		install: (s) => createTransaction(s, options),
+		subject: new Subject()
+	};
+	const target = newest(store);
+	target.transactions.set(newTransaction.key, newTransaction);
+	const token = deposit(newTransaction);
+	store.on.transactionCreation.next(token);
+	return token;
+}
+
+//#endregion
+//#region src/internal/transaction/index.ts
+const TRANSACTION_PHASES = [
+	`idle`,
+	`building`,
+	`applying`
+];
+
+//#endregion
+//#region src/internal/store/store.ts
+var Store = class {
+	parent = null;
+	child = null;
+	valueMap = new Map();
+	defaults = new Map();
+	atoms = new Map();
+	selectors = new Map();
+	readonlySelectors = new Map();
+	atomsThatAreDefault = new Set();
+	selectorAtoms = new Junction({
+		between: [`selectorKey`, `atomKey`],
+		cardinality: `n:n`
+	});
+	selectorGraph = new Junction({
+		between: [`upstreamSelectorKey`, `downstreamSelectorKey`],
+		cardinality: `n:n`
+	}, { makeContentKey: (...keys) => keys.sort().join(`:`) });
+	trackers = new Map();
+	families = new Map();
+	joins = new Map();
+	transactions = new Map();
+	transactionMeta = {
+		epoch: new Map(),
+		actionContinuities: new Junction({
+			between: [`continuity`, `action`],
+			cardinality: `1:n`
+		})
+	};
+	timelines = new Map();
+	timelineTopics = new Junction({
+		between: [`timelineKey`, `topicKey`],
+		cardinality: `1:n`
+	});
+	disposalTraces = new CircularBuffer(100);
+	molecules = new Map();
+	moleculeJoins = new Junction({
+		between: [`moleculeKey`, `joinKey`],
+		cardinality: `n:n`
+	}, { makeContentKey: (...keys) => keys.sort().join(`:`) });
+	moleculeGraph = new Junction({
+		between: [`upstreamMoleculeKey`, `downstreamMoleculeKey`],
+		cardinality: `n:n`
+	}, { makeContentKey: (...keys) => keys.sort().join(`:`) });
+	moleculeData = new Junction({
+		between: [`moleculeKey`, `stateFamilyKey`],
+		cardinality: `n:n`
+	}, { makeContentKey: (...keys) => keys.sort().join(`:`) });
+	miscResources = new Map();
+	on = {
+		atomCreation: new Subject(),
+		atomDisposal: new Subject(),
+		selectorCreation: new Subject(),
+		selectorDisposal: new Subject(),
+		timelineCreation: new Subject(),
+		transactionCreation: new Subject(),
+		transactionApplying: new StatefulSubject(null),
+		operationClose: new Subject(),
+		moleculeCreation: new Subject(),
+		moleculeDisposal: new Subject()
+	};
+	operation = { open: false };
+	config = {
+		name: `IMPLICIT_STORE`,
+		lifespan: `ephemeral`
+	};
+	loggers = [new AtomIOLogger(`warn`, (_, __, key) => !isReservedIntrospectionKey(key))];
+	logger = {
+		error: (...messages) => {
+			for (const logger of this.loggers) logger.error(...messages);
+		},
+		info: (...messages) => {
+			for (const logger of this.loggers) logger.info(...messages);
+		},
+		warn: (...messages) => {
+			for (const logger of this.loggers) logger.warn(...messages);
+		}
+	};
+	constructor(config, store = null) {
+		this.config = {
+			...store?.config,
+			...config
+		};
+		if (store !== null) {
+			this.valueMap = new Map(store?.valueMap);
+			this.operation = { ...store?.operation };
+			if (isRootStore(store)) this.transactionMeta = {
+				epoch: new Map(store?.transactionMeta.epoch),
+				actionContinuities: new Junction(store?.transactionMeta.actionContinuities.toJSON())
+			};
+			for (const [, family] of store.families) {
+				if (family.internalRoles?.includes(`mutable`) || family.internalRoles?.includes(`join`)) continue;
+				family.install(this);
+			}
+			const mutableHelpers = new Set();
+			for (const [, atom$1] of store.atoms) {
+				if (mutableHelpers.has(atom$1.key)) continue;
+				atom$1.install(this);
+				if (atom$1.type === `mutable_atom`) {
+					const originalJsonToken = getJsonToken(store, atom$1);
+					const originalUpdateToken = getUpdateToken(atom$1);
+					mutableHelpers.add(originalJsonToken.key);
+					mutableHelpers.add(originalUpdateToken.key);
+				}
+			}
+			for (const [, selector] of store.readonlySelectors) selector.install(this);
+			for (const [, selector] of store.selectors) {
+				if (mutableHelpers.has(selector.key)) continue;
+				selector.install(this);
+			}
+			for (const [, tx] of store.transactions) tx.install(this);
+			for (const [, timeline] of store.timelines) timeline.install(this);
+		}
+	}
+};
+const IMPLICIT = { get STORE() {
+	globalThis.ATOM_IO_IMPLICIT_STORE ??= new Store({
+		name: `IMPLICIT_STORE`,
+		lifespan: `ephemeral`
+	});
+	return globalThis.ATOM_IO_IMPLICIT_STORE;
+} };
+const clearStore = (store) => {
+	const { config } = store;
+	for (const disposable of store.miscResources.values()) disposable[Symbol.dispose]();
+	Object.assign(store, new Store(config));
+	store.config = config;
+};
+
+//#endregion
+//#region src/internal/store/withdraw.ts
+function withdraw(store, token) {
+	let withdrawn;
+	let target = store;
+	while (target !== null) {
+		switch (token.type) {
+			case `atom`:
+			case `mutable_atom`:
+				withdrawn = target.atoms.get(token.key);
+				break;
+			case `selector`:
+				withdrawn = target.selectors.get(token.key);
+				break;
+			case `readonly_selector`:
+				withdrawn = target.readonlySelectors.get(token.key);
+				break;
+			case `atom_family`:
+			case `mutable_atom_family`:
+			case `selector_family`:
+			case `readonly_selector_family`:
+				withdrawn = target.families.get(token.key);
+				break;
+			case `timeline`:
+				withdrawn = target.timelines.get(token.key);
+				break;
+			case `transaction`:
+				withdrawn = target.transactions.get(token.key);
+				break;
+		}
+		if (withdrawn) return withdrawn;
+		target = target.child;
+	}
+	throw new NotFoundError(token, store);
+}
+
+//#endregion
+//#region src/internal/subscribe/recall-state.ts
+const recallState = (store, state) => {
+	const target = newest(store);
+	if (target.operation.open) return target.operation.prev.get(state.key);
+	return target.valueMap.get(state.key);
+};
+
+//#endregion
+//#region src/internal/subscribe/subscribe-in-store.ts
+function subscribeInStore(store, token, handleUpdate, key = arbitrary$1()) {
+	switch (token.type) {
+		case `atom`:
+		case `mutable_atom`:
+		case `readonly_selector`:
+		case `selector`: return subscribeToState$1(store, token, key, handleUpdate);
+		case `transaction`: return subscribeToTransaction$1(store, token, key, handleUpdate);
+		case `timeline`: return subscribeToTimeline$1(store, token, key, handleUpdate);
+	}
+}
+
+//#endregion
+//#region src/internal/subscribe/subscribe-to-root-atoms.ts
+const subscribeToRootAtoms = (store, selector) => {
+	const target = newest(store);
+	const dependencySubscriptions = traceAllSelectorAtoms(selector, store).map((atomKey) => {
+		const atom$1 = target.atoms.get(atomKey);
+		if (atom$1 === void 0) throw new Error(`Atom "${atomKey}", a dependency of selector "${selector.key}", not found in store "${store.config.name}".`);
+		return atom$1.subject.subscribe(`${selector.type}:${selector.key}`, (atomChange) => {
+			store.logger.info(`📢`, selector.type, selector.key, `root`, atomKey, `went`, atomChange.oldValue, `->`, atomChange.newValue);
+			const oldValue = recallState(target, selector);
+			const newValue = readOrComputeValue(target, selector);
+			store.logger.info(`✨`, selector.type, selector.key, `went`, oldValue, `->`, newValue);
+			selector.subject.next({
+				newValue,
+				oldValue
+			});
+		});
+	});
+	return dependencySubscriptions;
+};
+
+//#endregion
+//#region src/internal/subscribe/subscribe-to-state.ts
+function subscribeToState(store, token, key, handleUpdate) {
+	function safelyHandleUpdate(update) {
+		if (store.operation.open) {
+			const unsubscribe$1 = store.on.operationClose.subscribe(`state subscription ${key}`, () => {
+				unsubscribe$1();
+				handleUpdate(update);
+			});
+		} else handleUpdate(update);
+	}
+	const state = withdraw(store, token);
+	store.logger.info(`👀`, state.type, state.key, `Adding subscription "${key}"`);
+	const isSelector = state.type === `selector` || state.type === `readonly_selector`;
+	let dependencyUnsubFunctions = null;
+	let updateHandler = safelyHandleUpdate;
+	if (isSelector) {
+		dependencyUnsubFunctions = subscribeToRootAtoms(store, state);
+		updateHandler = (update) => {
+			if (dependencyUnsubFunctions) {
+				dependencyUnsubFunctions.length = 0;
+				dependencyUnsubFunctions.push(...subscribeToRootAtoms(store, state));
+			}
+			safelyHandleUpdate(update);
+		};
+	}
+	const mainUnsubFunction = state.subject.subscribe(key, updateHandler);
+	const unsubscribe = () => {
+		store.logger.info(`🙈`, state.type, state.key, `Removing subscription "${key}"`);
+		mainUnsubFunction();
+		if (dependencyUnsubFunctions) for (const unsubFromDependency of dependencyUnsubFunctions) unsubFromDependency();
+	};
+	return unsubscribe;
+}
+
+//#endregion
+//#region src/internal/subscribe/subscribe-to-timeline.ts
+const subscribeToTimeline = (store, token, key, handleUpdate) => {
+	const tl = withdraw(store, token);
+	store.logger.info(`👀`, `timeline`, token.key, `Adding subscription "${key}"`);
+	const unsubscribe = tl.subject.subscribe(key, handleUpdate);
+	return () => {
+		store.logger.info(`🙈`, `timeline`, token.key, `Removing subscription "${key}" from timeline`);
+		unsubscribe();
+	};
+};
+
+//#endregion
+//#region src/internal/subscribe/subscribe-to-transaction.ts
+const subscribeToTransaction = (store, token, key, handleUpdate) => {
+	const tx = withdraw(store, token);
+	store.logger.info(`👀`, `transaction`, token.key, `Adding subscription "${key}"`);
+	const unsubscribe = tx.subject.subscribe(key, handleUpdate);
+	return () => {
+		store.logger.info(`🙈`, `transaction`, token.key, `Removing subscription "${key}"`);
+		unsubscribe();
+	};
+};
+
+//#endregion
+//#region src/internal/mutable/tracker.ts
+/**
+* @internal Give the tracker a transceiver state and a store, and it will
+* subscribe to the transceiver's inner value. When the inner value changes,
+* the tracker will update its own state to reflect the change.
+*/
+var Tracker = class {
+	initializeState(mutableState, store) {
+		const latestUpdateStateKey = `*${mutableState.key}`;
+		store.atoms.delete(latestUpdateStateKey);
+		store.valueMap.delete(latestUpdateStateKey);
+		const familyMetaData = mutableState.family ? {
+			key: `*${mutableState.family.key}`,
+			subKey: mutableState.family.subKey
+		} : void 0;
+		const latestUpdateState = createRegularAtom(store, {
+			key: latestUpdateStateKey,
+			default: null
+		}, familyMetaData);
+		if (store.parent?.valueMap.has(latestUpdateStateKey)) {
+			const parentValue = store.parent.valueMap.get(latestUpdateStateKey);
+			store.valueMap.set(latestUpdateStateKey, parentValue);
+		}
+		return latestUpdateState;
+	}
+	unsubscribeFromInnerValue;
+	unsubscribeFromState;
+	observeCore(mutableState, latestUpdateState, target) {
+		const subscriptionKey = `tracker:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.key : `main`}:${mutableState.key}`;
+		const originalInnerValue = getFromStore(target, mutableState);
+		this.unsubscribeFromInnerValue = originalInnerValue.subscribe(subscriptionKey, (update) => {
+			setIntoStore(target, latestUpdateState, update);
+		});
+		this.unsubscribeFromState = subscribeToState(target, mutableState, subscriptionKey, (update) => {
+			if (update.newValue !== update.oldValue) {
+				this.unsubscribeFromInnerValue();
+				this.unsubscribeFromInnerValue = update.newValue.subscribe(subscriptionKey, (transceiverUpdate) => {
+					setIntoStore(target, latestUpdateState, transceiverUpdate);
+				});
+			}
+		});
+	}
+	updateCore(mutableState, latestUpdateState, target) {
+		const subscriptionKey = `tracker:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.key : `main`}:${mutableState.key}`;
+		subscribeToState(target, latestUpdateState, subscriptionKey, ({ newValue, oldValue }) => {
+			const timelineId = target.timelineTopics.getRelatedKey(latestUpdateState.key);
+			if (timelineId) {
+				const timelineData = target.timelines.get(timelineId);
+				if (timelineData?.timeTraveling) {
+					const unsubscribe$1 = subscribeToTimeline(target, {
+						key: timelineId,
+						type: `timeline`
+					}, subscriptionKey, (update) => {
+						unsubscribe$1();
+						setIntoStore(target, mutableState, (transceiver) => {
+							if (update === `redo` && newValue) transceiver.do(newValue);
+							else if (update === `undo` && oldValue) transceiver.undo(oldValue);
+							return transceiver;
+						});
+					});
+					return;
+				}
+			}
+			const unsubscribe = target.on.operationClose.subscribe(subscriptionKey, () => {
+				unsubscribe();
+				const mutable = getFromStore(target, mutableState);
+				const updateNumber = newValue === null ? -1 : mutable.getUpdateNumber(newValue);
+				const eventOffset = updateNumber - mutable.cacheUpdateNumber;
+				if (newValue && eventOffset === 1) setIntoStore(target, mutableState, (transceiver) => (transceiver.do(newValue), transceiver));
+				else target.logger.info(`❌`, `mutable_atom`, mutableState.key, `could not be updated. Expected update number ${mutable.cacheUpdateNumber + 1}, but got ${updateNumber}`);
+			});
+		});
+	}
+	mutableState;
+	latestUpdateState;
+	[Symbol.dispose];
+	constructor(mutableState, store) {
+		this.mutableState = mutableState;
+		const target = newest(store);
+		this.latestUpdateState = this.initializeState(mutableState, target);
+		this.observeCore(mutableState, this.latestUpdateState, target);
+		this.updateCore(mutableState, this.latestUpdateState, target);
+		target.trackers.set(mutableState.key, this);
+		this[Symbol.dispose] = () => {
+			this.unsubscribeFromInnerValue();
+			this.unsubscribeFromState();
+			target.trackers.delete(mutableState.key);
+		};
+	}
+};
+
+//#endregion
+//#region src/internal/mutable/create-mutable-atom.ts
+function createMutableAtom(store, options, family) {
+	store.logger.info(`🔨`, `atom`, options.key, `creating in store "${store.config.name}"`);
+	const target = newest(store);
+	const existing = target.atoms.get(options.key);
+	if (existing && existing.type === `mutable_atom`) {
+		store.logger.error(`❌`, `atom`, options.key, `Tried to create atom, but it already exists in the store.`);
+		return deposit(existing);
+	}
+	const subject = new Subject();
+	const newAtom = {
+		...options,
+		type: `mutable_atom`,
+		install: (s) => {
+			s.logger.info(`🛠️`, `atom`, options.key, `installing in store "${s.config.name}"`);
+			return createMutableAtom(s, options, family);
+		},
+		subject
+	};
+	if (family) newAtom.family = family;
+	const initialValue = options.default();
+	target.atoms.set(newAtom.key, newAtom);
+	markAtomAsDefault(store, options.key);
+	cacheValue(target, options.key, initialValue, subject);
+	const token = deposit(newAtom);
+	if (options.effects) {
+		let effectIndex = 0;
+		const cleanupFunctions = [];
+		for (const effect of options.effects) {
+			const cleanup = effect({
+				setSelf: (next) => {
+					setIntoStore(store, token, next);
+				},
+				onSet: (handle) => subscribeToState(store, token, `effect[${effectIndex}]`, handle)
+			});
+			if (cleanup) cleanupFunctions.push(cleanup);
+			++effectIndex;
+		}
+		newAtom.cleanup = () => {
+			for (const cleanup of cleanupFunctions) cleanup();
+		};
+	}
+	new Tracker(token, store);
+	if (!family) selectJson(token, options, store);
+	return token;
+}
+
+//#endregion
+//#region src/internal/mutable/tracker-family.ts
+var FamilyTracker = class {
+	trackers = new Map();
+	latestUpdateAtoms;
+	mutableAtoms;
+	constructor(mutableAtoms, store) {
+		const updateAtoms = createRegularAtomFamily(store, {
+			key: `*${mutableAtoms.key}`,
+			default: null
+		}, [`mutable`, `updates`]);
+		this.latestUpdateAtoms = withdraw(store, updateAtoms);
+		this.mutableAtoms = mutableAtoms;
+		this.mutableAtoms.subject.subscribe(`store=${store.config.name}::tracker-atom-family`, (event) => {
+			const { type, token } = event;
+			if (token.family) {
+				const key = parseJson(token.family.subKey);
+				switch (type) {
+					case `state_creation`:
+						this.trackers.set(key, new Tracker(token, store));
+						break;
+					case `state_disposal`:
+						{
+							const tracker = this.trackers.get(key);
+							if (tracker) {
+								tracker[Symbol.dispose]();
+								this.trackers.delete(key);
+							}
+						}
+						break;
+				}
+			}
+		});
+	}
+};
+
+//#endregion
+//#region src/internal/mutable/create-mutable-atom-family.ts
+function createMutableAtomFamily(store, options, internalRoles) {
+	const familyToken = {
+		key: options.key,
+		type: `mutable_atom_family`
+	};
+	const existing = store.families.get(options.key);
+	if (existing) store.logger.error(`❗`, `mutable_atom_family`, options.key, `Overwriting an existing ${prettyPrintTokenType(existing)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);
+	const subject = new Subject();
+	const familyFunction = (key) => {
+		const subKey = stringifyJson(key);
+		const family = {
+			key: options.key,
+			subKey
+		};
+		const fullKey = `${options.key}(${subKey})`;
+		const target = newest(store);
+		const individualOptions = {
+			key: fullKey,
+			default: () => options.default(key),
+			toJson: options.toJson,
+			fromJson: options.fromJson,
+			mutable: true
+		};
+		if (options.effects) individualOptions.effects = options.effects(key);
+		const token = createMutableAtom(target, individualOptions, family);
+		subject.next({
+			type: `state_creation`,
+			token
+		});
+		return token;
+	};
+	const atomFamily$1 = Object.assign(familyFunction, familyToken, {
+		subject,
+		install: (s) => createMutableAtomFamily(s, options),
+		toJson: options.toJson,
+		fromJson: options.fromJson,
+		internalRoles
+	});
+	store.families.set(options.key, atomFamily$1);
+	selectJsonFamily(store, atomFamily$1, options);
+	new FamilyTracker(atomFamily$1, store);
+	return familyToken;
+}
+
+//#endregion
+//#region src/internal/mutable/get-json-family.ts
+const getJsonFamily = (mutableAtomFamily, store) => {
+	const target = newest(store);
+	const key = `${mutableAtomFamily.key}:JSON`;
+	const jsonFamily = target.families.get(key);
+	return jsonFamily;
+};
+
+//#endregion
+//#region src/internal/mutable/get-json-token.ts
+const getJsonToken = (store, mutableAtomToken) => {
+	if (mutableAtomToken.family) {
+		const target = newest(store);
+		const jsonFamilyKey = `${mutableAtomToken.family.key}:JSON`;
+		const jsonFamilyToken = {
+			key: jsonFamilyKey,
+			type: `selector_family`
+		};
+		const family = withdraw(target, jsonFamilyToken);
+		const subKey = JSON.parse(mutableAtomToken.family.subKey);
+		const jsonToken = findInStore(store, family, subKey);
+		return jsonToken;
+	}
+	const token = {
+		type: `selector`,
+		key: `${mutableAtomToken.key}:JSON`
+	};
+	return token;
+};
+
+//#endregion
+//#region src/internal/mutable/get-update-family.ts
+const getUpdateFamily = (mutableAtomFamily, store) => {
+	const target = newest(store);
+	const key = `*${mutableAtomFamily.key}`;
+	const updateFamily = target.families.get(key);
+	return updateFamily;
+};
+
+//#endregion
+//#region src/internal/mutable/get-update-token.ts
+const getUpdateToken = (mutableAtomToken) => {
+	const key = `*${mutableAtomToken.key}`;
+	const updateToken = {
+		type: `atom`,
+		key
+	};
+	if (mutableAtomToken.family) updateToken.family = {
+		key: `*${mutableAtomToken.family.key}`,
+		subKey: mutableAtomToken.family.subKey
+	};
+	return updateToken;
+};
+
+//#endregion
+//#region src/internal/mutable/transceiver.ts
+function isTransceiver(value) {
+	return typeof value === `object` && value !== null && `do` in value && `undo` in value && `subscribe` in value;
+}
+
+//#endregion
+//#region src/internal/set-state/copy-mutable-if-needed.ts
+function copyMutableIfNeeded(target, atom$1, origin) {
+	const originValue = origin.valueMap.get(atom$1.key);
+	const targetValue = target.valueMap.get(atom$1.key);
+	if (originValue !== targetValue) return targetValue;
+	if (originValue === void 0) return atom$1.default();
+	origin.logger.info(`📃`, `atom`, atom$1.key, `copying`);
+	const jsonValue = atom$1.toJson(originValue);
+	const copiedValue = atom$1.fromJson(jsonValue);
+	target.valueMap.set(atom$1.key, copiedValue);
+	new Tracker(atom$1, origin);
+	return copiedValue;
+}
+
+//#endregion
+//#region src/internal/caching.ts
+function cacheValue(target, key, value, subject) {
+	const currentValue = target.valueMap.get(key);
+	if (currentValue instanceof Future) {
+		const future = currentValue;
+		future.use(value);
+	}
+	if (value instanceof Promise) {
+		const future = new Future(value);
+		target.valueMap.set(key, future);
+		future.then((resolved) => {
+			cacheValue(target, key, resolved, subject);
+			subject.next({
+				newValue: resolved,
+				oldValue: future
+			});
+		}).catch((thrown) => {
+			target.logger.error(`💥`, `state`, key, `rejected:`, thrown);
+		});
+		return future;
+	}
+	target.valueMap.set(key, value);
+	return value;
+}
+const readCachedValue = (token, target) => {
+	let value = target.valueMap.get(token.key);
+	if (token.type === `mutable_atom` && isChildStore(target)) {
+		const { parent } = target;
+		const copiedValue = copyMutableIfNeeded(target, token, parent);
+		value = copiedValue;
+	}
+	return value;
+};
+const evictCachedValue = (key, target) => {
+	const currentValue = target.valueMap.get(key);
+	if (currentValue instanceof Future) {
+		const future = currentValue;
+		const selector = target.selectors.get(key) ?? target.readonlySelectors.get(key);
+		if (selector) future.use(selector.get());
+		return;
+	}
+	if (target.operation.open) target.operation.prev.set(key, currentValue);
+	target.valueMap.delete(key);
+	target.logger.info(`🗑`, `state`, key, `evicted`);
+};
+
+//#endregion
+//#region src/internal/atom/is-default.ts
+const isAtomDefault = (store, key) => {
+	const core = newest(store);
+	return core.atomsThatAreDefault.has(key);
+};
+const markAtomAsDefault = (store, key) => {
+	const core = newest(store);
+	core.atomsThatAreDefault = new Set(core.atomsThatAreDefault).add(key);
+};
+const markAtomAsNotDefault = (store, key) => {
+	const core = newest(store);
+	core.atomsThatAreDefault = new Set(newest(store).atomsThatAreDefault);
+	core.atomsThatAreDefault.delete(key);
+};
+
+//#endregion
+//#region src/internal/atom/create-regular-atom.ts
+function createRegularAtom(store, options, family) {
+	store.logger.info(`🔨`, `atom`, options.key, `creating in store "${store.config.name}"`);
+	const target = newest(store);
+	const existing = target.atoms.get(options.key);
+	if (existing && existing.type === `atom`) {
+		store.logger.error(`❌`, `atom`, options.key, `Tried to create atom, but it already exists in the store.`);
+		return deposit(existing);
+	}
+	const subject = new Subject();
+	const newAtom = {
+		...options,
+		type: `atom`,
+		install: (s) => {
+			s.logger.info(`🛠️`, `atom`, options.key, `installing in store "${s.config.name}"`);
+			return createRegularAtom(s, options, family);
+		},
+		subject
+	};
+	if (family) newAtom.family = family;
+	let initialValue = options.default;
+	if (options.default instanceof Function) initialValue = options.default();
+	target.atoms.set(newAtom.key, newAtom);
+	markAtomAsDefault(store, options.key);
+	cacheValue(target, options.key, initialValue, subject);
+	const token = deposit(newAtom);
+	if (options.effects) {
+		let effectIndex = 0;
+		const cleanupFunctions = [];
+		for (const effect of options.effects) {
+			const cleanup = effect({
+				setSelf: (next) => {
+					setIntoStore(store, token, next);
+				},
+				onSet: (handle) => subscribeToState(store, token, `effect[${effectIndex}]`, handle)
+			});
+			if (cleanup) cleanupFunctions.push(cleanup);
+			++effectIndex;
+		}
+		newAtom.cleanup = () => {
+			for (const cleanup of cleanupFunctions) cleanup();
+		};
+	}
+	return token;
+}
+
+//#endregion
+//#region src/internal/atom/create-standalone-atom.ts
+function createStandaloneAtom(store, options) {
+	const isMutable = `mutable` in options;
+	if (isMutable) {
+		const state$1 = createMutableAtom(store, options, void 0);
+		store.on.atomCreation.next(state$1);
+		return state$1;
+	}
+	const state = createRegularAtom(store, options, void 0);
+	store.on.atomCreation.next(state);
+	return state;
+}
+
+//#endregion
+//#region src/internal/atom/dispose-atom.ts
+function disposeAtom(store, atomToken) {
+	const target = newest(store);
+	const { key, family } = atomToken;
+	const atom$1 = withdraw(target, atomToken);
+	if (!family) store.logger.error(`❌`, `atom`, key, `Standalone atoms cannot be disposed.`);
+	else {
+		atom$1.cleanup?.();
+		const lastValue = store.valueMap.get(atom$1.key);
+		const atomFamily$1 = withdraw(store, {
+			key: family.key,
+			type: `atom_family`
+		});
+		const disposal = {
+			type: `state_disposal`,
+			subType: `atom`,
+			token: atomToken,
+			value: lastValue
+		};
+		atomFamily$1.subject.next(disposal);
+		const isChild = isChildStore(target);
+		target.atoms.delete(key);
+		target.valueMap.delete(key);
+		target.selectorAtoms.delete(key);
+		target.atomsThatAreDefault.delete(key);
+		store.timelineTopics.delete(key);
+		if (atomToken.type === `mutable_atom`) {
+			const updateToken = getUpdateToken(atomToken);
+			disposeAtom(store, updateToken);
+			store.trackers.delete(key);
+		}
+		store.logger.info(`🔥`, `atom`, key, `deleted`);
+		if (isChild && target.transactionMeta.phase === `building`) {
+			const mostRecentUpdate = target.transactionMeta.update.updates.at(-1);
+			const wasMoleculeDisposal = mostRecentUpdate?.type === `molecule_disposal`;
+			const updateAlreadyCaptured = wasMoleculeDisposal && mostRecentUpdate.values.some(([k]) => k === atom$1.family?.key);
+			if (!updateAlreadyCaptured) target.transactionMeta.update.updates.push(disposal);
+		} else store.on.atomDisposal.next(atomToken);
+	}
+}
+
+//#endregion
+//#region src/internal/install-into-store.ts
+/**
+* @public
+* Install the given tokens into the target store
+* @param tokens - States, families, transactions, and timelines to install into the target store
+* @param target - The store to install the tokens into
+* @param source - The store to install the tokens from
+*
+*/
+function installIntoStore(tokens, target, source) {
+	const sourceNewest = newest(source);
+	if (isChildStore(sourceNewest)) {
+		source.logger.error(`❌`, `transaction`, sourceNewest.transactionMeta.update.key, `could not install the following tokens into store "${target.config.name} from "${source.config.name}":`, tokens, `${sourceNewest.config.name} is undergoing a transaction.`);
+		return;
+	}
+	const targetNewest = newest(target);
+	if (isChildStore(targetNewest)) {
+		target.logger.error(`❌`, `transaction`, targetNewest.transactionMeta.update.key, `could not install the following tokens into store "${target.config.name} from "${source.config.name}":`, tokens, `${targetNewest.config.name} is undergoing a transaction.`);
+		return;
+	}
+	for (const token of tokens) {
+		const resource = withdraw(source, token);
+		resource.install(target);
+	}
+}
+
+//#endregion
+//#region src/internal/join/join-internal.ts
+var Join = class {
+	toolkit;
+	options;
+	defaultContent;
+	molecules = new Map();
+	relations;
+	states;
+	core;
+	transact(toolkit, run) {
+		const originalToolkit = this.toolkit;
+		this.toolkit = toolkit;
+		run(this);
+		this.toolkit = originalToolkit;
+	}
+	store;
+	realm;
+	[Symbol.dispose]() {}
+	constructor(options, defaultContent, store = IMPLICIT.STORE) {
+		this.store = store;
+		this.realm = new Anarchy(store);
+		this.options = options;
+		this.defaultContent = defaultContent;
+		this.store.miscResources.set(`join:${options.key}`, this);
+		this.realm.allocate(`root`, options.key);
+		this.toolkit = {
+			get: (...ps) => getFromStore(store, ...ps),
+			set: (...ps) => {
+				setIntoStore(store, ...ps);
+			},
+			find: (...ps) => findInStore(store, ...ps),
+			json: (token) => getJsonToken(store, token)
+		};
+		const aSide = options.between[0];
+		const bSide = options.between[1];
+		const relatedKeysAtoms = createMutableAtomFamily(store, {
+			key: `${options.key}/relatedKeys`,
+			default: () => new SetRTX(),
+			mutable: true,
+			fromJson: (json) => SetRTX.fromJSON(json),
+			toJson: (set) => set.toJSON()
+		}, [`join`, `relations`]);
+		this.core = { relatedKeysAtoms };
+		const getRelatedKeys = ({ get }, key) => get(relatedKeysAtoms, key);
+		const addRelation = ({ set }, a, b) => {
+			if (!this.store.molecules.has(stringifyJson(a))) this.realm.allocate(options.key, a);
+			set(relatedKeysAtoms, a, (aKeys) => aKeys.add(b));
+			set(relatedKeysAtoms, b, (bKeys) => bKeys.add(a));
+		};
+		const deleteRelation = ({ set }, a, b) => {
+			set(relatedKeysAtoms, a, (aKeys) => {
+				aKeys.delete(b);
+				return aKeys;
+			});
+			set(relatedKeysAtoms, b, (bKeys) => {
+				bKeys.delete(a);
+				return bKeys;
+			});
+		};
+		const replaceRelationsSafely = (toolkit, a, newRelationsOfA) => {
+			const { find, get, set } = toolkit;
+			const relationsOfAState = find(relatedKeysAtoms, a);
+			const currentRelationsOfA = get(relationsOfAState);
+			for (const currentRelationB of currentRelationsOfA) {
+				const remainsRelated = newRelationsOfA.includes(currentRelationB);
+				if (remainsRelated) continue;
+				set(relatedKeysAtoms, currentRelationB, (relationsOfB) => {
+					relationsOfB.delete(a);
+					return relationsOfB;
+				});
+			}
+			set(relationsOfAState, (relationsOfA) => {
+				relationsOfA.transaction((nextRelationsOfA) => {
+					nextRelationsOfA.clear();
+					for (const newRelationB of newRelationsOfA) {
+						const relationsOfB = getRelatedKeys(toolkit, newRelationB);
+						const newRelationBIsAlreadyRelated = relationsOfB.has(a);
+						if (this.relations.cardinality === `1:n`) {
+							const previousOwnersToDispose = [];
+							for (const previousOwner of relationsOfB) {
+								if (previousOwner === a) continue;
+								const previousOwnerRelations = getRelatedKeys(toolkit, previousOwner);
+								previousOwnerRelations.delete(newRelationB);
+								if (previousOwnerRelations.size === 0) previousOwnersToDispose.push(previousOwner);
+							}
+							if (!newRelationBIsAlreadyRelated && relationsOfB.size > 0) relationsOfB.clear();
+							for (const previousOwner of previousOwnersToDispose) {
+								const sorted = [newRelationB, previousOwner].sort();
+								const compositeKey = `"${sorted[0]}:${sorted[1]}"`;
+								this.molecules.delete(compositeKey);
+							}
+						}
+						if (!newRelationBIsAlreadyRelated) relationsOfB.add(a);
+						nextRelationsOfA.add(newRelationB);
+					}
+					return true;
+				});
+				return relationsOfA;
+			});
+		};
+		const replaceRelationsUnsafely = (toolkit, a, newRelationsOfA) => {
+			const { set } = toolkit;
+			set(relatedKeysAtoms, a, (relationsOfA) => {
+				relationsOfA.transaction((nextRelationsOfA) => {
+					for (const newRelationB of newRelationsOfA) nextRelationsOfA.add(newRelationB);
+					return true;
+				});
+				return relationsOfA;
+			});
+			for (const newRelationB of newRelationsOfA) set(relatedKeysAtoms, newRelationB, (newRelationsB) => {
+				newRelationsB.add(a);
+				return newRelationsB;
+			});
+			return true;
+		};
+		const has = (toolkit, a, b) => {
+			const aKeys = getRelatedKeys(toolkit, a);
+			return b ? aKeys.has(b) : aKeys.size > 0;
+		};
+		const baseExternalStoreConfiguration = {
+			getRelatedKeys: (key) => getRelatedKeys(this.toolkit, key),
+			addRelation: (a, b) => {
+				this.store.moleculeJoins.set(a, options.key);
+				this.store.moleculeJoins.set(b, options.key);
+				addRelation(this.toolkit, a, b);
+			},
+			deleteRelation: (a, b) => {
+				deleteRelation(this.toolkit, a, b);
+			},
+			replaceRelationsSafely: (a, bs) => {
+				replaceRelationsSafely(this.toolkit, a, bs);
+			},
+			replaceRelationsUnsafely: (a, bs) => {
+				replaceRelationsUnsafely(this.toolkit, a, bs);
+			},
+			has: (a, b) => has(this.toolkit, a, b)
+		};
+		let externalStore;
+		let contentAtoms;
+		if (defaultContent) {
+			contentAtoms = createRegularAtomFamily(store, {
+				key: `${options.key}/content`,
+				default: defaultContent
+			}, [`join`, `content`]);
+			const getContent = ({ get }, key) => get(contentAtoms, key);
+			const setContent = ({ set }, key, content) => {
+				set(contentAtoms, key, content);
+			};
+			const externalStoreWithContentConfiguration = {
+				getContent: (contentKey) => {
+					const content = getContent(this.toolkit, contentKey);
+					return content;
+				},
+				setContent: (contentKey, content) => {
+					setContent(this.toolkit, contentKey, content);
+				},
+				deleteContent: (contentKey) => {
+					this.realm.deallocate(contentKey);
+				}
+			};
+			externalStore = Object.assign(baseExternalStoreConfiguration, externalStoreWithContentConfiguration);
+		} else externalStore = baseExternalStoreConfiguration;
+		const relations = new Junction(options, {
+			externalStore,
+			isAType: options.isAType,
+			isBType: options.isBType,
+			makeContentKey: (...args) => {
+				const [a, b] = args;
+				const sorted = args.sort();
+				const compositeKey = `${sorted[0]}:${sorted[1]}`;
+				const aMolecule = store.molecules.get(stringifyJson(a));
+				const bMolecule = store.molecules.get(stringifyJson(b));
+				if (!aMolecule) this.realm.allocate(options.key, a);
+				if (!bMolecule) this.realm.allocate(options.key, b);
+				this.realm.allocate(a, compositeKey, `all`);
+				this.realm.claim(b, compositeKey);
+				this.store.moleculeJoins.set(compositeKey, options.key);
+				return compositeKey;
+			}
+		});
+		const createSingleKeySelectorFamily = () => createReadonlySelectorFamily(store, {
+			key: `${options.key}/singleRelatedKey`,
+			get: (key) => ({ get }) => {
+				const relatedKeys = get(relatedKeysAtoms, key);
+				for (const relatedKey of relatedKeys) return relatedKey;
+				return null;
+			}
+		}, [`join`, `keys`]);
+		const getMultipleKeySelectorFamily = () => {
+			return createReadonlySelectorFamily(store, {
+				key: `${options.key}/multipleRelatedKeys`,
+				get: (key) => ({ get }) => {
+					const jsonFamily = getJsonFamily(relatedKeysAtoms, store);
+					const json = get(jsonFamily, key);
+					return json.members;
+				}
+			}, [`join`, `keys`]);
+		};
+		const createSingleEntrySelectorFamily = () => createReadonlySelectorFamily(store, {
+			key: `${options.key}/singleRelatedEntry`,
+			get: (x) => ({ get }) => {
+				const relatedKeys = get(relatedKeysAtoms, x);
+				for (const y of relatedKeys) {
+					let a = relations.isAType?.(x) ? x : void 0;
+					let b = a === void 0 ? x : void 0;
+					a ??= y;
+					b ??= y;
+					const contentKey = relations.makeContentKey(a, b);
+					const content = get(contentAtoms, contentKey);
+					return [y, content];
+				}
+				return null;
+			}
+		}, [`join`, `entries`]);
+		const getMultipleEntrySelectorFamily = () => createReadonlySelectorFamily(store, {
+			key: `${options.key}/multipleRelatedEntries`,
+			get: (x) => ({ get }) => {
+				const jsonFamily = getJsonFamily(relatedKeysAtoms, store);
+				const json = get(jsonFamily, x);
+				return json.members.map((y) => {
+					let a = relations.isAType?.(x) ? x : void 0;
+					let b = a === void 0 ? x : void 0;
+					a ??= y;
+					b ??= y;
+					const contentKey = relations.makeContentKey(a, b);
+					const content = get(contentAtoms, contentKey);
+					return [y, content];
+				});
+			}
+		}, [`join`, `entries`]);
+		switch (options.cardinality) {
+			case `1:1`: {
+				const singleRelatedKeySelectors = createSingleKeySelectorFamily();
+				const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
+				const stateKeyB = `${bSide}KeyOf${capitalize(aSide)}`;
+				const baseStates = {
+					[stateKeyA]: singleRelatedKeySelectors,
+					[stateKeyB]: singleRelatedKeySelectors
+				};
+				let states;
+				if (defaultContent) {
+					const singleEntrySelectors = createSingleEntrySelectorFamily();
+					const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
+					const entriesStateKeyB = `${bSide}EntryOf${capitalize(aSide)}`;
+					const contentStates = {
+						[entriesStateKeyA]: singleEntrySelectors,
+						[entriesStateKeyB]: singleEntrySelectors
+					};
+					states = Object.assign(baseStates, contentStates);
+				} else states = baseStates;
+				this.relations = relations;
+				this.states = states;
+				break;
+			}
+			case `1:n`: {
+				const singleRelatedKeySelectors = createSingleKeySelectorFamily();
+				const multipleRelatedKeysSelectors = getMultipleKeySelectorFamily();
+				const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
+				const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
+				const baseStates = {
+					[stateKeyA]: singleRelatedKeySelectors,
+					[stateKeyB]: multipleRelatedKeysSelectors
+				};
+				let states;
+				if (defaultContent) {
+					const singleRelatedEntrySelectors = createSingleEntrySelectorFamily();
+					const multipleRelatedEntriesSelectors = getMultipleEntrySelectorFamily();
+					const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
+					const entriesStateKeyB = `${bSide}EntriesOf${capitalize(aSide)}`;
+					const contentStates = {
+						[entriesStateKeyA]: singleRelatedEntrySelectors,
+						[entriesStateKeyB]: multipleRelatedEntriesSelectors
+					};
+					states = Object.assign(baseStates, contentStates);
+				} else states = baseStates;
+				this.relations = relations;
+				this.states = states;
+				break;
+			}
+			case `n:n`: {
+				const multipleRelatedKeysSelectors = getMultipleKeySelectorFamily();
+				const stateKeyA = `${aSide}KeysOf${capitalize(bSide)}`;
+				const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
+				const baseStates = {
+					[stateKeyA]: multipleRelatedKeysSelectors,
+					[stateKeyB]: multipleRelatedKeysSelectors
+				};
+				let states;
+				if (defaultContent) {
+					const multipleRelatedEntriesSelectors = getMultipleEntrySelectorFamily();
+					const entriesStateKeyA = `${aSide}EntriesOf${capitalize(bSide)}`;
+					const entriesStateKeyB = `${bSide}EntriesOf${capitalize(aSide)}`;
+					const contentStates = {
+						[entriesStateKeyA]: multipleRelatedEntriesSelectors,
+						[entriesStateKeyB]: multipleRelatedEntriesSelectors
+					};
+					states = Object.assign(baseStates, contentStates);
+				} else states = baseStates;
+				this.relations = relations;
+				this.states = states;
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/internal/join/get-join.ts
+function getJoin(token, store) {
+	let myJoin = store.joins.get(token.key);
+	if (myJoin === void 0) {
+		const rootJoinMap = IMPLICIT.STORE.joins;
+		const rootJoin = rootJoinMap.get(token.key);
+		if (rootJoin === void 0) throw new Error(`Join "${token.key}" not found in store "${store.config.name}"`);
+		myJoin = new Join(rootJoin.options, rootJoin.defaultContent, store);
+		store.joins.set(token.key, myJoin);
+	}
+	return myJoin;
+}
+
+//#endregion
+//#region src/internal/join/edit-relations-in-store.ts
+function editRelationsInStore(token, change, store) {
+	const myJoin = getJoin(token, store);
+	const target = newest(store);
+	if (isChildStore(target)) {
+		const { toolkit } = target.transactionMeta;
+		myJoin.transact(toolkit, ({ relations }) => {
+			change(relations);
+		});
+	} else change(myJoin.relations);
+}
+
+//#endregion
+//#region src/internal/join/find-relations-in-store.ts
+function findRelationsInStore(token, key, store) {
+	const myJoin = getJoin(token, store);
+	let relations;
+	switch (token.cardinality) {
+		case `1:1`: {
+			const keyAB = `${token.a}KeyOf${capitalize(token.b)}`;
+			const keyBA = `${token.b}KeyOf${capitalize(token.a)}`;
+			relations = {
+				get [keyAB]() {
+					const familyAB = myJoin.states[keyAB];
+					const state = findInStore(store, familyAB, key);
+					return state;
+				},
+				get [keyBA]() {
+					const familyBA = myJoin.states[keyBA];
+					const state = findInStore(store, familyBA, key);
+					return state;
+				}
+			};
+			const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
+			if (entryAB in myJoin.states) {
+				const entryBA = `${token.b}EntryOf${capitalize(token.a)}`;
+				Object.assign(relations, {
+					get [entryAB]() {
+						const familyAB = myJoin.states[entryAB];
+						const state = findInStore(store, familyAB, key);
+						return state;
+					},
+					get [entryBA]() {
+						const familyBA = myJoin.states[entryBA];
+						const state = findInStore(store, familyBA, key);
+						return state;
+					}
+				});
+			}
+			break;
+		}
+		case `1:n`: {
+			const keyAB = `${token.a}KeyOf${capitalize(token.b)}`;
+			const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
+			relations = {
+				get [keyAB]() {
+					const familyAB = myJoin.states[keyAB];
+					const state = findInStore(store, familyAB, key);
+					return state;
+				},
+				get [keysBA]() {
+					const familyBA = myJoin.states[keysBA];
+					const state = findInStore(store, familyBA, key);
+					return state;
+				}
+			};
+			const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
+			if (entryAB in myJoin.states) {
+				const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
+				Object.assign(relations, {
+					get [entryAB]() {
+						const familyAB = myJoin.states[entryAB];
+						const state = findInStore(store, familyAB, key);
+						return state;
+					},
+					get [entriesBA]() {
+						const familyBA = myJoin.states[entriesBA];
+						const state = findInStore(store, familyBA, key);
+						return state;
+					}
+				});
+			}
+			break;
+		}
+		case `n:n`: {
+			const keysAB = `${token.a}KeysOf${capitalize(token.b)}`;
+			const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
+			relations = {
+				get [keysAB]() {
+					const familyAB = myJoin.states[keysAB];
+					const state = findInStore(store, familyAB, key);
+					return state;
+				},
+				get [keysBA]() {
+					const familyBA = myJoin.states[keysBA];
+					const state = findInStore(store, familyBA, key);
+					return state;
+				}
+			};
+			const entriesAB = `${token.a}EntriesOf${capitalize(token.b)}`;
+			if (entriesAB in myJoin.states) {
+				const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
+				Object.assign(relations, {
+					get [entriesAB]() {
+						const familyAB = myJoin.states[entriesAB];
+						const state = findInStore(store, familyAB, key);
+						return state;
+					},
+					get [entriesBA]() {
+						const familyBA = myJoin.states[entriesBA];
+						const state = findInStore(store, familyBA, key);
+						return state;
+					}
+				});
+			}
+		}
+	}
+	return relations;
+}
+
+//#endregion
+//#region src/internal/join/get-internal-relations-from-store.ts
+function getInternalRelationsFromStore(token, store) {
+	const myJoin = getJoin(token, store);
+	const family = myJoin.core.relatedKeysAtoms;
+	return family;
+}
+
+//#endregion
+//#region src/internal/reserved-keys.ts
+function isReservedIntrospectionKey(value) {
+	return value.startsWith(`🔍 `);
+}
+
+//#endregion
+//#region src/internal/timeline/create-timeline.ts
+function createTimeline(store, options, data) {
+	const tl = {
+		type: `timeline`,
+		key: options.key,
+		at: 0,
+		timeTraveling: null,
+		selectorTime: null,
+		transactionKey: null,
+		...data,
+		history: data?.history.map((update) => ({ ...update })) ?? [],
+		install: (s) => createTimeline(s, options, tl),
+		subject: new Subject(),
+		subscriptions: new Map()
+	};
+	if (options.shouldCapture) tl.shouldCapture = options.shouldCapture;
+	const timelineKey = options.key;
+	const target = newest(store);
+	for (const initialTopic of options.scope) switch (initialTopic.type) {
+		case `atom`:
+		case `mutable_atom`:
+			{
+				const atomToken = initialTopic;
+				const atomKey = atomToken.key;
+				let existingTimelineKey = target.timelineTopics.getRelatedKey(atomKey);
+				if (`family` in atomToken) {
+					const familyKey = atomToken.family.key;
+					existingTimelineKey = target.timelineTopics.getRelatedKey(familyKey);
+					if (existingTimelineKey) {
+						store.logger.error(`❌`, `timeline`, options.key, `Failed to add atom "${atomKey}" because its family "${familyKey}" already belongs to timeline "${existingTimelineKey}"`);
+						continue;
+					}
+				}
+				if (existingTimelineKey) {
+					store.logger.error(`❌`, `timeline`, options.key, `Failed to add atom "${atomKey}" because it already belongs to timeline "${existingTimelineKey}"`);
+					continue;
+				}
+				addAtomToTimeline(store, atomToken, tl);
+			}
+			break;
+		case `atom_family`:
+		case `mutable_atom_family`:
+			{
+				const familyToken = initialTopic;
+				const familyKey = familyToken.key;
+				const existingTimelineKey = target.timelineTopics.getRelatedKey(familyKey);
+				if (existingTimelineKey) {
+					store.logger.error(`❌`, `timeline`, options.key, `Failed to add atom family "${familyKey}" because it already belongs to timeline "${existingTimelineKey}"`);
+					continue;
+				}
+				addAtomFamilyToTimeline(store, familyToken, tl);
+			}
+			break;
+	}
+	store.timelines.set(options.key, tl);
+	const token = {
+		key: timelineKey,
+		type: `timeline`
+	};
+	store.on.timelineCreation.next(token);
+	return token;
+}
+function addAtomToTimeline(store, atomToken, tl) {
+	let maybeAtom = withdraw(store, atomToken);
+	if (maybeAtom.type === `mutable_atom`) {
+		const updateToken = getUpdateToken(maybeAtom);
+		maybeAtom = withdraw(store, updateToken);
+	}
+	const atom$1 = maybeAtom;
+	store.timelineTopics.set({
+		topicKey: atom$1.key,
+		timelineKey: tl.key
+	}, { topicType: `atom` });
+	tl.subscriptions.set(atom$1.key, atom$1.subject.subscribe(`timeline`, function timelineCapturesAtomUpdate(update) {
+		const target = newest(store);
+		const currentSelectorKey = store.operation.open && store.operation.token.type === `selector` ? store.operation.token.key : null;
+		const currentSelectorTime = store.operation.open && store.operation.token.type === `selector` ? store.operation.time : null;
+		const txUpdateInProgress = target.on.transactionApplying.state?.update;
+		store.logger.info(`⏳`, `timeline`, tl.key, `atom`, atomToken.key, `went`, update.oldValue, `->`, update.newValue, txUpdateInProgress ? `in transaction "${txUpdateInProgress.key}"` : currentSelectorKey ? `in selector "${currentSelectorKey}"` : ``);
+		if (tl.timeTraveling === null) if (txUpdateInProgress) joinTransaction(store, tl, txUpdateInProgress);
+		else if (currentSelectorKey && currentSelectorTime) {
+			let latestUpdate = tl.history.at(-1);
+			if (currentSelectorTime !== tl.selectorTime) {
+				latestUpdate = {
+					type: `selector_update`,
+					timestamp: currentSelectorTime,
+					key: currentSelectorKey,
+					atomUpdates: []
+				};
+				latestUpdate.atomUpdates.push({
+					key: atom$1.key,
+					type: `atom_update`,
+					...update
+				});
+				if (tl.at !== tl.history.length) tl.history.splice(tl.at);
+				tl.history.push(latestUpdate);
+				store.logger.info(`⌛`, `timeline`, tl.key, `got a selector_update "${currentSelectorKey}" with`, latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key));
+				tl.at = tl.history.length;
+				tl.selectorTime = currentSelectorTime;
+			} else if (latestUpdate?.type === `selector_update`) {
+				latestUpdate.atomUpdates.push({
+					key: atom$1.key,
+					type: `atom_update`,
+					...update
+				});
+				store.logger.info(`⌛`, `timeline`, tl.key, `set selector_update "${currentSelectorKey}" to`, latestUpdate?.atomUpdates.map((atomUpdate) => atomUpdate.key));
+			}
+			if (latestUpdate) {
+				const willCaptureSelectorUpdate = tl.shouldCapture?.(latestUpdate, tl) ?? true;
+				if (willCaptureSelectorUpdate) tl.subject.next(latestUpdate);
+				else {
+					tl.history.pop();
+					tl.at = tl.history.length;
+				}
+			}
+		} else {
+			const timestamp = Date.now();
+			tl.selectorTime = null;
+			if (tl.at !== tl.history.length) tl.history.splice(tl.at);
+			const atomUpdate = {
+				type: `atom_update`,
+				timestamp,
+				key: atom$1.key,
+				oldValue: update.oldValue,
+				newValue: update.newValue
+			};
+			if (atom$1.family) atomUpdate.family = atom$1.family;
+			const willCapture = tl.shouldCapture?.(atomUpdate, tl) ?? true;
+			store.logger.info(`⌛`, `timeline`, tl.key, `got an atom_update to "${atom$1.key}"`);
+			if (willCapture) {
+				tl.history.push(atomUpdate);
+				tl.at = tl.history.length;
+				tl.subject.next(atomUpdate);
+			}
+		}
+	}));
+}
+function addAtomFamilyToTimeline(store, atomFamilyToken, tl) {
+	const family = withdraw(store, atomFamilyToken);
+	store.timelineTopics.set({
+		topicKey: family.key,
+		timelineKey: tl.key
+	}, { topicType: `atom_family` });
+	tl.subscriptions.set(family.key, family.subject.subscribe(`timeline`, function timelineCapturesStateLifecycleEvent(creationOrDisposal) {
+		handleStateLifecycleEvent(store, creationOrDisposal, tl);
+	}));
+	for (const atom$1 of store.atoms.values()) if (atom$1.family?.key === family.key) addAtomToTimeline(store, atom$1, tl);
+}
+function joinTransaction(store, tl, txUpdateInProgress) {
+	const currentTxKey = txUpdateInProgress.key;
+	const currentTxInstanceId = txUpdateInProgress.id;
+	const currentTxToken = {
+		key: currentTxKey,
+		type: `transaction`
+	};
+	const currentTransaction = withdraw(store, currentTxToken);
+	if (currentTxKey && tl.transactionKey === null) {
+		tl.transactionKey = currentTxKey;
+		const unsubscribe = currentTransaction.subject.subscribe(`timeline:${tl.key}`, (transactionUpdate) => {
+			unsubscribe();
+			tl.transactionKey = null;
+			if (tl.timeTraveling === null && currentTxInstanceId) {
+				if (tl.at !== tl.history.length) tl.history.splice(tl.at);
+				const timelineTopics = store.timelineTopics.getRelatedKeys(tl.key);
+				const updates = filterTransactionUpdates(transactionUpdate.updates, timelineTopics);
+				const timelineTransactionUpdate = {
+					timestamp: Date.now(),
+					...transactionUpdate,
+					updates
+				};
+				const willCapture = tl.shouldCapture?.(timelineTransactionUpdate, tl) ?? true;
+				if (willCapture) {
+					tl.history.push(timelineTransactionUpdate);
+					tl.at = tl.history.length;
+					tl.subject.next(timelineTransactionUpdate);
+				}
+			}
+		});
+	}
+}
+function filterTransactionUpdates(updates, timelineTopics) {
+	return updates.filter((updateFromTx) => {
+		if (updateFromTx.type === `transaction_update`) return true;
+		let key;
+		let familyKey;
+		switch (updateFromTx.type) {
+			case `state_creation`:
+			case `state_disposal`:
+				key = updateFromTx.token.key;
+				familyKey = updateFromTx.token.family?.key;
+				break;
+			case `molecule_creation`:
+			case `molecule_disposal`:
+			case `molecule_transfer`: return true;
+			case `atom_update`:
+			case `selector_update`:
+				key = updateFromTx.key;
+				familyKey = updateFromTx.family?.key;
+				break;
+		}
+		timelineTopics.has(key);
+		if (familyKey && timelineTopics.has(familyKey)) return true;
+		return timelineTopics.has(key);
+	}).map((updateFromTx) => {
+		if (`updates` in updateFromTx) return {
+			...updateFromTx,
+			updates: filterTransactionUpdates(updateFromTx.updates, timelineTopics)
+		};
+		return updateFromTx;
+	});
+}
+function handleStateLifecycleEvent(store, event, tl) {
+	const timestamp = Date.now();
+	const timelineEvent = Object.assign(event, { timestamp });
+	if (!tl.timeTraveling) {
+		const target = newest(store);
+		if (isChildStore(target)) {} else {
+			const txUpdateInProgress = target.on.transactionApplying.state;
+			if (txUpdateInProgress) joinTransaction(store, tl, txUpdateInProgress.update);
+			else {
+				tl.history.push(timelineEvent);
+				tl.at = tl.history.length;
+				tl.subject.next(timelineEvent);
+			}
+		}
+	}
+	switch (event.type) {
+		case `state_creation`:
+			addAtomToTimeline(store, event.token, tl);
+			break;
+		case `state_disposal`:
+			tl.subscriptions.get(event.token.key)?.();
+			tl.subscriptions.delete(event.token.key);
+			break;
+	}
+}
+
+//#endregion
+//#region src/internal/timeline/time-travel.ts
+const timeTravel = (store, action, token) => {
+	store.logger.info(action === `redo` ? `⏩` : `⏪`, `timeline`, token.key, action);
+	const timelineData = store.timelines.get(token.key);
+	if (!timelineData) {
+		store.logger.error(`🐞`, `timeline`, token.key, `Failed to ${action}. This timeline has not been initialized.`);
+		return;
+	}
+	if (action === `redo` && timelineData.at === timelineData.history.length || action === `undo` && timelineData.at === 0) {
+		store.logger.warn(`💁`, `timeline`, token.key, `Failed to ${action} at the ${action === `redo` ? `end` : `beginning`} of timeline "${token.key}". There is nothing to ${action}.`);
+		return;
+	}
+	timelineData.timeTraveling = action === `redo` ? `into_future` : `into_past`;
+	if (action === `undo`) --timelineData.at;
+	const update = timelineData.history[timelineData.at];
+	const applying = action === `redo` ? `newValue` : `oldValue`;
+	switch (update.type) {
+		case `atom_update`: {
+			ingestAtomUpdate(applying, update, store);
+			break;
+		}
+		case `selector_update`: {
+			ingestSelectorUpdate(applying, update, store);
+			break;
+		}
+		case `transaction_update`: {
+			ingestTransactionUpdate(applying, update, store);
+			break;
+		}
+		case `state_creation`: {
+			ingestCreationEvent(update, applying, store);
+			break;
+		}
+		case `state_disposal`: {
+			ingestDisposalEvent(update, applying, store);
+			break;
+		}
+		case `molecule_creation`:
+		case `molecule_disposal`:
+	}
+	if (action === `redo`) ++timelineData.at;
+	timelineData.subject.next(action);
+	timelineData.timeTraveling = null;
+	store.logger.info(`⏹️`, `timeline`, token.key, `"${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`);
+};
+
+//#endregion
+export { CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, Join, Junction, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, capitalize, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, createWritableSelectorFamily, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, evictCachedValue, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, installIntoStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+//# sourceMappingURL=index.js.map