atom.io 0.40.6 → 0.40.7

package/dist/internal/index.js

@@ -1,5 +1,7 @@
-import { parseJson, stringifyJson } from "atom.io/json";
+import { DO_NOT_CREATE, Future, INTERNAL_ROLES, JOIN_OP, NotFoundError, RESET_STATE, StatefulSubject, Subject, Tracker, become, closeOperation, createRegularAtom, deposit, eldest, evictCachedValue, evictDownstreamFromAtom, evictDownstreamFromSelector, getFallback, getFamilyOfToken, getFromStore, getSelectorDependencyKeys, hasRole, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markDone, mintInStore, newest, openOperation, operateOnStore, readFromCache, readOrComputeValue, recallState, reduceReference, resetAtomOrSelector, resetInStore, seekInStore, setAtomOrSelector, setIntoStore, subscribeToRootDependency, subscribeToState, subscribeToTimeline, traceRootSelectorAtoms, withdraw, writeToCache } from "../has-role-hv4-hJMw.js";
+import { isFn } from "../is-fn-DY1wZ-md.js";
 import { Anarchy, AtomIOLogger, PRETTY_TOKEN_TYPES } from "atom.io";
+import { parseJson, stringifyJson } from "atom.io/json";
 import { SetRTX } from "atom.io/transceivers/set-rtx";
 
 //#region src/internal/arbitrary.ts
@@ -7,17 +9,6 @@ function arbitrary(random = Math.random) {
 	return random().toString(36).slice(2);
 }
 
-//#endregion
-//#region src/internal/lineage.ts
-function newest(scion) {
-	while (scion.child !== null) scion = scion.child;
-	return scion;
-}
-function eldest(scion) {
-	while (scion.parent !== null) scion = scion.parent;
-	return scion;
-}
-
 //#endregion
 //#region src/internal/store/circular-buffer.ts
 var CircularBuffer = class CircularBuffer {
@@ -46,45 +37,6 @@ var CircularBuffer = class CircularBuffer {
 	}
 };
 
