atom.io 0.33.21 → 0.34.1

package/dist/internal/index.js

@@ -1,4 +1,4 @@
-import { arbitrary as arbitrary$1, subscribeToState as subscribeToState$1, subscribeToTimeline as subscribeToTimeline$1, subscribeToTransaction as subscribeToTransaction$1 } from "atom.io/internal";
+import { Join as Join$1, 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";
@@ -8,61 +8,6 @@ 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) {
@@ -300,12 +245,11 @@ var Junction = class {
 				}
 				break;
 			}
-			default: {
+			default:
 				a = params[0];
 				b = params[1];
 				content = params[2];
 				break;
-			}
 		}
 		switch (this.cardinality) {
 			case `1:1`: {
@@ -432,85 +376,107 @@ var StatefulSubject = class extends Subject {
 };
 
 //#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) => {
+//#region src/internal/subscribe/recall-state.ts
+const recallState = (store, state) => {
 	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;
+	if (target.operation.open) return target.operation.prev.get(state.key);
+	return target.valueMap.get(state.key);
 };
 
 //#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(` `);
+//#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_pure_selector`:
+		case `readonly_held_selector`:
+		case `writable_pure_selector`:
+		case `writable_held_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/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}".`);
+//#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/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);
-	};
+//#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/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 `readonly_held_selector`:
-		case `readonly_pure_selector`:
-		case `writable_held_selector`:
-		case `writable_pure_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;
-		}
-	}
-};
+//#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
@@ -549,22 +515,6 @@ const markDone = (store, key) => {
 	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 `writable_pure_selector`:
-		case `readonly_pure_selector`:
-		case `writable_held_selector`:
-		case `readonly_held_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
 function evictDownStream(store, atom$1) {
@@ -575,7 +525,7 @@ function evictDownStream(store, atom$1) {
 		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);
+			evictCachedValue(target, key);
 			markDone(target, key);
 		}
 	}
@@ -585,81 +535,117 @@ function evictDownStreamFromSelector(store, selector) {
 	const relationEntries = target.selectorGraph.getRelationEntries({ upstreamSelectorKey: selector.key }).filter(([_, { source }]) => source === selector.key);
 	for (const [downstreamSelectorKey] of relationEntries) {
 		if (isDone(target, downstreamSelectorKey)) continue;
-		evictCachedValue(downstreamSelectorKey, target);
+		evictCachedValue(target, downstreamSelectorKey);
 		markDone(target, downstreamSelectorKey);
 	}
 }
 
 //#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);
