atom.io 0.39.1 → 0.40.1

package/dist/internal/index.js

@@ -13,6 +13,10 @@ function newest(scion) {
 	while (scion.child !== null) scion = scion.child;
 	return scion;
 }
+function eldest(scion) {
+	while (scion.parent !== null) scion = scion.parent;
+	return scion;
+}
 
 //#endregion
 //#region src/internal/store/circular-buffer.ts
@@ -663,7 +667,8 @@ function openOperation(store, token) {
 		done: /* @__PURE__ */ new Set(),
 		prev: /* @__PURE__ */ new Map(),
 		timestamp: Date.now(),
-		token
+		token,
+		subEvents: []
 	};
 	store.logger.info(`⭕`, token.type, token.key, `operation start in store "${store.config.name}"${isChildStore(store) ? ` ${store.transactionMeta.phase} "${store.transactionMeta.update.token.key}"` : ``}`);
 	return store;
@@ -871,31 +876,17 @@ function mintInStore(store, family, key, mustCreate) {
 
 //#endregion
 //#region src/internal/transaction/abort-transaction.ts
-const abortTransaction = (store) => {
-	const target = newest(store);
-	if (!isChildStore(target)) {
-		store.logger.warn(`🐞`, `transaction`, `???`, `abortTransaction called outside of a transaction. This is probably a bug in AtomIO.`);
-		return;
-	}
-	store.logger.info(`🪂`, `transaction`, target.transactionMeta.update.token.key, `Aborting transaction`);
+const abortTransaction = (target) => {
+	target.logger.info(`🪂`, `transaction`, target.transactionMeta.update.token.key, `Aborting transaction`);
 	target.parent.child = null;
 };
 
-//#endregion
-//#region src/internal/not-found-error.ts
-var NotFoundError = class extends Error {
-	constructor(token, store) {
-		super(`${PRETTY_TOKEN_TYPES[token.type]} ${stringifyJson(token.key)} not found in store "${store.config.name}".`);
-	}
-};
-
 //#endregion
 //#region src/internal/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);
+		return tx.run(parameters, id);
 	};
 }
 
