atom.io 0.41.1 → 0.42.0

package/dist/internal/index.js

@@ -1,6 +1,6 @@
 import { Anarchy, AtomIOLogger, PRETTY_TOKEN_TYPES } from "atom.io";
 import { parseJson, stringifyJson } from "atom.io/json";
-import { SetRTX } from "atom.io/transceivers/set-rtx";
+import { UList } from "atom.io/transceivers/u-list";
 
 //#region src/internal/arbitrary.ts
 function arbitrary(random = Math.random) {
@@ -3064,10 +3064,9 @@ function installIntoStore(tokens, target, source) {
 var Join = class {
 	toolkit;
 	options;
-	defaultContent;
 	relations;
 	states;
-	core;
+	relatedKeysAtoms;
 	transact(toolkit, run) {
 		const originalToolkit = this.toolkit;
 		this.toolkit = toolkit;
@@ -3077,11 +3076,10 @@ var Join = class {
 	store;
 	realm;
 	[Symbol.dispose]() {}
-	constructor(options, defaultContent, store = IMPLICIT.STORE) {
+	constructor(options, store = IMPLICIT.STORE) {
 		this.store = store;
 		this.realm = new Anarchy(store);
 		this.options = options;
-		this.defaultContent = defaultContent;
 		this.store.miscResources.set(`join:${options.key}`, this);
 		this.realm.allocate(`root`, options.key);
 		this.toolkit = {
@@ -3096,28 +3094,9 @@ var Join = class {
 		const bSide = options.between[1];
 		const relatedKeysAtoms = createMutableAtomFamily(store, {
 			key: `${options.key}/relatedKeys`,
-			class: SetRTX
+			class: UList
 		}, [`join`, `relations`]);
-		this.core = { relatedKeysAtoms };
-		const getRelatedKeys = ({ get }, key) => get(relatedKeysAtoms, key);
-		const addRelation = ({ set }, a, b) => {
-			if (!this.store.molecules.has(stringifyJson(a))) this.realm.allocate(options.key, a);
-			set(relatedKeysAtoms, a, (aKeys) => aKeys.add(b));
-			set(relatedKeysAtoms, b, (bKeys) => bKeys.add(a));
-		};
-		const deleteRelation = ({ set }, a, b) => {
-			set(relatedKeysAtoms, a, (aKeys) => {
-				aKeys.delete(b);
-				return aKeys;
-			});
-			set(relatedKeysAtoms, b, (bKeys) => {
-				bKeys.delete(a);
-				return bKeys;
-			});
-			const [x, y] = [a, b].sort();
-			const compositeKey = `${x}:${y}`;
-			this.store.moleculeJoins.delete(compositeKey);
-		};
+		this.relatedKeysAtoms = relatedKeysAtoms;
 		const replaceRelationsSafely = (toolkit, a, newRelationsOfA) => {
 			const { find, get, set } = toolkit;
 			const relationsOfAState = find(relatedKeysAtoms, a);
@@ -3130,41 +3109,46 @@ var Join = class {
 				});
 			}
 			set(relationsOfAState, (relationsOfA) => {
-				relationsOfA.transaction((nextRelationsOfA) => {
-					nextRelationsOfA.clear();
-					for (const newRelationB of newRelationsOfA) {
-						const relationsOfB = getRelatedKeys(toolkit, newRelationB);
-						const newRelationBIsAlreadyRelated = relationsOfB.has(a);
-						if (this.relations.cardinality === `1:n`) {
-							const previousOwnersToDispose = [];
-							for (const previousOwner of relationsOfB) {
-								if (previousOwner === a) continue;
-								const previousOwnerRelations = getRelatedKeys(toolkit, previousOwner);
-								previousOwnerRelations.delete(newRelationB);
-								if (previousOwnerRelations.size === 0) previousOwnersToDispose.push(previousOwner);
-							}
-							if (!newRelationBIsAlreadyRelated && relationsOfB.size > 0) relationsOfB.clear();
-							for (const previousOwner of previousOwnersToDispose) {
-								const [x, y] = [newRelationB, previousOwner].sort();
-								const compositeKey = `${x}:${y}`;
-								store.moleculeJoins.delete(compositeKey);
-							}
+				relationsOfA.clear();
+				for (const newRelationB of newRelationsOfA) {
+					const relationsOfBAtom = find(relatedKeysAtoms, newRelationB);
+					const relationsOfB = get(relationsOfBAtom);
+					const newRelationBIsAlreadyRelated = relationsOfB.has(a);
+					if (this.relations.cardinality === `1:n`) {
+						const previousOwnersToDispose = [];
+						for (const previousOwner of relationsOfB) {
+							if (previousOwner === a) continue;
+							let previousOwnerSize;
+							operateOnStore(JOIN_OP, this.store, relatedKeysAtoms, previousOwner, (relations$1) => {
+								relations$1.delete(newRelationB);
+								previousOwnerSize = relations$1.size;
+								return relations$1;
+							});
+							if (previousOwnerSize === 0) previousOwnersToDispose.push(previousOwner);
+						}
+						if (!newRelationBIsAlreadyRelated && relationsOfB.size > 0) set(relationsOfBAtom, (relations$1) => {
+							relations$1.clear();
+							return relations$1;
+						});
+						for (const previousOwner of previousOwnersToDispose) {
+							const [x, y] = [newRelationB, previousOwner].sort();
+							const compositeKey = `${x}:${y}`;
+							store.moleculeJoins.delete(compositeKey);
 						}
-						if (!newRelationBIsAlreadyRelated) relationsOfB.add(a);
-						nextRelationsOfA.add(newRelationB);
 					}
-					return true;
-				});
+					if (!newRelationBIsAlreadyRelated) set(relationsOfBAtom, (relations$1) => {
+						relations$1.add(a);
+						return relations$1;
+					});
+					relationsOfA.add(newRelationB);
+				}
 				return relationsOfA;
 			});
 		};
 		const replaceRelationsUnsafely = (toolkit, a, newRelationsOfA) => {
 			const { set } = toolkit;
 			set(relatedKeysAtoms, a, (relationsOfA) => {
-				relationsOfA.transaction((nextRelationsOfA) => {
-					for (const newRelationB of newRelationsOfA) nextRelationsOfA.add(newRelationB);
-					return true;
-				});
+				for (const newRelationB of newRelationsOfA) relationsOfA.add(newRelationB);
 				return relationsOfA;
 			});
 			for (const newRelationB of newRelationsOfA) set(relatedKeysAtoms, newRelationB, (newRelationsB) => {
@@ -3173,66 +3157,43 @@ var Join = class {
 			});
 			return true;
 		};
-		const has = (toolkit, a, b) => {
-			const aKeys = getRelatedKeys(toolkit, a);
-			return b ? aKeys.has(b) : aKeys.size > 0;
-		};
-		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);
-				addRelation(this.toolkit, a, b);
-			},
-			deleteRelation: (a, b) => {
-				deleteRelation(this.toolkit, a, b);
-			},
-			replaceRelationsSafely: (a, bs) => {
-				replaceRelationsSafely(this.toolkit, a, bs);
-			},
-			replaceRelationsUnsafely: (a, bs) => {
-				replaceRelationsUnsafely(this.toolkit, a, bs);
-			},
-			has: (a, b) => has(this.toolkit, a, b)
-		};
-		let externalStore;
-		let contentAtoms;
-		if (defaultContent) {
-			contentAtoms = createRegularAtomFamily(store, {
-				key: `${options.key}/content`,
-				default: defaultContent
-			}, [`join`, `content`]);
-			const getContent = ({ get }, key) => get(contentAtoms, key);
-			const setContent = ({ set }, key, content) => {
-				set(contentAtoms, key, content);
-			};
-			externalStore = Object.assign(baseExternalStoreConfiguration, {
-				getContent: (contentKey) => {
-					return getContent(this.toolkit, contentKey);
+		const relations = new Junction(options, {
+			externalStore: {
+				getRelatedKeys: (key) => this.toolkit.get(relatedKeysAtoms, key),
+				addRelation: (a, b) => {
+					this.store.moleculeJoins.set(`"${a}"`, options.key);
+					this.store.moleculeJoins.set(`"${b}"`, options.key);
+					if (!this.store.molecules.has(stringifyJson(a))) this.realm.allocate(options.key, a);
+					if (!this.store.molecules.has(stringifyJson(b))) this.realm.allocate(options.key, b);
+					this.toolkit.set(relatedKeysAtoms, a, (aKeys) => aKeys.add(b));
+					this.toolkit.set(relatedKeysAtoms, b, (bKeys) => bKeys.add(a));
 				},
-				setContent: (contentKey, content) => {
-					setContent(this.toolkit, contentKey, content);
+				deleteRelation: (a, b) => {
+					this.toolkit.set(relatedKeysAtoms, a, (aKeys) => {
+						aKeys.delete(b);
+						return aKeys;
+					});
+					this.toolkit.set(relatedKeysAtoms, b, (bKeys) => {
+						bKeys.delete(a);
+						return bKeys;
+					});
+					const [x, y] = [a, b].sort();
+					const compositeKey = `${x}:${y}`;
+					this.store.moleculeJoins.delete(compositeKey);
 				},
-				deleteContent: (_) => {}
-			});
-		} else externalStore = baseExternalStoreConfiguration;
-		const relations = new Junction(options, {
-			externalStore,
+				replaceRelationsSafely: (a, bs) => {
+					replaceRelationsSafely(this.toolkit, a, bs);
+				},
+				replaceRelationsUnsafely: (a, bs) => {
+					replaceRelationsUnsafely(this.toolkit, a, bs);
+				},
+				has: (a, b) => {
+					const aKeys = this.toolkit.get(relatedKeysAtoms, a);
+					return b ? aKeys.has(b) : aKeys.size > 0;
+				}
+			},
 			isAType: options.isAType,
-			isBType: options.isBType,
-			makeContentKey: (...args) => {
-				const [a, b] = args;
-				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);
-				if (!bMolecule) this.realm.allocate(options.key, b);
-				this.realm.allocate(a, compositeKey, `all`);
-				this.realm.claim(b, compositeKey);
-				this.store.moleculeJoins.set(compositeKey, options.key);
-				return compositeKey;
-			}
+			isBType: options.isBType
 		});
 		const createSingleKeySelectorFamily = () => createReadonlyPureSelectorFamily(store, {
 			key: `${options.key}/singleRelatedKey`,
@@ -3247,63 +3208,20 @@ var Join = class {
 				key: `${options.key}/multipleRelatedKeys`,
 				get: (key) => ({ get }) => {
 					const jsonFamily = getJsonFamily(relatedKeysAtoms, store);
-					return get(jsonFamily, key).members;
+					return get(jsonFamily, key);
 				}
 			}, [`join`, `keys`]);
 		};
-		const createSingleEntrySelectorFamily = () => createReadonlyPureSelectorFamily(store, {
-			key: `${options.key}/singleRelatedEntry`,
-			get: (x) => ({ get }) => {
-				const relatedKeys = get(relatedKeysAtoms, x);
-				for (const y of relatedKeys) {
-					let a = relations.isAType?.(x) ? x : void 0;
-					let b = a === void 0 ? x : void 0;
-					a ??= y;
-					b ??= y;
-					const contentKey = relations.makeContentKey(a, b);
-					const content = get(contentAtoms, contentKey);
-					return [y, content];
-				}
-				return null;
-			}
-		}, [`join`, `entries`]);
-		const getMultipleEntrySelectorFamily = () => createReadonlyPureSelectorFamily(store, {
-			key: `${options.key}/multipleRelatedEntries`,
-			get: (x) => ({ get }) => {
-				const jsonFamily = getJsonFamily(relatedKeysAtoms, store);
-				return get(jsonFamily, x).members.map((y) => {
-					let a = relations.isAType?.(x) ? x : void 0;
-					let b = a === void 0 ? x : void 0;
-					a ??= y;
-					b ??= y;
-					const contentKey = relations.makeContentKey(a, b);
-					const content = get(contentAtoms, contentKey);
-					return [y, content];
-				});
-			}
-		}, [`join`, `entries`]);
 		switch (options.cardinality) {
 			case `1:1`: {
 				const singleRelatedKeySelectors = createSingleKeySelectorFamily();
 				const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
 				const stateKeyB = `${bSide}KeyOf${capitalize(aSide)}`;
-				const baseStates = {
+				this.relations = relations;
+				this.states = {
 					[stateKeyA]: singleRelatedKeySelectors,
 					[stateKeyB]: singleRelatedKeySelectors
 				};
-				let states;
-				if (defaultContent) {
-					const singleEntrySelectors = createSingleEntrySelectorFamily();
-					const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
-					const entriesStateKeyB = `${bSide}EntryOf${capitalize(aSide)}`;
-					const contentStates = {
-						[entriesStateKeyA]: singleEntrySelectors,
-						[entriesStateKeyB]: singleEntrySelectors
-					};
-					states = Object.assign(baseStates, contentStates);
-				} else states = baseStates;
-				this.relations = relations;
-				this.states = states;
 				break;
 			}
 			case `1:n`: {
@@ -3315,43 +3233,19 @@ var Join = class {
 					[stateKeyA]: singleRelatedKeySelectors,
 					[stateKeyB]: multipleRelatedKeysSelectors
 				};
-				let states;
-				if (defaultContent) {
-					const singleRelatedEntrySelectors = createSingleEntrySelectorFamily();
-					const multipleRelatedEntriesSelectors = getMultipleEntrySelectorFamily();
-					const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
-					const entriesStateKeyB = `${bSide}EntriesOf${capitalize(aSide)}`;
-					const contentStates = {
-						[entriesStateKeyA]: singleRelatedEntrySelectors,
-						[entriesStateKeyB]: multipleRelatedEntriesSelectors
-					};
-					states = Object.assign(baseStates, contentStates);
-				} else states = baseStates;
 				this.relations = relations;
-				this.states = states;
+				this.states = baseStates;
 				break;
 			}
 			case `n:n`: {
 				const multipleRelatedKeysSelectors = getMultipleKeySelectorFamily();
 				const stateKeyA = `${aSide}KeysOf${capitalize(bSide)}`;
 				const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
-				const baseStates = {
+				this.relations = relations;
+				this.states = {
 					[stateKeyA]: multipleRelatedKeysSelectors,
 					[stateKeyB]: multipleRelatedKeysSelectors
 				};
-				let states;
-				if (defaultContent) {
-					const multipleRelatedEntriesSelectors = getMultipleEntrySelectorFamily();
-					const entriesStateKeyA = `${aSide}EntriesOf${capitalize(bSide)}`;
-					const entriesStateKeyB = `${bSide}EntriesOf${capitalize(aSide)}`;
-					const contentStates = {
-						[entriesStateKeyA]: multipleRelatedEntriesSelectors,
-						[entriesStateKeyB]: multipleRelatedEntriesSelectors
-					};
-					states = Object.assign(baseStates, contentStates);
-				} else states = baseStates;
-				this.relations = relations;
-				this.states = states;
 			}
 		}
 	}
@@ -3359,8 +3253,8 @@ 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));
+function createJoin(store, options) {
+	store.joins.set(options.key, new Join(options));
 	return {
 		key: options.key,
 		type: `join`,
@@ -3378,7 +3272,7 @@ function getJoin(token, store) {
 		const rootJoin = IMPLICIT.STORE.joins.get(token.key);
 		if (rootJoin === void 0) throw new Error(`Join "${token.key}" not found in store "${store.config.name}"`);
 		const root = eldest(store);
-		myJoin = new Join(rootJoin.options, rootJoin.defaultContent, root);
+		myJoin = new Join(rootJoin.options, root);
 		store.joins.set(token.key, myJoin);
 	}
 	return myJoin;
@@ -3416,20 +3310,6 @@ function findRelationsInStore(token, key, store) {
 					return findInStore(store, familyBA, key);
 				}
 			};
-			const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
-			if (entryAB in myJoin.states) {
-				const entryBA = `${token.b}EntryOf${capitalize(token.a)}`;
-				Object.assign(relations, {
-					get [entryAB]() {
-						const familyAB = myJoin.states[entryAB];
-						return findInStore(store, familyAB, key);
-					},
-					get [entryBA]() {
-						const familyBA = myJoin.states[entryBA];
-						return findInStore(store, familyBA, key);
-					}
-				});
-			}
 			break;
 		}
 		case `1:n`: {
@@ -3445,20 +3325,6 @@ function findRelationsInStore(token, key, store) {
 					return findInStore(store, familyBA, key);
 				}
 			};
-			const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
-			if (entryAB in myJoin.states) {
-				const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
-				Object.assign(relations, {
-					get [entryAB]() {
-						const familyAB = myJoin.states[entryAB];
-						return findInStore(store, familyAB, key);
-					},
-					get [entriesBA]() {
-						const familyBA = myJoin.states[entriesBA];
-						return findInStore(store, familyBA, key);
-					}
-				});
-			}
 			break;
 		}
 		case `n:n`: {
@@ -3474,20 +3340,6 @@ function findRelationsInStore(token, key, store) {
 					return findInStore(store, familyBA, key);
 				}
 			};
-			const entriesAB = `${token.a}EntriesOf${capitalize(token.b)}`;
-			if (entriesAB in myJoin.states) {
-				const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
-				Object.assign(relations, {
-					get [entriesAB]() {
-						const familyAB = myJoin.states[entriesAB];
-						return findInStore(store, familyAB, key);
-					},
-					get [entriesBA]() {
-						const familyBA = myJoin.states[entriesBA];
-						return findInStore(store, familyBA, key);
-					}
-				});
-			}
 		}
 	}
 	return relations;
@@ -3496,41 +3348,8 @@ function findRelationsInStore(token, key, store) {
 //#endregion
 //#region src/internal/join/get-internal-relations-from-store.ts
 function getInternalRelationsFromStore(token, store) {
-	return getJoin(token, store).core.relatedKeysAtoms;
-}
-
-//#endregion
-//#region src/internal/micro.ts
-function enumeration(values) {
-	const result = {};
-	let i = 0;
-	for (const value of values) {
-		result[value] = i;
-		result[i] = value;
-		++i;
-	}
-	return result;
+	return getJoin(token, store).relatedKeysAtoms;
 }
-const BOOL = `\u0001`;
-const NULL = `\u0002`;
-const STRING = `\u0003`;
-const NUMBER = `\u0004`;
-const packValue = (value) => {
-	switch (typeof value) {
-		case `string`: return STRING + value;
-		case `number`: return NUMBER + value;
-		case `boolean`: return BOOL + +value;
-		case `object`: return NULL;
-	}
-};
-const unpackValue = (value) => {
-	switch (value[0]) {
-		case STRING: return value.slice(1);
-		case NUMBER: return +value.slice(1);
-		case BOOL: return value.slice(1) === `1`;
-		case NULL: return null;
-	}
-};
 
 //#endregion
 //#region src/internal/timeline/create-timeline.ts
@@ -3809,5 +3628,5 @@ const timeTravel = (store, action, token) => {
 };
 
 //#endregion
-export { CircularBuffer, FamilyTracker, Future, IMPLICIT, INTERNAL_ROLES, JOIN_OP, Join, Junction, MapOverlay, NotFoundError, OWN_OP, 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, enumeration, evictCachedValue, evictDownstreamFromAtom, evictDownstreamFromSelector, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFamilyOfToken, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, hasRole, ingestAtomUpdateEvent, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdateEvent, ingestTransactionOutcomeEvent, installIntoStore, isAtomKey, isChildStore, isDone, isFn, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markDone, newest, openOperation, operateOnStore, packValue, readFromCache, readOrComputeValue, recallState, registerSelector, resetAtomOrSelector, resetInStore, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootDependency, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceRootSelectorAtoms, unpackValue, updateSelectorAtoms, withdraw, writeToCache };
+export { CircularBuffer, FamilyTracker, Future, IMPLICIT, INTERNAL_ROLES, JOIN_OP, Join, Junction, MapOverlay, NotFoundError, OWN_OP, RESET_STATE, RelationsOverlay, SetOverlay, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, capitalize, claimWithinStore, clearStore, closeOperation, createClaimTX, createDeallocateTX, createJoin, createMutableAtom, createMutableAtomFamily, createReadonlyHeldSelector, createReadonlyPureSelector, createReadonlyPureSelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneSelector, createTimeline, createTransaction, createWritableHeldSelector, createWritablePureSelector, createWritablePureSelectorFamily, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, eldest, evictCachedValue, evictDownstreamFromAtom, evictDownstreamFromSelector, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFamilyOfToken, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, hasRole, ingestAtomUpdateEvent, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdateEvent, ingestTransactionOutcomeEvent, installIntoStore, isAtomKey, isChildStore, isDone, isFn, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markDone, newest, openOperation, operateOnStore, 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