-	markDone(target, atom$1.key);
-	evictDownStream(target, atom$1);
-	const update = {
-		oldValue,
-		newValue
-	};
-	if (!isChildStore(target)) {
-		emitUpdate(target, atom$1, update);
-		return;
+//#region src/internal/caching.ts
+function cacheValue(target, key, value, subject) {
+	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 (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);
+	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) {
+				cacheValue(target, key, resolved, subject);
+				const atom$1 = target.atoms.get(key);
+				if (atom$1) {
+					openOperation(target, atom$1);
+					evictDownStream(target, atom$1);
+					closeOperation(target);
+				} else {
+					const selector = target.writableSelectors.get(key) ?? target.readonlySelectors.get(key);
+					if (selector) {
+						openOperation(target, selector);
+						evictDownStreamFromSelector(target, selector);
+						closeOperation(target);
+					}
+				}
+				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 = (state, target) => {
+	target.logger.info(`📖`, state.type, state.key, `reading cached value`);
+	let value = target.valueMap.get(state.key);
+	if (state.type === `mutable_atom` && isChildStore(target)) {
+		const { parent } = target;
+		const copiedValue = copyMutableIfNeeded(target, state, parent);
+		value = copiedValue;
+	}
+	return value;
+};
+const 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.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/set-state/reset-atom-or-selector.ts
-function resetAtom(store, state) {
-	let def = state.default;
-	if (def instanceof Function) def = def();
-	setAtom(store, state, def);
-}
-function resetAtomOrSelector(store, state) {
+//#region src/internal/get-state/read-or-compute-value.ts
+const readOrComputeValue = (target, state) => {
+	if (target.valueMap.has(state.key)) return readCachedValue(state, target);
 	switch (state.type) {
-		case `atom`:
-		case `mutable_atom`:
-			resetAtom(store, state);
-			break;
-		case `writable_pure_selector`:
+		case `readonly_held_selector`:
+		case `readonly_pure_selector`:
 		case `writable_held_selector`:
-			{
-				const atoms = traceAllSelectorAtoms(state, store);
-				for (const atom$1 of atoms) resetAtom(store, atom$1);
-			}
-			break;
+		case `writable_pure_selector`:
+			target.logger.info(`🧮`, state.type, state.key, `computing value`);
+			return state.get();
+		case `atom`:
+		case `mutable_atom`: {
+			const def = state.default;
+			let defaultValue;
+			if (def instanceof Function) defaultValue = def();
+			else defaultValue = def;
+			const cachedValue = cacheValue(target, state.key, defaultValue, state.subject);
+			target.logger.info(`💁`, `atom`, state.key, `could not find cached value; using default`, defaultValue);
+			return cachedValue;
+		}
 	}
-}
+};
+
+//#endregion
+//#region src/internal/subscribe/subscribe-to-root-atoms.ts
+const subscribeToRootDependency = (target, selector, atom$1) => {
+	return atom$1.subject.subscribe(`${selector.type}:${selector.key}`, (atomChange) => {
+		target.logger.info(`📢`, selector.type, selector.key, `root`, atom$1.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/families/create-regular-atom-family.ts
@@ -711,65 +697,255 @@ function createAtomFamily(store, options) {
 }
 
 //#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);
+//#region src/internal/set-state/become.ts
+const become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(originalThing) : nextVersionOfThing;
 
 //#endregion
-//#region src/internal/selector/get-selector-dependency-keys.ts
-const 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;
+//#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 `writable_pure_selector`:
+		case `readonly_pure_selector`:
+		case `writable_held_selector`:
+		case `readonly_held_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/selector/trace-selector-atoms.ts
-const traceSelectorAtoms = (store, directDependencyKey, covered) => {
-	const rootKeys = [];
-	const indirectDependencyKeys = getSelectorDependencyKeys(store, directDependencyKey);
-	while (indirectDependencyKeys.length > 0) {
-		const indirectDependencyKey = indirectDependencyKeys.shift();
-		if (covered.has(indirectDependencyKey)) continue;
-		covered.add(indirectDependencyKey);
-		if (!isAtomKey(store, indirectDependencyKey)) indirectDependencyKeys.push(...getSelectorDependencyKeys(store, indirectDependencyKey));
-		else if (!rootKeys.includes(indirectDependencyKey)) rootKeys.push(indirectDependencyKey);
-	}
-	return rootKeys;
-};
-const traceAllSelectorAtoms = (selector, store) => {
-	const selectorKey = selector.key;
-	const directDependencyKeys = getSelectorDependencyKeys(store, selectorKey);
-	const covered = /* @__PURE__ */ new Set();
-	return directDependencyKeys.flatMap((depKey) => isAtomKey(store, depKey) ? depKey : traceSelectorAtoms(store, depKey, covered)).map((atomKey) => store.atoms.get(atomKey));
+//#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);
+	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/selector/update-selector-atoms.ts
-const 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}"`);
+//#region src/internal/set-state/reset-atom-or-selector.ts
+function resetAtom(store, state) {
+	let def = state.default;
+	if (def instanceof Function) def = def();
+	setAtom(store, state, def);
+}
+function resetAtomOrSelector(store, state) {
+	switch (state.type) {
+		case `atom`:
+		case `mutable_atom`:
+			resetAtom(store, state);
+			break;
+		case `writable_pure_selector`:
+		case `writable_held_selector`:
+			{
+				const atoms = traceRootSelectorAtoms(store, state.key);
+				for (const atom$1 of atoms.values()) resetAtom(store, atom$1);
+			}
+			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/reset-in-store.ts
+function resetInStore(store, ...params) {
+	let token;
+	let family;
+	let key;
+	if (params.length === 1) {
+		token = params[0];
+		family = getFamilyOfToken(store, token) ?? null;
+		if (family) {
+			key = token.family ? parseJson(token.family.subKey) : null;
+			token = findInStore(store, family, key);
+		}
 	} else {
-		const rootKeys = traceSelectorAtoms(store, dependencyKey, covered);
-		store.logger.info(`🔍`, selectorType, selectorKey, `discovers root atoms: [ ${rootKeys.map((key) => `"${key}"`).join(`, `)} ]`);
-		for (const atomKey of rootKeys) target.selectorAtoms = target.selectorAtoms.set({
-			selectorKey,
-			atomKey
+		family = params[0];
+		key = params[1];
+		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 reset 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 reset "${token.key}" at T-${rejectionTime}`, () => {
+			unsubscribe();
+			store.logger.info(`🟢`, token.type, token.key, `resuming deferred resetState from T-${rejectionTime}`);
+			resetInStore(store, token);
 		});
+		return;
+	}
+	const state = withdraw(store, token);
+	resetAtomOrSelector(store, state);
+	closeOperation(store);
+}
+
+//#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 `writable_pure_selector`:
+		case `writable_held_selector`:
+			state.set(value);
+			break;
 	}
-	covered.add(dependencyKey);
 };
 
 //#endregion
-//#region src/internal/selector/register-selector.ts
-const registerSelector = (store, selectorType, selectorKey, covered) => ({
+//#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/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
+const 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
+const 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$1 = store.atoms.get(dependencyKey);
+			roots.set(atom$1.key, atom$1);
+		} else dependencies.push(...getSelectorDependencyKeys(store, dependencyKey));
+	}
+	return roots;
+};
+
+//#endregion
+//#region src/internal/selector/update-selector-atoms.ts
+const 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
+const registerSelector = (store, selectorType, selectorKey, covered) => ({
 	get: (...params) => {
 		const target = newest(store);
 		let dependency;
@@ -818,6 +994,10 @@ const createReadonlyHeldSelector = (store, options, family) => {
 	const type = `readonly_held_selector`;
 	const { get, find, json } = registerSelector(target, type, key, covered);
 	const getSelf = () => {
+		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);
 		options.get({
 			get,
 			find,
@@ -855,14 +1035,19 @@ const createReadonlyPureSelector = (store, options, family) => {
 	const type = `readonly_pure_selector`;
 	const { get, find, json } = registerSelector(target, type, key, covered);
 	const getSelf = () => {
+		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
 		});
-		cacheValue(newest(store), key, value, subject);
+		const cached = cacheValue(innerTarget, key, value, subject);
+		store.logger.info(`✨`, type, key, `=`, cached);
 		covered.clear();
-		return value;
+		return cached;
 	};
 	const readonlySelector = {
 		...options,
@@ -873,8 +1058,6 @@ const createReadonlyPureSelector = (store, options, family) => {
 		...family && { family }
 	};
 	target.readonlySelectors.set(key, readonlySelector);
-	const initialValue = getSelf();
-	store.logger.info(`✨`, type, key, `=`, initialValue);
 	const token = {
 		key,
 		type
@@ -884,639 +1067,66 @@ const createReadonlyPureSelector = (store, options, family) => {
 };
 
 //#endregion
-//#region src/internal/selector/create-writable-held-selector.ts
-const createWritableHeldSelector = (store, options, family) => {
+//#region src/internal/transaction/abort-transaction.ts
+const abortTransaction = (store) => {
 	const target = newest(store);
-	const subject = new Subject();
-	const covered = /* @__PURE__ */ new Set();
-	const { key, const: constant } = options;
-	const type = `writable_held_selector`;
-	const setterToolkit = registerSelector(target, type, key, covered);
-	const { find, get, json } = setterToolkit;
-	const getterToolkit = {
-		find,
-		get,
-		json
-	};
-	const getSelf = (getFn = options.get, innerTarget = newest(store)) => {
-		getFn(getterToolkit, constant);
-		cacheValue(innerTarget, key, constant, subject);
-		covered.clear();
-		return constant;
-	};
-	const setSelf = (next) => {
-		const innerTarget = newest(store);
-		const oldValue = getSelf(options.get, innerTarget);
-		const newValue = become(next)(oldValue);
-		store.logger.info(`📝`, type, key, `set (`, oldValue, `->`, newValue, `)`);
-		cacheValue(innerTarget, key, newValue, subject);
-		markDone(innerTarget, key);
-		if (isRootStore(innerTarget)) subject.next({
-			newValue,
-			oldValue
-		});
-		options.set(setterToolkit, newValue);
-	};
-	const mySelector = {
-		...options,
-		type,
-		subject,
-		install: (s) => createWritableHeldSelector(s, options, family),
-		get: getSelf,
-		set: setSelf,
-		...family && { family }
-	};
-	target.writableSelectors.set(key, mySelector);
-	const initialValue = getSelf();
-	store.logger.info(`✨`, type, key, `=`, initialValue);
-	const token = {
-		key,
-		type
-	};
-	if (family) token.family = family;
-	return token;
+	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/selector/create-writable-pure-selector.ts
-const 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`;
-	const setterToolkit = registerSelector(target, type, key, covered);
-	const { find, get, json } = setterToolkit;
-	const getterToolkit = {
-		find,
-		get,
-		json
-	};
-	const getSelf = (getFn = options.get, innerTarget = newest(store)) => {
-		const value = getFn(getterToolkit);
-		cacheValue(innerTarget, 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(`📝`, type, 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,
-		type,
-		subject,
-		install: (s) => createWritablePureSelector(s, options, family),
-		get: getSelf,
-		set: setSelf,
-		...family && { family }
+//#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);
 	};
-	target.writableSelectors.set(key, mySelector);
-	const initialValue = getSelf();
-	store.logger.info(`✨`, mySelector.type, mySelector.key, `=`, initialValue);
+}
+
+//#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
+		type: `atom`
 	};
-	if (family) token.family = family;
-	return token;
-};
+	if (atomUpdate.family) Object.assign(token, { family: atomUpdate.family });
+	setIntoStore(store, token, value);
+}
 
 //#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 } = selectorToken;
-	const selector = withdraw(target, selectorToken);
-	if (!selector.family) store.logger.error(`❌`, type, 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 `writable_held_selector`:
-				{
-					target.writableSelectors.delete(key);
-					familyToken = {
-						key: selector.family.key,
-						type: `writable_held_selector_family`
-					};
-					const family = withdraw(store, familyToken);
-					family.subject.next({
-						type: `state_disposal`,
-						subType: `selector`,
-						token: selectorToken
-					});
-				}
-				break;
-			case `writable_pure_selector`:
-				{
-					target.writableSelectors.delete(key);
-					familyToken = {
-						key: selector.family.key,
-						type: `writable_pure_selector_family`
-					};
-					const family = withdraw(store, familyToken);
-					family.subject.next({
-						type: `state_disposal`,
-						subType: `selector`,
-						token: selectorToken
-					});
-				}
-				break;
-			case `readonly_held_selector`:
-				{
-					target.readonlySelectors.delete(key);
-					familyToken = {
-						key: selector.family.key,
-						type: `readonly_held_selector_family`
-					};
-					const family = withdraw(store, familyToken);
-					family.subject.next({
-						type: `state_disposal`,
-						subType: `selector`,
-						token: selectorToken
-					});
-				}
-				break;
-			case `readonly_pure_selector`:
-				{
-					target.readonlySelectors.delete(key);
-					familyToken = {
-						key: selector.family.key,
-						type: `readonly_pure_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-pure-selector-family.ts
-function createReadonlyPureSelectorFamily(store, options, internalRoles) {
-	const familyKey = options.key;
-	const type = `readonly_pure_selector_family`;
-	const familyToken = {
-		key: familyKey,
-		type
-	};
-	const existing = store.families.get(familyKey);
-	if (existing) store.logger.error(`❗`, type, familyKey, `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: familyKey,
-			subKey
-		};
-		const fullKey = `${familyKey}(${subKey})`;
-		const target = newest(store);
-		const token = createReadonlyPureSelector(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) => createReadonlyPureSelectorFamily(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, readonlySelectorFamily);
-	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 ${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: familyKey,
-			subKey
-		};
-		const fullKey = `${familyKey}(${subKey})`;
-		const target = newest(store);
-		const token = createReadonlyHeldSelector(target, {
-			key: fullKey,
-			const: options.const(key),
-			get: options.get(key)
-		}, family);
-		subject.next({
-			type: `state_creation`,
-			token
-		});
-		return token;
-	};
-	const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
-		internalRoles,
-		subject,
-		install: (s) => createReadonlyHeldSelectorFamily(s, options),
-		default: options.const
-	});
-	store.families.set(familyKey, readonlySelectorFamily);
-	return familyToken;
-}
-
-//#endregion
-//#region src/internal/families/create-writable-held-selector-family.ts
-function createWritableHeldSelectorFamily(store, options, internalRoles) {
-	const familyKey = options.key;
-	const type = `writable_held_selector_family`;
-	const familyToken = {
-		key: familyKey,
-		type
-	};
-	const existing = store.families.get(familyKey);
-	if (existing) store.logger.error(`❗`, type, familyKey, `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: familyKey,
-			subKey
-		};
-		const fullKey = `${familyKey}(${subKey})`;
-		const target = newest(store);
-		const token = createWritableHeldSelector(target, {
-			key: fullKey,
-			const: options.const(key),
-			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) => createWritableHeldSelectorFamily(s, options),
-		default: options.const
-	});
-	store.families.set(familyKey, selectorFamily$1);
-	return familyToken;
-}
-
-//#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 ${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: familyKey,
-			subKey
-		};
-		const fullKey = `${familyKey}(${subKey})`;
-		const target = newest(store);
-		const token = createWritablePureSelector(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) => 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/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 `writable_pure_selector`:
-			case `readonly_pure_selector`:
-			case `writable_held_selector`:
-			case `readonly_held_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 `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, 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 (_) {
-		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/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/reset-in-store.ts
-function resetInStore(store, ...params) {
-	let token;
-	let family;
-	let key;
-	if (params.length === 1) {
-		token = params[0];
-		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];
-		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 reset 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 reset "${token.key}" at T-${rejectionTime}`, () => {
-			unsubscribe();
-			store.logger.info(`🟢`, token.type, token.key, `resuming deferred resetState from T-${rejectionTime}`);
-			resetInStore(store, token);
-		});
-		return;
-	}
-	const state = withdraw(store, token);
-	resetAtomOrSelector(store, state);
-	closeOperation(store);
-}
-
-//#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 `writable_pure_selector`:
-		case `writable_held_selector`:
-			state.set(value);
-			break;
-	}
-};
-
-//#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 ``;
+//#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
@@ -1661,27 +1271,23 @@ function claimWithinStore(store, newProvenance, claim, exclusive) {
 //#region src/internal/ingest-updates/ingest-creation-disposal.ts
 function ingestCreationEvent(update, applying, store) {
 	switch (applying) {
-		case `newValue`: {
+		case `newValue`:
 			createInStore(update, store);
 			break;
-		}
-		case `oldValue`: {
+		case `oldValue`:
 			disposeFromStore(store, update.token);
 			break;
-		}
 	}
 }
 function ingestDisposalEvent(update, applying, store) {
 	switch (applying) {
-		case `newValue`: {
+		case `newValue`:
 			disposeFromStore(store, update.token);
 			break;
-		}
-		case `oldValue`: {
+		case `oldValue`:
 			createInStore(update, store);
 			if (update.subType === `atom`) store.valueMap.set(update.token.key, update.value);
 			break;
-		}
 	}
 }
 function createInStore(update, store) {
@@ -1830,59 +1436,25 @@ const applyTransaction = (output, store) => {
 			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 `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(token.family.key);
-				const defaultValue = withdraw(store, family).default(subKey);
-				store.defaults.set(family.key, defaultValue);
-				return defaultValue;
-			}
-		}
-	}
-	return readOrComputeValue(store, withdraw(store, token));
+		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
@@ -1980,264 +1552,604 @@ const buildTransaction = (store, key, params, id) => {
 			}),
 			env: () => getEnvironmentData(child)
 		}
-	};
-	const child = Object.assign(childBase, { transactionMeta });
-	parent.child = child;
-	store.logger.info(`🛫`, `transaction`, key, `Building transaction with params:`, params);
-	return 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 { key } = options;
+	const transactionAlreadyExists = store.transactions.has(key);
+	const newTransaction = {
+		key,
+		type: `transaction`,
+		run: (params, id) => {
+			const childStore = buildTransaction(store, 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`, key, `caught:`, thrown);
+				throw thrown;
+			}
+		},
+		install: (s) => createTransaction(s, options),
+		subject: new Subject()
+	};
+	const target = newest(store);
+	target.transactions.set(key, newTransaction);
+	const token = deposit(newTransaction);
+	if (!transactionAlreadyExists) store.on.transactionCreation.next(token);
+	return token;
+}
+
+//#endregion
+//#region src/internal/transaction/index.ts
+const TRANSACTION_PHASES = [
+	`idle`,
+	`building`,
+	`applying`
+];
+
+//#endregion
+//#region src/internal/selector/create-writable-held-selector.ts
+const 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`;
+	const setterToolkit = registerSelector(target, type, key, covered);
+	const { find, get, json } = setterToolkit;
+	const getterToolkit = {
+		find,
+		get,
+		json
+	};
+	const getSelf = (getFn = options.get, 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);
+		getFn(getterToolkit, constant);
+		cacheValue(innerTarget, key, constant, subject);
+		store.logger.info(`✨`, type, key, `=`, constant);
+		covered.clear();
+		return constant;
+	};
+	const setSelf = (next) => {
+		const innerTarget = newest(store);
+		const oldValue = getSelf(options.get, innerTarget);
+		const newValue = become(next)(oldValue);
+		store.logger.info(`📝`, type, key, `set (`, oldValue, `->`, newValue, `)`);
+		cacheValue(innerTarget, key, newValue, subject);
+		markDone(innerTarget, key);
+		if (isRootStore(innerTarget)) subject.next({
+			newValue,
+			oldValue
+		});
+		options.set(setterToolkit, newValue);
+	};
+	const mySelector = {
+		...options,
+		type,
+		subject,
+		install: (s) => createWritableHeldSelector(s, options, family),
+		get: getSelf,
+		set: setSelf,
+		...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
+const 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`;
+	const setterToolkit = registerSelector(target, type, key, covered);
+	const { find, get, json } = setterToolkit;
+	const getterToolkit = {
+		find,
+		get,
+		json
+	};
+	const getSelf = (getFn = options.get, 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 = getFn(getterToolkit);
+		const cached = cacheValue(innerTarget, key, value, subject);
+		store.logger.info(`✨`, type, key, `=`, cached);
+		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(`📝`, type, 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,
+		type,
+		subject,
+		install: (s) => createWritablePureSelector(s, options, family),
+		get: getSelf,
+		set: setSelf,
+		...family && { family }
+	};
+	target.writableSelectors.set(key, mySelector);
+	const initialValue = getSelf();
+	store.logger.info(`✨`, mySelector.type, mySelector.key, `=`, initialValue);
+	const token = {
+		key,
+		type
+	};
+	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 } = selectorToken;
+	const selector = withdraw(target, selectorToken);
+	if (!selector.family) store.logger.error(`❌`, type, 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 `writable_held_selector`:
+				{
+					target.writableSelectors.delete(key);
+					familyToken = {
+						key: selector.family.key,
+						type: `writable_held_selector_family`
+					};
+					const family = withdraw(store, familyToken);
+					family.subject.next({
+						type: `state_disposal`,
+						subType: `selector`,
+						token: selectorToken
+					});
+				}
+				break;
+			case `writable_pure_selector`:
+				{
+					target.writableSelectors.delete(key);
+					familyToken = {
+						key: selector.family.key,
+						type: `writable_pure_selector_family`
+					};
+					const family = withdraw(store, familyToken);
+					family.subject.next({
+						type: `state_disposal`,
+						subType: `selector`,
+						token: selectorToken
+					});
+				}
+				break;
+			case `readonly_held_selector`:
+				{
+					target.readonlySelectors.delete(key);
+					familyToken = {
+						key: selector.family.key,
+						type: `readonly_held_selector_family`
+					};
+					const family = withdraw(store, familyToken);
+					family.subject.next({
+						type: `state_disposal`,
+						subType: `selector`,
+						token: selectorToken
+					});
+				}
+				break;
+			case `readonly_pure_selector`:
+				{
+					target.readonlySelectors.delete(key);
+					familyToken = {
+						key: selector.family.key,
+						type: `readonly_pure_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/transaction/create-transaction.ts
-function createTransaction(store, options) {
-	const { key } = options;
-	const transactionAlreadyExists = store.transactions.has(key);
-	const newTransaction = {
-		key,
-		type: `transaction`,
-		run: (params, id) => {
-			const childStore = buildTransaction(store, 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`, key, `caught:`, thrown);
-				throw thrown;
-			}
-		},
-		install: (s) => createTransaction(s, options),
-		subject: new Subject()
+//#region src/internal/families/create-readonly-pure-selector-family.ts
+function createReadonlyPureSelectorFamily(store, options, internalRoles) {
+	const familyKey = options.key;
+	const type = `readonly_pure_selector_family`;
+	const familyToken = {
+		key: familyKey,
+		type
 	};
-	const target = newest(store);
-	target.transactions.set(key, newTransaction);
-	const token = deposit(newTransaction);
-	if (!transactionAlreadyExists) store.on.transactionCreation.next(token);
-	return token;
+	const existing = store.families.get(familyKey);
+	if (existing) store.logger.error(`❗`, type, familyKey, `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: familyKey,
+			subKey
+		};
+		const fullKey = `${familyKey}(${subKey})`;
+		const target = newest(store);
+		const token = createReadonlyPureSelector(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) => createReadonlyPureSelectorFamily(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, readonlySelectorFamily);
+	return familyToken;
 }
 
 //#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 = /* @__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`
-		})
+//#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
 	};
-	timelines = /* @__PURE__ */ new Map();
-	timelineTopics = new Junction({
-		between: [`timelineKey`, `topicKey`],
-		cardinality: `1:n`
+	const existing = store.families.get(familyKey);
+	if (existing) store.logger.error(`❗`, type, familyKey, `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: familyKey,
+			subKey
+		};
+		const fullKey = `${familyKey}(${subKey})`;
+		const target = newest(store);
+		const token = createReadonlyHeldSelector(target, {
+			key: fullKey,
+			const: options.const(key),
+			get: options.get(key)
+		}, family);
+		subject.next({
+			type: `state_creation`,
+			token
+		});
+		return token;
+	};
+	const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
+		internalRoles,
+		subject,
+		install: (s) => createReadonlyHeldSelectorFamily(s, options),
+		default: options.const
 	});
-	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()
+	store.families.set(familyKey, readonlySelectorFamily);
+	return familyToken;
+}
+
+//#endregion
+//#region src/internal/families/create-writable-held-selector-family.ts
+function createWritableHeldSelectorFamily(store, options, internalRoles) {
+	const familyKey = options.key;
+	const type = `writable_held_selector_family`;
+	const familyToken = {
+		key: familyKey,
+		type
 	};
-	operation = { open: false };
-	config = {
-		name: `IMPLICIT_STORE`,
-		lifespan: `ephemeral`
+	const existing = store.families.get(familyKey);
+	if (existing) store.logger.error(`❗`, type, familyKey, `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: familyKey,
+			subKey
+		};
+		const fullKey = `${familyKey}(${subKey})`;
+		const target = newest(store);
+		const token = createWritableHeldSelector(target, {
+			key: fullKey,
+			const: options.const(key),
+			get: options.get(key),
+			set: options.set(key)
+		}, family);
+		subject.next({
+			type: `state_creation`,
+			token
+		});
+		return token;
 	};
-	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);
-		}
+	const selectorFamily$1 = Object.assign(familyFunction, familyToken, {
+		internalRoles,
+		subject,
+		install: (s) => createWritableHeldSelectorFamily(s, options),
+		default: options.const
+	});
+	store.families.set(familyKey, selectorFamily$1);
+	return familyToken;
+}
+
+//#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
 	};
