atom.io 0.36.1 → 0.36.3

package/dist/internal/index.js

@@ -1,4 +1,3 @@
-import { Join as Join$1, arbitrary as arbitrary$1, subscribeToState as subscribeToState$1, subscribeToTimeline as subscribeToTimeline$1, subscribeToTransaction as subscribeToTransaction$1 } from "atom.io/internal";
 import { parseJson, stringifyJson } from "atom.io/json";
 import { Anarchy, AtomIOLogger } from "atom.io";
 import { SetRTX } from "atom.io/transceivers/set-rtx";
@@ -383,21 +382,6 @@ const recallState = (store, state) => {
 	return target.valueMap.get(state.key);
 };
 
-//#endregion
-//#region src/internal/subscribe/subscribe-in-store.ts
-function subscribeInStore(store, token, handleUpdate, key = arbitrary$1()) {
-	switch (token.type) {
-		case `atom`:
-		case `mutable_atom`:
-		case `readonly_pure_selector`:
-		case `readonly_held_selector`:
-		case `writable_pure_selector`:
-		case `writable_held_selector`: return subscribeToState$1(store, token, key, handleUpdate);
-		case `transaction`: return subscribeToTransaction$1(store, token, key, handleUpdate);
-		case `timeline`: return subscribeToTimeline$1(store, token, key, handleUpdate);
-	}
-}
-
 //#endregion
 //#region src/internal/future.ts
 /**
@@ -502,32 +486,35 @@ const markDone = (store, key) => {
 
 //#endregion
 //#region src/internal/set-state/evict-downstream.ts
-function evictDownStream(store, atom) {
+function evictDownstreamFromAtom(store, atom) {
 	const target = newest(store);
-	const downstreamKeys = target.selectorAtoms.getRelatedKeys(atom.key);
-	target.logger.info(`🧹`, atom.type, atom.key, downstreamKeys ? `evicting ${downstreamKeys.size} states downstream:` : `no downstream states`, downstreamKeys ?? `to evict`);
+	const { key, type } = atom;
+	const downstreamKeys = target.selectorAtoms.getRelatedKeys(key);
+	target.logger.info(`🧹`, type, key, downstreamKeys ? `evicting ${downstreamKeys.size} states downstream:` : `no downstream states`, downstreamKeys ?? `to evict`);
 	if (downstreamKeys) {
-		if (target.operation.open) target.logger.info(`🧹`, atom.type, atom.key, `[ ${[...target.operation.done].join(`, `)} ] already done`);
-		for (const key of downstreamKeys) {
-			if (isDone(target, key)) continue;
-			evictCachedValue(target, key);
-			markDone(target, key);
+		if (target.operation.open) target.logger.info(`🧹`, type, key, `[ ${[...target.operation.done].join(`, `)} ] already done`);
+		for (const downstreamKey of downstreamKeys) {
+			if (isDone(target, downstreamKey)) continue;
+			evictCachedValue(target, downstreamKey);
+			markDone(target, downstreamKey);
 		}
 	}
 }
-function evictDownStreamFromSelector(store, selector) {
+function evictDownstreamFromSelector(store, selectorKey) {
 	const target = newest(store);
-	const relationEntries = target.selectorGraph.getRelationEntries({ upstreamSelectorKey: selector.key }).filter(([_, { source }]) => source === selector.key);
+	const relationEntries = target.selectorGraph.getRelationEntries({ upstreamSelectorKey: selectorKey }).filter(([_, { source }]) => source === selectorKey);
 	for (const [downstreamSelectorKey] of relationEntries) {
 		if (isDone(target, downstreamSelectorKey)) continue;
 		evictCachedValue(target, downstreamSelectorKey);
 		markDone(target, downstreamSelectorKey);
+		evictDownstreamFromSelector(store, downstreamSelectorKey);
 	}
 }
 
 //#endregion
 //#region src/internal/caching.ts
-function writeToCache(target, key, value, subject) {
+function writeToCache(target, state, value) {
+	const { key, subject, type } = state;
 	const currentValue = target.valueMap.get(key);
 	if (currentValue instanceof Future && !currentValue.done) {
 		const future = currentValue;
@@ -544,20 +531,19 @@ function writeToCache(target, key, value, subject) {
 		future.then(function handleResolvedFuture(resolved) {
 			const current = target.valueMap.get(key);
 			if (current === future) {
-				writeToCache(target, key, resolved, subject);
-				const atom = target.atoms.get(key);
-				if (atom) {
-					openOperation(target, atom);
-					evictDownStream(target, atom);
-					closeOperation(target);
-				} else {
-					const selector = target.writableSelectors.get(key) ?? target.readonlySelectors.get(key);
-					if (selector) {
-						openOperation(target, selector);
-						evictDownStreamFromSelector(target, selector);
-						closeOperation(target);
-					}
+				openOperation(target, state);
+				writeToCache(target, state, resolved);
+				switch (type) {
+					case `atom`:
+					case `mutable_atom`:
+						evictDownstreamFromAtom(target, state);
+						break;
+					case `readonly_pure_selector`:
+					case `writable_pure_selector`:
+						evictDownstreamFromSelector(target, key);
+						break;
 				}
+				closeOperation(target);
 				subject.next({
 					newValue: resolved,
 					oldValue: future
@@ -611,45 +597,31 @@ function evictCachedValue(target, key) {
 //#region src/internal/get-state/read-or-compute-value.ts
 function readOrComputeValue(target, state, mut) {
 	if (target.valueMap.has(state.key)) return readFromCache(target, state, mut);
+	const { key } = state;
 	switch (state.type) {
 		case `readonly_held_selector`:
 		case `readonly_pure_selector`:
 		case `writable_held_selector`:
 		case `writable_pure_selector`:
-			target.logger.info(`🧮`, state.type, state.key, `computing value`);
+			target.logger.info(`🧮`, state.type, key, `computing value`);
 			return state.get();
 		case `atom`: {
 			let def;
 			if (state.default instanceof Function) def = state.default();
 			else def = state.default;
-			const cachedValue = writeToCache(target, state.key, def, state.subject);
+			const cachedValue = writeToCache(target, state, def);
 			target.logger.info(`💁`, `atom`, state.key, `could not find cached value; using default`, def);
 			return cachedValue;
 		}
 		case `mutable_atom`: {
 			const instance = new state.class();
-			const cachedValue = writeToCache(target, state.key, instance, state.subject);
+			const cachedValue = writeToCache(target, state, instance);
 			target.logger.info(`💁`, `mutable_atom`, state.key, `could not find cached value; using default`, instance);
 			return cachedValue;
 		}
 	}
 }
 
-//#endregion
-//#region src/internal/subscribe/subscribe-to-root-atoms.ts
-const subscribeToRootDependency = (target, selector, atom) => {
-	return atom.subject.subscribe(`${selector.type}:${selector.key}`, (atomChange) => {
-		target.logger.info(`📢`, selector.type, selector.key, `root`, atom.key, `went`, atomChange.oldValue, `->`, atomChange.newValue);
-		const oldValue = recallState(target, selector);
-		const newValue = readOrComputeValue(target, selector);
-		target.logger.info(`✨`, selector.type, selector.key, `went`, oldValue, `->`, newValue);
-		selector.subject.next({
-			newValue,
-			oldValue
-		});
-	});
-};
-
 //#endregion
 //#region src/internal/set-state/become.ts
 const become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(originalThing) : nextVersionOfThing;
@@ -684,9 +656,9 @@ const setAtom = (target, atom, next) => {
 	const oldValue = readOrComputeValue(target, atom, `mut`);
 	let newValue = become(next)(oldValue);
 	target.logger.info(`📝`, `atom`, atom.key, `set to`, newValue);
-	newValue = writeToCache(target, atom.key, newValue, atom.subject);
+	newValue = writeToCache(target, atom, newValue);
 	markDone(target, atom.key);
-	evictDownStream(target, atom);
+	evictDownstreamFromAtom(target, atom);
 	const update = {
 		oldValue,
 		newValue
@@ -711,7 +683,7 @@ const setAtom = (target, atom, next) => {
 		const mutable = target.atoms.get(key);
 		const transceiver = readOrComputeValue(target, mutable, `mut`);
 		const accepted = transceiver.do(update.newValue) === null;
-		if (accepted === true) evictDownStream(target, mutable);
+		if (accepted === true) evictDownstreamFromAtom(target, mutable);
 	}
 };
 
@@ -754,44 +726,6 @@ function getFamilyOfToken(store, token) {
 	}
 }
 
-//#endregion
-//#region src/internal/set-state/reset-in-store.ts
-function resetInStore(store, ...params) {
-	let token;
-	let family;
-	let key;
-	if (params.length === 1) {
-		token = params[0];
-		family = getFamilyOfToken(store, token) ?? null;
-		if (family) {
-			key = token.family ? parseJson(token.family.subKey) : null;
-			token = findInStore(store, family, key);
-		}
-	} else {
-		family = params[0];
-		key = params[1];
-		token = findInStore(store, family, key);
-	}
-	if (`counterfeit` in token && `family` in token) {
-		const subKey = token.family.subKey;
-		const disposal = store.disposalTraces.buffer.find((item) => item?.key === subKey);
-		store.logger.error(`❌`, token.type, token.key, `could not be reset because it was not found in the store "${store.config.name}".`, disposal ? `This state was previously disposed:\n${disposal.trace}` : `No previous disposal trace was found.`);
-		return;
-	}
-	const rejectionTime = openOperation(store, token);
-	if (rejectionTime) {
-		const unsubscribe = store.on.operationClose.subscribe(`waiting to reset "${token.key}" at T-${rejectionTime}`, () => {
-			unsubscribe();
-			store.logger.info(`🟢`, token.type, token.key, `resuming deferred resetState from T-${rejectionTime}`);
-			resetInStore(store, token);
-		});
-		return;
-	}
-	const state = withdraw(store, token);
-	resetAtomOrSelector(store, state);
-	closeOperation(store);
-}
-
 //#endregion
 //#region src/internal/set-state/set-atom-or-selector.ts
 const setAtomOrSelector = (store, state, value) => {
@@ -828,26 +762,45 @@ function setIntoStore(store, ...params) {
 		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 set because it was not found in the store "${store.config.name}".`, disposal ? `This state was previously disposed:\n${disposal.trace}` : `No previous disposal trace was found.`);
+		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 set "${token.key}" at T-${rejectionTime}`, function waitUntilOperationCloseToSetState() {
+		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 setState from T-${rejectionTime}`);
+			store.logger.info(`🟢`, token.type, token.key, `resuming deferred`, action, `from T-${rejectionTime}`);
 			setIntoStore(store, token, value);
 		});
 		return;
 	}
 	const state = withdraw(store, token);
-	setAtomOrSelector(store, state, value);
+	if (value === RESET_STATE) resetAtomOrSelector(store, state);
+	else setAtomOrSelector(store, state, value);
 	closeOperation(store);
 }
 
+//#endregion
+//#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);
+	}
+}
+
 //#endregion
 //#region src/internal/keys.ts
 const isAtomKey = (store, key) => newest(store).atoms.has(key);
@@ -961,7 +914,7 @@ const createReadonlyHeldSelector = (store, options, family) => {
 			find,
 			json
 		}, constant);
-		writeToCache(newest(store), key, constant, subject);
+		writeToCache(newest(store), readonlySelector, constant);
 		covered.clear();
 		return constant;
 	};
@@ -1002,7 +955,7 @@ const createReadonlyPureSelector = (store, options, family) => {
 			find,
 			json
 		});
-		const cached = writeToCache(innerTarget, key, value, subject);
+		const cached = writeToCache(innerTarget, readonlySelector, value);
 		store.logger.info(`✨`, type, key, `=`, cached);
 		covered.clear();
 		return cached;
@@ -1580,7 +1533,7 @@ const createWritableHeldSelector = (store, options, family) => {
 		for (const [downstreamSelectorKey, { source }] of upstreamStates) if (source !== key) innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
 		innerTarget.selectorAtoms.delete(key);
 		getFn(getterToolkit, constant);
-		writeToCache(innerTarget, key, constant, subject);
+		writeToCache(innerTarget, mySelector, constant);
 		store.logger.info(`✨`, type, key, `=`, constant);
 		covered.clear();
 		return constant;
@@ -1590,7 +1543,7 @@ const createWritableHeldSelector = (store, options, family) => {
 		const oldValue = getSelf(options.get, innerTarget);
 		const newValue = become(next)(oldValue);
 		store.logger.info(`📝`, type, key, `set (`, oldValue, `->`, newValue, `)`);
-		writeToCache(innerTarget, key, newValue, subject);
+		writeToCache(innerTarget, mySelector, newValue);
 		markDone(innerTarget, key);
 		if (isRootStore(innerTarget)) subject.next({
 			newValue,
@@ -1636,17 +1589,17 @@ const createWritablePureSelector = (store, options, family) => {
 		for (const [downstreamSelectorKey, { source }] of upstreamStates) if (source !== key) innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
 		innerTarget.selectorAtoms.delete(key);
 		const value = getFn(getterToolkit);
-		const cached = writeToCache(innerTarget, key, value, subject);
+		const cached = writeToCache(innerTarget, mySelector, value);
 		store.logger.info(`✨`, type, key, `=`, cached);
 		covered.clear();
-		return value;
+		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, options.key, newValue, subject);
+		writeToCache(innerTarget, mySelector, newValue);
 		markDone(innerTarget, options.key);
 		if (isRootStore(innerTarget)) subject.next({
 			newValue,
@@ -2153,6 +2106,21 @@ function getFromStore(store, ...params) {
 	return readOrComputeValue(store, withdraw(store, token));
 }
 
+//#endregion
+//#region src/internal/subscribe/subscribe-to-root-atoms.ts
+const subscribeToRootDependency = (target, selector, atom) => {
+	return atom.subject.subscribe(`${selector.type}:${selector.key}`, (atomChange) => {
+		target.logger.info(`📢`, selector.type, selector.key, `root`, atom.key, `went`, atomChange.oldValue, `->`, atomChange.newValue);
+		const oldValue = recallState(target, selector);
+		const newValue = readOrComputeValue(target, selector);
+		target.logger.info(`✨`, selector.type, selector.key, `went`, oldValue, `->`, newValue);
+		selector.subject.next({
+			newValue,
+			oldValue
+		});
+	});
+};
+
 //#endregion
 //#region src/internal/subscribe/subscribe-to-state.ts
 function subscribeToState(store, token, key, handleUpdate) {
@@ -2195,6 +2163,46 @@ function subscribeToState(store, token, key, handleUpdate) {
 	return unsubscribe;
 }
 
+//#endregion
+//#region src/internal/store/withdraw.ts
+function withdraw(store, token) {
+	let withdrawn;
+	let target = store;
+	while (target !== null) {
+		switch (token.type) {
+			case `atom`:
+			case `mutable_atom`:
+				withdrawn = target.atoms.get(token.key);
+				break;
+			case `writable_pure_selector`:
+			case `writable_held_selector`:
+				withdrawn = target.writableSelectors.get(token.key);
+				break;
+			case `readonly_pure_selector`:
+			case `readonly_held_selector`:
+				withdrawn = target.readonlySelectors.get(token.key);
+				break;
+			case `atom_family`:
+			case `mutable_atom_family`:
+			case `writable_pure_selector_family`:
+			case `readonly_pure_selector_family`:
+			case `writable_held_selector_family`:
+			case `readonly_held_selector_family`:
+				withdrawn = target.families.get(token.key);
+				break;
+			case `timeline`:
+				withdrawn = target.timelines.get(token.key);
+				break;
+			case `transaction`:
+				withdrawn = target.transactions.get(token.key);
+				break;
+		}
+		if (withdrawn) return withdrawn;
+		target = target.child;
+	}
+	throw new NotFoundError(token, store);
+}
+
 //#endregion
 //#region src/internal/subscribe/subscribe-to-timeline.ts
 const subscribeToTimeline = (store, token, key, handleUpdate) => {
@@ -2219,6 +2227,21 @@ const subscribeToTransaction = (store, token, key, handleUpdate) => {
 	};
 };
 
+//#endregion
+//#region src/internal/subscribe/subscribe-in-store.ts
+function subscribeInStore(store, token, handleUpdate, key = arbitrary()) {
+	switch (token.type) {
+		case `atom`:
+		case `mutable_atom`:
+		case `readonly_pure_selector`:
+		case `readonly_held_selector`:
+		case `writable_pure_selector`:
+		case `writable_held_selector`: return subscribeToState(store, token, key, handleUpdate);
+		case `transaction`: return subscribeToTransaction(store, token, key, handleUpdate);
+		case `timeline`: return subscribeToTimeline(store, token, key, handleUpdate);
+	}
+}
+
 //#endregion
 //#region src/internal/mutable/tracker.ts
 /**
@@ -2640,46 +2663,6 @@ const clearStore = (store) => {
 	store.config = config;
 };
 
-//#endregion
-//#region src/internal/store/withdraw.ts
-function withdraw(store, token) {
-	let withdrawn;
-	let target = store;
-	while (target !== null) {
-		switch (token.type) {
-			case `atom`:
-			case `mutable_atom`:
-				withdrawn = target.atoms.get(token.key);
-				break;
-			case `writable_pure_selector`:
-			case `writable_held_selector`:
-				withdrawn = target.writableSelectors.get(token.key);
-				break;
-			case `readonly_pure_selector`:
-			case `readonly_held_selector`:
-				withdrawn = target.readonlySelectors.get(token.key);
-				break;
-			case `atom_family`:
-			case `mutable_atom_family`:
-			case `writable_pure_selector_family`:
-			case `readonly_pure_selector_family`:
-			case `writable_held_selector_family`:
-			case `readonly_held_selector_family`:
-				withdrawn = target.families.get(token.key);
-				break;
-			case `timeline`:
-				withdrawn = target.timelines.get(token.key);
-				break;
-			case `transaction`:
-				withdrawn = target.transactions.get(token.key);
-				break;
-		}
-		if (withdrawn) return withdrawn;
-		target = target.child;
-	}
-	throw new NotFoundError(token, store);
-}
-
 //#endregion
 //#region src/internal/atom/create-regular-atom.ts
 function createRegularAtom(store, options, family, internalRoles) {
@@ -2800,20 +2783,6 @@ function installIntoStore(tokens, target, source) {
 	}
 }
 
-//#endregion
-//#region src/internal/join/create-join.ts
-function createJoin(store, options, defaultContent) {
-	store.joins.set(options.key, new Join$1(options, defaultContent, store));
-	const token = {
-		key: options.key,
-		type: `join`,
-		a: options.between[0],
-		b: options.between[1],
-		cardinality: options.cardinality
-	};
-	return token;
-}
-
 //#endregion
 //#region src/internal/join/join-internal.ts
 var Join = class {
@@ -3117,6 +3086,20 @@ var Join = class {
 	}
 };
 
+//#endregion
+//#region src/internal/join/create-join.ts
+function createJoin(store, options, defaultContent) {
+	store.joins.set(options.key, new Join(options, defaultContent, store));
+	const token = {
+		key: options.key,
+		type: `join`,
+		a: options.between[0],
+		b: options.between[1],
+		cardinality: options.cardinality
+	};
+	return token;
+}
+
 //#endregion
 //#region src/internal/join/get-join.ts
 function getJoin(token, store) {
@@ -3547,5 +3530,5 @@ const timeTravel = (store, action, token) => {
 };
 
 //#endregion
-export { CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, INTERNAL_ROLES, Join, Junction, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, capitalize, claimWithinStore, clearStore, closeOperation, counterfeit, createJoin, createMutableAtom, createMutableAtomFamily, createReadonlyHeldSelector, createReadonlyPureSelector, createReadonlyPureSelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneSelector, createTimeline, createTransaction, createWritableHeldSelector, createWritablePureSelector, createWritablePureSelectorFamily, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, evictCachedValue, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, hasRole, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, installIntoStore, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markDone, newest, openOperation, prettyPrintTokenType, readFromCache, readOrComputeValue, recallState, registerSelector, resetAtomOrSelector, resetInStore, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootDependency, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceRootSelectorAtoms, updateSelectorAtoms, withdraw, writeToCache };
+export { CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, INTERNAL_ROLES, Join, Junction, LazyMap, NotFoundError, RESET_STATE, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, capitalize, claimWithinStore, clearStore, closeOperation, counterfeit, 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, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, installIntoStore, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markDone, newest, openOperation, prettyPrintTokenType, 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