atom.io 0.41.1 → 0.42.1

package/dist/internal/index.js

@@ -1,6 +1,6 @@
-import { Anarchy, AtomIOLogger, PRETTY_TOKEN_TYPES } from "atom.io";
+import { AtomIOLogger, PRETTY_TOKEN_TYPES, decomposeCompound, simpleCompound } 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) {
@@ -625,7 +625,8 @@ function makeRootMoleculeInStore(store, key) {
 	const molecule = {
 		key,
 		stringKey: stringifyJson(key),
-		dependsOn: `any`
+		dependsOn: `any`,
+		subject: new Subject()
 	};
 	store.molecules.set(stringifyJson(key), molecule);
 	return key;
@@ -645,10 +646,12 @@ function allocateIntoStore(store, provenance, key, dependsOn = `any`) {
 		if (target.molecules.get(claimString)) store.moleculeGraph.set(claimString, stringKey, { source: claimString });
 		else invalidKeys.push(claimString);
 	}
+	const subject = new Subject();
 	if (invalidKeys.length === 0) target.molecules.set(stringKey, {
 		key,
 		stringKey,
-		dependsOn
+		dependsOn,
+		subject
 	});
 	const creationEvent = {
 		type: `molecule_creation`,
@@ -685,12 +688,24 @@ function deallocateFromStore(target, claim) {
 		target.logger.error(`❌`, `key`, claim, `deallocation failed:`, `Could not find allocation for ${stringKey} in store "${target.config.name}".`, disposal ? `\n   This state was most recently deallocated\n${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`);
 		return;
 	}
-	const joinKeys = target.moleculeJoins.getRelatedKeys(stringKey);
+	molecule.subject.next();
+	const joinKeys = target.keyRefsInJoins.getRelatedKeys(stringKey);
 	if (joinKeys) for (const joinKey of joinKeys) {
 		const join$1 = target.joins.get(joinKey);
 		if (join$1) join$1.relations.delete(claim);
 	}
-	target.moleculeJoins.delete(stringKey);
+	else {
+		const compound = decomposeCompound(claim);
+		if (compound) {
+			const [, a, b] = compound;
+			const joinKey = target.keyRefsInJoins.getRelatedKey(simpleCompound(a, b));
+			if (joinKey) {
+				const join$1 = target.joins.get(joinKey);
+				if (join$1) join$1.relations.delete(a, b);
+			}
+		}
+	}
+	target.keyRefsInJoins.delete(stringKey);
 	const provenance = [];
 	const values = [];
 	const relatedMolecules = target.moleculeGraph.getRelationEntries({ downstreamMoleculeKey: stringKey });
@@ -716,7 +731,7 @@ function deallocateFromStore(target, claim) {
 	const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
 	if (isTransaction) target.transactionMeta.update.subEvents.push(disposalEvent);
 	target.moleculeGraph.delete(molecule.stringKey);
-	target.moleculeJoins.delete(molecule.stringKey);
+	target.keyRefsInJoins.delete(molecule.stringKey);
 	target.moleculeData.delete(molecule.stringKey);
 	if (!isTransaction) target.on.moleculeDisposal.next(disposalEvent);
 	target.molecules.delete(molecule.stringKey);
@@ -983,7 +998,7 @@ const buildTransaction = (store, token, params, id) => {
 		molecules: new MapOverlay(parent.molecules),
 		moleculeGraph: parent.moleculeGraph.overlay(),
 		moleculeData: parent.moleculeData.overlay(),
-		moleculeJoins: parent.moleculeJoins.overlay(),
+		keyRefsInJoins: parent.keyRefsInJoins.overlay(),
 		miscResources: new MapOverlay(parent.miscResources)
 	};
 	const epoch = getEpochNumberOfAction(store, token.key);
@@ -1098,10 +1113,6 @@ var Store = class {
 	});
 	disposalTraces = new CircularBuffer(100);
 	molecules = /* @__PURE__ */ new Map();
-	moleculeJoins = new Junction({
-		between: [`moleculeKey`, `joinKey`],
-		cardinality: `n:n`
-	}, { makeContentKey: (...keys) => keys.sort().join(`:`) });
 	moleculeGraph = new Junction({
 		between: [`upstreamMoleculeKey`, `downstreamMoleculeKey`],
 		cardinality: `n:n`
@@ -1110,6 +1121,10 @@ var Store = class {
 		between: [`moleculeKey`, `stateFamilyKey`],
 		cardinality: `n:n`
 	}, { makeContentKey: (...keys) => keys.sort().join(`:`) });
+	keyRefsInJoins = new Junction({
+		between: [`moleculeKey`, `joinKey`],
+		cardinality: `n:n`
+	}, { makeContentKey: (...keys) => keys.sort().join(`:`) });
 	miscResources = /* @__PURE__ */ new Map();
 	on = {
 		atomCreation: new Subject(),
@@ -2655,6 +2670,14 @@ function createMutableAtom(store, options, family) {
 	if (family) newAtom.family = family;
 	target.atoms.set(newAtom.key, newAtom);
 	const token = deposit(newAtom);
+	new Tracker(token, store);
+	if (!family) createStandaloneSelector(store, {
+		key: `${key}:JSON`,
+		get: ({ get }) => get(token).toJSON(),
+		set: ({ set }, newValue) => {
+			set(token, options.class.fromJSON(newValue));
+		}
+	});
 	if (options.effects) {
 		let effectIndex = 0;
 		const cleanupFunctions = [];
@@ -2666,7 +2689,9 @@ function createMutableAtom(store, options, family) {
 				setSelf: (next) => {
 					setIntoStore(store, token, next);
 				},
-				onSet: (handle) => subscribeToState(store, token, `effect[${effectIndex}]`, handle)
+				onSet: (handle) => subscribeToState(store, token, `effect[${effectIndex}]`, handle),
+				token,
+				store: eldest(store)
 			});
 			if (cleanup) cleanupFunctions.push(cleanup);
 			++effectIndex;
@@ -2675,14 +2700,6 @@ function createMutableAtom(store, options, family) {
 			for (const cleanup of cleanupFunctions) cleanup();
 		};
 	}
-	new Tracker(token, store);
-	if (!family) createStandaloneSelector(store, {
-		key: `${key}:JSON`,
-		get: ({ get }) => get(token).toJSON(),
-		set: ({ set }, newValue) => {
-			set(token, options.class.fromJSON(newValue));
-		}
-	});
 	store.on.atomCreation.next(token);
 	return token;
 }
@@ -2966,7 +2983,9 @@ function createRegularAtom(store, options, family, internalRoles) {
 				setSelf: (next) => {
 					setIntoStore(store, token, next);
 				},
-				onSet: (handle) => subscribeToState(store, token, `effect[${effectIndex}]`, handle)
+				onSet: (handle) => subscribeToState(store, token, `effect[${effectIndex}]`, handle),
+				token,
+				store: eldest(store)
 			});
 			if (cleanup) cleanupFunctions.push(cleanup);
 			++effectIndex;
@@ -3064,10 +3083,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;
@@ -3075,15 +3093,11 @@ var Join = class {
 		this.toolkit = originalToolkit;
 	}
 	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 = {
 			get: ((...ps) => getFromStore(store, ...ps)),
 			set: ((...ps) => {
@@ -3096,28 +3110,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 +3125,42 @@ 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.add(a);
-						nextRelationsOfA.add(newRelationB);
+						if (!newRelationBIsAlreadyRelated && relationsOfB.size > 0) set(relationsOfBAtom, (relations$1) => {
+							relations$1.clear();
+							return relations$1;
+						});
+						for (const previousOwner of previousOwnersToDispose) store.keyRefsInJoins.delete(simpleCompound(newRelationB, previousOwner));
 					}
-					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 +3169,41 @@ 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.keyRefsInJoins.set(`"${a}"`, options.key);
+					this.store.keyRefsInJoins.set(`"${b}"`, options.key);
+					this.store.keyRefsInJoins.set(simpleCompound(a, b), options.key);
+					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 compositeKey = simpleCompound(a, b);
+					this.store.keyRefsInJoins.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 +3218,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 +3243,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 +3263,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 +3282,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 +3320,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 +3335,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 +3350,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,42 +3358,9 @@ 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;
+	return getJoin(token, store).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;
-}
-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
 function createTimeline(store, options, data) {
@@ -3809,5 +3638,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