-	constructor(config, store = null) {
-		this.config = {
-			...store?.config,
-			...config
+	const existing = store.families.get(familyKey);
+	if (existing) store.logger.error(`❗`, type, familyKey, `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: familyKey,
+			subKey
 		};
-		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 = /* @__PURE__ */ 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.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 fullKey = `${familyKey}(${subKey})`;
+		const target = newest(store);
+		const token = createWritablePureSelector(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) => 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)
+			});
 		}
-	}
-};
-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;
-};
+	store.families.set(familyKey, selectorFamily$1);
+	return familyToken;
+}
 
 //#endregion
-//#region src/internal/store/withdraw.ts
-function withdraw(store, token) {
-	let withdrawn;
-	let target = store;
-	while (target !== null) {
-		switch (token.type) {
+//#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/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`:
-				withdrawn = target.atoms.get(token.key);
+				store.on.atomCreation.next(state);
 				break;
 			case `writable_pure_selector`:
-			case `writable_held_selector`:
-				withdrawn = target.writableSelectors.get(token.key);
-				break;
 			case `readonly_pure_selector`:
+			case `writable_held_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);
-				break;
-			case `transaction`:
-				withdrawn = target.transactions.get(token.key);
+				store.on.selectorCreation.next(state);
 				break;
 		}
-		if (withdrawn) return withdrawn;
-		target = target.child;
+		else if (isChildStore(target) && target.on.transactionApplying.state === null) target.transactionMeta.update.updates.push({
+			type: `state_creation`,
+			token: state
+		});
 	}
-	throw new NotFoundError(token, store);
+	return state;
 }
 
 //#endregion
-//#region src/internal/subscribe/recall-state.ts
-const recallState = (store, state) => {
+//#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);
-	if (target.operation.open) return target.operation.prev.get(state.key);
-	return target.valueMap.get(state.key);
-};
+	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/subscribe/subscribe-in-store.ts
-function subscribeInStore(store, token, handleUpdate, key = arbitrary$1()) {
+//#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 (_) {
+		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`:
-		case `writable_pure_selector`:
-		case `writable_held_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);
+			disposeSelector(store, token);
+			break;
 	}
 }
 
 //#endregion
-//#region src/internal/subscribe/subscribe-to-root-atoms.ts
-const subscribeToRootAtoms = (store, selector) => {
-	const target = newest(store);
-	const dependencySubscriptions = traceAllSelectorAtoms(selector, store).map((atom$1) => {
-		return atom$1.subject.subscribe(`${selector.type}:${selector.key}`, (atomChange) => {
-			store.logger.info(`📢`, selector.type, selector.key, `root`, atom$1.key, `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;
-};
+//#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 `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(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/subscribe/subscribe-to-state.ts
@@ -2253,15 +2165,22 @@ function subscribeToState(store, token, key, handleUpdate) {
 	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`;
-	let dependencyUnsubFunctions = null;
+	const rootSubs = /* @__PURE__ */ new Map();
 	let updateHandler = safelyHandleUpdate;
 	if (isSelector) {
-		dependencyUnsubFunctions = subscribeToRootAtoms(store, state);
-		updateHandler = (update) => {
-			if (dependencyUnsubFunctions) {
-				dependencyUnsubFunctions.length = 0;
-				dependencyUnsubFunctions.push(...subscribeToRootAtoms(store, state));
+		readOrComputeValue(store, state);
+		for (const [atomKey, atom$1] of traceRootSelectorAtoms(store, state.key)) rootSubs.set(atomKey, subscribeToRootDependency(store, state, atom$1));
+		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);
+				}
 			}
+			for (const [atomKey, atom$1] of dependencies) rootSubs.set(atomKey, subscribeToRootDependency(store, state, atom$1));
 			safelyHandleUpdate(update);
 		};
 	}
@@ -2269,7 +2188,7 @@ function subscribeToState(store, token, key, handleUpdate) {
 	const unsubscribe = () => {
 		store.logger.info(`🙈`, state.type, state.key, `Removing subscription "${key}"`);
 		mainUnsubFunction();
-		if (dependencyUnsubFunctions) for (const unsubFromDependency of dependencyUnsubFunctions) unsubFromDependency();
+		for (const unsubFromDependency of rootSubs.values()) unsubFromDependency();
 	};
 	return unsubscribe;
 }
@@ -2395,7 +2314,7 @@ var Tracker = class {
 function createMutableAtom(store, options, family) {
 	store.logger.info(`🔨`, `atom`, options.key, `creating in store "${store.config.name}"`);
 	const target = newest(store);
-	const { key, default: def } = options;
+	const { key } = options;
 	const existing = target.atoms.get(key);
 	const type = `mutable_atom`;
 	if (existing && existing.type === type) {
@@ -2413,9 +2332,7 @@ function createMutableAtom(store, options, family) {
 		subject
 	};
 	if (family) newAtom.family = family;
-	const initialValue = def();
 	target.atoms.set(newAtom.key, newAtom);
-	cacheValue(target, key, initialValue, subject);
 	const token = deposit(newAtom);
 	if (options.effects) {
 		let effectIndex = 0;
@@ -2586,93 +2503,179 @@ function isTransceiver(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;
-		if (value instanceof Promise) {
-			future.use(value);
-			return future;
+//#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);
 		}
-		target.valueMap.set(key, value);
-		return value;
-	}
-	if (value instanceof Promise) {
-		const future = new Future(value);
-		target.valueMap.set(key, future);
-		future.then((resolved) => {
-			const current = target.valueMap.get(key);
-			if (current === future) {
-				cacheValue(target, key, resolved, subject);
-				const atom$1 = target.atoms.get(key);
-				if (atom$1) {
-					openOperation(target, atom$1);
-					evictDownStream(target, atom$1);
-					closeOperation(target);
-				} else {
-					const selector = target.writableSelectors.get(key) ?? target.readonlySelectors.get(key);
-					if (selector) {
-						openOperation(target, selector);
-						evictDownStreamFromSelector(target, selector);
-						closeOperation(target);
-					}
+	};
+	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$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);
 				}
-				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;
+			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);
+		}
 	}
-	return value;
 };
-const evictCachedValue = (key, target) => {
-	const currentValue = target.valueMap.get(key);
-	if (currentValue instanceof Future) {
-		const future = currentValue;
-		const selector = target.writableSelectors.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`);
+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 `writable_pure_selector`:
+			case `writable_held_selector`:
+				withdrawn = target.writableSelectors.get(token.key);
+				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);
+				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/atom/create-regular-atom.ts
 function createRegularAtom(store, options, family) {
 	const type = `atom`;
-	const { key, default: def } = options;
+	const { key } = options;
 	store.logger.info(`🔨`, `atom`, key, `creating in store "${store.config.name}"`);
 	const target = newest(store);
 	const existing = target.atoms.get(key);
@@ -2691,10 +2694,7 @@ function createRegularAtom(store, options, family) {
 		subject
 	};
 	if (family) newAtom.family = family;
-	let initialValue = def;
-	if (def instanceof Function) initialValue = def();
 	target.atoms.set(key, newAtom);
-	cacheValue(target, key, initialValue, subject);
 	const token = deposit(newAtom);
 	if (options.effects) {
 		let effectIndex = 0;
@@ -2802,6 +2802,20 @@ function installIntoStore(tokens, target, source) {
 	}
 }
 
+//#endregion
+//#region src/internal/join/create-join.ts
+function createJoin(store, options, defaultContent) {
+	store.joins.set(options.key, new Join$1(options, defaultContent, store));
+	const token = {
+		key: options.key,
+		type: `join`,
+		a: options.between[0],
+		b: options.between[1],
+		cardinality: options.cardinality
+	};
+	return token;
+}
+
 //#endregion
 //#region src/internal/join/join-internal.ts
 var Join = class {
@@ -3513,26 +3527,21 @@ const timeTravel = (store, action, token) => {
 	const update = timelineData.history[timelineData.at];
 	const applying = action === `redo` ? `newValue` : `oldValue`;
 	switch (update.type) {
-		case `atom_update`: {
+		case `atom_update`:
 			ingestAtomUpdate(applying, update, store);
 			break;
-		}
-		case `selector_update`: {
+		case `selector_update`:
 			ingestSelectorUpdate(applying, update, store);
 			break;
-		}
-		case `transaction_update`: {
+		case `transaction_update`:
 			ingestTransactionUpdate(applying, update, store);
 			break;
-		}
-		case `state_creation`: {
+		case `state_creation`:
 			ingestCreationEvent(update, applying, store);
 			break;
-		}
-		case `state_disposal`: {
+		case `state_disposal`:
 			ingestDisposalEvent(update, applying, store);
 			break;
-		}
 		case `molecule_creation`:
 		case `molecule_disposal`:
 	}
@@ -3543,5 +3552,5 @@ const timeTravel = (store, action, token) => {
 };
 
 //#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, createReadonlyHeldSelector, createReadonlyPureSelector, createReadonlyPureSelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableHeldSelector, createWritablePureSelector, createWritablePureSelectorFamily, 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, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, resetAtomOrSelector, resetInStore, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+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, createJoin, createMutableAtom, createMutableAtomFamily, createReadonlyHeldSelector, createReadonlyPureSelector, createReadonlyPureSelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableHeldSelector, createWritablePureSelector, createWritablePureSelectorFamily, 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, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, resetAtomOrSelector, resetInStore, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootDependency, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceRootSelectorAtoms, updateSelectorAtoms, withdraw };
 //# sourceMappingURL=index.js.map