-//#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/store/mint-or-counterfeit.ts
-const COUNTERFEIT = Symbol(`counterfeit`);
-const FAMILY_MEMBER_TOKEN_TYPES = {
-	atom_family: `atom`,
-	molecule_family: `molecule`,
-	mutable_atom_family: `mutable_atom`,
-	readonly_held_selector_family: `readonly_held_selector`,
-	readonly_pure_selector_family: `readonly_pure_selector`,
-	writable_held_selector_family: `writable_held_selector`,
-	writable_pure_selector_family: `writable_pure_selector`
-};
-function mint(token, key, counterfeit) {
-	const subKey = stringifyJson(key);
-	const fullKey = `${token.key}(${subKey})`;
-	const type = FAMILY_MEMBER_TOKEN_TYPES[token.type];
-	const stateToken = {
-		key: fullKey,
-		type,
-		family: {
-			key: token.key,
-			subKey
-		}
-	};
-	if (counterfeit) stateToken.counterfeit = true;
-	return stateToken;
-}
-
 //#endregion
 //#region src/internal/overlays/map-overlay.ts
 var MapOverlay = class extends Map {
@@ -519,407 +471,9 @@ var Junction = class Junction {
 };
 
 //#endregion
-//#region src/internal/subject.ts
-var Subject = class {
-	Subscriber;
-	subscribers = /* @__PURE__ */ 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/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/get-state/get-fallback.ts
-function getFallback(store, token, family, subKey) {
-	const disposal = store.disposalTraces.buffer.find((item) => item?.key === stringifyJson(subKey));
-	store.logger.error(`❌`, token.type, token.key, `gets a fallback value because key`, subKey, `is not allocated`, disposal ? `This key was previously disposed:\n${disposal.trace}` : `(no previous disposal trace found)`);
-	switch (family.type) {
-		case `mutable_atom_family`: {
-			if (store.defaults.has(family.key)) return store.defaults.get(family.key);
-			const defaultValue = new family.class();
-			store.defaults.set(family.key, defaultValue);
-			return defaultValue.READONLY_VIEW;
-		}
-		case `atom_family`: {
-			if (store.defaults.has(family.key)) return store.defaults.get(family.key);
-			const def = family.default;
-			const defaultValue = def(subKey);
-			store.defaults.set(family.key, defaultValue);
-			return defaultValue;
-		}
-		case `readonly_pure_selector_family`:
-		case `writable_pure_selector_family`:
-		case `readonly_held_selector_family`:
-		case `writable_held_selector_family`: {
-			if (store.defaults.has(family.key)) return store.defaults.get(family.key);
-			const defaultValue = family.default(subKey);
-			store.defaults.set(family.key, defaultValue);
-			return defaultValue;
-		}
-	}
-}
-
-//#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 (this === value) return;
-		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/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/operation.ts
-function 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: /* @__PURE__ */ new Set(),
-		prev: /* @__PURE__ */ new Map(),
-		timestamp: Date.now(),
-		token,
-		subEvents: []
-	};
-	store.logger.info(`⭕`, token.type, token.key, `operation start in store "${store.config.name}"${isChildStore(store) ? ` ${store.transactionMeta.phase} "${store.transactionMeta.update.token.key}"` : ``}`);
-	return store;
-}
-function 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/evict-downstream.ts
-function evictDownstreamFromAtom(store, atom) {
-	const target = newest(store);
-	const { key, type } = atom;
-	const downstreamKeys = target.selectorAtoms.getRelatedKeys(key);
-	target.logger.info(`🧹`, type, key, downstreamKeys ? `evicting ${downstreamKeys.size} states downstream:` : `no downstream states`, downstreamKeys ?? `to evict`);
-	if (downstreamKeys) {
-		if (target.operation.open) target.logger.info(`🧹`, type, key, `[ ${[...target.operation.done].join(`, `)} ] already done`);
-		for (const downstreamKey of downstreamKeys) {
-			if (isDone(target, downstreamKey)) continue;
-			evictCachedValue(target, downstreamKey);
-			markDone(target, downstreamKey);
-		}
-	}
-}
-function evictDownstreamFromSelector(store, selectorKey) {
-	const target = newest(store);
-	const relationEntries = target.selectorGraph.getRelationEntries({ upstreamSelectorKey: selectorKey }).filter(([_, { source }]) => source === selectorKey);
-	for (const [downstreamSelectorKey] of relationEntries) {
-		if (isDone(target, downstreamSelectorKey)) continue;
-		evictCachedValue(target, downstreamSelectorKey);
-		markDone(target, downstreamSelectorKey);
-		evictDownstreamFromSelector(store, downstreamSelectorKey);
-	}
-}
-
-//#endregion
-//#region src/internal/caching.ts
-function writeToCache(target, state, value) {
-	const { key, subject, type } = state;
-	const currentValue = target.valueMap.get(key);
-	if (currentValue instanceof Future && !currentValue.done) {
-		const future = currentValue;
-		if (value instanceof Promise) {
-			future.use(value);
-			return future;
-		}
-		target.valueMap.set(key, value);
-		return value;
-	}
-	if (value instanceof Promise) {
-		const future = new Future(value);
-		target.valueMap.set(key, future);
-		future.then(function handleResolvedFuture(resolved) {
-			const current = target.valueMap.get(key);
-			if (current === future) {
-				openOperation(target, state);
-				writeToCache(target, state, resolved);
-				switch (type) {
-					case `atom`:
-						evictDownstreamFromAtom(target, state);
-						break;
-					case `readonly_pure_selector`:
-					case `writable_pure_selector`:
-						evictDownstreamFromSelector(target, key);
-						break;
-				}
-				closeOperation(target);
-				subject.next({
-					newValue: resolved,
-					oldValue: future
-				});
-			}
-		}).catch((thrown) => {
-			target.logger.error(`💥`, state.type, key, `rejected:`, thrown);
-		});
-		return future;
-	}
-	target.logger.info(`📝`, state.type, state.key, `writing to cache`, value);
-	target.valueMap.set(key, value);
-	return value;
-}
-/**
-* @param target - the newest layer of the store
-* @param state - the state to read from cache
-* @param mut - whether the value is intended to be mutable
-* @returns the state's current value
-*/
-function readFromCache(target, state, mut) {
-	target.logger.info(`📖`, state.type, state.key, `reading cached value`);
-	let value = target.valueMap.get(state.key);
-	const mayNeedToBeCopied = mut === `mut` && state.type === `mutable_atom` && isChildStore(target);
-	if (mayNeedToBeCopied) {
-		const mutableAtom$1 = state;
-		const { parent } = target;
-		if (target.valueMap.hasOwn(mutableAtom$1.key)) return value;
-		const parentValue = parent.valueMap.get(mutableAtom$1.key);
-		target.logger.info(`📃`, `atom`, mutableAtom$1.key, `copying`);
-		const jsonValue = parentValue.toJSON();
-		const copiedValue = mutableAtom$1.class.fromJSON(jsonValue);
-		target.valueMap.set(mutableAtom$1.key, copiedValue);
-		new Tracker(mutableAtom$1, parent);
-		value = copiedValue;
-	}
-	return value;
-}
-function evictCachedValue(target, key) {
-	const currentValue = target.valueMap.get(key);
-	if (currentValue instanceof Future) {
-		const selector = target.writableSelectors.get(key) ?? target.readonlySelectors.get(key);
-		if (selector) selector.getFrom(target);
-		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/is-fn.ts
-const NON_CTOR_FN_REGEX = /^\[object (?:Async|Generator|AsyncGenerator)?Function\]$/;
-function isFn(input) {
-	const protoString = Object.prototype.toString.call(input);
-	return NON_CTOR_FN_REGEX.test(protoString);
-}
-
-//#endregion
-//#region src/internal/safe-compute.ts
-function safeCompute(target, state) {
-	const { type, key, catch: canCatch } = state;
-	switch (type) {
-		case `readonly_pure_selector`:
-		case `writable_pure_selector`: {
-			let val;
-			target.logger.info(`🧮`, type, key, `computing value`);
-			try {
-				val = state.getFrom(target);
-				if (val instanceof Promise) return val.catch((thrown) => {
-					target.logger.error(`💥`, type, key, `rejected:`, thrown);
-					if (canCatch) {
-						for (const Class of canCatch) if (thrown instanceof Class) return thrown;
-					}
-					throw thrown;
-				});
-			} catch (e) {
-				target.logger.error(`💥`, type, key, `rejected:`, e);
-				if (canCatch) {
-					for (const Class of canCatch) if (e instanceof Class) return writeToCache(target, state, e);
-				}
-				throw e;
-			}
-			const cachedValue = writeToCache(target, state, val);
-			return cachedValue;
-		}
-		case `atom`: {
-			let def;
-			if (isFn(state.default)) try {
-				def = state.default();
-				if (def instanceof Promise) def = def.catch((thrown) => {
-					target.logger.error(`💥`, type, key, `rejected:`, thrown);
-					if (canCatch) {
-						for (const Class of canCatch) if (thrown instanceof Class) return thrown;
-					}
-					throw thrown;
-				});
-			} catch (e) {
-				target.logger.error(`💥`, type, key, `rejected:`, e);
-				if (canCatch) {
-					for (const Class of canCatch) if (e instanceof Class) {
-						def = writeToCache(target, state, e);
-						target.logger.info(`✨`, state.type, key, `computed default`, def);
-						return def;
-					}
-				}
-				throw e;
-			}
-			else {
-				def = state.default;
-				target.logger.info(`✨`, state.type, key, `using static default`, def);
-			}
-			const cachedValue = writeToCache(target, state, def);
-			return cachedValue;
-		}
-	}
-}
-
-//#endregion
-//#region src/internal/get-state/read-or-compute-value.ts
-function readOrComputeValue(target, state, mut) {
-	if (target.valueMap.has(state.key)) return readFromCache(target, state, mut);
-	target.logger.info(`❔`, state.type, state.key, `value not found in cache`);
-	const { key } = state;
-	switch (state.type) {
-		case `readonly_held_selector`:
-		case `writable_held_selector`:
-			target.logger.info(`🧮`, state.type, key, `computing value`);
-			return state.getFrom(target);
-		case `writable_pure_selector`:
-		case `readonly_pure_selector`:
-		case `atom`: return safeCompute(target, state);
-		case `mutable_atom`: {
-			const instance = new state.class();
-			target.logger.info(`✨`, state.type, key, `created new instance`, instance);
-			const cachedValue = writeToCache(target, state, instance);
-			return cachedValue;
-		}
-	}
-}
-
-//#endregion
-//#region src/internal/families/get-family-of-token.ts
-function getFamilyOfToken(store, token) {
-	return withdraw(store, {
-		key: token.family.key,
-		type: `${token.type}_family`
-	});
-}
-
-//#endregion
-//#region src/internal/families/mint-in-store.ts
-const MUST_CREATE = Symbol(`MUST_CREATE`);
-function mintInStore(store, family, key, mustCreate) {
-	const stringKey = stringifyJson(key);
-	const molecule = store.molecules.get(stringKey);
-	const cannotCreate = !molecule && store.config.lifespan === `immortal`;
-	if (cannotCreate) {
-		store.logger.warn(`💣`, `key`, stringKey, `was used to mint a counterfeit token for`, family.type, `"${family.key}"`);
-		return mint(family, key, COUNTERFEIT);
-	}
-	let token;
-	if (mustCreate === MUST_CREATE) {
-		store.logger.info(`👪`, family.type, family.key, `adds member`, typeof key === `string` ? `\`${key}\`` : key);
-		token = family.create(key);
-		if (molecule) store.moleculeData.set(stringKey, family.key);
-	} else token = mint(family, key);
-	return token;
+//#region src/internal/reserved-keys.ts
+function isReservedIntrospectionKey(value) {
+	return value.startsWith(`🔍 `);
 }
 
 //#endregion
@@ -938,140 +492,6 @@ function actUponStore(store, token, id) {
 	};
 }
 
-//#endregion
-//#region src/internal/set-state/become.ts
-function become(nextVersionOfThing, originalThing) {
-	if (isFn(nextVersionOfThing)) return nextVersionOfThing(originalThing);
-	return nextVersionOfThing;
-}
-
-//#endregion
-//#region src/internal/set-state/set-atom.ts
-const setAtom = (target, atom, next) => {
-	const oldValue = readOrComputeValue(target, atom, `mut`);
-	let newValue = become(next, oldValue);
-	target.logger.info(`⭐`, `atom`, atom.key, `setting value`, newValue);
-	newValue = writeToCache(target, atom, newValue);
-	markDone(target, atom.key);
-	evictDownstreamFromAtom(target, atom);
-	return {
-		oldValue,
-		newValue
-	};
-};
-
-//#endregion
-//#region src/internal/set-state/reset-atom-or-selector.ts
-function resetAtom(target, atom) {
-	switch (atom.type) {
-		case `mutable_atom`: return setAtom(target, atom, new atom.class());
-		case `atom`: {
-			let def;
-			if (isFn(atom.default)) def = safeCompute(target, atom);
-			else def = atom.default;
-			return setAtom(target, atom, def);
-		}
-	}
-}
-function resetAtomOrSelector(target, state) {
-	let protoUpdate;
-	switch (state.type) {
-		case `atom`:
-		case `mutable_atom`:
-			protoUpdate = resetAtom(target, state);
-			break;
-		case `writable_held_selector`:
-			{
-				const atoms = traceRootSelectorAtoms(target, state.key);
-				for (const atom of atoms.values()) {
-					const rootProtoUpdate = resetAtom(target, atom);
-					dispatchOrDeferStateUpdate(target, state, rootProtoUpdate, false);
-				}
-				const value = state.getFrom(target);
-				protoUpdate = {
-					oldValue: value,
-					newValue: value
-				};
-			}
-			break;
-		case `writable_pure_selector`:
-			{
-				const oldValue = safeCompute(target, state);
-				const atoms = traceRootSelectorAtoms(target, state.key);
-				for (const atom of atoms.values()) {
-					const rootProtoUpdate = resetAtom(target, atom);
-					dispatchOrDeferStateUpdate(target, state, rootProtoUpdate, false);
-				}
-				const newValue = safeCompute(target, state);
-				protoUpdate = {
-					oldValue,
-					newValue
-				};
-			}
-			break;
-	}
-	return protoUpdate;
-}
-
-//#endregion
-//#region src/internal/set-state/set-into-store.ts
-function setIntoStore(store, ...params) {
-	operateOnStore(store, OWN_OP, ...params);
-}
-
-//#endregion
-//#region src/internal/set-state/reset-in-store.ts
-const RESET_STATE = Symbol(`RESET`);
-function resetInStore(store, ...params) {
-	const subParams = [...params, RESET_STATE];
-	setIntoStore(store, ...subParams);
-}
-
-//#endregion
-//#region src/internal/set-state/set-selector.ts
-function setSelector(target, selector, next) {
-	let oldValue;
-	let newValue;
-	let constant;
-	const { type, key } = selector;
-	switch (selector.type) {
-		case `writable_pure_selector`:
-			oldValue = readOrComputeValue(target, selector, `mut`);
-			newValue = become(next, oldValue);
-			newValue = writeToCache(target, selector, newValue);
-			break;
-		case `writable_held_selector`:
-			constant = selector.const;
-			become(next, constant);
-			oldValue = constant;
-			newValue = constant;
-	}
-	target.logger.info(`⭐`, type, key, `setting to`, newValue);
-	markDone(target, key);
-	selector.setSelf(newValue);
-	return {
-		oldValue,
-		newValue
-	};
-}
-
-//#endregion
-//#region src/internal/set-state/set-atom-or-selector.ts
-const setAtomOrSelector = (target, state, value) => {
-	let protoUpdate;
-	switch (state.type) {
-		case `atom`:
-		case `mutable_atom`:
-			protoUpdate = setAtom(target, state, value);
-			break;
-		case `writable_pure_selector`:
-		case `writable_held_selector`:
-			protoUpdate = setSelector(target, state, value);
-			break;
-	}
-	return protoUpdate;
-};
-
 //#endregion
 //#region src/internal/events/ingest-atom-update.ts
 function ingestAtomUpdateEvent(store, event, applying) {
@@ -1090,7 +510,7 @@ function getTrace(error) {
 
 //#endregion
 //#region src/internal/molecule.ts
-function makeRootMoleculeInStore(key, store = IMPLICIT.STORE) {
+function makeRootMoleculeInStore(store, key) {
 	const molecule = {
 		key,
 		stringKey: stringifyJson(key),
@@ -1523,7 +943,7 @@ function createTransaction(store, options) {
 }
 
 //#endregion
-//#region src/internal/transaction/index.ts
+//#region src/internal/transaction/transaction-meta-progress.ts
 const TRANSACTION_PHASES = [
 	`idle`,
 	`building`,
@@ -1531,512 +951,142 @@ const TRANSACTION_PHASES = [
 ];
 
 //#endregion
-//#region src/internal/set-state/dispatch-state-update.ts
-function dispatchOrDeferStateUpdate(target, state, { oldValue, newValue }, stateIsNewlyCreated, family) {
-	const token = deposit(state);
-	if (stateIsNewlyCreated && family) {
-		state.subject.next({ newValue });
-		const stateCreationEvent = {
-			checkpoint: true,
-			type: `state_creation`,
-			subType: `writable`,
-			token,
-			timestamp: Date.now(),
-			value: newValue
-		};
-		target.operation.subEvents.push(stateCreationEvent);
-		const familySubject = family.subject;
-		familySubject.next(stateCreationEvent);
-		const innerTarget = newest(target);
-		if (token.family) {
-			if (isRootStore(innerTarget)) switch (token.type) {
-				case `atom`:
-				case `mutable_atom`:
-					target.on.atomCreation.next(token);
-					break;
-				case `writable_pure_selector`:
-				case `writable_held_selector`:
-					target.on.selectorCreation.next(token);
-					break;
-			}
-			else if (isChildStore(innerTarget) && innerTarget.on.transactionApplying.state === null) innerTarget.transactionMeta.update.subEvents.push(stateCreationEvent);
-		}
-		return;
-	}
-	const { key, subject, type } = state;
-	const update = {
-		oldValue: isTransceiver(oldValue) ? oldValue.READONLY_VIEW : oldValue,
-		newValue: isTransceiver(newValue) ? newValue.READONLY_VIEW : newValue
+//#region src/internal/store/store.ts
+var Store = class {
+	parent = null;
+	child = null;
+	valueMap = /* @__PURE__ */ new Map();
+	defaults = /* @__PURE__ */ new Map();
+	atoms = /* @__PURE__ */ new Map();
+	writableSelectors = /* @__PURE__ */ new Map();
+	readonlySelectors = /* @__PURE__ */ new Map();
+	atomsThatAreDefault = /* @__PURE__ */ 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 = /* @__PURE__ */ new Map();
+	families = /* @__PURE__ */ new Map();
+	joins = /* @__PURE__ */ new Map();
+	transactions = /* @__PURE__ */ new Map();
+	transactionMeta = {
+		epoch: /* @__PURE__ */ new Map(),
+		actionContinuities: new Junction({
+			between: [`continuity`, `action`],
+			cardinality: `1:n`
+		})
 	};
-	if (isRootStore(target)) {
-		switch (type) {
-			case `mutable_atom`:
-				target.logger.info(`📢`, type, key, `is now (`, newValue, `) subscribers:`, subject.subscribers.keys());
-				break;
-			case `atom`:
-			case `writable_pure_selector`:
-			case `writable_held_selector`: target.logger.info(`📢`, type, key, `went (`, oldValue, `->`, newValue, `) subscribers:`, subject.subscribers.keys());
-		}
-		subject.next(update);
-	}
-	if (isChildStore(target) && (type === `mutable_atom` || type === `atom`)) {
-		if (target.on.transactionApplying.state === null) {
-			if (isTransceiver(newValue)) return;
-			const { timestamp } = target.operation;
-			const atomUpdate = {
-				type: `atom_update`,
-				token,
-				timestamp,
-				update
-			};
-			target.transactionMeta.update.subEvents.push(atomUpdate);
-			target.logger.info(`📁`, `atom`, key, `stowed (`, oldValue, `->`, newValue, `)`);
-			return;
-		}
-		if (hasRole(state, `tracker:signal`)) {
-			const keyOfMutable = key.slice(1);
-			const mutable = target.atoms.get(keyOfMutable);
-			const transceiver = readOrComputeValue(target, mutable, `mut`);
-			const accepted = transceiver.do(update.newValue) === null;
-			if (accepted === true) evictDownstreamFromAtom(target, mutable);
-		}
-	}
-}
-
-//#endregion
-//#region src/internal/set-state/operate-on-store.ts
-const OWN_OP = Symbol(`OWN_OP`);
-const JOIN_OP = Symbol(`JOIN_OP`);
-function operateOnStore(store, opMode, ...params) {
-	let existingToken;
-	let brandNewToken;
-	let token;
-	let family;
-	let key;
-	let value;
-	if (params.length === 2) {
-		token = params[0];
-		value = params[1];
-		if (`family` in token) {
-			family = getFamilyOfToken(store, token);
-			key = parseJson(token.family.subKey);
-			existingToken = seekInStore(store, family, key);
-			if (!existingToken) token = brandNewToken = mintInStore(store, family, key, MUST_CREATE);
-			else token = existingToken;
-		}
-	} else {
-		family = withdraw(store, params[0]);
-		key = params[1];
-		value = params[2];
-		existingToken = seekInStore(store, family, key);
-		if (!existingToken) token = brandNewToken = mintInStore(store, family, key, MUST_CREATE);
-		else token = existingToken;
-	}
-	const action = value === RESET_STATE ? `reset` : `set`;
-	let target;
-	if (opMode === OWN_OP) {
-		const result = openOperation(store, token);
-		const rejected = typeof result === `number`;
-		if (rejected) {
-			const rejectionTime = result;
-			const unsubscribe = store.on.operationClose.subscribe(`waiting to ${action} "${token.key}" at T-${rejectionTime}`, function waitUntilOperationCloseToSetState() {
-				unsubscribe();
-				store.logger.info(`🟢`, token.type, token.key, `resuming deferred`, action, `from T-${rejectionTime}`);
-				operateOnStore(store, opMode, token, value);
-			});
-			return;
-		}
-		target = result;
-	} else target = store;
-	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`, action, `because key`, subKey, `is not allocated.`, disposal ? `this key was previously disposed:${disposal.trace}` : `(no previous disposal trace found)`);
-		return;
-	}
-	const state = withdraw(target, token);
-	let protoUpdate;
-	if (value === RESET_STATE) protoUpdate = resetAtomOrSelector(target, state);
-	else protoUpdate = setAtomOrSelector(target, state, value);
-	const isNewlyCreated = Boolean(brandNewToken);
-	dispatchOrDeferStateUpdate(target, state, protoUpdate, isNewlyCreated, family);
-	if (opMode === OWN_OP) closeOperation(target);
-}
-
-//#endregion
-//#region src/internal/keys.ts
-const isAtomKey = (store, key) => newest(store).atoms.has(key);
-const isSelectorKey = (store, key) => newest(store).writableSelectors.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
-function getSelectorDependencyKeys(store, key) {
-	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
-function traceRootSelectorAtoms(store, selectorKey, covered = /* @__PURE__ */ new Set()) {
-	const dependencies = getSelectorDependencyKeys(store, selectorKey);
-	const roots = /* @__PURE__ */ new Map();
-	while (dependencies.length > 0) {
-		const dependencyKey = dependencies.pop();
-		if (covered.has(dependencyKey)) continue;
-		covered.add(dependencyKey);
-		if (isAtomKey(store, dependencyKey)) {
-			const atom = store.atoms.get(dependencyKey);
-			roots.set(atom.key, atom);
-		} else dependencies.push(...getSelectorDependencyKeys(store, dependencyKey));
-	}
-	return roots;
-}
-
-//#endregion
-//#region src/internal/selector/update-selector-atoms.ts
-function updateSelectorAtoms(store, selectorType, selectorKey, dependency, covered) {
-	const target = newest(store);
-	const { type: dependencyType, key: dependencyKey } = dependency;
-	if (dependencyType === `atom` || dependencyType === `mutable_atom`) {
-		target.selectorAtoms.set({
-			selectorKey,
-			atomKey: dependencyKey
-		});
-		store.logger.info(`🔍`, selectorType, selectorKey, `discovers root atom "${dependencyKey}"`);
-	} else {
-		const rootKeys = traceRootSelectorAtoms(store, dependencyKey, covered);
-		store.logger.info(`🔍`, selectorType, selectorKey, `discovers root atoms: [ ${[...rootKeys.values()].map((root) => `"${root.key}"`).join(`, `)} ]`);
-		for (const { key: atomKey } of rootKeys.values()) target.selectorAtoms = target.selectorAtoms.set({
-			selectorKey,
-			atomKey
-		});
-	}
-	covered.add(dependencyKey);
-}
-
-//#endregion
-//#region src/internal/selector/register-selector.ts
-function registerSelector(store, selectorType, selectorKey, covered) {
-	return {
-		get: (...params) => {
-			const target = newest(store);
-			const { token, family, subKey } = reduceReference(store, ...params);
-			let dependencyValue;
-			if (`counterfeit` in token && family && subKey) dependencyValue = getFallback(store, token, family, subKey);
-			else {
-				const dependency = withdraw(store, token);
-				dependencyValue = readOrComputeValue(store, dependency);
-			}
-			store.logger.info(`🔌`, selectorType, selectorKey, `registers dependency ( "${token.key}" =`, dependencyValue, `)`);
-			target.selectorGraph.set({
-				upstreamSelectorKey: token.key,
-				downstreamSelectorKey: selectorKey
-			}, { source: token.key });
-			updateSelectorAtoms(store, selectorType, selectorKey, token, covered);
-			return dependencyValue;
-		},
-		set: ((...params) => {
-			const target = newest(store);
-			operateOnStore(target, JOIN_OP, ...params);
-		}),
-		find: ((...args) => findInStore(store, ...args)),
-		json: (token) => getJsonToken(store, token)
-	};
-}
-
-//#endregion
-//#region src/internal/selector/create-readonly-held-selector.ts
-function createReadonlyHeldSelector(store, options, family) {
-	const target = newest(store);
-	const subject = new Subject();
-	const covered = /* @__PURE__ */ new Set();
-	const { key, const: constant } = options;
-	const type = `readonly_held_selector`;
-	store.logger.info(`🔨`, type, key, `is being created`);
-	const { get, find, json } = registerSelector(target, type, key, covered);
-	const getFrom = (innerTarget) => {
-		const upstreamStates = innerTarget.selectorGraph.getRelationEntries({ downstreamSelectorKey: key });
-		for (const [downstreamSelectorKey, { source }] of upstreamStates) if (source !== key) innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
-		innerTarget.selectorAtoms.delete(key);
-		options.get({
-			get,
-			find,
-			json
-		}, constant);
-		writeToCache(innerTarget, readonlySelector, constant);
-		store.logger.info(`✨`, type, key, `=`, constant);
-		covered.clear();
-		return constant;
-	};
-	const readonlySelector = {
-		...options,
-		type,
-		subject,
-		getFrom,
-		install: (s) => createReadonlyHeldSelector(s, options, family)
-	};
-	if (family) readonlySelector.family = family;
-	target.readonlySelectors.set(key, readonlySelector);
-	const token = {
-		key,
-		type
-	};
-	if (family) token.family = family;
-	return token;
-}
-
-//#endregion
-//#region src/internal/selector/create-readonly-pure-selector.ts
-function createReadonlyPureSelector(store, options, family) {
-	const target = newest(store);
-	const subject = new Subject();
-	const covered = /* @__PURE__ */ new Set();
-	const key = options.key;
-	const type = `readonly_pure_selector`;
-	store.logger.info(`🔨`, type, key, `is being created`);
-	const { get, find, json } = registerSelector(target, type, key, covered);
-	const getFrom = () => {
-		const innerTarget = newest(store);
-		const upstreamStates = innerTarget.selectorGraph.getRelationEntries({ downstreamSelectorKey: key });
-		for (const [downstreamSelectorKey, { source }] of upstreamStates) if (source !== key) innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
-		innerTarget.selectorAtoms.delete(key);
-		const value = options.get({
-			get,
-			find,
-			json
-		});
-		const cached = writeToCache(innerTarget, readonlySelector, value);
-		store.logger.info(`✨`, type, key, `=`, cached);
-		covered.clear();
-		return cached;
-	};
-	const readonlySelector = {
-		...options,
-		type,
-		subject,
-		getFrom,
-		install: (s) => createReadonlyPureSelector(s, options, family)
-	};
-	if (family) readonlySelector.family = family;
-	target.readonlySelectors.set(key, readonlySelector);
-	const token = {
-		key,
-		type
-	};
-	if (family) token.family = family;
-	return token;
-}
-
-//#endregion
-//#region src/internal/selector/create-writable-held-selector.ts
-function createWritableHeldSelector(store, options, family) {
-	const target = newest(store);
-	const subject = new Subject();
-	const covered = /* @__PURE__ */ new Set();
-	const { key, const: constant } = options;
-	const type = `writable_held_selector`;
-	store.logger.info(`🔨`, type, key, `is being created`);
-	const setterToolkit = registerSelector(target, type, key, covered);
-	const { find, get, json } = setterToolkit;
-	const getterToolkit = {
-		find,
-		get,
-		json
-	};
-	const getFrom = (innerTarget) => {
-		const upstreamStates = innerTarget.selectorGraph.getRelationEntries({ downstreamSelectorKey: key });
-		for (const [downstreamSelectorKey, { source }] of upstreamStates) if (source !== key) innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
-		innerTarget.selectorAtoms.delete(key);
-		options.get(getterToolkit, constant);
-		writeToCache(innerTarget, mySelector, constant);
-		store.logger.info(`✨`, type, key, `=`, constant);
-		covered.clear();
-		return constant;
-	};
-	const setSelf = () => {
-		options.set(setterToolkit, constant);
-	};
-	const mySelector = {
-		...options,
-		type,
-		subject,
-		getFrom,
-		setSelf,
-		install: (s) => createWritableHeldSelector(s, options, family)
-	};
-	if (family) mySelector.family = family;
-	target.writableSelectors.set(key, mySelector);
-	const token = {
-		key,
-		type
-	};
-	if (family) token.family = family;
-	return token;
-}
-
-//#endregion
-//#region src/internal/selector/create-writable-pure-selector.ts
-function createWritablePureSelector(store, options, family) {
-	const target = newest(store);
-	const subject = new Subject();
-	const covered = /* @__PURE__ */ new Set();
-	const key = options.key;
-	const type = `writable_pure_selector`;
-	store.logger.info(`🔨`, type, key, `is being created`);
-	const setterToolkit = registerSelector(target, type, key, covered);
-	const { find, get, json } = setterToolkit;
-	const getterToolkit = {
-		find,
-		get,
-		json
-	};
-	const getFrom = (innerTarget) => {
-		const upstreamStates = innerTarget.selectorGraph.getRelationEntries({ downstreamSelectorKey: key });
-		for (const [downstreamSelectorKey, { source }] of upstreamStates) if (source !== key) innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
-		innerTarget.selectorAtoms.delete(key);
-		const value = options.get(getterToolkit);
-		const cached = writeToCache(innerTarget, mySelector, value);
-		store.logger.info(`✨`, type, key, `=`, cached);
-		covered.clear();
-		return cached;
-	};
-	const setSelf = (newValue) => {
-		options.set(setterToolkit, newValue);
+	timelines = /* @__PURE__ */ new Map();
+	timelineTopics = new Junction({
+		between: [`timelineKey`, `topicKey`],
+		cardinality: `1:n`
+	});
+	disposalTraces = new CircularBuffer(100);
+	molecules = /* @__PURE__ */ 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 = /* @__PURE__ */ 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()
 	};
-	const mySelector = {
-		...options,
-		type,
-		subject,
-		getFrom,
-		setSelf,
-		install: (s) => createWritablePureSelector(s, options, family)
+	operation = { open: false };
+	config = {
+		name: `IMPLICIT_STORE`,
+		lifespan: `ephemeral`
 	};
-	if (family) mySelector.family = family;
-	target.writableSelectors.set(key, mySelector);
-	const token = {
-		key,
-		type
+	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);
+		}
 	};
-	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;
-	const isHeld = `const` in options;
-	if (isHeld && isWritable) {
-		const state$1 = createWritableHeldSelector(store, options, void 0);
-		store.on.selectorCreation.next(state$1);
-		return state$1;
-	}
-	if (isHeld) {
-		const state$1 = createReadonlyHeldSelector(store, options, void 0);
-		store.on.selectorCreation.next(state$1);
-		return state$1;
-	}
-	if (isWritable) {
-		const state$1 = createWritablePureSelector(store, options, void 0);
-		store.on.selectorCreation.next(state$1);
-		return state$1;
-	}
-	const state = createReadonlyPureSelector(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, type, family: familyMeta } = selectorToken;
-	if (!familyMeta) store.logger.error(`❌`, type, key, `Standalone selectors cannot be disposed.`);
-	else {
-		const molecule = target.molecules.get(familyMeta.subKey);
-		if (molecule) target.moleculeData.delete(familyMeta.subKey, familyMeta.key);
-		let familyToken;
-		switch (selectorToken.type) {
-			case `writable_held_selector`:
-				{
-					target.writableSelectors.delete(key);
-					familyToken = {
-						key: familyMeta.key,
-						type: `writable_held_selector_family`
-					};
-					const family = withdraw(store, familyToken);
-					family.subject.next({
-						type: `state_disposal`,
-						subType: `selector`,
-						token: selectorToken,
-						timestamp: Date.now()
-					});
-				}
-				break;
-			case `writable_pure_selector`:
-				{
-					target.writableSelectors.delete(key);
-					familyToken = {
-						key: familyMeta.key,
-						type: `writable_pure_selector_family`
-					};
-					const family = withdraw(store, familyToken);
-					family.subject.next({
-						type: `state_disposal`,
-						subType: `selector`,
-						token: selectorToken,
-						timestamp: Date.now()
-					});
-				}
-				break;
-			case `readonly_held_selector`:
-				{
-					target.readonlySelectors.delete(key);
-					familyToken = {
-						key: familyMeta.key,
-						type: `readonly_held_selector_family`
-					};
-					const family = withdraw(store, familyToken);
-					family.subject.next({
-						type: `state_disposal`,
-						subType: `selector`,
-						token: selectorToken,
-						timestamp: Date.now()
-					});
-				}
-				break;
-			case `readonly_pure_selector`:
-				{
-					target.readonlySelectors.delete(key);
-					familyToken = {
-						key: familyMeta.key,
-						type: `readonly_pure_selector_family`
-					};
-					const family = withdraw(store, familyToken);
-					family.subject.next({
-						type: `state_disposal`,
-						subType: `selector`,
-						token: selectorToken,
-						timestamp: Date.now()
-					});
+	constructor(config, store = null) {
+		this.config = {
+			...store?.config,
+			...config
+		};
+		if (store !== null) {
+			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 = /* @__PURE__ */ new Set();
+			for (const [, atom] of store.atoms) {
+				if (mutableHelpers.has(atom.key)) continue;
+				atom.install(this);
+				if (atom.type === `mutable_atom`) {
+					const originalJsonToken = getJsonToken(store, atom);
+					const originalUpdateToken = getUpdateToken(atom);
+					mutableHelpers.add(originalJsonToken.key);
+					mutableHelpers.add(originalUpdateToken.key);
 				}
-				break;
+			}
+			for (const [, selector] of store.readonlySelectors) selector.install(this);
+			for (const [, selector] of store.writableSelectors) {
+				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);
 		}
-		target.valueMap.delete(key);
-		target.selectorAtoms.delete(key);
-		target.selectorGraph.delete(key);
-		target.moleculeData.delete(familyMeta.key, familyMeta.subKey);
-		store.logger.info(`🔥`, selectorToken.type, key, `deleted`);
-		if (isChildStore(target) && target.transactionMeta.phase === `building`) target.transactionMeta.update.subEvents.push({
-			type: `state_disposal`,
-			subType: `selector`,
-			token: selectorToken,
-			timestamp: Date.now()
-		});
-		else store.on.selectorDisposal.next(selectorToken);
 	}
+};
+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/families/find-in-store.ts
+function findInStore(store, familyToken, key) {
+	const family = withdraw(store, familyToken);
+	const existingStateToken = seekInStore(store, familyToken, key);
+	if (existingStateToken) return existingStateToken;
+	const newStateToken = mintInStore(DO_NOT_CREATE, store, family, key);
+	return newStateToken;
 }
 
 //#endregion
@@ -2117,19 +1167,57 @@ function createRegularAtomFamily(store, options, internalRoles) {
 		create,
 		default: options.default,
 		subject,
-		install: (s) => createRegularAtomFamily(s, options),
-		internalRoles
+		install: (s) => createRegularAtomFamily(s, options),
+		internalRoles
+	};
+	store.families.set(options.key, atomFamily$1);
+	if (isFn(options.default) === false) store.defaults.set(options.key, options.default);
+	return familyToken;
+}
+
+//#endregion
+//#region src/internal/families/create-readonly-held-selector-family.ts
+function createReadonlyHeldSelectorFamily(store, options, internalRoles) {
+	const familyKey = options.key;
+	const type = `readonly_held_selector_family`;
+	const familyToken = {
+		key: familyKey,
+		type
+	};
+	const existing = store.families.get(familyKey);
+	if (existing) store.logger.error(`❗`, type, familyKey, `Overwriting an existing ${PRETTY_TOKEN_TYPES[existing.type]} "${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 create = (key) => {
+		const subKey = stringifyJson(key);
+		const family = {
+			key: familyKey,
+			subKey
+		};
+		const fullKey = `${familyKey}(${subKey})`;
+		const target = newest(store);
+		return createReadonlyHeldSelector(target, {
+			key: fullKey,
+			const: options.const(key),
+			get: options.get(key)
+		}, family);
+	};
+	const readonlySelectorFamily = {
+		...familyToken,
+		create,
+		internalRoles,
+		subject,
+		install: (s) => createReadonlyHeldSelectorFamily(s, options),
+		default: options.const
 	};
-	store.families.set(options.key, atomFamily$1);
-	if (isFn(options.default) === false) store.defaults.set(options.key, options.default);
+	store.families.set(familyKey, readonlySelectorFamily);
 	return familyToken;
 }
 
 //#endregion
-//#region src/internal/families/create-readonly-held-selector-family.ts
-function createReadonlyHeldSelectorFamily(store, options, internalRoles) {
+//#region src/internal/families/create-writable-held-selector-family.ts
+function createWritableHeldSelectorFamily(store, options, internalRoles) {
 	const familyKey = options.key;
-	const type = `readonly_held_selector_family`;
+	const type = `writable_held_selector_family`;
 	const familyToken = {
 		key: familyKey,
 		type
@@ -2145,29 +1233,30 @@ function createReadonlyHeldSelectorFamily(store, options, internalRoles) {
 		};
 		const fullKey = `${familyKey}(${subKey})`;
 		const target = newest(store);
-		return createReadonlyHeldSelector(target, {
+		return createWritableHeldSelector(target, {
 			key: fullKey,
 			const: options.const(key),
-			get: options.get(key)
+			get: options.get(key),
+			set: options.set(key)
 		}, family);
 	};
-	const readonlySelectorFamily = {
+	const selectorFamily$1 = {
 		...familyToken,
 		create,
 		internalRoles,
 		subject,
-		install: (s) => createReadonlyHeldSelectorFamily(s, options),
+		install: (s) => createWritableHeldSelectorFamily(s, options),
 		default: options.const
 	};
-	store.families.set(familyKey, readonlySelectorFamily);
+	store.families.set(familyKey, selectorFamily$1);
 	return familyToken;
 }
 
 //#endregion
-//#region src/internal/families/create-writable-held-selector-family.ts
-function createWritableHeldSelectorFamily(store, options, internalRoles) {
+//#region src/internal/families/create-writable-pure-selector-family.ts
+function createWritablePureSelectorFamily(store, options, internalRoles) {
 	const familyKey = options.key;
-	const type = `writable_held_selector_family`;
+	const type = `writable_pure_selector_family`;
 	const familyToken = {
 		key: familyKey,
 		type
@@ -2183,352 +1272,420 @@ function createWritableHeldSelectorFamily(store, options, internalRoles) {
 		};
 		const fullKey = `${familyKey}(${subKey})`;
 		const target = newest(store);
-		return createWritableHeldSelector(target, {
+		const individualOptions = {
 			key: fullKey,
-			const: options.const(key),
 			get: options.get(key),
 			set: options.set(key)
-		}, family);
+		};
+		if (options.catch) individualOptions.catch = options.catch;
+		return createWritablePureSelector(target, individualOptions, family);
+	};
+	const selectorFamily$1 = {
+		...familyToken,
+		create,
+		internalRoles,
+		subject,
+		install: (s) => createWritablePureSelectorFamily(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(familyKey, selectorFamily$1);
+	return familyToken;
+}
+
+//#endregion
+//#region src/internal/families/create-selector-family.ts
+function createSelectorFamily(store, options) {
+	const isWritable = `set` in options;
+	const isHeld = `const` in options;
+	if (isHeld && isWritable) return createWritableHeldSelectorFamily(store, options, void 0);
+	if (isHeld) return createReadonlyHeldSelectorFamily(store, options, void 0);
+	if (isWritable) return createWritablePureSelectorFamily(store, options);
+	return createReadonlyPureSelectorFamily(store, options);
+}
+
+//#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 (_) {
+		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 `writable_pure_selector`:
+		case `readonly_pure_selector`:
+		case `writable_held_selector`:
+		case `readonly_held_selector`:
+			disposeSelector(store, token);
+			break;
+	}
+}
+
+//#endregion
+//#region src/internal/selector/update-selector-atoms.ts
+function updateSelectorAtoms(store, selectorType, selectorKey, dependency, covered) {
+	const target = newest(store);
+	const { type: dependencyType, key: dependencyKey } = dependency;
+	if (dependencyType === `atom` || dependencyType === `mutable_atom`) {
+		target.selectorAtoms.set({
+			selectorKey,
+			atomKey: dependencyKey
+		});
+		store.logger.info(`🔍`, selectorType, selectorKey, `discovers root atom "${dependencyKey}"`);
+	} else {
+		const rootKeys = traceRootSelectorAtoms(store, dependencyKey, covered);
+		store.logger.info(`🔍`, selectorType, selectorKey, `discovers root atoms: [ ${[...rootKeys.values()].map((root) => `"${root.key}"`).join(`, `)} ]`);
+		for (const { key: atomKey } of rootKeys.values()) target.selectorAtoms = target.selectorAtoms.set({
+			selectorKey,
+			atomKey
+		});
+	}
+	covered.add(dependencyKey);
+}
+
+//#endregion
+//#region src/internal/selector/register-selector.ts
+function registerSelector(store, selectorType, selectorKey, covered) {
+	return {
+		get: (...params) => {
+			const target = newest(store);
+			const { token, family, subKey } = reduceReference(store, ...params);
+			let dependencyValue;
+			if (`counterfeit` in token && family && subKey) dependencyValue = getFallback(store, token, family, subKey);
+			else {
+				const dependency = withdraw(store, token);
+				dependencyValue = readOrComputeValue(store, dependency);
+			}
+			store.logger.info(`🔌`, selectorType, selectorKey, `registers dependency ( "${token.key}" =`, dependencyValue, `)`);
+			target.selectorGraph.set({
+				upstreamSelectorKey: token.key,
+				downstreamSelectorKey: selectorKey
+			}, { source: token.key });
+			updateSelectorAtoms(store, selectorType, selectorKey, token, covered);
+			return dependencyValue;
+		},
+		set: ((...params) => {
+			const target = newest(store);
+			operateOnStore(JOIN_OP, target, ...params);
+		}),
+		find: ((...args) => findInStore(store, ...args)),
+		json: (token) => getJsonToken(store, token)
+	};
+}
+
+//#endregion
+//#region src/internal/selector/create-readonly-held-selector.ts
+function createReadonlyHeldSelector(store, options, family) {
+	const target = newest(store);
+	const subject = new Subject();
+	const covered = /* @__PURE__ */ new Set();
+	const { key, const: constant } = options;
+	const type = `readonly_held_selector`;
+	store.logger.info(`🔨`, type, key, `is being created`);
+	const { get, find, json } = registerSelector(target, type, key, covered);
+	const getFrom = (innerTarget) => {
+		const upstreamStates = innerTarget.selectorGraph.getRelationEntries({ downstreamSelectorKey: key });
+		for (const [downstreamSelectorKey, { source }] of upstreamStates) if (source !== key) innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
+		innerTarget.selectorAtoms.delete(key);
+		options.get({
+			get,
+			find,
+			json
+		}, constant);
+		writeToCache(innerTarget, readonlySelector, constant);
+		store.logger.info(`✨`, type, key, `=`, constant);
+		covered.clear();
+		return constant;
+	};
+	const readonlySelector = {
+		...options,
+		type,
+		subject,
+		getFrom,
+		install: (s) => createReadonlyHeldSelector(s, options, family)
+	};
+	if (family) readonlySelector.family = family;
+	target.readonlySelectors.set(key, readonlySelector);
+	const token = {
+		key,
+		type
+	};
+	if (family) token.family = family;
+	return token;
+}
+
+//#endregion
+//#region src/internal/selector/create-readonly-pure-selector.ts
+function createReadonlyPureSelector(store, options, family) {
+	const target = newest(store);
+	const subject = new Subject();
+	const covered = /* @__PURE__ */ new Set();
+	const key = options.key;
+	const type = `readonly_pure_selector`;
+	store.logger.info(`🔨`, type, key, `is being created`);
+	const { get, find, json } = registerSelector(target, type, key, covered);
+	const getFrom = () => {
+		const innerTarget = newest(store);
+		const upstreamStates = innerTarget.selectorGraph.getRelationEntries({ downstreamSelectorKey: key });
+		for (const [downstreamSelectorKey, { source }] of upstreamStates) if (source !== key) innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
+		innerTarget.selectorAtoms.delete(key);
+		const value = options.get({
+			get,
+			find,
+			json
+		});
+		const cached = writeToCache(innerTarget, readonlySelector, value);
+		store.logger.info(`✨`, type, key, `=`, cached);
+		covered.clear();
+		return cached;
+	};
+	const readonlySelector = {
+		...options,
+		type,
+		subject,
+		getFrom,
+		install: (s) => createReadonlyPureSelector(s, options, family)
+	};
+	if (family) readonlySelector.family = family;
+	target.readonlySelectors.set(key, readonlySelector);
+	const token = {
+		key,
+		type
+	};
+	if (family) token.family = family;
+	return token;
+}
+
+//#endregion
+//#region src/internal/selector/create-writable-held-selector.ts
+function createWritableHeldSelector(store, options, family) {
+	const target = newest(store);
+	const subject = new Subject();
+	const covered = /* @__PURE__ */ new Set();
+	const { key, const: constant } = options;
+	const type = `writable_held_selector`;
+	store.logger.info(`🔨`, type, key, `is being created`);
+	const setterToolkit = registerSelector(target, type, key, covered);
+	const { find, get, json } = setterToolkit;
+	const getterToolkit = {
+		find,
+		get,
+		json
+	};
+	const getFrom = (innerTarget) => {
+		const upstreamStates = innerTarget.selectorGraph.getRelationEntries({ downstreamSelectorKey: key });
+		for (const [downstreamSelectorKey, { source }] of upstreamStates) if (source !== key) innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
+		innerTarget.selectorAtoms.delete(key);
+		options.get(getterToolkit, constant);
+		writeToCache(innerTarget, mySelector, constant);
+		store.logger.info(`✨`, type, key, `=`, constant);
+		covered.clear();
+		return constant;
 	};
-	const selectorFamily$1 = {
-		...familyToken,
-		create,
-		internalRoles,
+	const setSelf = () => {
+		options.set(setterToolkit, constant);
+	};
+	const mySelector = {
+		...options,
+		type,
 		subject,
-		install: (s) => createWritableHeldSelectorFamily(s, options),
-		default: options.const
+		getFrom,
+		setSelf,
+		install: (s) => createWritableHeldSelector(s, options, family)
 	};
-	store.families.set(familyKey, selectorFamily$1);
-	return familyToken;
+	if (family) mySelector.family = family;
+	target.writableSelectors.set(key, mySelector);
+	const token = {
+		key,
+		type
+	};
+	if (family) token.family = family;
+	return token;
 }
 
 //#endregion
-//#region src/internal/families/create-writable-pure-selector-family.ts
-function createWritablePureSelectorFamily(store, options, internalRoles) {
-	const familyKey = options.key;
-	const type = `writable_pure_selector_family`;
-	const familyToken = {
-		key: familyKey,
-		type
-	};
-	const existing = store.families.get(familyKey);
-	if (existing) store.logger.error(`❗`, type, familyKey, `Overwriting an existing ${PRETTY_TOKEN_TYPES[existing.type]} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);
+//#region src/internal/selector/create-writable-pure-selector.ts
+function createWritablePureSelector(store, options, family) {
+	const target = newest(store);
 	const subject = new Subject();
-	const create = (key) => {
-		const subKey = stringifyJson(key);
-		const family = {
-			key: familyKey,
-			subKey
-		};
-		const fullKey = `${familyKey}(${subKey})`;
-		const target = newest(store);
-		const individualOptions = {
-			key: fullKey,
-			get: options.get(key),
-			set: options.set(key)
-		};
-		if (options.catch) individualOptions.catch = options.catch;
-		return createWritablePureSelector(target, individualOptions, family);
+	const covered = /* @__PURE__ */ new Set();
+	const key = options.key;
+	const type = `writable_pure_selector`;
+	store.logger.info(`🔨`, type, key, `is being created`);
+	const setterToolkit = registerSelector(target, type, key, covered);
+	const { find, get, json } = setterToolkit;
+	const getterToolkit = {
+		find,
+		get,
+		json
 	};
-	const selectorFamily$1 = {
-		...familyToken,
-		create,
-		internalRoles,
+	const getFrom = (innerTarget) => {
+		const upstreamStates = innerTarget.selectorGraph.getRelationEntries({ downstreamSelectorKey: key });
+		for (const [downstreamSelectorKey, { source }] of upstreamStates) if (source !== key) innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
+		innerTarget.selectorAtoms.delete(key);
+		const value = options.get(getterToolkit);
+		const cached = writeToCache(innerTarget, mySelector, value);
+		store.logger.info(`✨`, type, key, `=`, cached);
+		covered.clear();
+		return cached;
+	};
+	const setSelf = (newValue) => {
+		options.set(setterToolkit, newValue);
+	};
+	const mySelector = {
+		...options,
+		type,
 		subject,
-		install: (s) => createWritablePureSelectorFamily(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)
-			});
-		}
+		getFrom,
+		setSelf,
+		install: (s) => createWritablePureSelector(s, options, family)
 	};
-	store.families.set(familyKey, selectorFamily$1);
-	return familyToken;
+	if (family) mySelector.family = family;
+	target.writableSelectors.set(key, mySelector);
+	const token = {
+		key,
+		type
+	};
+	if (family) token.family = family;
+	return token;
 }
 
 //#endregion
-//#region src/internal/families/create-selector-family.ts
-function createSelectorFamily(store, options) {
+//#region src/internal/selector/create-standalone-selector.ts
+function createStandaloneSelector(store, options) {
 	const isWritable = `set` in options;
 	const isHeld = `const` in options;
-	if (isHeld && isWritable) return createWritableHeldSelectorFamily(store, options, void 0);
-	if (isHeld) return createReadonlyHeldSelectorFamily(store, options, void 0);
-	if (isWritable) return createWritablePureSelectorFamily(store, options);
-	return createReadonlyPureSelectorFamily(store, options);
-}
-
-//#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 `writable_held_selector_family`:
-		case `writable_pure_selector_family`:
-			state = target.writableSelectors.get(fullKey);
-			break;
-		case `readonly_held_selector_family`:
-		case `readonly_pure_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, familyToken, key) {
-	const family = withdraw(store, familyToken);
-	const existingStateToken = seekInStore(store, familyToken, key);
-	if (existingStateToken) return existingStateToken;
-	const newStateToken = mintInStore(store, family, key);
-	return newStateToken;
-}
-
-//#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;
+	if (isHeld && isWritable) {
+		const state$1 = createWritableHeldSelector(store, options, void 0);
+		store.on.selectorCreation.next(state$1);
+		return state$1;
 	}
-	try {
-		withdraw(store, token);
-	} catch (_) {
-		store.logger.error(`❌`, token.type, token.key, `could not be disposed because it was not found in the store "${store.config.name}".`);
-		return;
+	if (isHeld) {
+		const state$1 = createReadonlyHeldSelector(store, options, void 0);
+		store.on.selectorCreation.next(state$1);
+		return state$1;
 	}
-	switch (token.type) {
-		case `atom`:
-		case `mutable_atom`:
-			disposeAtom(store, token);
-			break;
-		case `writable_pure_selector`:
-		case `readonly_pure_selector`:
-		case `writable_held_selector`:
-		case `readonly_held_selector`:
-			disposeSelector(store, token);
-			break;
+	if (isWritable) {
+		const state$1 = createWritablePureSelector(store, options, void 0);
+		store.on.selectorCreation.next(state$1);
+		return state$1;
 	}
+	const state = createReadonlyPureSelector(store, options, void 0);
+	store.on.selectorCreation.next(state);
+	return state;
 }
 
 //#endregion
-//#region src/internal/get-state/reduce-reference.ts
-function reduceReference(store, ...params) {
-	let existingToken;
-	let brandNewToken;
-	let family;
-	let subKey;
-	let token;
-	if (params.length === 1) {
-		token = params[0];
-		if (`family` in token) {
-			const familyToken = getFamilyOfToken(store, token);
-			family = withdraw(store, familyToken);
-			subKey = parseJson(token.family.subKey);
-			existingToken = seekInStore(store, familyToken, subKey);
-			if (`counterfeit` in token) return {
-				token,
-				family,
-				subKey,
-				isNew: false
-			};
-			if (!existingToken) {
-				brandNewToken = mintInStore(store, familyToken, subKey, MUST_CREATE);
-				token = brandNewToken;
-			} else token = existingToken;
-		}
-	} else {
-		family = withdraw(store, params[0]);
-		subKey = params[1];
-		existingToken = seekInStore(store, family, subKey);
-		if (!existingToken) {
-			brandNewToken = mintInStore(store, family, subKey, MUST_CREATE);
-			token = brandNewToken;
-		} else token = existingToken;
-	}
-	const isCounterfeit = `counterfeit` in token;
-	const isNewlyCreated = Boolean(brandNewToken) && isCounterfeit === false;
-	if (isNewlyCreated && family) {
-		let subType;
-		switch (token.type) {
-			case `readonly_pure_selector`:
-			case `readonly_held_selector`:
-				subType = `readable`;
-				break;
-			case `atom`:
-			case `mutable_atom`:
-			case `writable_pure_selector`:
+//#region src/internal/selector/dispose-selector.ts
+function disposeSelector(store, selectorToken) {
+	const target = newest(store);
+	const { key, type, family: familyMeta } = selectorToken;
+	if (!familyMeta) store.logger.error(`❌`, type, key, `Standalone selectors cannot be disposed.`);
+	else {
+		const molecule = target.molecules.get(familyMeta.subKey);
+		if (molecule) target.moleculeData.delete(familyMeta.subKey, familyMeta.key);
+		let familyToken;
+		switch (selectorToken.type) {
 			case `writable_held_selector`:
-				subType = `writable`;
-				break;
-		}
-		const stateCreationEvent = {
-			type: `state_creation`,
-			subType,
-			token,
-			timestamp: Date.now()
-		};
-		const familySubject = family.subject;
-		familySubject.next(stateCreationEvent);
-		const target = newest(store);
-		if (token.family) {
-			if (isRootStore(target)) switch (token.type) {
-				case `atom`:
-				case `mutable_atom`:
-					store.on.atomCreation.next(token);
-					break;
-				case `writable_pure_selector`:
-				case `readonly_pure_selector`:
-				case `writable_held_selector`:
-				case `readonly_held_selector`:
-					store.on.selectorCreation.next(token);
-					break;
-			}
-			else if (isChildStore(target) && target.on.transactionApplying.state === null) target.transactionMeta.update.subEvents.push(stateCreationEvent);
-		}
-	}
-	return {
-		token,
-		family,
-		subKey,
-		isNew: Boolean(brandNewToken)
-	};
-}
-
-//#endregion
-//#region src/internal/get-state/get-from-store.ts
-function getFromStore(store, ...params) {
-	const { token, family, subKey } = reduceReference(store, ...params);
-	if (`counterfeit` in token && family && subKey) return getFallback(store, token, family, subKey);
-	const state = withdraw(store, token);
-	return readOrComputeValue(store, state);
-}
-
-//#endregion
-//#region src/internal/subscribe/subscribe-to-root-atoms.ts
-const subscribeToRootDependency = (target, selector, atom) => {
-	return atom.subject.subscribe(`${selector.type}:${selector.key}`, (atomChange) => {
-		target.logger.info(`📢`, selector.type, selector.key, `root`, atom.key, `went`, atomChange.oldValue, `->`, atomChange.newValue);
-		const oldValue = recallState(target, selector);
-		const newValue = readOrComputeValue(target, selector);
-		target.logger.info(`✨`, selector.type, selector.key, `went`, oldValue, `->`, newValue);
-		selector.subject.next({
-			newValue,
-			oldValue
-		});
-	});
-};
-
-//#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);
-	}
-	reduceReference(store, token);
-	const state = withdraw(store, token);
-	store.logger.info(`👀`, state.type, state.key, `Adding subscription "${key}"`);
-	const isSelector = state.type === `writable_pure_selector` || state.type === `readonly_pure_selector`;
-	const rootSubs = /* @__PURE__ */ new Map();
-	let updateHandler = safelyHandleUpdate;
-	if (isSelector) {
-		readOrComputeValue(store, state);
-		for (const [atomKey, atom] of traceRootSelectorAtoms(store, state.key)) rootSubs.set(atomKey, subscribeToRootDependency(store, state, atom));
-		updateHandler = function updateRootsBeforeHandlingUpdate(update) {
-			const dependencies = traceRootSelectorAtoms(store, state.key);
-			for (const [previousRootKey, unsub] of rootSubs) {
-				const currentRoot = dependencies.get(previousRootKey);
-				if (currentRoot) dependencies.delete(previousRootKey);
-				else {
-					unsub();
-					rootSubs.delete(previousRootKey);
+				{
+					target.writableSelectors.delete(key);
+					familyToken = {
+						key: familyMeta.key,
+						type: `writable_held_selector_family`
+					};
+					const family = withdraw(store, familyToken);
+					family.subject.next({
+						type: `state_disposal`,
+						subType: `selector`,
+						token: selectorToken,
+						timestamp: Date.now()
+					});
 				}
-			}
-			for (const [atomKey, atom] of dependencies) rootSubs.set(atomKey, subscribeToRootDependency(store, state, atom));
-			safelyHandleUpdate(update);
-		};
-	}
-	const mainUnsubFunction = state.subject.subscribe(key, updateHandler);
-	const unsubscribe = () => {
-		store.logger.info(`🙈`, state.type, state.key, `Removing subscription "${key}"`);
-		mainUnsubFunction();
-		for (const unsubFromDependency of rootSubs.values()) unsubFromDependency();
-	};
-	return unsubscribe;
-}
-
-//#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 `writable_pure_selector`:
-			case `writable_held_selector`:
-				withdrawn = target.writableSelectors.get(token.key);
+				{
+					target.writableSelectors.delete(key);
+					familyToken = {
+						key: familyMeta.key,
+						type: `writable_pure_selector_family`
+					};
+					const family = withdraw(store, familyToken);
+					family.subject.next({
+						type: `state_disposal`,
+						subType: `selector`,
+						token: selectorToken,
+						timestamp: Date.now()
+					});
+				}
 				break;
-			case `readonly_pure_selector`:
 			case `readonly_held_selector`:
-				withdrawn = target.readonlySelectors.get(token.key);
-				break;
-			case `atom_family`:
-			case `mutable_atom_family`:
-			case `writable_pure_selector_family`:
-			case `readonly_pure_selector_family`:
-			case `writable_held_selector_family`:
-			case `readonly_held_selector_family`:
-				withdrawn = target.families.get(token.key);
-				break;
-			case `timeline`:
-				withdrawn = target.timelines.get(token.key);
+				{
+					target.readonlySelectors.delete(key);
+					familyToken = {
+						key: familyMeta.key,
+						type: `readonly_held_selector_family`
+					};
+					const family = withdraw(store, familyToken);
+					family.subject.next({
+						type: `state_disposal`,
+						subType: `selector`,
+						token: selectorToken,
+						timestamp: Date.now()
+					});
+				}
 				break;
-			case `transaction`:
-				withdrawn = target.transactions.get(token.key);
+			case `readonly_pure_selector`:
+				{
+					target.readonlySelectors.delete(key);
+					familyToken = {
+						key: familyMeta.key,
+						type: `readonly_pure_selector_family`
+					};
+					const family = withdraw(store, familyToken);
+					family.subject.next({
+						type: `state_disposal`,
+						subType: `selector`,
+						token: selectorToken,
+						timestamp: Date.now()
+					});
+				}
 				break;
 		}
-		if (withdrawn) return withdrawn;
-		target = target.child;
+		target.valueMap.delete(key);
+		target.selectorAtoms.delete(key);
+		target.selectorGraph.delete(key);
+		target.moleculeData.delete(familyMeta.key, familyMeta.subKey);
+		store.logger.info(`🔥`, selectorToken.type, key, `deleted`);
+		if (isChildStore(target) && target.transactionMeta.phase === `building`) target.transactionMeta.update.subEvents.push({
+			type: `state_disposal`,
+			subType: `selector`,
+			token: selectorToken,
+			timestamp: Date.now()
+		});
+		else store.on.selectorDisposal.next(selectorToken);
 	}
-	throw new NotFoundError(token, store);
 }
 
-//#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) => {
@@ -2556,98 +1713,6 @@ function subscribeInStore(store, token, handleUpdate, key = arbitrary()) {
 	}
 }
 
-//#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 {
-	initializeSignalAtom(mutableState, store) {
-		const latestSignalStateKey = `*${mutableState.key}`;
-		store.atoms.delete(latestSignalStateKey);
-		store.valueMap.delete(latestSignalStateKey);
-		const familyMetaData = mutableState.family ? {
-			key: `*${mutableState.family.key}`,
-			subKey: mutableState.family.subKey
-		} : void 0;
-		const latestSignalState = createRegularAtom(store, {
-			key: latestSignalStateKey,
-			default: null
-		}, familyMetaData, [`tracker:signal`]);
-		if (store.parent?.valueMap.has(latestSignalStateKey)) {
-			const parentValue = store.parent.valueMap.get(latestSignalStateKey);
-			store.valueMap.set(latestSignalStateKey, parentValue);
-		}
-		return latestSignalState;
-	}
-	unsubscribeFromInnerValue;
-	unsubscribeFromState;
-	captureSignalsFromCore(mutableState, latestSignalState, target) {
-		const stateKey = mutableState.key;
-		const storeName = target.config.name;
-		const storeStatus = isChildStore(target) ? target.transactionMeta.update.token.key : `main`;
-		const subscriptionKey = `tracker:${storeName}:${storeStatus}:${stateKey}`;
-		const trackerCapturesOutboundSignal = (update) => {
-			setIntoStore(target, latestSignalState, update);
-		};
-		const originalInnerValue = getFromStore(target, mutableState);
-		this.unsubscribeFromInnerValue = originalInnerValue.subscribe(subscriptionKey, trackerCapturesOutboundSignal);
-		this.unsubscribeFromState = subscribeToState(target, mutableState, subscriptionKey, function trackerLooksForNewReference(update) {
-			if (update.newValue !== update.oldValue) {
-				this.unsubscribeFromInnerValue();
-				this.unsubscribeFromInnerValue = update.newValue.subscribe(subscriptionKey, trackerCapturesOutboundSignal);
-			}
-		}.bind(this));
-	}
-	supplySignalsToCore(mutableState, latestSignalState, target) {
-		const subscriptionKey = `tracker:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.token.key : `main`}:${mutableState.key}`;
-		subscribeToState(target, latestSignalState, subscriptionKey, function trackerCapturesInboundSignal({ newValue, oldValue }) {
-			const timelineId = target.timelineTopics.getRelatedKey(latestSignalState.key);
-			if (timelineId && target.timelines.get(timelineId)?.timeTraveling) {
-				const unsubscribe = subscribeToTimeline(target, {
-					key: timelineId,
-					type: `timeline`
-				}, subscriptionKey, function trackerWaitsForTimeTravelToFinish(update) {
-					unsubscribe();
-					setIntoStore(target, mutableState, (transceiver) => {
-						if (update === `redo` && newValue) transceiver.do(newValue);
-						else if (update === `undo` && oldValue) transceiver.undo(oldValue);
-						return transceiver;
-					});
-				});
-				return;
-			}
-			const mutable = getFromStore(target, mutableState);
-			const updateNumber = mutable.getUpdateNumber(newValue);
-			const eventOffset = updateNumber - mutable.cacheUpdateNumber;
-			if (newValue && eventOffset === 1) setIntoStore(target, mutableState, (transceiver) => (transceiver.do(newValue), transceiver));
-			else {
-				const expected = mutable.cacheUpdateNumber + 1;
-				target.logger.info(`❌`, `mutable_atom`, mutableState.key, `could not be updated. Expected update number`, expected, `but got`, updateNumber);
-			}
-		});
-	}
-	mutableAtomToken;
-	latestSignalToken;
-	[Symbol.dispose];
-	constructor(mutableAtomToken, store) {
-		const target = newest(store);
-		const latestSignalToken = this.initializeSignalAtom(mutableAtomToken, target);
-		this.mutableAtomToken = mutableAtomToken;
-		this.latestSignalToken = latestSignalToken;
-		this.captureSignalsFromCore(mutableAtomToken, latestSignalToken, target);
-		this.supplySignalsToCore(mutableAtomToken, latestSignalToken, target);
-		target.trackers.set(mutableAtomToken.key, this);
-		this[Symbol.dispose] = () => {
-			this.unsubscribeFromInnerValue();
-			this.unsubscribeFromState();
-			target.trackers.delete(mutableAtomToken.key);
-		};
-	}
-};
-
 //#endregion
 //#region src/internal/mutable/create-mutable-atom.ts
 function createMutableAtom(store, options, family) {
@@ -2840,191 +1905,6 @@ const getUpdateToken = (mutableAtomToken) => {
 	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 && `cacheUpdateNumber` in value && `getUpdateNumber` in value && `READONLY_VIEW` in value && `toJSON` in value;
-}
-
-//#endregion
-//#region src/internal/store/store.ts
-var Store = class {
-	parent = null;
-	child = null;
-	valueMap = /* @__PURE__ */ new Map();
-	defaults = /* @__PURE__ */ new Map();
-	atoms = /* @__PURE__ */ new Map();
-	writableSelectors = /* @__PURE__ */ new Map();
-	readonlySelectors = /* @__PURE__ */ new Map();
-	atomsThatAreDefault = /* @__PURE__ */ 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 = /* @__PURE__ */ new Map();
-	families = /* @__PURE__ */ new Map();
-	joins = /* @__PURE__ */ new Map();
-	transactions = /* @__PURE__ */ new Map();
-	transactionMeta = {
-		epoch: /* @__PURE__ */ new Map(),
-		actionContinuities: new Junction({
-			between: [`continuity`, `action`],
-			cardinality: `1:n`
-		})
-	};
-	timelines = /* @__PURE__ */ new Map();
-	timelineTopics = new Junction({
-		between: [`timelineKey`, `topicKey`],
-		cardinality: `1:n`
-	});
-	disposalTraces = new CircularBuffer(100);
-	molecules = /* @__PURE__ */ 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 = /* @__PURE__ */ 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.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 = /* @__PURE__ */ new Set();
-			for (const [, atom] of store.atoms) {
-				if (mutableHelpers.has(atom.key)) continue;
-				atom.install(this);
-				if (atom.type === `mutable_atom`) {
-					const originalJsonToken = getJsonToken(store, atom);
-					const originalUpdateToken = getUpdateToken(atom);
-					mutableHelpers.add(originalJsonToken.key);
-					mutableHelpers.add(originalUpdateToken.key);
-				}
-			}
-			for (const [, selector] of store.readonlySelectors) selector.install(this);
-			for (const [, selector] of store.writableSelectors) {
-				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/atom/create-regular-atom.ts
-function createRegularAtom(store, options, family, internalRoles) {
-	const type = `atom`;
-	const { key } = options;
-	store.logger.info(`🔨`, type, key, `is being created`);
-	const target = newest(store);
-	const existing = target.atoms.get(key);
-	if (existing && existing.type === type) {
-		store.logger.error(`❌`, `atom`, key, `Tried to create atom, but it already exists in the store.`);
-		return deposit(existing);
-	}
-	const subject = new Subject();
-	const newAtom = {
-		...options,
-		type,
-		install: (s) => {
-			s.logger.info(`🛠️`, type, key, `installing in store "${s.config.name}"`);
-			return createRegularAtom(s, options, family);
-		},
-		subject
-	};
-	if (family) newAtom.family = family;
-	if (internalRoles) newAtom.internalRoles = internalRoles;
-	target.atoms.set(key, newAtom);
-	const token = deposit(newAtom);
-	if (options.effects) {
-		let effectIndex = 0;
-		const cleanupFunctions = [];
-		for (const effect of options.effects) {
-			const cleanup = effect({
-				resetSelf: () => {
-					resetInStore(store, token);
-				},
-				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();
-		};
-	}
-	store.on.atomCreation.next(token);
-	return token;
-}
-
 //#endregion
 //#region src/internal/atom/dispose-atom.ts
 function disposeAtom(store, atomToken) {
@@ -3069,14 +1949,6 @@ function disposeAtom(store, atomToken) {
 	}
 }
 
-//#endregion
-//#region src/internal/atom/has-role.ts
-const INTERNAL_ROLES = [`tracker:signal`];
-function hasRole(atom, role) {
-	if (`internalRoles` in atom === false) return false;
-	return atom.internalRoles.includes(role);
-}
-
 //#endregion
 //#region src/internal/capitalize.ts
 function capitalize(string) {
@@ -3571,20 +2443,6 @@ function getInternalRelationsFromStore(token, store) {
 	return family;
 }
 
-//#endregion
-//#region src/internal/not-found-error.ts
-var NotFoundError = class extends Error {
-	constructor(token, store) {
-		super(`${PRETTY_TOKEN_TYPES[token.type]} ${stringifyJson(token.key)} not found in store "${store.config.name}".`);
-	}
-};
-
-//#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) {
@@ -3863,5 +2721,5 @@ const timeTravel = (store, action, token) => {
 };
 
 //#endregion
-export { COUNTERFEIT, CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, INTERNAL_ROLES, Join, Junction, MapOverlay, NotFoundError, RESET_STATE, RelationsOverlay, SetOverlay, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, capitalize, claimWithinStore, clearStore, closeOperation, createClaimTX, createDeallocateTX, createJoin, createMutableAtom, createMutableAtomFamily, createReadonlyHeldSelector, createReadonlyPureSelector, createReadonlyPureSelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneSelector, createTimeline, createTransaction, createWritableHeldSelector, createWritablePureSelector, createWritablePureSelectorFamily, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, eldest, evictCachedValue, evictDownstreamFromAtom, evictDownstreamFromSelector, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, hasRole, ingestAtomUpdateEvent, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdateEvent, ingestTransactionOutcomeEvent, installIntoStore, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markDone, mint, newest, openOperation, readFromCache, readOrComputeValue, recallState, registerSelector, resetAtomOrSelector, resetInStore, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootDependency, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceRootSelectorAtoms, updateSelectorAtoms, withdraw, writeToCache };
+export { CircularBuffer, FamilyTracker, Future, IMPLICIT, INTERNAL_ROLES, Join, Junction, MapOverlay, NotFoundError, RESET_STATE, RelationsOverlay, SetOverlay, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, capitalize, claimWithinStore, clearStore, closeOperation, createClaimTX, createDeallocateTX, createJoin, createMutableAtom, createMutableAtomFamily, createReadonlyHeldSelector, createReadonlyPureSelector, createReadonlyPureSelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneSelector, createTimeline, createTransaction, createWritableHeldSelector, createWritablePureSelector, createWritablePureSelectorFamily, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, eldest, evictCachedValue, evictDownstreamFromAtom, evictDownstreamFromSelector, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFamilyOfToken, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, hasRole, ingestAtomUpdateEvent, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdateEvent, ingestTransactionOutcomeEvent, installIntoStore, isAtomKey, isChildStore, isDone, isFn, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markDone, newest, openOperation, readFromCache, readOrComputeValue, recallState, registerSelector, resetAtomOrSelector, resetInStore, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootDependency, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceRootSelectorAtoms, updateSelectorAtoms, withdraw, writeToCache };
 //# sourceMappingURL=index.js.map