@@ -970,17 +961,8 @@ function setIntoStore(store, ...params) {
 //#region src/internal/set-state/reset-in-store.ts
 const RESET_STATE = Symbol(`RESET`);
 function resetInStore(store, ...params) {
-	let token;
-	let family;
-	let key;
-	if (params.length === 1) {
-		token = params[0];
-		setIntoStore(store, token, RESET_STATE);
-	} else {
-		family = params[0];
-		key = params[1];
-		setIntoStore(store, family, key, RESET_STATE);
-	}
+	const subParams = [...params, RESET_STATE];
+	setIntoStore(store, ...subParams);
 }
 
 //#endregion
@@ -1098,25 +1080,42 @@ function fuseWithinStore(store, type, sideA, sideB) {
 	allocateIntoStore(store, above, compoundKey, `all`);
 	return compoundKey;
 }
-function deallocateFromStore(store, claim) {
+function createDeallocateTX(store) {
+	return createTransaction(store, {
+		key: `[Internal] deallocate`,
+		do: (_, claim) => {
+			deallocateFromStore(newest(store), claim);
+		}
+	});
+}
+function deallocateFromStore(target, claim) {
 	const stringKey = stringifyJson(claim);
-	const molecule = store.molecules.get(stringKey);
+	const molecule = target.molecules.get(stringKey);
 	if (!molecule) {
-		const disposal = store.disposalTraces.buffer.find((item) => item?.key === stringKey);
-		store.logger.error(`❌`, `key`, claim, `deallocation failed:`, `Could not find allocation for ${stringKey} in store "${store.config.name}".`, disposal ? `\n   This state was most recently deallocated\n${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`);
+		const disposal = target.disposalTraces.buffer.find((item) => item?.key === stringKey);
+		target.logger.error(`❌`, `key`, claim, `deallocation failed:`, `Could not find allocation for ${stringKey} in store "${target.config.name}".`, disposal ? `\n   This state was most recently deallocated\n${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`);
 		return;
 	}
-	const joinKeys = store.moleculeJoins.getRelatedKeys(molecule.key);
+	const joinKeys = target.moleculeJoins.getRelatedKeys(stringKey);
 	if (joinKeys) for (const joinKey of joinKeys) {
-		const join$1 = store.joins.get(joinKey);
-		if (join$1) {
-			join$1.relations.delete(molecule.key);
-			join$1.molecules.delete(molecule.stringKey);
-		}
+		const join$1 = target.joins.get(joinKey);
+		if (join$1) join$1.relations.delete(claim);
 	}
-	store.moleculeJoins.delete(molecule.stringKey);
+	target.moleculeJoins.delete(stringKey);
 	const provenance = [];
 	const values = [];
+	const relatedMolecules = target.moleculeGraph.getRelationEntries({ downstreamMoleculeKey: stringKey });
+	if (relatedMolecules) for (const [relatedStringKey, { source }] of relatedMolecules) if (source === stringKey) {
+		const relatedKey = parseJson(relatedStringKey);
+		deallocateFromStore(target, relatedKey);
+	} else provenance.push(source);
+	const familyKeys = target.moleculeData.getRelatedKeys(molecule.stringKey);
+	if (familyKeys) for (const familyKey of familyKeys) {
+		const family = target.families.get(familyKey);
+		const value = getFromStore(target, family, claim);
+		values.push([family.key, value]);
+		disposeFromStore(target, family, claim);
+	}
 	const disposalEvent = {
 		type: `molecule_disposal`,
 		key: molecule.key,
@@ -1124,34 +1123,28 @@ function deallocateFromStore(store, claim) {
 		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.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);
-		deallocateFromStore(store, relatedKey);
-	} else provenance.push(source);
-	const familyKeys = target.moleculeData.getRelatedKeys(molecule.stringKey);
-	if (familyKeys) for (const familyKey of familyKeys) {
-		const family = target.families.get(familyKey);
-		const token = findInStore(store, family, molecule.key);
-		const value = getFromStore(store, token);
-		values.push([family.key, value]);
-		disposeFromStore(store, token);
-	}
 	target.moleculeGraph.delete(molecule.stringKey);
 	target.moleculeJoins.delete(molecule.stringKey);
 	target.moleculeData.delete(molecule.stringKey);
 	if (!isTransaction) target.on.moleculeDisposal.next(disposalEvent);
 	target.molecules.delete(molecule.stringKey);
 	const trace = getTrace(/* @__PURE__ */ new Error());
-	store.disposalTraces.add({
+	target.disposalTraces.add({
 		key: stringKey,
 		trace
 	});
 }
+function createClaimTX(store) {
+	return createTransaction(store, {
+		key: `[Internal] claim`,
+		do: (_, newProvenance, claim, exclusive) => {
+			claimWithinStore(store, newProvenance, claim, exclusive);
+		}
+	});
+}
 function claimWithinStore(store, newProvenance, claim, exclusive) {
 	const stringKey = stringifyJson(claim);
 	const target = newest(store);
@@ -1267,9 +1260,10 @@ function ingestMoleculeTransferEvent(store, event, applying) {
 //#region src/internal/events/ingest-selector-update.ts
 function ingestSelectorUpdateEvent(store, selectorUpdate, applying) {
 	let updates;
-	if (applying === `newValue`) updates = selectorUpdate.atomUpdates;
-	else updates = selectorUpdate.atomUpdates.toReversed();
-	for (const atomUpdate of updates) ingestAtomUpdateEvent(store, atomUpdate, applying);
+	if (applying === `newValue`) updates = selectorUpdate.subEvents;
+	else updates = selectorUpdate.subEvents.toReversed();
+	for (const atomUpdate of updates) if (atomUpdate.type === `state_creation`) ingestCreationEvent(store, atomUpdate, applying);
+	else ingestAtomUpdateEvent(store, atomUpdate, applying);
 }
 
 //#endregion
@@ -1312,8 +1306,6 @@ function getEpochNumberOfContinuity(store, continuityKey) {
 	return epoch;
 }
 function getEpochNumberOfAction(store, transactionKey) {
-	const isRoot = isRootStore(store);
-	if (!isRoot) return void 0;
 	const continuityKey = getContinuityKey(store, transactionKey);
 	if (continuityKey === void 0) return void 0;
 	return getEpochNumberOfContinuity(store, continuityKey);
@@ -1322,12 +1314,9 @@ function getEpochNumberOfAction(store, transactionKey) {
 //#endregion
 //#region src/internal/transaction/set-epoch-number.ts
 function setEpochNumberOfContinuity(store, continuityKey, newEpoch) {
-	const isRoot = isRootStore(store);
-	if (isRoot && continuityKey) store.transactionMeta.epoch.set(continuityKey, newEpoch);
+	store.transactionMeta.epoch.set(continuityKey, newEpoch);
 }
 function setEpochNumberOfAction(store, transactionKey, newEpoch) {
-	const isRoot = isRootStore(store);
-	if (!isRoot) return;
 	const continuityKey = getContinuityKey(store, transactionKey);
 	if (continuityKey !== void 0) store.transactionMeta.epoch.set(continuityKey, newEpoch);
 }
@@ -1337,16 +1326,12 @@ function setEpochNumberOfAction(store, transactionKey, newEpoch) {
 function applyTransaction(store, output) {
 	const child = newest(store);
 	const { parent } = child;
-	if (parent === null || !isChildStore(child) || child.transactionMeta?.phase !== `building`) {
-		store.logger.warn(`🐞`, `transaction`, `???`, `applyTransaction called outside of a transaction. This is probably a bug in AtomIO.`);
-		return;
-	}
 	child.transactionMeta.phase = `applying`;
 	child.transactionMeta.update.output = output;
 	parent.child = null;
 	parent.on.transactionApplying.next(child.transactionMeta);
 	const { subEvents: updates } = child.transactionMeta.update;
-	store.logger.info(`🛄`, `transaction`, child.transactionMeta.update.token.key, `Applying transaction with ${updates.length} updates:`, updates);
+	store.logger.info(`🛄`, `transaction`, child.transactionMeta.update.token.key, `applying ${updates.length} subEvents:`, updates);
 	ingestTransactionOutcomeEvent(parent, child.transactionMeta.update, `newValue`);
 	if (isRootStore(parent)) {
 		setEpochNumberOfAction(parent, child.transactionMeta.update.token.key, child.transactionMeta.update.epoch);
@@ -1355,7 +1340,7 @@ function applyTransaction(store, output) {
 			type: `transaction`
 		});
 		myTransaction?.subject.next(child.transactionMeta.update);
-		store.logger.info(`🛬`, `transaction`, child.transactionMeta.update.token.key, `Finished applying transaction.`);
+		store.logger.info(`🛬`, `transaction`, child.transactionMeta.update.token.key, `applied`);
 	} else if (isChildStore(parent)) parent.transactionMeta.update.subEvents.push(child.transactionMeta.update);
 	parent.on.transactionApplying.next(null);
 }
@@ -1363,8 +1348,6 @@ function applyTransaction(store, output) {
 //#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);
@@ -1441,7 +1424,7 @@ const buildTransaction = (store, token, params, id) => {
 	};
 	const child = Object.assign(childBase, { transactionMeta });
 	parent.child = child;
-	store.logger.info(`🛫`, `transaction`, token.key, `Building transaction with params:`, params);
+	store.logger.info(`🛫`, `transaction`, token.key, `building with params:`, params);
 	return child;
 };
 
@@ -1455,15 +1438,14 @@ function createTransaction(store, options) {
 		type: `transaction`,
 		run: (params, id) => {
 			const token$1 = deposit(newTransaction);
-			const childStore = buildTransaction(store, token$1, params, id);
+			const target$1 = buildTransaction(store, token$1, params, id);
 			try {
-				const target$1 = newest(store);
-				const { toolkit } = childStore.transactionMeta;
+				const { toolkit } = target$1.transactionMeta;
 				const output = options.do(toolkit, ...params);
 				applyTransaction(target$1, output);
 				return output;
 			} catch (thrown) {
-				abortTransaction(target);
+				abortTransaction(target$1);
 				store.logger.warn(`💥`, `transaction`, key, `caught:`, thrown);
 				throw thrown;
 			}
@@ -1493,12 +1475,14 @@ function dispatchOrDeferStateUpdate(target, state, { oldValue, newValue }, state
 	if (stateIsNewlyCreated && family) {
 		state.subject.next({ newValue });
 		const stateCreationEvent = {
+			checkpoint: true,
 			type: `state_creation`,
 			subType: `writable`,
 			token,
 			timestamp: Date.now(),
 			value: newValue
 		};
+		target.operation.subEvents.push(stateCreationEvent);
 		const familySubject = family.subject;
 		familySubject.next(stateCreationEvent);
 		const innerTarget = newest(target);
@@ -1525,11 +1509,11 @@ function dispatchOrDeferStateUpdate(target, state, { oldValue, newValue }, state
 	if (isRootStore(target)) {
 		switch (type) {
 			case `mutable_atom`:
-				target.logger.info(`📢`, type, key, `is now (`, newValue, `) subscribers:`, subject.subscribers);
+				target.logger.info(`📢`, type, key, `is now (`, newValue, `) subscribers:`, subject.subscribers.keys());
 				break;
 			case `atom`:
 			case `writable_pure_selector`:
-			case `writable_held_selector`: target.logger.info(`📢`, type, key, `went (`, oldValue, `->`, newValue, `) subscribers:`, subject.subscribers);
+			case `writable_held_selector`: target.logger.info(`📢`, type, key, `went (`, oldValue, `->`, newValue, `) subscribers:`, subject.subscribers.keys());
 		}
 		subject.next(update);
 	}
@@ -2308,9 +2292,22 @@ function reduceReference(store, ...params) {
 	const isCounterfeit = `counterfeit` in token;
 	const isNewlyCreated = Boolean(brandNewToken) && isCounterfeit === false;
 	if (isNewlyCreated && family) {
+		let subType;
+		switch (token.type) {
+			case `readonly_pure_selector`:
+			case `readonly_held_selector`:
+				subType = `readable`;
+				break;
+			case `atom`:
+			case `mutable_atom`:
+			case `writable_pure_selector`:
+			case `writable_held_selector`:
+				subType = `writable`;
+				break;
+		}
 		const stateCreationEvent = {
 			type: `state_creation`,
-			subType: `readable`,
+			subType,
 			token,
 			timestamp: Date.now()
 		};
@@ -2968,14 +2965,14 @@ function disposeAtom(store, atomToken) {
 		const familyToken = getFamilyOfToken(store, atomToken);
 		const atomFamily$1 = withdraw(store, familyToken);
 		const subject = atomFamily$1.subject;
-		const disposal = {
+		const disposalEvent = {
 			type: `state_disposal`,
 			subType: `atom`,
 			token: atomToken,
 			value: lastValue,
 			timestamp: Date.now()
 		};
-		subject.next(disposal);
+		subject.next(disposalEvent);
 		const isChild = isChildStore(target);
 		target.atoms.delete(key);
 		target.valueMap.delete(key);
@@ -2993,7 +2990,8 @@ function disposeAtom(store, atomToken) {
 			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.subEvents.push(disposal);
+			const isTracker = hasRole(atom, `tracker:signal`);
+			if (!updateAlreadyCaptured && !isTracker) target.transactionMeta.update.subEvents.push(disposalEvent);
 		} else store.on.atomDisposal.next(atomToken);
 	}
 }
@@ -3045,7 +3043,6 @@ var Join = class {
 	toolkit;
 	options;
 	defaultContent;
-	molecules = /* @__PURE__ */ new Map();
 	relations;
 	states;
 	core;
@@ -3095,6 +3092,9 @@ var Join = class {
 				bKeys.delete(a);
 				return bKeys;
 			});
+			const [x, y] = [a, b].sort();
+			const compositeKey = `${x}:${y}`;
+			this.store.moleculeJoins.delete(compositeKey);
 		};
 		const replaceRelationsSafely = (toolkit, a, newRelationsOfA) => {
 			const { find, get, set } = toolkit;
@@ -3124,9 +3124,9 @@ var Join = class {
 							}
 							if (!newRelationBIsAlreadyRelated && relationsOfB.size > 0) relationsOfB.clear();
 							for (const previousOwner of previousOwnersToDispose) {
-								const sorted = [newRelationB, previousOwner].sort();
-								const compositeKey = `"${sorted[0]}:${sorted[1]}"`;
-								this.molecules.delete(compositeKey);
+								const [x, y] = [newRelationB, previousOwner].sort();
+								const compositeKey = `${x}:${y}`;
+								store.moleculeJoins.delete(compositeKey);
 							}
 						}
 						if (!newRelationBIsAlreadyRelated) relationsOfB.add(a);
@@ -3159,8 +3159,8 @@ var Join = class {
 		const baseExternalStoreConfiguration = {
 			getRelatedKeys: (key) => getRelatedKeys(this.toolkit, key),
 			addRelation: (a, b) => {
-				this.store.moleculeJoins.set(a, options.key);
-				this.store.moleculeJoins.set(b, options.key);
+				this.store.moleculeJoins.set(`"${a}"`, options.key);
+				this.store.moleculeJoins.set(`"${b}"`, options.key);
 				addRelation(this.toolkit, a, b);
 			},
 			deleteRelation: (a, b) => {
@@ -3193,9 +3193,7 @@ var Join = class {
 				setContent: (contentKey, content) => {
 					setContent(this.toolkit, contentKey, content);
 				},
-				deleteContent: (contentKey) => {
-					this.realm.deallocate(contentKey);
-				}
+				deleteContent: (_) => {}
 			};
 			externalStore = Object.assign(baseExternalStoreConfiguration, externalStoreWithContentConfiguration);
 		} else externalStore = baseExternalStoreConfiguration;
@@ -3205,8 +3203,8 @@ var Join = class {
 			isBType: options.isBType,
 			makeContentKey: (...args) => {
 				const [a, b] = args;
-				const sorted = args.sort();
-				const compositeKey = `${sorted[0]}:${sorted[1]}`;
+				const [x, y] = args.sort();
+				const compositeKey = `${x}:${y}`;
 				const aMolecule = store.molecules.get(stringifyJson(a));
 				const bMolecule = store.molecules.get(stringifyJson(b));
 				if (!aMolecule) this.realm.allocate(options.key, a);
@@ -3364,7 +3362,8 @@ function getJoin(token, store) {
 		const rootJoinMap = IMPLICIT.STORE.joins;
 		const rootJoin = rootJoinMap.get(token.key);
 		if (rootJoin === void 0) throw new Error(`Join "${token.key}" not found in store "${store.config.name}"`);
-		myJoin = new Join(rootJoin.options, rootJoin.defaultContent, store);
+		const root = eldest(store);
+		myJoin = new Join(rootJoin.options, rootJoin.defaultContent, root);
 		store.joins.set(token.key, myJoin);
 	}
 	return myJoin;
@@ -3499,6 +3498,14 @@ function getInternalRelationsFromStore(token, store) {
 	return family;
 }
 
+//#endregion
+//#region src/internal/not-found-error.ts
+var NotFoundError = class extends Error {
+	constructor(token, store) {
+		super(`${PRETTY_TOKEN_TYPES[token.type]} ${stringifyJson(token.key)} not found in store "${store.config.name}".`);
+	}
+};
+
 //#endregion
 //#region src/internal/reserved-keys.ts
 function isReservedIntrospectionKey(value) {
@@ -3521,7 +3528,6 @@ function createTimeline(store, options, data) {
 		subject: new Subject(),
 		subscriptions: /* @__PURE__ */ new Map()
 	};
-	if (options.shouldCapture) tl.shouldCapture = options.shouldCapture;
 	const timelineKey = options.key;
 	const target = newest(store);
 	for (const initialTopic of options.scope) switch (initialTopic.type) {
@@ -3587,60 +3593,19 @@ function addAtomToTimeline(store, atomToken, tl) {
 		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.token.key}"` : currentSelectorToken ? `in selector "${currentSelectorToken.key}"` : ``);
 		if (tl.timeTraveling === null) if (txUpdateInProgress) joinTransaction(store, tl, txUpdateInProgress);
-		else if (currentSelectorToken && currentSelectorTime) {
-			let latestUpdate = tl.history.at(-1);
-			if (currentSelectorTime !== tl.selectorTime) {
-				latestUpdate = {
-					type: `selector_update`,
-					timestamp: currentSelectorTime,
-					token: currentSelectorToken,
-					atomUpdates: []
-				};
-				latestUpdate.atomUpdates.push({
-					type: `atom_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 "${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({
-					type: `atom_update`,
-					token: atomToken,
-					update,
-					timestamp: Date.now()
-				});
-				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;
-				if (willCaptureSelectorUpdate) tl.subject.next(latestUpdate);
-				else {
-					tl.history.pop();
-					tl.at = tl.history.length;
-				}
-			}
-		} else {
+		else if (currentSelectorToken && currentSelectorTime) buildSelectorUpdate(store, tl, atomToken, update, currentSelectorToken, currentSelectorTime);
+		else {
 			const timestamp = Date.now();
 			tl.selectorTime = null;
-			if (tl.at !== tl.history.length) tl.history.splice(tl.at);
 			const atomUpdate = {
+				checkpoint: true,
 				type: `atom_update`,
 				token: deposit(atom),
 				update,
 				timestamp
 			};
-			const willCapture = tl.shouldCapture?.(atomUpdate, tl) ?? true;
 			store.logger.info(`⌛`, `timeline`, tl.key, `got an atom_update to "${atom.key}"`);
-			if (willCapture) {
-				tl.history.push(atomUpdate);
-				tl.at = tl.history.length;
-				tl.subject.next(atomUpdate);
-			}
+			addToHistory(tl, atomUpdate);
 		}
 	}));
 }
@@ -3669,23 +3634,55 @@ function joinTransaction(store, tl, txUpdateInProgress) {
 			unsubscribe();
 			tl.transactionKey = null;
 			if (tl.timeTraveling === null && currentTxInstanceId) {
-				if (tl.at !== tl.history.length) tl.history.splice(tl.at);
 				const timelineTopics = store.timelineTopics.getRelatedKeys(tl.key);
 				const subEventsFiltered = filterTransactionSubEvents(transactionUpdate.subEvents, timelineTopics);
 				const timelineTransactionUpdate = {
+					checkpoint: true,
 					...transactionUpdate,
 					subEvents: subEventsFiltered
 				};
-				const willCapture = tl.shouldCapture?.(timelineTransactionUpdate, tl) ?? true;
-				if (willCapture) {
-					tl.history.push(timelineTransactionUpdate);
-					tl.at = tl.history.length;
-					tl.subject.next(timelineTransactionUpdate);
-				}
+				addToHistory(tl, timelineTransactionUpdate);
 			}
 		});
 	}
 }
+function buildSelectorUpdate(store, tl, atomToken, eventOrUpdate, currentSelectorToken, currentSelectorTime) {
+	let latestUpdate = tl.history.at(-1);
+	if (currentSelectorTime !== tl.selectorTime) {
+		const selectorUpdate = latestUpdate = {
+			checkpoint: true,
+			type: `selector_update`,
+			timestamp: currentSelectorTime,
+			token: currentSelectorToken,
+			subEvents: []
+		};
+		if (`type` in eventOrUpdate) latestUpdate.subEvents.push(eventOrUpdate);
+		else latestUpdate.subEvents.push({
+			type: `atom_update`,
+			token: atomToken,
+			update: eventOrUpdate,
+			timestamp: Date.now()
+		});
+		addToHistory(tl, latestUpdate);
+		tl.selectorTime = currentSelectorTime;
+		store.logger.info(`⌛`, `timeline`, tl.key, `got a selector_update "${currentSelectorToken.key}" with`, latestUpdate.subEvents.map((event) => event.token.key));
+		const operation = store.operation;
+		const unsub = store.on.operationClose.subscribe(`timeline:${tl.key} (needs to gather nested selector creations)`, () => {
+			unsub();
+			if (operation.open) selectorUpdate.subEvents = [...operation.subEvents, ...selectorUpdate.subEvents];
+		});
+	} else if (latestUpdate?.type === `selector_update`) {
+		if (`type` in eventOrUpdate) latestUpdate.subEvents.push(eventOrUpdate);
+		else latestUpdate.subEvents.push({
+			type: `atom_update`,
+			token: atomToken,
+			update: eventOrUpdate,
+			timestamp: Date.now()
+		});
+		store.logger.info(`⌛`, `timeline`, tl.key, `set selector_update "${currentSelectorToken.key}" to`, latestUpdate?.subEvents.map((event) => event.token.key));
+	}
+	if (latestUpdate) tl.subject.next(latestUpdate);
+}
 function filterTransactionSubEvents(updates, timelineTopics) {
 	return updates.filter((updateFromTx) => {
 		if (updateFromTx.type === `transaction_outcome`) return true;
@@ -3714,16 +3711,15 @@ function filterTransactionSubEvents(updates, timelineTopics) {
 	});
 }
 function handleStateLifecycleEvent(store, event, tl) {
+	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;
 	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(event);
-				tl.at = tl.history.length;
-				tl.subject.next(event);
-			}
+			else if (currentSelectorToken && currentSelectorTime && event.type === `state_creation`) buildSelectorUpdate(store, tl, event.token, event, currentSelectorToken, currentSelectorTime);
+			else addToHistory(tl, event);
 		}
 	}
 	switch (event.type) {
@@ -3736,6 +3732,12 @@ function handleStateLifecycleEvent(store, event, tl) {
 			break;
 	}
 }
+function addToHistory(tl, event) {
+	if (tl.at !== tl.history.length) tl.history.splice(tl.at);
+	tl.history.push(event);
+	tl.at = tl.history.length;
+	tl.subject.next(event);
+}
 
 //#endregion
 //#region src/internal/timeline/time-travel.ts
@@ -3751,10 +3753,21 @@ const timeTravel = (store, action, token) => {
 		return;
 	}
 	timelineData.timeTraveling = action === `redo` ? `into_future` : `into_past`;
-	if (action === `undo`) --timelineData.at;
-	const event = timelineData.history[timelineData.at];
+	let nextIndex = timelineData.at;
+	let events;
+	switch (action) {
+		case `undo`:
+			--nextIndex;
+			while (nextIndex !== 0 && timelineData.history[nextIndex].checkpoint !== true) --nextIndex;
+			events = timelineData.history.slice(nextIndex, timelineData.at).reverse();
+			break;
+		case `redo`:
+			++nextIndex;
+			events = timelineData.history.slice(timelineData.at, nextIndex);
+	}
+	timelineData.at = nextIndex;
 	const applying = action === `redo` ? `newValue` : `oldValue`;
-	switch (event.type) {
+	for (const event of events) switch (event.type) {
 		case `atom_update`:
 			ingestAtomUpdateEvent(store, event, applying);
 			break;
@@ -3770,15 +3783,12 @@ const timeTravel = (store, action, token) => {
 		case `state_disposal`:
 			ingestDisposalEvent(store, event, applying);
 			break;
-		case `molecule_creation`:
-		case `molecule_disposal`:
 	}
-	if (action === `redo`) ++timelineData.at;
 	timelineData.subject.next(action);
 	timelineData.timeTraveling = null;
-	store.logger.info(`⏹️`, `timeline`, token.key, `"${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`);
+	store.logger.info(`⏸️`, `timeline`, token.key, `"${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`);
 };
 
 //#endregion
-export { COUNTERFEIT, CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, INTERNAL_ROLES, Join, Junction, MapOverlay, NotFoundError, RESET_STATE, RelationsOverlay, SetOverlay, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, capitalize, claimWithinStore, clearStore, closeOperation, createJoin, createMutableAtom, createMutableAtomFamily, createReadonlyHeldSelector, createReadonlyPureSelector, createReadonlyPureSelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneSelector, createTimeline, createTransaction, createWritableHeldSelector, createWritablePureSelector, createWritablePureSelectorFamily, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, evictCachedValue, evictDownstreamFromAtom, evictDownstreamFromSelector, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, hasRole, ingestAtomUpdateEvent, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdateEvent, ingestTransactionOutcomeEvent, installIntoStore, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markDone, mint, newest, openOperation, readFromCache, readOrComputeValue, recallState, registerSelector, resetAtomOrSelector, resetInStore, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootDependency, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceRootSelectorAtoms, updateSelectorAtoms, withdraw, writeToCache };
+export { COUNTERFEIT, CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, INTERNAL_ROLES, Join, Junction, MapOverlay, NotFoundError, RESET_STATE, RelationsOverlay, SetOverlay, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, capitalize, claimWithinStore, clearStore, closeOperation, createClaimTX, createDeallocateTX, createJoin, createMutableAtom, createMutableAtomFamily, createReadonlyHeldSelector, createReadonlyPureSelector, createReadonlyPureSelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneSelector, createTimeline, createTransaction, createWritableHeldSelector, createWritablePureSelector, createWritablePureSelectorFamily, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, eldest, evictCachedValue, evictDownstreamFromAtom, evictDownstreamFromSelector, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, hasRole, ingestAtomUpdateEvent, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdateEvent, ingestTransactionOutcomeEvent, installIntoStore, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markDone, mint, newest, openOperation, readFromCache, readOrComputeValue, recallState, registerSelector, resetAtomOrSelector, resetInStore, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootDependency, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceRootSelectorAtoms, updateSelectorAtoms, withdraw, writeToCache };
 //# sourceMappingURL=index.js.map