atom.io 0.38.2 → 0.39.1

package/dist/internal/index.js

@@ -81,9 +81,151 @@ function mint(token, key, counterfeit) {
 	return stateToken;
 }
 
+//#endregion
+//#region src/internal/overlays/map-overlay.ts
+var MapOverlay = class extends Map {
+	deleted = /* @__PURE__ */ new Set();
+	changed = /* @__PURE__ */ new Set();
+	source;
+	constructor(source) {
+		super();
+		this.source = source;
+	}
+	get(key) {
+		const has = super.has(key);
+		if (has) return super.get(key);
+		if (!this.deleted.has(key) && this.source.has(key)) {
+			const value = this.source.get(key);
+			return value;
+		}
+		return void 0;
+	}
+	set(key, value) {
+		this.deleted.delete(key);
+		if (this.source.has(key)) this.changed.add(key);
+		return super.set(key, value);
+	}
+	hasOwn(key) {
+		return super.has(key);
+	}
+	has(key) {
+		return !this.deleted.has(key) && (super.has(key) || this.source.has(key));
+	}
+	delete(key) {
+		if (this.source.has(key)) {
+			this.deleted.add(key);
+			this.changed.delete(key);
+		}
+		return super.delete(key);
+	}
+	clear() {
+		this.deleted = new Set(this.source.keys());
+		this.changed.clear();
+		super.clear();
+	}
+	*[Symbol.iterator]() {
+		yield* super[Symbol.iterator]();
+		for (const [key, value] of this.source) if (!this.deleted.has(key) && !this.changed.has(key)) yield [key, value];
+	}
+	*entries() {
+		yield* this[Symbol.iterator]();
+	}
+	*keys() {
+		yield* super.keys();
+		for (const key of this.source.keys()) if (!this.deleted.has(key) && !this.changed.has(key)) yield key;
+	}
+	*values() {
+		for (const [, value] of this[Symbol.iterator]()) yield value;
+	}
+	forEach(callbackfn) {
+		for (const [key, value] of this[Symbol.iterator]()) callbackfn(value, key, this);
+	}
+	get size() {
+		return super.size + this.source.size - this.changed.size - this.deleted.size;
+	}
+};
+
+//#endregion
+//#region src/internal/overlays/set-overlay.ts
+var SetOverlay = class extends Set {
+	deleted = /* @__PURE__ */ new Set();
+	source;
+	constructor(source) {
+		super();
+		this.source = source;
+	}
+	add(value) {
+		if (this.source.has(value)) {
+			this.deleted.delete(value);
+			return this;
+		}
+		return super.add(value);
+	}
+	hasOwn(member) {
+		return super.has(member);
+	}
+	has(key) {
+		return !this.deleted.has(key) && (super.has(key) || this.source.has(key));
+	}
+	delete(key) {
+		if (this.source.has(key)) {
+			this.deleted.add(key);
+			return true;
+		}
+		return super.delete(key);
+	}
+	clear() {
+		this.deleted = new Set(this.source);
+		super.clear();
+	}
+	*[Symbol.iterator]() {
+		yield* super[Symbol.iterator]();
+		for (const value of this.source) if (!this.deleted.has(value)) yield value;
+	}
+	*iterateOwn() {
+		yield* super[Symbol.iterator]();
+	}
+	get size() {
+		return super.size + this.source.size - this.deleted.size;
+	}
+};
+
+//#endregion
+//#region src/internal/overlays/relations-overlay.ts
+var RelationsOverlay = class extends Map {
+	deleted = /* @__PURE__ */ new Set();
+	source;
+	constructor(source) {
+		super();
+		this.source = source;
+	}
+	get(key) {
+		const has = super.has(key);
+		if (has) return super.get(key);
+		if (!this.deleted.has(key) && this.source.has(key)) {
+			const value = this.source.get(key);
+			const valueOverlay = new SetOverlay(value);
+			super.set(key, valueOverlay);
+			return valueOverlay;
+		}
+		return void 0;
+	}
+	set(key, value) {
+		this.deleted.delete(key);
+		return super.set(key, value);
+	}
+	has(key) {
+		return !this.deleted.has(key) && (super.has(key) || this.source.has(key));
+	}
+	delete(key) {
+		this.deleted.add(key);
+		return super.delete(key);
+	}
+};
+
 //#endregion
 //#region src/internal/junction.ts
-var Junction = class {
+var Junction = class Junction {
 	a;
 	b;
 	cardinality;
@@ -167,14 +309,21 @@ var Junction = class {
 		this.a = data.between[0];
 		this.b = data.between[1];
 		this.cardinality = data.cardinality;
-		if (!config?.externalStore) {
-			this.relations = new Map(data.relations?.map(([x, ys]) => [x, new Set(ys)]));
-			this.contents = new Map(data.contents);
-		}
 		this.isAType = config?.isAType ?? null;
 		this.isBType = config?.isBType ?? null;
 		this.isContent = config?.isContent ?? null;
 		if (config?.makeContentKey) this.makeContentKey = config.makeContentKey;
+		if (!config?.externalStore) {
+			const source = config?.source;
+			if (source === void 0) {
+				this.relations = new Map(data.relations?.map(([x, ys]) => [x, new Set(ys)]));
+				this.contents = new Map(data.contents);
+			}
+			if (source) {
+				this.relations = new RelationsOverlay(source.relations);
+				this.contents = new MapOverlay(source.contents);
+			}
+		}
 		if (config?.externalStore) {
 			const externalStore = config.externalStore;
 			this.has = (a, b) => externalStore.has(a, b);
@@ -277,12 +426,10 @@ var Junction = class {
 		if (a === void 0 && typeof b === `string`) {
 			const bRelations = this.getRelatedKeys(b);
 			if (bRelations) for (const bRelation of bRelations) this.delete(bRelation, b);
-		}
-		if (typeof a === `string` && b === void 0) {
+		} else if (typeof a === `string` && b === void 0) {
 			const aRelations = this.getRelatedKeys(a);
 			if (aRelations) for (const aRelation of aRelations) this.delete(a, aRelation);
-		}
-		if (typeof a === `string` && typeof b === `string`) {
+		} else if (typeof a === `string` && typeof b === `string`) {
 			this.deleteRelation(a, b);
 			const contentKey = this.makeContentKey(a, b);
 			this.deleteContent(contentKey);
@@ -341,6 +488,30 @@ var Junction = class {
 		}
 		return this.relations.has(a);
 	}
+	overlay() {
+		const config = {
+			source: this,
+			makeContentKey: this.makeContentKey
+		};
+		if (this.isAType) config.isAType = this.isAType;
+		if (this.isBType) config.isBType = this.isBType;
+		if (this.isContent) config.isContent = this.isContent;
+		if (this.warn) config.warn = this.warn;
+		return new Junction({
+			between: [this.a, this.b],
+			cardinality: this.cardinality
+		}, config);
+	}
+	incorporate(overlay) {
+		const { relations, contents } = overlay;
+		for (const [key, value] of relations) if (value instanceof SetOverlay) {
+			const { source } = value;
+			for (const keyAdded of value.iterateOwn()) source.add(keyAdded);
+		} else this.relations.set(key, value);
+		for (const key of relations.deleted) this.relations.delete(key);
+		for (const [key, value] of contents) this.contents.set(key, value);
+		for (const key of contents.deleted) this.contents.delete(key);
+	}
 };
 
 //#endregion
@@ -587,6 +758,7 @@ function writeToCache(target, state, value) {
 		});
 		return future;
 	}
+	target.logger.info(`📝`, state.type, state.key, `writing to cache`, value);
 	target.valueMap.set(key, value);
 	return value;
 }
@@ -626,10 +798,19 @@ function evictCachedValue(target, key) {
 	target.logger.info(`🗑`, `state`, key, `evicted`);
 }
 
+//#endregion
+//#region src/internal/is-fn.ts
+const NON_CTOR_FN_REGEX = /^\[object (?:Async|Generator|AsyncGenerator)?Function\]$/;
+function isFn(input) {
+	const protoString = Object.prototype.toString.call(input);
+	return NON_CTOR_FN_REGEX.test(protoString);
+}
+
 //#endregion
 //#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);
+	target.logger.info(`❔`, state.type, state.key, `value not found in cache`);
 	const { key } = state;
 	switch (state.type) {
 		case `readonly_held_selector`:
@@ -640,16 +821,20 @@ function readOrComputeValue(target, state, mut) {
 			return state.getFrom(target);
 		case `atom`: {
 			let def;
-			if (state.default instanceof Function) def = state.default();
-			else def = state.default;
+			if (isFn(state.default)) {
+				def = state.default();
+				target.logger.info(`✨`, state.type, key, `computed default`, def);
+			} else {
+				def = state.default;
+				target.logger.info(`✨`, state.type, key, `using static default`, def);
+			}
 			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();
+			target.logger.info(`✨`, state.type, key, `created new instance`, instance);
 			const cachedValue = writeToCache(target, state, instance);
-			target.logger.info(`💁`, `mutable_atom`, state.key, `could not find cached value; using default`, instance);
 			return cachedValue;
 		}
 	}
@@ -664,6 +849,26 @@ function getFamilyOfToken(store, token) {
 	});
 }
 
+//#endregion
+//#region src/internal/families/mint-in-store.ts
+const MUST_CREATE = Symbol(`MUST_CREATE`);
+function mintInStore(store, family, key, mustCreate) {
+	const stringKey = stringifyJson(key);
+	const molecule = store.molecules.get(stringKey);
+	const cannotCreate = !molecule && store.config.lifespan === `immortal`;
+	if (cannotCreate) {
+		store.logger.warn(`💣`, `key`, stringKey, `was used to mint a counterfeit token for`, family.type, `"${family.key}"`);
+		return mint(family, key, COUNTERFEIT);
+	}
+	let token;
+	if (mustCreate === MUST_CREATE) {
+		store.logger.info(`👪`, family.type, family.key, `adds member`, typeof key === `string` ? `\`${key}\`` : key);
+		token = family(key);
+		if (molecule) store.moleculeData.set(stringKey, family.key);
+	} else token = mint(family, key);
+	return token;
+}
+
 //#endregion
 //#region src/internal/transaction/abort-transaction.ts
 const abortTransaction = (store) => {
@@ -696,62 +901,24 @@ function actUponStore(store, token, id) {
 
 //#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);
-		}
-	}
+function become(nextVersionOfThing, originalThing) {
+	if (isFn(nextVersionOfThing)) return nextVersionOfThing(originalThing);
+	return nextVersionOfThing;
 }
 
 //#endregion
 //#region src/internal/set-state/set-atom.ts
 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);
+	let newValue = become(next, oldValue);
+	target.logger.info(`⭐`, `atom`, atom.key, `setting value`, newValue);
 	newValue = writeToCache(target, atom, newValue);
 	markDone(target, atom.key);
 	evictDownstreamFromAtom(target, atom);
-	return [oldValue, newValue];
+	return {
+		oldValue,
+		newValue
+	};
 };
 
 //#endregion
@@ -761,7 +928,7 @@ function resetAtom(target, atom) {
 		case `mutable_atom`: return setAtom(target, atom, new atom.class());
 		case `atom`: {
 			let def = atom.default;
-			if (def instanceof Function) def = def();
+			if (isFn(def)) def = def();
 			return setAtom(target, atom, def);
 		}
 	}
@@ -783,7 +950,10 @@ function resetAtomOrSelector(target, state) {
 					dispatchOrDeferStateUpdate(target, state, rootProtoUpdate, false);
 				}
 				const newValue = state.getFrom(target);
-				protoUpdate = [oldValue, newValue];
+				protoUpdate = {
+					oldValue,
+					newValue
+				};
 			}
 			break;
 	}
@@ -822,20 +992,23 @@ function setSelector(target, selector, next) {
 	const { type, key } = selector;
 	switch (selector.type) {
 		case `writable_pure_selector`:
-			oldValue = selector.getFrom(target);
-			newValue = become(next)(oldValue);
-			writeToCache(target, selector, newValue);
+			oldValue = readOrComputeValue(target, selector, `mut`);
+			newValue = become(next, oldValue);
+			newValue = writeToCache(target, selector, newValue);
 			break;
 		case `writable_held_selector`:
 			constant = selector.const;
-			become(next)(constant);
+			become(next, constant);
 			oldValue = constant;
 			newValue = constant;
 	}
-	target.logger.info(`📝`, type, key, `setting to`, newValue);
+	target.logger.info(`⭐`, type, key, `setting to`, newValue);
 	markDone(target, key);
 	selector.setSelf(newValue);
-	return [oldValue, newValue];
+	return {
+		oldValue,
+		newValue
+	};
 }
 
 //#endregion
@@ -856,9 +1029,9 @@ const setAtomOrSelector = (target, state, value) => {
 };
 
 //#endregion
-//#region src/internal/ingest-updates/ingest-atom-update.ts
-function ingestAtomUpdate(applying, atomUpdate, store) {
-	const { token, update: { newValue, oldValue } } = atomUpdate;
+//#region src/internal/events/ingest-atom-update.ts
+function ingestAtomUpdateEvent(store, event, applying) {
+	const { token, update: { newValue, oldValue } } = event;
 	const value = applying === `newValue` ? newValue : oldValue;
 	setIntoStore(store, token, value);
 }
@@ -1015,59 +1188,57 @@ function claimWithinStore(store, newProvenance, claim, exclusive) {
 }
 
 //#endregion
-//#region src/internal/ingest-updates/ingest-creation-disposal.ts
-function ingestCreationEvent(update, applying, store) {
+//#region src/internal/events/ingest-creation-disposal.ts
+function ingestCreationEvent(store, event, applying) {
 	switch (applying) {
 		case `newValue`:
-			createInStore(update, store);
+			createInStore(store, event);
 			break;
 		case `oldValue`:
-			disposeFromStore(store, update.token);
+			disposeFromStore(store, event.token);
 			break;
 	}
 }
-function ingestDisposalEvent(update, applying, store) {
+function ingestDisposalEvent(store, event, applying) {
 	switch (applying) {
 		case `newValue`:
-			disposeFromStore(store, update.token);
+			disposeFromStore(store, event.token);
 			break;
 		case `oldValue`:
-			createInStore(update, store);
-			if (update.subType === `atom`) store.valueMap.set(update.token.key, update.value);
+			createInStore(store, event);
+			if (event.subType === `atom`) store.valueMap.set(event.token.key, event.value);
 			break;
 	}
 }
-function createInStore(update, store) {
-	const { family: familyMeta } = update.token;
-	if (familyMeta) {
-		const family = store.families.get(familyMeta.key);
-		if (family) mintInStore(store, family, parseJson(familyMeta.subKey), MUST_CREATE);
-	}
+function createInStore(store, event) {
+	const { token } = event;
+	if (event.subType === `writable` && event.value) setIntoStore(store, token, event.value);
+	else getFromStore(store, token);
 }
-function ingestMoleculeCreationEvent(update, applying, store) {
+function ingestMoleculeCreationEvent(store, event, applying) {
 	switch (applying) {
 		case `newValue`:
-			allocateIntoStore(store, update.provenance, update.key);
+			allocateIntoStore(store, event.provenance, event.key);
 			break;
 		case `oldValue`:
-			deallocateFromStore(store, update.key);
+			deallocateFromStore(store, event.key);
 			break;
 	}
 }
-function ingestMoleculeDisposalEvent(update, applying, store) {
+function ingestMoleculeDisposalEvent(store, event, applying) {
 	switch (applying) {
 		case `newValue`:
-			deallocateFromStore(store, update.key);
+			deallocateFromStore(store, event.key);
 			break;
 		case `oldValue`:
 			{
-				const provenanceJson = update.provenance.map(parseJson);
-				allocateIntoStore(store, provenanceJson, update.key);
-				for (const [familyKey, value] of update.values) {
+				const provenanceJson = event.provenance.map(parseJson);
+				allocateIntoStore(store, provenanceJson, event.key);
+				for (const [familyKey, value] of event.values) {
 					const family = store.families.get(familyKey);
 					if (family) {
-						mintInStore(store, family, update.key, MUST_CREATE);
-						const memberKey = `${familyKey}(${stringifyJson(update.key)})`;
+						getFromStore(store, family, event.key);
+						const memberKey = `${familyKey}(${stringifyJson(event.key)})`;
 						store.valueMap.set(memberKey, value);
 					}
 				}
@@ -1075,16 +1246,16 @@ function ingestMoleculeDisposalEvent(update, applying, store) {
 			break;
 	}
 }
-function ingestMoleculeTransferEvent(update, applying, store) {
+function ingestMoleculeTransferEvent(store, event, applying) {
 	switch (applying) {
 		case `newValue`:
-			for (const newOwner of update.to) claimWithinStore(store, newOwner, update.key, update.exclusive ? `exclusive` : void 0);
+			for (const newOwner of event.to) claimWithinStore(store, newOwner, event.key, event.exclusive ? `exclusive` : void 0);
 			break;
 		case `oldValue`:
 			{
 				let exclusivity = `exclusive`;
-				for (const previousOwner of update.from) {
-					claimWithinStore(store, previousOwner, update.key, exclusivity);
+				for (const previousOwner of event.from) {
+					claimWithinStore(store, previousOwner, event.key, exclusivity);
 					exclusivity = void 0;
 				}
 			}
@@ -1093,39 +1264,39 @@ function ingestMoleculeTransferEvent(update, applying, store) {
 }
 
 //#endregion
-//#region src/internal/ingest-updates/ingest-selector-update.ts
-function ingestSelectorUpdate(applying, selectorUpdate, store) {
+//#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) ingestAtomUpdate(applying, atomUpdate, store);
+	for (const atomUpdate of updates) ingestAtomUpdateEvent(store, atomUpdate, applying);
 }
 
 //#endregion
-//#region src/internal/ingest-updates/ingest-transaction-update.ts
-function ingestTransactionUpdate(applying, transactionUpdate, store) {
-	const updates = applying === `newValue` ? transactionUpdate.subEvents : [...transactionUpdate.subEvents].reverse();
-	for (const updateFromTransaction of updates) switch (updateFromTransaction.type) {
+//#region src/internal/events/ingest-transaction-update.ts
+function ingestTransactionOutcomeEvent(store, event, applying) {
+	const subEvents = applying === `newValue` ? event.subEvents : [...event.subEvents].reverse();
+	for (const subEvent of subEvents) switch (subEvent.type) {
 		case `atom_update`:
-			ingestAtomUpdate(applying, updateFromTransaction, store);
+			ingestAtomUpdateEvent(store, subEvent, applying);
 			break;
 		case `state_creation`:
-			ingestCreationEvent(updateFromTransaction, applying, store);
+			ingestCreationEvent(store, subEvent, applying);
 			break;
 		case `state_disposal`:
-			ingestDisposalEvent(updateFromTransaction, applying, store);
+			ingestDisposalEvent(store, subEvent, applying);
 			break;
 		case `molecule_creation`:
-			ingestMoleculeCreationEvent(updateFromTransaction, applying, store);
+			ingestMoleculeCreationEvent(store, subEvent, applying);
 			break;
 		case `molecule_disposal`:
-			ingestMoleculeDisposalEvent(updateFromTransaction, applying, store);
+			ingestMoleculeDisposalEvent(store, subEvent, applying);
 			break;
 		case `molecule_transfer`:
-			ingestMoleculeTransferEvent(updateFromTransaction, applying, store);
+			ingestMoleculeTransferEvent(store, subEvent, applying);
 			break;
 		case `transaction_outcome`:
-			ingestTransactionUpdate(applying, updateFromTransaction, store);
+			ingestTransactionOutcomeEvent(store, subEvent, applying);
 			break;
 	}
 }
@@ -1163,7 +1334,7 @@ function setEpochNumberOfAction(store, transactionKey, newEpoch) {
 
 //#endregion
 //#region src/internal/transaction/apply-transaction.ts
-const applyTransaction = (output, store) => {
+function applyTransaction(store, output) {
 	const child = newest(store);
 	const { parent } = child;
 	if (parent === null || !isChildStore(child) || child.transactionMeta?.phase !== `building`) {
@@ -1176,7 +1347,7 @@ const applyTransaction = (output, store) => {
 	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);
-	ingestTransactionUpdate(`newValue`, child.transactionMeta.update, parent);
+	ingestTransactionOutcomeEvent(parent, child.transactionMeta.update, `newValue`);
 	if (isRootStore(parent)) {
 		setEpochNumberOfAction(parent, child.transactionMeta.update.token.key, child.transactionMeta.update.epoch);
 		const myTransaction = withdraw(store, {
@@ -1187,7 +1358,7 @@ const applyTransaction = (output, store) => {
 		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);
-};
+}
 
 //#endregion
 //#region src/internal/transaction/assign-transaction-to-continuity.ts
@@ -1205,40 +1376,6 @@ function getEnvironmentData(store) {
 	return { store };
 }
 
-//#endregion
-//#region src/internal/lazy-map.ts
-var LazyMap = class extends Map {
-	deleted = /* @__PURE__ */ new Set();
-	source;
-	constructor(source) {
-		super();
-		this.source = source;
-	}
-	get(key) {
-		const has = super.has(key);
-		if (has) return super.get(key);
-		if (!this.deleted.has(key) && this.source.has(key)) {
-			const value = this.source.get(key);
-			return value;
-		}
-		return void 0;
-	}
-	set(key, value) {
-		this.deleted.delete(key);
-		return super.set(key, value);
-	}
-	hasOwn(key) {
-		return super.has(key);
-	}
-	has(key) {
-		return !this.deleted.has(key) && (super.has(key) || this.source.has(key));
-	}
-	delete(key) {
-		this.deleted.add(key);
-		return super.delete(key);
-	}
-};
-
 //#endregion
 //#region src/internal/transaction/build-transaction.ts
 const buildTransaction = (store, token, params, id) => {
@@ -1250,27 +1387,27 @@ const buildTransaction = (store, token, params, id) => {
 		loggers: parent.loggers,
 		logger: parent.logger,
 		config: parent.config,
-		atoms: new LazyMap(parent.atoms),
+		atoms: new MapOverlay(parent.atoms),
 		atomsThatAreDefault: new Set(parent.atomsThatAreDefault),
-		families: new LazyMap(parent.families),
-		joins: new LazyMap(parent.joins),
+		families: new MapOverlay(parent.families),
+		joins: new MapOverlay(parent.joins),
 		operation: { open: false },
-		readonlySelectors: new LazyMap(parent.readonlySelectors),
-		timelines: new LazyMap(parent.timelines),
-		timelineTopics: new Junction(parent.timelineTopics.toJSON()),
+		readonlySelectors: new MapOverlay(parent.readonlySelectors),
+		timelines: new MapOverlay(parent.timelines),
+		timelineTopics: parent.timelineTopics.overlay(),
 		trackers: /* @__PURE__ */ new Map(),
-		transactions: new LazyMap(parent.transactions),
-		selectorAtoms: new Junction(parent.selectorAtoms.toJSON()),
-		selectorGraph: new Junction(parent.selectorGraph.toJSON(), { makeContentKey: (...keys) => keys.sort().join(`:`) }),
-		writableSelectors: new LazyMap(parent.writableSelectors),
-		valueMap: new LazyMap(parent.valueMap),
+		transactions: new MapOverlay(parent.transactions),
+		selectorAtoms: parent.selectorAtoms.overlay(),
+		selectorGraph: parent.selectorGraph.overlay(),
+		writableSelectors: new MapOverlay(parent.writableSelectors),
+		valueMap: new MapOverlay(parent.valueMap),
 		defaults: parent.defaults,
 		disposalTraces: store.disposalTraces.copy(),
-		molecules: new LazyMap(parent.molecules),
-		moleculeGraph: new Junction(parent.moleculeGraph.toJSON(), { makeContentKey: parent.moleculeGraph.makeContentKey }),
-		moleculeData: new Junction(parent.moleculeData.toJSON(), { makeContentKey: parent.moleculeData.makeContentKey }),
-		moleculeJoins: new Junction(parent.moleculeJoins.toJSON(), { makeContentKey: parent.moleculeJoins.makeContentKey }),
-		miscResources: new LazyMap(parent.miscResources)
+		molecules: new MapOverlay(parent.molecules),
+		moleculeGraph: parent.moleculeGraph.overlay(),
+		moleculeData: parent.moleculeData.overlay(),
+		moleculeJoins: parent.moleculeJoins.overlay(),
+		miscResources: new MapOverlay(parent.miscResources)
 	};
 	const epoch = getEpochNumberOfAction(store, token.key);
 	const transactionMeta = {
@@ -1323,7 +1460,7 @@ function createTransaction(store, options) {
 				const target$1 = newest(store);
 				const { toolkit } = childStore.transactionMeta;
 				const output = options.do(toolkit, ...params);
-				applyTransaction(output, target$1);
+				applyTransaction(target$1, output);
 				return output;
 			} catch (thrown) {
 				abortTransaction(target);
@@ -1350,59 +1487,74 @@ const TRANSACTION_PHASES = [
 ];
 
 //#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
-const MUST_CREATE = Symbol(`MUST_NOT_EXIST`);
-function mintInStore(store, familyToken, key, shouldCreate) {
-	let stateToken;
-	let willCreate;
-	switch (shouldCreate) {
-		case MUST_CREATE:
-			willCreate = true;
-			break;
-		case void 0:
-			willCreate = false;
-			break;
-	}
-	const stringKey = stringifyJson(key);
-	const molecule = store.molecules.get(stringKey);
-	if (!molecule && store.config.lifespan === `immortal`) {
-		const fakeToken = mint(familyToken, key, COUNTERFEIT);
-		store.logger.warn(`💣`, `key`, stringKey, `was used to mint a counterfeit token for`, familyToken.type, `"${familyToken.key}"`);
-		return fakeToken;
-	}
-	if (willCreate) {
-		stateToken = initFamilyMemberInStore(store, familyToken, key);
-		const target = newest(store);
-		if (stateToken.family) {
-			if (isRootStore(target)) switch (stateToken.type) {
+//#region src/internal/set-state/dispatch-state-update.ts
+function dispatchOrDeferStateUpdate(target, state, { oldValue, newValue }, stateIsNewlyCreated, family) {
+	const token = deposit(state);
+	if (stateIsNewlyCreated && family) {
+		state.subject.next({ newValue });
+		const stateCreationEvent = {
+			type: `state_creation`,
+			subType: `writable`,
+			token,
+			timestamp: Date.now(),
+			value: newValue
+		};
+		const familySubject = family.subject;
+		familySubject.next(stateCreationEvent);
+		const innerTarget = newest(target);
+		if (token.family) {
+			if (isRootStore(innerTarget)) switch (token.type) {
 				case `atom`:
 				case `mutable_atom`:
-					store.on.atomCreation.next(stateToken);
+					target.on.atomCreation.next(token);
 					break;
 				case `writable_pure_selector`:
-				case `readonly_pure_selector`:
 				case `writable_held_selector`:
-				case `readonly_held_selector`:
-					store.on.selectorCreation.next(stateToken);
+					target.on.selectorCreation.next(token);
 					break;
 			}
-			else if (isChildStore(target) && target.on.transactionApplying.state === null) target.transactionMeta.update.subEvents.push({
-				type: `state_creation`,
-				token: stateToken,
-				timestamp: Date.now()
-			});
+			else if (isChildStore(innerTarget) && innerTarget.on.transactionApplying.state === null) innerTarget.transactionMeta.update.subEvents.push(stateCreationEvent);
 		}
-		if (molecule) target.moleculeData.set(stringKey, familyToken.key);
-	} else stateToken = mint(familyToken, key);
-	return stateToken;
+		return;
+	}
+	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) {
+			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
@@ -1423,20 +1575,16 @@ function operateOnStore(store, opMode, ...params) {
 			family = getFamilyOfToken(store, token);
 			key = parseJson(token.family.subKey);
 			existingToken = seekInStore(store, family, key);
-			if (!existingToken) {
-				brandNewToken = mintInStore(store, family, key, MUST_CREATE);
-				token = brandNewToken;
-			} else token = existingToken;
+			if (!existingToken) token = brandNewToken = mintInStore(store, family, key, MUST_CREATE);
+			else token = existingToken;
 		}
 	} else {
-		family = params[0];
+		family = withdraw(store, params[0]);
 		key = params[1];
 		value = params[2];
 		existingToken = seekInStore(store, family, key);
-		if (!existingToken) {
-			brandNewToken = mintInStore(store, family, key, MUST_CREATE);
-			token = brandNewToken;
-		} else token = existingToken;
+		if (!existingToken) token = brandNewToken = mintInStore(store, family, key, MUST_CREATE);
+		else token = existingToken;
 	}
 	const action = value === RESET_STATE ? `reset` : `set`;
 	let target;
@@ -1465,7 +1613,7 @@ function operateOnStore(store, opMode, ...params) {
 	if (value === RESET_STATE) protoUpdate = resetAtomOrSelector(target, state);
 	else protoUpdate = setAtomOrSelector(target, state, value);
 	const isNewlyCreated = Boolean(brandNewToken);
-	dispatchOrDeferStateUpdate(target, state, protoUpdate, isNewlyCreated);
+	dispatchOrDeferStateUpdate(target, state, protoUpdate, isNewlyCreated, family);
 	if (opMode === OWN_OP) closeOperation(target);
 }
 
@@ -1528,12 +1676,10 @@ function registerSelector(store, selectorType, selectorKey, covered) {
 	return {
 		get: (...params) => {
 			const target = newest(store);
-			const { token, familyToken, subKey } = reduceReference(store, ...params);
+			const { token, family, subKey } = reduceReference(store, ...params);
 			let dependencyValue;
-			if (`counterfeit` in token && familyToken && subKey) {
-				const dependencyFamily = withdraw(store, familyToken);
-				dependencyValue = getFallback(store, token, dependencyFamily, subKey);
-			} else {
+			if (`counterfeit` in token && family && subKey) dependencyValue = getFallback(store, token, family, subKey);
+			else {
 				const dependency = withdraw(store, token);
 				dependencyValue = readOrComputeValue(store, dependency);
 			}
@@ -1562,6 +1708,7 @@ function createReadonlyHeldSelector(store, options, family) {
 	const covered = /* @__PURE__ */ new Set();
 	const { key, const: constant } = options;
 	const type = `readonly_held_selector`;
+	store.logger.info(`🔨`, type, key, `is being created`);
 	const { get, find, json } = registerSelector(target, type, key, covered);
 	const getFrom = (innerTarget) => {
 		const upstreamStates = innerTarget.selectorGraph.getRelationEntries({ downstreamSelectorKey: key });
@@ -1573,6 +1720,7 @@ function createReadonlyHeldSelector(store, options, family) {
 			json
 		}, constant);
 		writeToCache(innerTarget, readonlySelector, constant);
+		store.logger.info(`✨`, type, key, `=`, constant);
 		covered.clear();
 		return constant;
 	};
@@ -1585,7 +1733,6 @@ function createReadonlyHeldSelector(store, options, family) {
 	};
 	if (family) readonlySelector.family = family;
 	target.readonlySelectors.set(key, readonlySelector);
-	store.logger.info(`✨`, type, key, `=`, constant);
 	const token = {
 		key,
 		type
@@ -1602,6 +1749,7 @@ function createReadonlyPureSelector(store, options, family) {
 	const covered = /* @__PURE__ */ new Set();
 	const key = options.key;
 	const type = `readonly_pure_selector`;
+	store.logger.info(`🔨`, type, key, `is being created`);
 	const { get, find, json } = registerSelector(target, type, key, covered);
 	const getFrom = () => {
 		const innerTarget = newest(store);
@@ -1643,6 +1791,7 @@ function createWritableHeldSelector(store, options, family) {
 	const covered = /* @__PURE__ */ new Set();
 	const { key, const: constant } = options;
 	const type = `writable_held_selector`;
+	store.logger.info(`🔨`, type, key, `is being created`);
 	const setterToolkit = registerSelector(target, type, key, covered);
 	const { find, get, json } = setterToolkit;
 	const getterToolkit = {
@@ -1689,6 +1838,7 @@ function createWritablePureSelector(store, options, family) {
 	const covered = /* @__PURE__ */ new Set();
 	const key = options.key;
 	const type = `writable_pure_selector`;
+	store.logger.info(`🔨`, type, key, `is being created`);
 	const setterToolkit = registerSelector(target, type, key, covered);
 	const { find, get, json } = setterToolkit;
 	const getterToolkit = {
@@ -1719,8 +1869,6 @@ function createWritablePureSelector(store, options, family) {
 	};
 	if (family) mySelector.family = family;
 	target.writableSelectors.set(key, mySelector);
-	const initialValue = getFrom(target);
-	store.logger.info(`✨`, mySelector.type, mySelector.key, `=`, initialValue);
 	const token = {
 		key,
 		type
@@ -1869,11 +2017,6 @@ function createReadonlyPureSelectorFamily(store, options, internalRoles) {
 			key: fullKey,
 			get: options.get(key)
 		}, family);
-		subject.next({
-			type: `state_creation`,
-			token,
-			timestamp: Date.now()
-		});
 		return token;
 	};
 	const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
@@ -1914,15 +2057,10 @@ function createRegularAtomFamily(store, options, internalRoles) {
 		const def = options.default;
 		const individualOptions = {
 			key: fullKey,
-			default: def instanceof Function ? () => def(key) : def
+			default: isFn(def) ? () => def(key) : def
 		};
 		if (options.effects) individualOptions.effects = options.effects(key);
 		const token = createRegularAtom(target, individualOptions, family);
-		subject.next({
-			type: `state_creation`,
-			token,
-			timestamp: Date.now()
-		});
 		return token;
 	};
 	const atomFamily$1 = Object.assign(familyFunction, familyToken, {
@@ -1932,7 +2070,7 @@ function createRegularAtomFamily(store, options, internalRoles) {
 		internalRoles
 	});
 	store.families.set(options.key, atomFamily$1);
-	if (options.default instanceof Function === false) store.defaults.set(options.key, options.default);
+	if (isFn(options.default) === false) store.defaults.set(options.key, options.default);
 	return familyToken;
 }
 
@@ -1961,11 +2099,6 @@ function createReadonlyHeldSelectorFamily(store, options, internalRoles) {
 			const: options.const(key),
 			get: options.get(key)
 		}, family);
-		subject.next({
-			type: `state_creation`,
-			token,
-			timestamp: Date.now()
-		});
 		return token;
 	};
 	const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
@@ -2004,11 +2137,6 @@ function createWritableHeldSelectorFamily(store, options, internalRoles) {
 			get: options.get(key),
 			set: options.set(key)
 		}, family);
-		subject.next({
-			type: `state_creation`,
-			token,
-			timestamp: Date.now()
-		});
 		return token;
 	};
 	const selectorFamily$1 = Object.assign(familyFunction, familyToken, {
@@ -2046,11 +2174,6 @@ function createWritablePureSelectorFamily(store, options, internalRoles) {
 			get: options.get(key),
 			set: options.set(key)
 		}, family);
-		subject.next({
-			type: `state_creation`,
-			token,
-			timestamp: Date.now()
-		});
 		return token;
 	};
 	const selectorFamily$1 = Object.assign(familyFunction, familyToken, {
@@ -2109,10 +2232,10 @@ function seekInStore(store, token, key) {
 //#endregion
 //#region src/internal/families/find-in-store.ts
 function findInStore(store, familyToken, key) {
-	withdraw(store, familyToken);
+	const family = withdraw(store, familyToken);
 	const existingStateToken = seekInStore(store, familyToken, key);
 	if (existingStateToken) return existingStateToken;
-	const newStateToken = mintInStore(store, familyToken, key);
+	const newStateToken = mintInStore(store, family, key);
 	return newStateToken;
 }
 
@@ -2152,19 +2275,19 @@ function disposeFromStore(store, ...params) {
 function reduceReference(store, ...params) {
 	let existingToken;
 	let brandNewToken;
-	let familyToken;
+	let family;
 	let subKey;
 	let token;
 	if (params.length === 1) {
 		token = params[0];
 		if (`family` in token) {
-			familyToken = getFamilyOfToken(store, token);
-			withdraw(store, familyToken);
+			const familyToken = getFamilyOfToken(store, token);
+			family = withdraw(store, familyToken);
 			subKey = parseJson(token.family.subKey);
 			existingToken = seekInStore(store, familyToken, subKey);
 			if (`counterfeit` in token) return {
 				token,
-				familyToken,
+				family,
 				subKey,
 				isNew: false
 			};
@@ -2174,17 +2297,45 @@ function reduceReference(store, ...params) {
 			} else token = existingToken;
 		}
 	} else {
-		familyToken = params[0];
+		family = withdraw(store, params[0]);
 		subKey = params[1];
-		existingToken = seekInStore(store, familyToken, subKey);
+		existingToken = seekInStore(store, family, subKey);
 		if (!existingToken) {
-			brandNewToken = mintInStore(store, familyToken, subKey, MUST_CREATE);
+			brandNewToken = mintInStore(store, family, subKey, MUST_CREATE);
 			token = brandNewToken;
 		} else token = existingToken;
 	}
+	const isCounterfeit = `counterfeit` in token;
+	const isNewlyCreated = Boolean(brandNewToken) && isCounterfeit === false;
+	if (isNewlyCreated && family) {
+		const stateCreationEvent = {
+			type: `state_creation`,
+			subType: `readable`,
+			token,
+			timestamp: Date.now()
+		};
+		const familySubject = family.subject;
+		familySubject.next(stateCreationEvent);
+		const target = newest(store);
+		if (token.family) {
+			if (isRootStore(target)) switch (token.type) {
+				case `atom`:
+				case `mutable_atom`:
+					store.on.atomCreation.next(token);
+					break;
+				case `writable_pure_selector`:
+				case `readonly_pure_selector`:
+				case `writable_held_selector`:
+				case `readonly_held_selector`:
+					store.on.selectorCreation.next(token);
+					break;
+			}
+			else if (isChildStore(target) && target.on.transactionApplying.state === null) target.transactionMeta.update.subEvents.push(stateCreationEvent);
+		}
+	}
 	return {
 		token,
-		familyToken,
+		family,
 		subKey,
 		isNew: Boolean(brandNewToken)
 	};
@@ -2193,11 +2344,8 @@ function reduceReference(store, ...params) {
 //#endregion
 //#region src/internal/get-state/get-from-store.ts
 function getFromStore(store, ...params) {
-	const { token, familyToken, subKey } = reduceReference(store, ...params);
-	if (`counterfeit` in token && familyToken && subKey) {
-		const family = withdraw(store, familyToken);
-		return getFallback(store, token, family, subKey);
-	}
+	const { token, family, subKey } = reduceReference(store, ...params);
+	if (`counterfeit` in token && family && subKey) return getFallback(store, token, family, subKey);
 	const state = withdraw(store, token);
 	return readOrComputeValue(store, state);
 }
@@ -2547,11 +2695,6 @@ function createMutableAtomFamily(store, options, internalRoles) {
 		};
 		if (options.effects) individualOptions.effects = options.effects(key);
 		const token = createMutableAtom(target, individualOptions, family);
-		subject.next({
-			type: `state_creation`,
-			token,
-			timestamp: Date.now()
-		});
 		return token;
 	};
 	const atomFamily$1 = Object.assign(familyFunction, familyToken, {
@@ -2767,7 +2910,7 @@ const clearStore = (store) => {
 function createRegularAtom(store, options, family, internalRoles) {
 	const type = `atom`;
 	const { key } = options;
-	store.logger.info(`🔨`, `atom`, key, `creating in store "${store.config.name}"`);
+	store.logger.info(`🔨`, type, key, `is being created`);
 	const target = newest(store);
 	const existing = target.atoms.get(key);
 	if (existing && existing.type === type) {
@@ -3609,23 +3752,23 @@ const timeTravel = (store, action, token) => {
 	}
 	timelineData.timeTraveling = action === `redo` ? `into_future` : `into_past`;
 	if (action === `undo`) --timelineData.at;
-	const update = timelineData.history[timelineData.at];
+	const event = timelineData.history[timelineData.at];
 	const applying = action === `redo` ? `newValue` : `oldValue`;
-	switch (update.type) {
+	switch (event.type) {
 		case `atom_update`:
-			ingestAtomUpdate(applying, update, store);
+			ingestAtomUpdateEvent(store, event, applying);
 			break;
 		case `selector_update`:
-			ingestSelectorUpdate(applying, update, store);
+			ingestSelectorUpdateEvent(store, event, applying);
 			break;
 		case `transaction_outcome`:
-			ingestTransactionUpdate(applying, update, store);
+			ingestTransactionOutcomeEvent(store, event, applying);
 			break;
 		case `state_creation`:
-			ingestCreationEvent(update, applying, store);
+			ingestCreationEvent(store, event, applying);
 			break;
 		case `state_disposal`:
-			ingestDisposalEvent(update, applying, store);
+			ingestDisposalEvent(store, event, applying);
 			break;
 		case `molecule_creation`:
 		case `molecule_disposal`:
@@ -3637,5 +3780,5 @@ const timeTravel = (store, action, token) => {
 };
 
 //#endregion
-export { COUNTERFEIT, 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, 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, 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, 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 };
 //# sourceMappingURL=index.js.map