atom.io 0.36.3 → 0.37.1

package/dist/internal/index.js

@@ -449,7 +449,7 @@ function isChildStore(store) {
 
 //#endregion
 //#region src/internal/operation.ts
-const openOperation = (store, token) => {
+function openOperation(store, token) {
 	if (store.operation.open) {
 		const rejectionTime = performance.now();
 		store.logger.info(`❗`, token.type, token.key, `deferring setState at T-${rejectionTime} until setState for "${store.operation.token.key}" is done`);
@@ -459,16 +459,17 @@ const openOperation = (store, token) => {
 		open: true,
 		done: /* @__PURE__ */ new Set(),
 		prev: /* @__PURE__ */ new Map(),
-		time: Date.now(),
+		timestamp: Date.now(),
 		token
 	};
-	store.logger.info(`⭕`, token.type, token.key, `operation start in store "${store.config.name}"${!isChildStore(store) ? `` : ` ${store.transactionMeta.phase} "${store.transactionMeta.update.key}"`}`);
-};
-const closeOperation = (store) => {
+	store.logger.info(`⭕`, token.type, token.key, `operation start in store "${store.config.name}"${isChildStore(store) ? ` ${store.transactionMeta.phase} "${store.transactionMeta.update.token.key}"` : ``}`);
+	return store;
+}
+function closeOperation(store) {
 	if (store.operation.open) store.logger.info(`🔴`, store.operation.token.type, store.operation.token.key, `operation done in store "${store.config.name}"`);
 	store.operation = { open: false };
 	store.on.operationClose.next(store.operation);
-};
+}
 const isDone = (store, key) => {
 	if (!store.operation.open) {
 		store.logger.error(`🐞`, `unknown`, key, `isDone called outside of an operation. This is probably a bug in AtomIO.`);
@@ -585,7 +586,7 @@ function evictCachedValue(target, key) {
 	const currentValue = target.valueMap.get(key);
 	if (currentValue instanceof Future) {
 		const selector = target.writableSelectors.get(key) ?? target.readonlySelectors.get(key);
-		if (selector) selector.get();
+		if (selector) selector.getFrom(target);
 		return;
 	}
 	if (target.operation.open) target.operation.prev.set(key, currentValue);
@@ -604,7 +605,7 @@ function readOrComputeValue(target, state, mut) {
 		case `writable_held_selector`:
 		case `writable_pure_selector`:
 			target.logger.info(`🧮`, state.type, key, `computing value`);
-			return state.get();
+			return state.getFrom(target);
 		case `atom`: {
 			let def;
 			if (state.default instanceof Function) def = state.default();
@@ -623,33 +624,104 @@ function readOrComputeValue(target, state, mut) {
 }
 
 //#endregion
-//#region src/internal/set-state/become.ts
-const become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(originalThing) : nextVersionOfThing;
+//#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/atom/has-role.ts
-const INTERNAL_ROLES = [`tracker:signal`];
-function hasRole(atom, role) {
-	if (`internalRoles` in atom === false) return false;
-	return atom.internalRoles.includes(role);
+//#region src/internal/transaction/abort-transaction.ts
+const abortTransaction = (store) => {
+	const target = newest(store);
+	if (!isChildStore(target)) {
+		store.logger.warn(`🐞`, `transaction`, `???`, `abortTransaction called outside of a transaction. This is probably a bug in AtomIO.`);
+		return;
+	}
+	store.logger.info(`🪂`, `transaction`, target.transactionMeta.update.token.key, `Aborting transaction`);
+	target.parent.child = null;
+};
+
+//#endregion
+//#region src/internal/capitalize.ts
+function capitalize(string) {
+	return string[0].toUpperCase() + string.slice(1);
 }
 
 //#endregion
-//#region src/internal/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);
+//#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}".`);
 	}
-	state.subject.next(update);
 };
 
+//#endregion
+//#region src/internal/transaction/act-upon-store.ts
+function actUponStore(store, token, id) {
+	return (...parameters) => {
+		const tx = withdraw(store, token);
+		if (tx) return tx.run(parameters, id);
+		throw new NotFoundError(token, store);
+	};
+}
+
+//#endregion
+//#region src/internal/set-state/become.ts
+const become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(originalThing) : nextVersionOfThing;
+
+//#endregion
+//#region src/internal/set-state/dispatch-state-update.ts
+function dispatchOrDeferStateUpdate(target, state, [oldValue, newValue], _stateIsNewlyCreated) {
+	const { key, subject, type } = state;
+	const update = {
+		oldValue: isTransceiver(oldValue) ? oldValue.READONLY_VIEW : oldValue,
+		newValue: isTransceiver(newValue) ? newValue.READONLY_VIEW : newValue
+	};
+	if (isRootStore(target)) {
+		switch (type) {
+			case `mutable_atom`:
+				target.logger.info(`📢`, type, key, `is now (`, newValue, `) subscribers:`, subject.subscribers);
+				break;
+			case `atom`:
+			case `writable_pure_selector`:
+			case `writable_held_selector`: target.logger.info(`📢`, type, key, `went (`, oldValue, `->`, newValue, `) subscribers:`, subject.subscribers);
+		}
+		subject.next(update);
+	}
+	if (isChildStore(target) && (type === `mutable_atom` || type === `atom`)) {
+		if (target.on.transactionApplying.state === null) {
+			const token = deposit(state);
+			if (isTransceiver(newValue)) return;
+			const { timestamp } = target.operation;
+			const atomUpdate = {
+				type: `atom_update`,
+				token,
+				timestamp,
+				update
+			};
+			target.transactionMeta.update.subEvents.push(atomUpdate);
+			target.logger.info(`📁`, `atom`, key, `stowed (`, oldValue, `->`, newValue, `)`);
+			return;
+		}
+		if (hasRole(state, `tracker:signal`)) {
+			const keyOfMutable = key.slice(1);
+			const mutable = target.atoms.get(keyOfMutable);
+			const transceiver = readOrComputeValue(target, mutable, `mut`);
+			const accepted = transceiver.do(update.newValue) === null;
+			if (accepted === true) evictDownstreamFromAtom(target, mutable);
+		}
+	}
+}
+
 //#endregion
 //#region src/internal/set-state/set-atom.ts
 const setAtom = (target, atom, next) => {
@@ -659,129 +731,49 @@ const setAtom = (target, atom, next) => {
 	newValue = writeToCache(target, atom, newValue);
 	markDone(target, atom.key);
 	evictDownstreamFromAtom(target, atom);
-	const update = {
-		oldValue,
-		newValue
-	};
-	if (!isChildStore(target)) {
-		emitUpdate(target, atom, update);
-		return;
-	}
-	if (target.on.transactionApplying.state === null) {
-		const { key } = atom;
-		if (isTransceiver(update.newValue)) return;
-		const atomUpdate = {
-			type: `atom_update`,
-			key,
-			...update
-		};
-		if (atom.family) atomUpdate.family = atom.family;
-		target.transactionMeta.update.updates.push(atomUpdate);
-		target.logger.info(`📁`, `atom`, key, `stowed (`, update.oldValue, `->`, update.newValue, `)`);
-	} else if (hasRole(atom, `tracker:signal`)) {
-		const key = atom.key.slice(1);
-		const mutable = target.atoms.get(key);
-		const transceiver = readOrComputeValue(target, mutable, `mut`);
-		const accepted = transceiver.do(update.newValue) === null;
-		if (accepted === true) evictDownstreamFromAtom(target, mutable);
-	}
+	return [oldValue, newValue];
 };
 
 //#endregion
 //#region src/internal/set-state/reset-atom-or-selector.ts
-function resetAtom(store, state) {
-	switch (state.type) {
-		case `mutable_atom`:
-			setAtom(store, state, new state.class());
-			return;
+function resetAtom(target, atom) {
+	switch (atom.type) {
+		case `mutable_atom`: return setAtom(target, atom, new atom.class());
 		case `atom`: {
-			let def = state.default;
+			let def = atom.default;
 			if (def instanceof Function) def = def();
-			setAtom(store, state, def);
+			return setAtom(target, atom, def);
 		}
 	}
 }
-function resetAtomOrSelector(store, state) {
+function resetAtomOrSelector(target, state) {
+	let protoUpdate;
 	switch (state.type) {
 		case `atom`:
 		case `mutable_atom`:
-			resetAtom(store, state);
+			protoUpdate = resetAtom(target, state);
 			break;
 		case `writable_pure_selector`:
 		case `writable_held_selector`:
 			{
-				const atoms = traceRootSelectorAtoms(store, state.key);
-				for (const atom of atoms.values()) resetAtom(store, atom);
+				const oldValue = state.getFrom(target);
+				const atoms = traceRootSelectorAtoms(target, state.key);
+				for (const atom of atoms.values()) {
+					const rootProtoUpdate = resetAtom(target, atom);
+					dispatchOrDeferStateUpdate(target, state, rootProtoUpdate, false);
+				}
+				const newValue = state.getFrom(target);
+				protoUpdate = [oldValue, newValue];
 			}
 			break;
 	}
+	return protoUpdate;
 }
 
-//#endregion
-//#region src/internal/families/get-family-of-token.ts
-function getFamilyOfToken(store, token) {
-	if (token.family) {
-		const family = store.families.get(token.family.key);
-		if (family) return family;
-	}
-}
-
-//#endregion
-//#region src/internal/set-state/set-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];
-		if (token.family) {
-			family = getFamilyOfToken(store, token);
-			key = parseJson(token.family.subKey);
-			token = findInStore(store, family, key);
-		}
-	} else {
-		family = params[0];
-		key = params[1];
-		value = params[2];
-		token = findInStore(store, family, key);
-	}
-	const action = value === RESET_STATE ? `reset` : `set`;
-	if (`counterfeit` in token && `family` in token) {
-		const subKey = token.family.subKey;
-		const disposal = store.disposalTraces.buffer.find((item) => item?.key === subKey);
-		store.logger.error(`❌`, token.type, token.key, `could not be`, action, `because 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 ${action} "${token.key}" at T-${rejectionTime}`, function waitUntilOperationCloseToSetState() {
-			unsubscribe();
-			store.logger.info(`🟢`, token.type, token.key, `resuming deferred`, action, `from T-${rejectionTime}`);
-			setIntoStore(store, token, value);
-		});
-		return;
-	}
-	const state = withdraw(store, token);
-	if (value === RESET_STATE) resetAtomOrSelector(store, state);
-	else setAtomOrSelector(store, state, value);
-	closeOperation(store);
+	operateOnStore(store, true, ...params);
 }
 
 //#endregion
@@ -802,233 +794,52 @@ function resetInStore(store, ...params) {
 }
 
 //#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 = store.atoms.get(dependencyKey);
-			roots.set(atom.key, atom);
-		} else dependencies.push(...getSelectorDependencyKeys(store, dependencyKey));
-	}
-	return roots;
-};
-
-//#endregion
-//#region src/internal/selector/update-selector-atoms.ts
-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;
-		if (params.length === 2) {
-			const [family, key] = params;
-			dependency = findInStore(store, family, key);
-		} else [dependency] = params;
-		const dependencyState = withdraw(store, dependency);
-		const dependencyValue = readOrComputeValue(store, dependencyState);
-		const dependencyKey = dependency.key;
-		store.logger.info(`🔌`, selectorType, selectorKey, `registers dependency ( "${dependencyKey}" =`, dependencyValue, `)`);
-		target.selectorGraph.set({
-			upstreamSelectorKey: dependencyKey,
-			downstreamSelectorKey: selectorKey
-		}, { source: dependency.key });
-		updateSelectorAtoms(store, selectorType, selectorKey, dependency, covered);
-		return dependencyValue;
-	},
-	set: ((...params) => {
-		let token;
-		let value;
-		if (params.length === 2) {
-			token = params[0];
-			value = params[1];
-		} else {
-			const family = params[0];
-			const key = params[1];
-			value = params[2];
-			token = findInStore(store, family, key);
-		}
-		const target = newest(store);
-		const state = withdraw(target, token);
-		setAtomOrSelector(target, state, value);
-	}),
-	find: ((...args) => findInStore(store, ...args)),
-	json: (token) => getJsonToken(store, token)
-});
-
-//#endregion
-//#region src/internal/selector/create-readonly-held-selector.ts
-const createReadonlyHeldSelector = (store, options, family) => {
-	const target = newest(store);
-	const subject = new Subject();
-	const covered = /* @__PURE__ */ new Set();
-	const { key, const: constant } = options;
-	const type = `readonly_held_selector`;
-	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,
-			json
-		}, constant);
-		writeToCache(newest(store), readonlySelector, constant);
-		covered.clear();
-		return constant;
-	};
-	const readonlySelector = {
-		...options,
-		type,
-		subject,
-		install: (s) => createReadonlyHeldSelector(s, options, family),
-		get: getSelf,
-		...family && { family }
-	};
-	target.readonlySelectors.set(key, readonlySelector);
-	store.logger.info(`✨`, type, key, `=`, constant);
-	const token = {
-		key,
-		type
-	};
-	if (family) token.family = family;
-	return token;
-};
-
-//#endregion
-//#region src/internal/selector/create-readonly-pure-selector.ts
-const createReadonlyPureSelector = (store, options, family) => {
-	const target = newest(store);
-	const subject = new Subject();
-	const covered = /* @__PURE__ */ new Set();
-	const key = options.key;
-	const type = `readonly_pure_selector`;
-	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
-		});
-		const cached = writeToCache(innerTarget, readonlySelector, value);
-		store.logger.info(`✨`, type, key, `=`, cached);
-		covered.clear();
-		return cached;
-	};
-	const readonlySelector = {
-		...options,
-		type,
-		subject,
-		install: (s) => createReadonlyPureSelector(s, options, family),
-		get: getSelf,
-		...family && { family }
-	};
-	target.readonlySelectors.set(key, readonlySelector);
-	const token = {
-		key,
-		type
-	};
-	if (family) token.family = family;
-	return token;
-};
-
-//#endregion
-//#region src/internal/transaction/abort-transaction.ts
-const abortTransaction = (store) => {
-	const target = newest(store);
-	if (!isChildStore(target)) {
-		store.logger.warn(`🐞`, `transaction`, `???`, `abortTransaction called outside of a transaction. This is probably a bug in AtomIO.`);
-		return;
+//#region src/internal/set-state/set-selector.ts
+function setSelector(target, selector, next) {
+	let oldValue;
+	let newValue;
+	let constant;
+	const { type, key } = selector;
+	switch (selector.type) {
+		case `writable_pure_selector`:
+			oldValue = selector.getFrom(target);
+			newValue = become(next)(oldValue);
+			writeToCache(target, selector, newValue);
+			break;
+		case `writable_held_selector`:
+			constant = selector.const;
+			become(next)(constant);
+			oldValue = constant;
+			newValue = constant;
 	}
-	store.logger.info(`🪂`, `transaction`, target.transactionMeta.update.key, `Aborting transaction`);
-	target.parent.child = null;
-};
-
-//#endregion
-//#region src/internal/capitalize.ts
-function capitalize(string) {
-	return string[0].toUpperCase() + string.slice(1);
-}
-
-//#endregion
-//#region src/internal/pretty-print.ts
-function prettyPrintTokenType(token) {
-	return token.type.split(`_`).map(capitalize).join(` `);
+	target.logger.info(`📝`, type, key, `setting to`, newValue);
+	markDone(target, key);
+	selector.setSelf(newValue);
+	return [oldValue, newValue];
 }
 
 //#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);
-	};
-}
+//#region src/internal/set-state/set-atom-or-selector.ts
+const setAtomOrSelector = (target, state, value) => {
+	let protoUpdate;
+	switch (state.type) {
+		case `atom`:
+		case `mutable_atom`:
+			protoUpdate = setAtom(target, state, value);
+			break;
+		case `writable_pure_selector`:
+		case `writable_held_selector`:
+			protoUpdate = setSelector(target, state, value);
+			break;
+	}
+	return protoUpdate;
+};
 
 //#endregion
 //#region src/internal/ingest-updates/ingest-atom-update.ts
 function ingestAtomUpdate(applying, atomUpdate, store) {
-	const { key, newValue, oldValue } = atomUpdate;
+	const { token, update: { 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);
 }
 
@@ -1076,10 +887,11 @@ function allocateIntoStore(store, provenance, key, dependsOn = `any`) {
 	const creationEvent = {
 		type: `molecule_creation`,
 		key,
-		provenance: origin
+		provenance: origin,
+		timestamp: Date.now()
 	};
 	const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
-	if (isTransaction) target.transactionMeta.update.updates.push(creationEvent);
+	if (isTransaction) target.transactionMeta.update.subEvents.push(creationEvent);
 	else target.on.moleculeCreation.next(creationEvent);
 	for (const claim of invalidKeys) {
 		const disposal = store.disposalTraces.buffer.find((item) => item?.key === claim);
@@ -1116,12 +928,13 @@ function deallocateFromStore(store, claim) {
 		type: `molecule_disposal`,
 		key: molecule.key,
 		values,
-		provenance
+		provenance,
+		timestamp: Date.now()
 	};
 	const target = newest(store);
 	target.molecules.delete(stringKey);
 	const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
-	if (isTransaction) target.transactionMeta.update.updates.push(disposalEvent);
+	if (isTransaction) target.transactionMeta.update.subEvents.push(disposalEvent);
 	const relatedMolecules = store.moleculeGraph.getRelationEntries({ downstreamMoleculeKey: molecule.stringKey });
 	if (relatedMolecules) for (const [relatedStringKey, { source }] of relatedMolecules) if (source === molecule.stringKey) {
 		const relatedKey = parseJson(relatedStringKey);
@@ -1172,10 +985,11 @@ function claimWithinStore(store, newProvenance, claim, exclusive) {
 		key: molecule.key,
 		exclusive: Boolean(exclusive),
 		from: priorProvenance,
-		to: [newProvenanceMolecule.key]
+		to: [newProvenanceMolecule.key],
+		timestamp: Date.now()
 	};
 	const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
-	if (isTransaction) target.transactionMeta.update.updates.push(transferEvent);
+	if (isTransaction) target.transactionMeta.update.subEvents.push(transferEvent);
 	return claim;
 }
 
@@ -1269,10 +1083,9 @@ function ingestSelectorUpdate(applying, selectorUpdate, store) {
 //#endregion
 //#region src/internal/ingest-updates/ingest-transaction-update.ts
 function ingestTransactionUpdate(applying, transactionUpdate, store) {
-	const updates = applying === `newValue` ? transactionUpdate.updates : [...transactionUpdate.updates].reverse();
+	const updates = applying === `newValue` ? transactionUpdate.subEvents : [...transactionUpdate.subEvents].reverse();
 	for (const updateFromTransaction of updates) switch (updateFromTransaction.type) {
 		case `atom_update`:
-		case `selector_update`:
 			ingestAtomUpdate(applying, updateFromTransaction, store);
 			break;
 		case `state_creation`:
@@ -1290,7 +1103,7 @@ function ingestTransactionUpdate(applying, transactionUpdate, store) {
 		case `molecule_transfer`:
 			ingestMoleculeTransferEvent(updateFromTransaction, applying, store);
 			break;
-		case `transaction_update`:
+		case `transaction_outcome`:
 			ingestTransactionUpdate(applying, updateFromTransaction, store);
 			break;
 	}
@@ -1340,18 +1153,18 @@ const applyTransaction = (output, store) => {
 	child.transactionMeta.update.output = output;
 	parent.child = null;
 	parent.on.transactionApplying.next(child.transactionMeta);
-	const { updates } = child.transactionMeta.update;
-	store.logger.info(`🛄`, `transaction`, child.transactionMeta.update.key, `Applying transaction with ${updates.length} updates:`, updates);
+	const { subEvents: updates } = child.transactionMeta.update;
+	store.logger.info(`🛄`, `transaction`, child.transactionMeta.update.token.key, `Applying transaction with ${updates.length} updates:`, updates);
 	ingestTransactionUpdate(`newValue`, child.transactionMeta.update, parent);
 	if (isRootStore(parent)) {
-		setEpochNumberOfAction(parent, child.transactionMeta.update.key, child.transactionMeta.update.epoch);
+		setEpochNumberOfAction(parent, child.transactionMeta.update.token.key, child.transactionMeta.update.epoch);
 		const myTransaction = withdraw(store, {
-			key: child.transactionMeta.update.key,
+			key: child.transactionMeta.update.token.key,
 			type: `transaction`
 		});
 		myTransaction?.subject.next(child.transactionMeta.update);
-		store.logger.info(`🛬`, `transaction`, child.transactionMeta.update.key, `Finished applying transaction.`);
-	} else if (isChildStore(parent)) parent.transactionMeta.update.updates.push(child.transactionMeta.update);
+		store.logger.info(`🛬`, `transaction`, child.transactionMeta.update.token.key, `Finished applying transaction.`);
+	} else if (isChildStore(parent)) parent.transactionMeta.update.subEvents.push(child.transactionMeta.update);
 	parent.on.transactionApplying.next(null);
 };
 
@@ -1407,7 +1220,7 @@ var LazyMap = class extends Map {
 
 //#endregion
 //#region src/internal/transaction/build-transaction.ts
-const buildTransaction = (store, key, params, id) => {
+const buildTransaction = (store, token, params, id) => {
 	const parent = newest(store);
 	const childBase = {
 		parent,
@@ -1438,15 +1251,16 @@ const buildTransaction = (store, key, params, id) => {
 		moleculeJoins: new Junction(parent.moleculeJoins.toJSON(), { makeContentKey: parent.moleculeJoins.makeContentKey }),
 		miscResources: new LazyMap(parent.miscResources)
 	};
-	const epoch = getEpochNumberOfAction(store, key);
+	const epoch = getEpochNumberOfAction(store, token.key);
 	const transactionMeta = {
 		phase: `building`,
 		update: {
-			type: `transaction_update`,
-			key,
+			type: `transaction_outcome`,
+			token,
 			id,
 			epoch: epoch === void 0 ? NaN : epoch + 1,
-			updates: [],
+			timestamp: Date.now(),
+			subEvents: [],
 			params,
 			output: void 0
 		},
@@ -1458,9 +1272,9 @@ const buildTransaction = (store, key, params, id) => {
 			reset: ((...ps) => {
 				resetInStore(child, ...ps);
 			}),
-			run: (token, identifier = arbitrary()) => actUponStore(child, token, identifier),
+			run: (t, identifier = arbitrary()) => actUponStore(child, t, identifier),
 			find: ((...ps) => findInStore(store, ...ps)),
-			json: (token) => getJsonToken(child, token),
+			json: (t) => getJsonToken(child, t),
 			dispose: ((...ps) => {
 				disposeFromStore(child, ...ps);
 			}),
@@ -1469,7 +1283,7 @@ const buildTransaction = (store, key, params, id) => {
 	};
 	const child = Object.assign(childBase, { transactionMeta });
 	parent.child = child;
-	store.logger.info(`🛫`, `transaction`, key, `Building transaction with params:`, params);
+	store.logger.info(`🛫`, `transaction`, token.key, `Building transaction with params:`, params);
 	return child;
 };
 
@@ -1482,7 +1296,8 @@ function createTransaction(store, options) {
 		key,
 		type: `transaction`,
 		run: (params, id) => {
-			const childStore = buildTransaction(store, key, params, id);
+			const token$1 = deposit(newTransaction);
+			const childStore = buildTransaction(store, token$1, params, id);
 			try {
 				const target$1 = newest(store);
 				const { toolkit } = childStore.transactionMeta;
@@ -1513,9 +1328,279 @@ const TRANSACTION_PHASES = [
 	`applying`
 ];
 
+//#endregion
+//#region src/internal/families/init-family-member.ts
+function initFamilyMemberInStore(store, token, key) {
+	const family = withdraw(store, token);
+	const state = family(key);
+	return state;
+}
+
+//#endregion
+//#region src/internal/families/mint-in-store.ts
+function mintInStore(store, familyToken, key) {
+	const stringKey = stringifyJson(key);
+	const molecule = store.molecules.get(stringKey);
+	if (!molecule && store.config.lifespan === `immortal`) {
+		const fakeToken = counterfeit(familyToken, key);
+		store.logger.error(`❌`, fakeToken.type, fakeToken.key, `was not found in store "${store.config.name}"; returned a counterfeit token.`);
+		return fakeToken;
+	}
+	const newStateToken = initFamilyMemberInStore(store, familyToken, key);
+	const target = newest(store);
+	if (newStateToken.family) {
+		if (isRootStore(target)) switch (newStateToken.type) {
+			case `atom`:
+			case `mutable_atom`:
+				store.on.atomCreation.next(newStateToken);
+				break;
+			case `writable_pure_selector`:
+			case `readonly_pure_selector`:
+			case `writable_held_selector`:
+			case `readonly_held_selector`:
+				store.on.selectorCreation.next(newStateToken);
+				break;
+		}
+		else if (isChildStore(target) && target.on.transactionApplying.state === null) target.transactionMeta.update.subEvents.push({
+			type: `state_creation`,
+			token: newStateToken,
+			timestamp: Date.now()
+		});
+	}
+	if (molecule) target.moleculeData.set(stringKey, familyToken.key);
+	return newStateToken;
+}
+
+//#endregion
+//#region src/internal/set-state/operate-on-store.ts
+function operateOnStore(store, ownOp, ...params) {
+	let existingToken;
+	let brandNewToken;
+	let token;
+	let family;
+	let key;
+	let value;
+	if (params.length === 2) {
+		token = params[0];
+		value = params[1];
+		if (token.family) {
+			family = getFamilyOfToken(store, token);
+			key = parseJson(token.family.subKey);
+			existingToken = seekInStore(store, family, key);
+			if (!existingToken) {
+				brandNewToken = mintInStore(store, family, key);
+				token = brandNewToken;
+			} else token = existingToken;
+		}
+	} else {
+		family = params[0];
+		key = params[1];
+		value = params[2];
+		existingToken = seekInStore(store, family, key);
+		if (!existingToken) {
+			brandNewToken = mintInStore(store, family, key);
+			token = brandNewToken;
+		} else token = existingToken;
+	}
+	const action = value === RESET_STATE ? `reset` : `set`;
+	let target;
+	if (ownOp) {
+		const result = openOperation(store, token);
+		const rejected = typeof result === `number`;
+		if (rejected) {
+			const rejectionTime = result;
+			const unsubscribe = store.on.operationClose.subscribe(`waiting to ${action} "${token.key}" at T-${rejectionTime}`, function waitUntilOperationCloseToSetState() {
+				unsubscribe();
+				store.logger.info(`🟢`, token.type, token.key, `resuming deferred`, action, `from T-${rejectionTime}`);
+				operateOnStore(store, ownOp, token, value);
+			});
+			return;
+		}
+		target = result;
+	} else target = store;
+	if (`counterfeit` in token && `family` in token) {
+		const subKey = token.family.subKey;
+		const disposal = store.disposalTraces.buffer.find((item) => item?.key === subKey);
+		store.logger.error(`❌`, token.type, token.key, `could not be`, action, `because 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 state = withdraw(target, token);
+	let protoUpdate;
+	if (value === RESET_STATE) protoUpdate = resetAtomOrSelector(target, state);
+	else protoUpdate = setAtomOrSelector(target, state, value);
+	const isNewlyCreated = Boolean(brandNewToken);
+	dispatchOrDeferStateUpdate(target, state, protoUpdate, isNewlyCreated);
+	if (ownOp) closeOperation(target);
+}
+
+//#endregion
+//#region src/internal/keys.ts
+const isAtomKey = (store, key) => newest(store).atoms.has(key);
+const isSelectorKey = (store, key) => newest(store).writableSelectors.has(key);
+const isReadonlySelectorKey = (store, key) => newest(store).readonlySelectors.has(key);
+const isStateKey = (store, key) => isAtomKey(store, key) || isSelectorKey(store, key) || isReadonlySelectorKey(store, key);
+
+//#endregion
+//#region src/internal/selector/get-selector-dependency-keys.ts
+function getSelectorDependencyKeys(store, key) {
+	const sources = newest(store).selectorGraph.getRelationEntries({ downstreamSelectorKey: key }).filter(([_, { source }]) => source !== key).map(([_, { source }]) => source).filter((source) => isStateKey(store, source));
+	return sources;
+}
+
+//#endregion
+//#region src/internal/selector/trace-selector-atoms.ts
+function traceRootSelectorAtoms(store, selectorKey, covered = /* @__PURE__ */ new Set()) {
+	const dependencies = getSelectorDependencyKeys(store, selectorKey);
+	const roots = /* @__PURE__ */ new Map();
+	while (dependencies.length > 0) {
+		const dependencyKey = dependencies.pop();
+		if (covered.has(dependencyKey)) continue;
+		covered.add(dependencyKey);
+		if (isAtomKey(store, dependencyKey)) {
+			const atom = store.atoms.get(dependencyKey);
+			roots.set(atom.key, atom);
+		} else dependencies.push(...getSelectorDependencyKeys(store, dependencyKey));
+	}
+	return roots;
+}
+
+//#endregion
+//#region src/internal/selector/update-selector-atoms.ts
+function updateSelectorAtoms(store, selectorType, selectorKey, dependency, covered) {
+	const target = newest(store);
+	const { type: dependencyType, key: dependencyKey } = dependency;
+	if (dependencyType === `atom` || dependencyType === `mutable_atom`) {
+		target.selectorAtoms.set({
+			selectorKey,
+			atomKey: dependencyKey
+		});
+		store.logger.info(`🔍`, selectorType, selectorKey, `discovers root atom "${dependencyKey}"`);
+	} else {
+		const rootKeys = traceRootSelectorAtoms(store, dependencyKey, covered);
+		store.logger.info(`🔍`, selectorType, selectorKey, `discovers root atoms: [ ${[...rootKeys.values()].map((root) => `"${root.key}"`).join(`, `)} ]`);
+		for (const { key: atomKey } of rootKeys.values()) target.selectorAtoms = target.selectorAtoms.set({
+			selectorKey,
+			atomKey
+		});
+	}
+	covered.add(dependencyKey);
+}
+
+//#endregion
+//#region src/internal/selector/register-selector.ts
+function registerSelector(store, selectorType, selectorKey, covered) {
+	return {
+		get: (...params) => {
+			const target = newest(store);
+			let dependency;
+			if (params.length === 2) {
+				const [family, key] = params;
+				dependency = findInStore(store, family, key);
+			} else [dependency] = params;
+			const dependencyState = withdraw(store, dependency);
+			const dependencyValue = readOrComputeValue(store, dependencyState);
+			const dependencyKey = dependency.key;
+			store.logger.info(`🔌`, selectorType, selectorKey, `registers dependency ( "${dependencyKey}" =`, dependencyValue, `)`);
+			target.selectorGraph.set({
+				upstreamSelectorKey: dependencyKey,
+				downstreamSelectorKey: selectorKey
+			}, { source: dependency.key });
+			updateSelectorAtoms(store, selectorType, selectorKey, dependency, covered);
+			return dependencyValue;
+		},
+		set: ((...params) => {
+			const target = newest(store);
+			operateOnStore(target, false, ...params);
+		}),
+		find: ((...args) => findInStore(store, ...args)),
+		json: (token) => getJsonToken(store, token)
+	};
+}
+
+//#endregion
+//#region src/internal/selector/create-readonly-held-selector.ts
+function createReadonlyHeldSelector(store, options, family) {
+	const target = newest(store);
+	const subject = new Subject();
+	const covered = /* @__PURE__ */ new Set();
+	const { key, const: constant } = options;
+	const type = `readonly_held_selector`;
+	const { get, find, json } = registerSelector(target, type, key, covered);
+	const getFrom = (innerTarget) => {
+		const upstreamStates = innerTarget.selectorGraph.getRelationEntries({ downstreamSelectorKey: key });
+		for (const [downstreamSelectorKey, { source }] of upstreamStates) if (source !== key) innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
+		innerTarget.selectorAtoms.delete(key);
+		options.get({
+			get,
+			find,
+			json
+		}, constant);
+		writeToCache(innerTarget, readonlySelector, constant);
+		covered.clear();
+		return constant;
+	};
+	const readonlySelector = {
+		...options,
+		type,
+		subject,
+		getFrom,
+		install: (s) => createReadonlyHeldSelector(s, options, family)
+	};
+	if (family) readonlySelector.family = family;
+	target.readonlySelectors.set(key, readonlySelector);
+	store.logger.info(`✨`, type, key, `=`, constant);
+	const token = {
+		key,
+		type
+	};
+	if (family) token.family = family;
+	return token;
+}
+
+//#endregion
+//#region src/internal/selector/create-readonly-pure-selector.ts
+function createReadonlyPureSelector(store, options, family) {
+	const target = newest(store);
+	const subject = new Subject();
+	const covered = /* @__PURE__ */ new Set();
+	const key = options.key;
+	const type = `readonly_pure_selector`;
+	const { get, find, json } = registerSelector(target, type, key, covered);
+	const getFrom = () => {
+		const innerTarget = newest(store);
+		const upstreamStates = innerTarget.selectorGraph.getRelationEntries({ downstreamSelectorKey: key });
+		for (const [downstreamSelectorKey, { source }] of upstreamStates) if (source !== key) innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
+		innerTarget.selectorAtoms.delete(key);
+		const value = options.get({
+			get,
+			find,
+			json
+		});
+		const cached = writeToCache(innerTarget, readonlySelector, value);
+		store.logger.info(`✨`, type, key, `=`, cached);
+		covered.clear();
+		return cached;
+	};
+	const readonlySelector = {
+		...options,
+		type,
+		subject,
+		getFrom,
+		install: (s) => createReadonlyPureSelector(s, options, family)
+	};
+	if (family) readonlySelector.family = family;
+	target.readonlySelectors.set(key, readonlySelector);
+	const token = {
+		key,
+		type
+	};
+	if (family) token.family = family;
+	return token;
+}
+
 //#endregion
 //#region src/internal/selector/create-writable-held-selector.ts
-const createWritableHeldSelector = (store, options, family) => {
+function createWritableHeldSelector(store, options, family) {
 	const target = newest(store);
 	const subject = new Subject();
 	const covered = /* @__PURE__ */ new Set();
@@ -1528,38 +1613,28 @@ const createWritableHeldSelector = (store, options, family) => {
 		get,
 		json
 	};
-	const getSelf = (getFn = options.get, innerTarget = newest(store)) => {
+	const getFrom = (innerTarget) => {
 		const upstreamStates = innerTarget.selectorGraph.getRelationEntries({ downstreamSelectorKey: key });
 		for (const [downstreamSelectorKey, { source }] of upstreamStates) if (source !== key) innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
 		innerTarget.selectorAtoms.delete(key);
-		getFn(getterToolkit, constant);
+		options.get(getterToolkit, constant);
 		writeToCache(innerTarget, mySelector, constant);
 		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, `)`);
-		writeToCache(innerTarget, mySelector, newValue);
-		markDone(innerTarget, key);
-		if (isRootStore(innerTarget)) subject.next({
-			newValue,
-			oldValue
-		});
-		options.set(setterToolkit, newValue);
+	const setSelf = () => {
+		options.set(setterToolkit, constant);
 	};
 	const mySelector = {
 		...options,
 		type,
 		subject,
-		install: (s) => createWritableHeldSelector(s, options, family),
-		get: getSelf,
-		set: setSelf,
-		...family && { family }
+		getFrom,
+		setSelf,
+		install: (s) => createWritableHeldSelector(s, options, family)
 	};
+	if (family) mySelector.family = family;
 	target.writableSelectors.set(key, mySelector);
 	const token = {
 		key,
@@ -1567,11 +1642,11 @@ const createWritableHeldSelector = (store, options, family) => {
 	};
 	if (family) token.family = family;
 	return token;
-};
+}
 
 //#endregion
 //#region src/internal/selector/create-writable-pure-selector.ts
-const createWritablePureSelector = (store, options, family) => {
+function createWritablePureSelector(store, options, family) {
 	const target = newest(store);
 	const subject = new Subject();
 	const covered = /* @__PURE__ */ new Set();
@@ -1584,40 +1659,30 @@ const createWritablePureSelector = (store, options, family) => {
 		get,
 		json
 	};
-	const getSelf = (getFn = options.get, innerTarget = newest(store)) => {
+	const getFrom = (innerTarget) => {
 		const upstreamStates = innerTarget.selectorGraph.getRelationEntries({ downstreamSelectorKey: key });
 		for (const [downstreamSelectorKey, { source }] of upstreamStates) if (source !== key) innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
 		innerTarget.selectorAtoms.delete(key);
-		const value = getFn(getterToolkit);
+		const value = options.get(getterToolkit);
 		const cached = writeToCache(innerTarget, mySelector, value);
 		store.logger.info(`✨`, type, key, `=`, cached);
 		covered.clear();
 		return cached;
 	};
-	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, `)`);
-		writeToCache(innerTarget, mySelector, newValue);
-		markDone(innerTarget, options.key);
-		if (isRootStore(innerTarget)) subject.next({
-			newValue,
-			oldValue
-		});
+	const setSelf = (newValue) => {
 		options.set(setterToolkit, newValue);
 	};
 	const mySelector = {
 		...options,
 		type,
 		subject,
-		install: (s) => createWritablePureSelector(s, options, family),
-		get: getSelf,
-		set: setSelf,
-		...family && { family }
+		getFrom,
+		setSelf,
+		install: (s) => createWritablePureSelector(s, options, family)
 	};
+	if (family) mySelector.family = family;
 	target.writableSelectors.set(key, mySelector);
-	const initialValue = getSelf();
+	const initialValue = getFrom(target);
 	store.logger.info(`✨`, mySelector.type, mySelector.key, `=`, initialValue);
 	const token = {
 		key,
@@ -1625,7 +1690,7 @@ const createWritablePureSelector = (store, options, family) => {
 	};
 	if (family) token.family = family;
 	return token;
-};
+}
 
 //#endregion
 //#region src/internal/selector/create-standalone-selector.ts
@@ -1674,7 +1739,8 @@ function disposeSelector(store, selectorToken) {
 					family.subject.next({
 						type: `state_disposal`,
 						subType: `selector`,
-						token: selectorToken
+						token: selectorToken,
+						timestamp: Date.now()
 					});
 				}
 				break;
@@ -1689,7 +1755,8 @@ function disposeSelector(store, selectorToken) {
 					family.subject.next({
 						type: `state_disposal`,
 						subType: `selector`,
-						token: selectorToken
+						token: selectorToken,
+						timestamp: Date.now()
 					});
 				}
 				break;
@@ -1704,7 +1771,8 @@ function disposeSelector(store, selectorToken) {
 					family.subject.next({
 						type: `state_disposal`,
 						subType: `selector`,
-						token: selectorToken
+						token: selectorToken,
+						timestamp: Date.now()
 					});
 				}
 				break;
@@ -1719,7 +1787,8 @@ function disposeSelector(store, selectorToken) {
 					family.subject.next({
 						type: `state_disposal`,
 						subType: `selector`,
-						token: selectorToken
+						token: selectorToken,
+						timestamp: Date.now()
 					});
 				}
 				break;
@@ -1729,10 +1798,11 @@ function disposeSelector(store, selectorToken) {
 		target.selectorGraph.delete(key);
 		target.moleculeData.delete(familyMeta.key, familyMeta.subKey);
 		store.logger.info(`🔥`, selectorToken.type, key, `deleted`);
-		if (isChildStore(target) && target.transactionMeta.phase === `building`) target.transactionMeta.update.updates.push({
+		if (isChildStore(target) && target.transactionMeta.phase === `building`) target.transactionMeta.update.subEvents.push({
 			type: `state_disposal`,
 			subType: `selector`,
-			token: selectorToken
+			token: selectorToken,
+			timestamp: Date.now()
 		});
 		else store.on.selectorDisposal.next(selectorToken);
 	}
@@ -1764,7 +1834,8 @@ function createReadonlyPureSelectorFamily(store, options, internalRoles) {
 		}, family);
 		subject.next({
 			type: `state_creation`,
-			token
+			token,
+			timestamp: Date.now()
 		});
 		return token;
 	};
@@ -1812,17 +1883,19 @@ function createRegularAtomFamily(store, options, internalRoles) {
 		const token = createRegularAtom(target, individualOptions, family);
 		subject.next({
 			type: `state_creation`,
-			token
+			token,
+			timestamp: Date.now()
 		});
 		return token;
 	};
 	const atomFamily$1 = Object.assign(familyFunction, familyToken, {
+		default: options.default,
 		subject,
 		install: (s) => createRegularAtomFamily(s, options),
 		internalRoles
 	});
 	store.families.set(options.key, atomFamily$1);
-	store.defaults.set(options.key, options.default);
+	if (options.default instanceof Function === false) store.defaults.set(options.key, options.default);
 	return familyToken;
 }
 
@@ -1853,7 +1926,8 @@ function createReadonlyHeldSelectorFamily(store, options, internalRoles) {
 		}, family);
 		subject.next({
 			type: `state_creation`,
-			token
+			token,
+			timestamp: Date.now()
 		});
 		return token;
 	};
@@ -1895,7 +1969,8 @@ function createWritableHeldSelectorFamily(store, options, internalRoles) {
 		}, family);
 		subject.next({
 			type: `state_creation`,
-			token
+			token,
+			timestamp: Date.now()
 		});
 		return token;
 	};
@@ -1936,7 +2011,8 @@ function createWritablePureSelectorFamily(store, options, internalRoles) {
 		}, family);
 		subject.next({
 			type: `state_creation`,
-			token
+			token,
+			timestamp: Date.now()
 		});
 		return token;
 	};
@@ -1968,34 +2044,6 @@ function createSelectorFamily(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) {
@@ -2023,22 +2071,11 @@ function seekInStore(store, token, key) {
 
 //#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;
+function findInStore(store, familyToken, key) {
+	const existingStateToken = seekInStore(store, familyToken, key);
+	if (existingStateToken) return existingStateToken;
+	const newStateToken = mintInStore(store, familyToken, key);
+	return newStateToken;
 }
 
 //#endregion
@@ -2090,14 +2127,25 @@ function getFromStore(store, ...params) {
 		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 `mutable_atom_family`: {
+				if (store.defaults.has(family.key)) return store.defaults.get(family.key);
+				const mutableFamily = withdraw(store, family);
+				const defaultValue = new mutableFamily.class();
+				store.defaults.set(family.key, defaultValue);
+				return defaultValue;
+			}
+			case `atom_family`: {
+				if (store.defaults.has(family.key)) return store.defaults.get(token.family.key);
+				const defaultValue = withdraw(store, family).default(parseJson(subKey));
+				store.defaults.set(family.key, defaultValue);
+				return defaultValue;
+			}
 			case `readonly_pure_selector_family`:
 			case `writable_pure_selector_family`:
 			case `readonly_held_selector_family`:
 			case `writable_held_selector_family`: {
 				if (store.defaults.has(family.key)) return store.defaults.get(token.family.key);
-				const defaultValue = withdraw(store, family).default(subKey);
+				const defaultValue = withdraw(store, family).default(parseJson(subKey));
 				store.defaults.set(family.key, defaultValue);
 				return defaultValue;
 			}
@@ -2273,7 +2321,7 @@ var Tracker = class {
 	captureSignalsFromCore(mutableState, latestSignalState, target) {
 		const stateKey = mutableState.key;
 		const storeName = target.config.name;
-		const storeStatus = isChildStore(target) ? target.transactionMeta.update.key : `main`;
+		const storeStatus = isChildStore(target) ? target.transactionMeta.update.token.key : `main`;
 		const subscriptionKey = `tracker:${storeName}:${storeStatus}:${stateKey}`;
 		const trackerCapturesOutboundSignal = (update) => {
 			setIntoStore(target, latestSignalState, update);
@@ -2288,7 +2336,7 @@ var Tracker = class {
 		}.bind(this));
 	}
 	supplySignalsToCore(mutableState, latestSignalState, target) {
-		const subscriptionKey = `tracker:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.key : `main`}:${mutableState.key}`;
+		const subscriptionKey = `tracker:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.token.key : `main`}:${mutableState.key}`;
 		subscribeToState(target, latestSignalState, subscriptionKey, function trackerCapturesInboundSignal({ newValue, oldValue }) {
 			const timelineId = target.timelineTopics.getRelatedKey(latestSignalState.key);
 			if (timelineId && target.timelines.get(timelineId)?.timeTraveling) {
@@ -2452,11 +2500,13 @@ function createMutableAtomFamily(store, options, internalRoles) {
 		const token = createMutableAtom(target, individualOptions, family);
 		subject.next({
 			type: `state_creation`,
-			token
+			token,
+			timestamp: Date.now()
 		});
 		return token;
 	};
 	const atomFamily$1 = Object.assign(familyFunction, familyToken, {
+		class: options.class,
 		subject,
 		install: (s) => createMutableAtomFamily(s, options),
 		internalRoles
@@ -2531,7 +2581,7 @@ const getUpdateToken = (mutableAtomToken) => {
 //#endregion
 //#region src/internal/mutable/transceiver.ts
 function isTransceiver(value) {
-	return typeof value === `object` && value !== null && `do` in value && `undo` in value && `subscribe` in value;
+	return typeof value === `object` && value !== null && `do` in value && `undo` in value && `subscribe` in value && `cacheUpdateNumber` in value && `getUpdateNumber` in value && `READONLY_VIEW` in value && `toJSON` in value;
 }
 
 //#endregion
@@ -2723,17 +2773,17 @@ function disposeAtom(store, atomToken) {
 	else {
 		atom.cleanup?.();
 		const lastValue = store.valueMap.get(atom.key);
-		const atomFamily$1 = withdraw(store, {
-			key: family.key,
-			type: `atom_family`
-		});
+		const familyToken = getFamilyOfToken(store, atomToken);
+		const atomFamily$1 = withdraw(store, familyToken);
+		const subject = atomFamily$1.subject;
 		const disposal = {
 			type: `state_disposal`,
 			subType: `atom`,
 			token: atomToken,
-			value: lastValue
+			value: lastValue,
+			timestamp: Date.now()
 		};
-		atomFamily$1.subject.next(disposal);
+		subject.next(disposal);
 		const isChild = isChildStore(target);
 		target.atoms.delete(key);
 		target.valueMap.delete(key);
@@ -2748,14 +2798,22 @@ function disposeAtom(store, atomToken) {
 		}
 		store.logger.info(`🔥`, `atom`, key, `deleted`);
 		if (isChild && target.transactionMeta.phase === `building`) {
-			const mostRecentUpdate = target.transactionMeta.update.updates.at(-1);
+			const mostRecentUpdate = target.transactionMeta.update.subEvents.at(-1);
 			const wasMoleculeDisposal = mostRecentUpdate?.type === `molecule_disposal`;
 			const updateAlreadyCaptured = wasMoleculeDisposal && mostRecentUpdate.values.some(([k]) => k === atom.family?.key);
-			if (!updateAlreadyCaptured) target.transactionMeta.update.updates.push(disposal);
+			if (!updateAlreadyCaptured) target.transactionMeta.update.subEvents.push(disposal);
 		} else store.on.atomDisposal.next(atomToken);
 	}
 }
 
+//#endregion
+//#region src/internal/atom/has-role.ts
+const INTERNAL_ROLES = [`tracker:signal`];
+function hasRole(atom, role) {
+	if (`internalRoles` in atom === false) return false;
+	return atom.internalRoles.includes(role);
+}
+
 //#endregion
 //#region src/internal/install-into-store.ts
 /**
@@ -2769,12 +2827,12 @@ function disposeAtom(store, atomToken) {
 function installIntoStore(tokens, target, source) {
 	const sourceNewest = newest(source);
 	if (isChildStore(sourceNewest)) {
-		source.logger.error(`❌`, `transaction`, sourceNewest.transactionMeta.update.key, `could not install the following tokens into store "${target.config.name} from "${source.config.name}":`, tokens, `${sourceNewest.config.name} is undergoing a transaction.`);
+		source.logger.error(`❌`, `transaction`, sourceNewest.transactionMeta.update.token.key, `could not install the following tokens into store "${target.config.name} from "${source.config.name}":`, tokens, `${sourceNewest.config.name} is undergoing a transaction.`);
 		return;
 	}
 	const targetNewest = newest(target);
 	if (isChildStore(targetNewest)) {
-		target.logger.error(`❌`, `transaction`, targetNewest.transactionMeta.update.key, `could not install the following tokens into store "${target.config.name} from "${source.config.name}":`, tokens, `${targetNewest.config.name} is undergoing a transaction.`);
+		target.logger.error(`❌`, `transaction`, targetNewest.transactionMeta.update.token.key, `could not install the following tokens into store "${target.config.name} from "${source.config.name}":`, tokens, `${targetNewest.config.name} is undergoing a transaction.`);
 		return;
 	}
 	for (const token of tokens) {
@@ -3325,37 +3383,39 @@ function addAtomToTimeline(store, atomToken, tl) {
 	}, { topicType: `atom` });
 	tl.subscriptions.set(atom.key, atom.subject.subscribe(`timeline`, function timelineCapturesAtomUpdate(update) {
 		const target = newest(store);
-		const currentSelectorKey = store.operation.open && store.operation.token.type === `writable_pure_selector` ? store.operation.token.key : null;
-		const currentSelectorTime = store.operation.open && store.operation.token.type === `writable_pure_selector` ? store.operation.time : null;
+		const currentSelectorToken = store.operation.open && store.operation.token.type === `writable_pure_selector` ? store.operation.token : null;
+		const currentSelectorTime = store.operation.open && store.operation.token.type === `writable_pure_selector` ? store.operation.timestamp : null;
 		const txUpdateInProgress = target.on.transactionApplying.state?.update;
-		store.logger.info(`⏳`, `timeline`, tl.key, `atom`, atomToken.key, `went`, update.oldValue, `->`, update.newValue, txUpdateInProgress ? `in transaction "${txUpdateInProgress.key}"` : currentSelectorKey ? `in selector "${currentSelectorKey}"` : ``);
+		store.logger.info(`⏳`, `timeline`, tl.key, `atom`, atomToken.key, `went`, update.oldValue, `->`, update.newValue, txUpdateInProgress ? `in transaction "${txUpdateInProgress.token.key}"` : currentSelectorToken ? `in selector "${currentSelectorToken.key}"` : ``);
 		if (tl.timeTraveling === null) if (txUpdateInProgress) joinTransaction(store, tl, txUpdateInProgress);
-		else if (currentSelectorKey && currentSelectorTime) {
+		else if (currentSelectorToken && currentSelectorTime) {
 			let latestUpdate = tl.history.at(-1);
 			if (currentSelectorTime !== tl.selectorTime) {
 				latestUpdate = {
 					type: `selector_update`,
 					timestamp: currentSelectorTime,
-					key: currentSelectorKey,
+					token: currentSelectorToken,
 					atomUpdates: []
 				};
 				latestUpdate.atomUpdates.push({
-					key: atom.key,
 					type: `atom_update`,
-					...update
+					token: atomToken,
+					update,
+					timestamp: Date.now()
 				});
 				if (tl.at !== tl.history.length) tl.history.splice(tl.at);
 				tl.history.push(latestUpdate);
-				store.logger.info(`⌛`, `timeline`, tl.key, `got a selector_update "${currentSelectorKey}" with`, latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key));
+				store.logger.info(`⌛`, `timeline`, tl.key, `got a selector_update "${currentSelectorToken.key}" with`, latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.token.key));
 				tl.at = tl.history.length;
 				tl.selectorTime = currentSelectorTime;
 			} else if (latestUpdate?.type === `selector_update`) {
 				latestUpdate.atomUpdates.push({
-					key: atom.key,
 					type: `atom_update`,
-					...update
+					token: atomToken,
+					update,
+					timestamp: Date.now()
 				});
-				store.logger.info(`⌛`, `timeline`, tl.key, `set selector_update "${currentSelectorKey}" to`, latestUpdate?.atomUpdates.map((atomUpdate) => atomUpdate.key));
+				store.logger.info(`⌛`, `timeline`, tl.key, `set selector_update "${currentSelectorToken.key}" to`, latestUpdate?.atomUpdates.map((atomUpdate) => atomUpdate.token.key));
 			}
 			if (latestUpdate) {
 				const willCaptureSelectorUpdate = tl.shouldCapture?.(latestUpdate, tl) ?? true;
@@ -3371,12 +3431,10 @@ function addAtomToTimeline(store, atomToken, tl) {
 			if (tl.at !== tl.history.length) tl.history.splice(tl.at);
 			const atomUpdate = {
 				type: `atom_update`,
-				timestamp,
-				key: atom.key,
-				oldValue: update.oldValue,
-				newValue: update.newValue
+				token: deposit(atom),
+				update,
+				timestamp
 			};
-			if (atom.family) atomUpdate.family = atom.family;
 			const willCapture = tl.shouldCapture?.(atomUpdate, tl) ?? true;
 			store.logger.info(`⌛`, `timeline`, tl.key, `got an atom_update to "${atom.key}"`);
 			if (willCapture) {
@@ -3399,7 +3457,7 @@ function addAtomFamilyToTimeline(store, atomFamilyToken, tl) {
 	for (const atom of store.atoms.values()) if (atom.family?.key === family.key) addAtomToTimeline(store, atom, tl);
 }
 function joinTransaction(store, tl, txUpdateInProgress) {
-	const currentTxKey = txUpdateInProgress.key;
+	const currentTxKey = txUpdateInProgress.token.key;
 	const currentTxInstanceId = txUpdateInProgress.id;
 	const currentTxToken = {
 		key: currentTxKey,
@@ -3414,11 +3472,10 @@ function joinTransaction(store, tl, txUpdateInProgress) {
 			if (tl.timeTraveling === null && currentTxInstanceId) {
 				if (tl.at !== tl.history.length) tl.history.splice(tl.at);
 				const timelineTopics = store.timelineTopics.getRelatedKeys(tl.key);
-				const updates = filterTransactionUpdates(transactionUpdate.updates, timelineTopics);
+				const subEventsFiltered = filterTransactionSubEvents(transactionUpdate.subEvents, timelineTopics);
 				const timelineTransactionUpdate = {
-					timestamp: Date.now(),
 					...transactionUpdate,
-					updates
+					subEvents: subEventsFiltered
 				};
 				const willCapture = tl.shouldCapture?.(timelineTransactionUpdate, tl) ?? true;
 				if (willCapture) {
@@ -3430,12 +3487,13 @@ function joinTransaction(store, tl, txUpdateInProgress) {
 		});
 	}
 }
-function filterTransactionUpdates(updates, timelineTopics) {
+function filterTransactionSubEvents(updates, timelineTopics) {
 	return updates.filter((updateFromTx) => {
-		if (updateFromTx.type === `transaction_update`) return true;
+		if (updateFromTx.type === `transaction_outcome`) return true;
 		let key;
 		let familyKey;
 		switch (updateFromTx.type) {
+			case `atom_update`:
 			case `state_creation`:
 			case `state_disposal`:
 				key = updateFromTx.token.key;
@@ -3444,35 +3502,28 @@ function filterTransactionUpdates(updates, timelineTopics) {
 			case `molecule_creation`:
 			case `molecule_disposal`:
 			case `molecule_transfer`: return true;
-			case `atom_update`:
-			case `selector_update`:
-				key = updateFromTx.key;
-				familyKey = updateFromTx.family?.key;
-				break;
 		}
 		timelineTopics.has(key);
 		if (familyKey && timelineTopics.has(familyKey)) return true;
 		return timelineTopics.has(key);
 	}).map((updateFromTx) => {
-		if (`updates` in updateFromTx) return {
+		if (`subEvents` in updateFromTx) return {
 			...updateFromTx,
-			updates: filterTransactionUpdates(updateFromTx.updates, timelineTopics)
+			subEvents: filterTransactionSubEvents(updateFromTx.subEvents, timelineTopics)
 		};
 		return updateFromTx;
 	});
 }
 function handleStateLifecycleEvent(store, event, tl) {
-	const timestamp = Date.now();
-	const timelineEvent = Object.assign(event, { timestamp });
 	if (!tl.timeTraveling) {
 		const target = newest(store);
 		if (isChildStore(target)) {} else {
 			const txUpdateInProgress = target.on.transactionApplying.state;
 			if (txUpdateInProgress) joinTransaction(store, tl, txUpdateInProgress.update);
 			else {
-				tl.history.push(timelineEvent);
+				tl.history.push(event);
 				tl.at = tl.history.length;
-				tl.subject.next(timelineEvent);
+				tl.subject.next(event);
 			}
 		}
 	}
@@ -3511,7 +3562,7 @@ const timeTravel = (store, action, token) => {
 		case `selector_update`:
 			ingestSelectorUpdate(applying, update, store);
 			break;
-		case `transaction_update`:
+		case `transaction_outcome`:
 			ingestTransactionUpdate(applying, update, store);
 			break;
 		case `state_creation`: