atom.io 0.6.5 → 0.6.7

package/src/internal/atom-internal.ts

@@ -1,9 +1,7 @@
-import HAMT from "hamt_plus"
-
 import { Subject } from "."
 import { deposit } from "./get"
 import { markAtomAsDefault } from "./is-default"
-import { cacheValue, hasKeyBeenUsed } from "./operation"
+import { cacheValue } from "./operation"
 import type { Store } from "./store"
 import { IMPLICIT } from "./store"
 import { target } from "./transaction-internal"
@@ -25,11 +23,12 @@ export function atom__INTERNAL<T>(
 	store: Store = IMPLICIT.STORE,
 ): AtomToken<T> {
 	const core = target(store)
-	if (hasKeyBeenUsed(options.key, store)) {
+	const existing = core.atoms.get(options.key)
+	if (existing) {
 		store.config.logger?.error?.(
 			`Key "${options.key}" already exists in the store.`,
 		)
-		return deposit(core.atoms.get(options.key))
+		return deposit(existing)
 	}
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
 	const newAtom = {
@@ -40,7 +39,7 @@ export function atom__INTERNAL<T>(
 	} as const
 	const initialValue =
 		options.default instanceof Function ? options.default() : options.default
-	core.atoms = HAMT.set(newAtom.key, newAtom, core.atoms)
+	core.atoms.set(newAtom.key, newAtom)
 	markAtomAsDefault(options.key, store)
 	cacheValue(options.key, initialValue, store)
 	const token = deposit(newAtom)

package/src/internal/get.ts

@@ -1,5 +1,3 @@
-import HAMT from "hamt_plus"
-
 import type { ƒn } from "~/packages/anvl/src/function"
 
 import type {
@@ -29,9 +27,9 @@ export function lookup(
 	store: Store,
 ): AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown> {
 	const core = target(store)
-	const type = HAMT.has(key, core.atoms)
+	const type = core.atoms.has(key)
 		? `atom`
-		: HAMT.has(key, core.selectors)
+		: core.selectors.has(key)
 		? `selector`
 		: `readonly_selector`
 	return { key, type } as any
@@ -75,11 +73,11 @@ export function withdraw<T>(
 	| null {
 	const core = target(store)
 	return (
-		HAMT.get(token.key, core.atoms) ??
-		HAMT.get(token.key, core.selectors) ??
-		HAMT.get(token.key, core.readonlySelectors) ??
-		HAMT.get(token.key, core.transactions) ??
-		HAMT.get(token.key, core.timelines) ??
+		core.atoms.get(token.key) ??
+		core.selectors.get(token.key) ??
+		core.readonlySelectors.get(token.key) ??
+		core.transactions.get(token.key) ??
+		core.timelines.get(token.key) ??
 		null
 	)
 }

package/src/internal/index.ts

@@ -2,7 +2,6 @@ export * from "./atom-internal"
 export * from "./families-internal"
 export * from "./get"
 export * from "./is-default"
-export * as META from "./meta"
 export * from "./operation"
 export * from "./selector-internal"
 export * from "./selector"

package/src/internal/operation.ts

@@ -1,6 +1,3 @@
-import type { Hamt } from "hamt_plus"
-import HAMT from "hamt_plus"
-
 import type { Atom, ReadonlySelector, Selector } from "."
 import { target } from "."
 import type { Store } from "./store"
@@ -14,7 +11,7 @@ export type OperationProgress =
 	| {
 			open: true
 			done: Set<string>
-			prev: Hamt<any, string>
+			prev: Map<string, any>
 			time: number
 			token: StateToken<any>
 	  }
@@ -30,7 +27,7 @@ export const openOperation = (token: StateToken<any>, store: Store): void => {
 	core.operation = {
 		open: true,
 		done: new Set(),
-		prev: store.valueMap,
+		prev: new Map(store.valueMap),
 		time: Date.now(),
 		token,
 	}
@@ -42,6 +39,7 @@ export const closeOperation = (store: Store): void => {
 	const core = target(store)
 	core.operation = { open: false }
 	store.config.logger?.info(`🔴 operation done`)
+	store.subject.operationStatus.next(core.operation)
 }
 
 export const isDone = (key: string, store: Store = IMPLICIT.STORE): boolean => {
@@ -73,9 +71,9 @@ export const recallState = <T>(
 		store.config.logger?.warn(
 			`recall called outside of an operation. This is probably a bug.`,
 		)
-		return HAMT.get(state.key, core.valueMap)
+		return core.valueMap.get(state.key)
 	}
-	return HAMT.get(state.key, core.operation.prev)
+	return core.operation.prev.get(state.key)
 }
 
 export const cacheValue = (
@@ -84,7 +82,7 @@ export const cacheValue = (
 	store: Store = IMPLICIT.STORE,
 ): void => {
 	const core = target(store)
-	core.valueMap = HAMT.set(key, value, core.valueMap)
+	core.valueMap.set(key, value)
 }
 
 export const evictCachedValue = (
@@ -92,24 +90,24 @@ export const evictCachedValue = (
 	store: Store = IMPLICIT.STORE,
 ): void => {
 	const core = target(store)
-	core.valueMap = HAMT.remove(key, core.valueMap)
+	core.valueMap.delete(key)
 }
 export const readCachedValue = <T>(
 	key: string,
 	store: Store = IMPLICIT.STORE,
-): T => HAMT.get(key, target(store).valueMap)
+): T => target(store).valueMap.get(key)
 
 export const isValueCached = (
 	key: string,
 	store: Store = IMPLICIT.STORE,
-): boolean => HAMT.has(key, target(store).valueMap)
+): boolean => target(store).valueMap.has(key)
 
 export const storeAtom = (
 	atom: Atom<any>,
 	store: Store = IMPLICIT.STORE,
 ): void => {
 	const core = target(store)
-	core.atoms = HAMT.set(atom.key, atom, core.atoms)
+	core.atoms.set(atom.key, atom)
 }
 
 export const storeSelector = (
@@ -117,7 +115,7 @@ export const storeSelector = (
 	store: Store = IMPLICIT.STORE,
 ): void => {
 	const core = target(store)
-	core.selectors = HAMT.set(selector.key, selector, core.selectors)
+	core.selectors.set(selector.key, selector)
 }
 
 export const storeReadonlySelector = (
@@ -125,11 +123,7 @@ export const storeReadonlySelector = (
 	store: Store = IMPLICIT.STORE,
 ): void => {
 	const core = target(store)
-	core.readonlySelectors = HAMT.set(
-		selector.key,
-		selector,
-		core.readonlySelectors,
-	)
+	core.readonlySelectors.set(selector.key, selector)
 }
 
 export const hasKeyBeenUsed = (
@@ -138,8 +132,8 @@ export const hasKeyBeenUsed = (
 ): boolean => {
 	const core = target(store)
 	return (
-		HAMT.has(key, core.atoms) ||
-		HAMT.has(key, core.selectors) ||
-		HAMT.has(key, core.readonlySelectors)
+		core.atoms.has(key) ||
+		core.selectors.has(key) ||
+		core.readonlySelectors.has(key)
 	)
 }

package/src/internal/selector/create-read-write-selector.ts

@@ -1,5 +1,3 @@
-import HAMT from "hamt_plus"
-
 import { become } from "~/packages/anvl/src/function"
 
 import { Subject } from ".."
@@ -30,8 +28,14 @@ export const createReadWriteSelector = <T>(
 	}
 
 	const setSelf = (next: T | ((oldValue: T) => T)): void => {
-		store.config.logger?.info(`   <- "${options.key}" became`, next)
 		const oldValue = getSelf()
+		store.config.logger?.info(
+			`   <- "${options.key}" went (`,
+			oldValue,
+			`->`,
+			next,
+			`)`,
+		)
 		const newValue = become(next)(oldValue)
 		cacheValue(options.key, newValue, store)
 		markDone(options.key, store)
@@ -49,7 +53,7 @@ export const createReadWriteSelector = <T>(
 		type: `selector`,
 		...(family && { family }),
 	}
-	core.selectors = HAMT.set(options.key, mySelector, core.selectors)
+	core.selectors.set(options.key, mySelector)
 	const initialValue = getSelf()
 	store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
 	const token: SelectorToken<T> = {

package/src/internal/selector/create-readonly-selector.ts

@@ -1,5 +1,3 @@
-import HAMT from "hamt_plus"
-
 import { registerSelector } from "./register-selector"
 import { Subject } from ".."
 import type {
@@ -35,11 +33,7 @@ export const createReadonlySelector = <T>(
 		type: `readonly_selector`,
 		...(family && { family }),
 	}
-	core.readonlySelectors = HAMT.set(
-		options.key,
-		readonlySelector,
-		core.readonlySelectors,
-	)
+	core.readonlySelectors.set(options.key, readonlySelector)
 	const initialValue = getSelf()
 	store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
 	const token: ReadonlySelectorToken<T> = {

package/src/internal/selector-internal.ts

@@ -1,5 +1,3 @@
-import HAMT from "hamt_plus"
-
 import { target, IMPLICIT } from "."
 import type { Store, Subject } from "."
 import { createReadWriteSelector } from "./selector/create-read-write-selector"
@@ -47,7 +45,7 @@ export function selector__INTERNAL<T>(
 ): ReadonlySelectorToken<T> | SelectorToken<T> {
 	const core = target(store)
 
-	if (HAMT.has(options.key, core.selectors)) {
+	if (core.selectors.has(options.key)) {
 		store.config.logger?.error(
 			`Key "${options.key}" already exists in the store.`,
 		)

package/src/internal/set.ts

@@ -1,5 +1,3 @@
-import HAMT from "hamt_plus"
-
 import { become } from "~/packages/anvl/src/function"
 
 import type { Atom, Selector, Store } from "."
@@ -37,8 +35,7 @@ export const evictDownStream = <T>(
 			return
 		}
 		const state =
-			HAMT.get(stateKey, core.selectors) ??
-			HAMT.get(stateKey, core.readonlySelectors)
+			core.selectors.get(stateKey) ?? core.readonlySelectors.get(stateKey)
 		if (!state) {
 			store.config.logger?.info(
 				`   || ${stateKey} is an atom, and can't be downstream`,

package/src/internal/store.ts

@@ -1,6 +1,3 @@
-import type { Hamt } from "hamt_plus"
-import HAMT from "hamt_plus"
-
 import type { ƒn } from "~/packages/anvl/src/function"
 import { doNothing } from "~/packages/anvl/src/function"
 import { Join } from "~/packages/anvl/src/join"
@@ -40,24 +37,25 @@ export type StoreCore = Pick<
 >
 
 export interface Store {
-	atoms: Hamt<Atom<any>, string>
+	atoms: Map<string, Atom<any>>
 	atomsThatAreDefault: Set<string>
-	readonlySelectors: Hamt<ReadonlySelector<any>, string>
+	readonlySelectors: Map<string, ReadonlySelector<any>>
 	selectorAtoms: Join<null, `selectorKey`, `atomKey`>
 	selectorGraph: Join<{ source: string }>
-	selectors: Hamt<Selector<any>, string>
+	selectors: Map<string, Selector<any>>
 	timelineAtoms: Join<null, `timelineKey`, `atomKey`>
-	timelines: Hamt<Timeline, string>
-	transactions: Hamt<Transaction<any>, string>
-	valueMap: Hamt<any, string>
+	timelines: Map<string, Timeline>
+	transactions: Map<string, Transaction<any>>
+	valueMap: Map<string, any>
 
 	subject: {
 		atomCreation: Subject<AtomToken<unknown>>
 		selectorCreation: Subject<
 			ReadonlySelectorToken<unknown> | SelectorToken<unknown>
 		>
-		transactionCreation: Subject<TransactionToken<unknown>>
+		transactionCreation: Subject<TransactionToken<ƒn>>
 		timelineCreation: Subject<TimelineToken>
+		operationStatus: Subject<OperationProgress>
 	}
 
 	operation: OperationProgress
@@ -70,7 +68,7 @@ export interface Store {
 }
 
 export const createStore = (name: string, store: Store | null = null): Store => {
-	const copiedStore = {
+	const created = {
 		...(store ??
 			(() => ({
 				atomsThatAreDefault: new Set(),
@@ -78,14 +76,14 @@ export const createStore = (name: string, store: Store | null = null): Store =>
 					.from(`selectorKey`)
 					.to(`atomKey`),
 				selectorGraph: new Join({ relationType: `n:n` }),
-				valueMap: HAMT.make<any, string>(),
 			}))()),
 
-		atoms: HAMT.make<Atom<any>, string>(),
-		readonlySelectors: HAMT.make<ReadonlySelector<any>, string>(),
-		selectors: HAMT.make<Selector<any>, string>(),
-		transactions: HAMT.make<Transaction<any>, string>(),
-		timelines: HAMT.make<Timeline, string>(),
+		valueMap: new Map(store?.valueMap),
+		atoms: new Map(),
+		readonlySelectors: new Map(),
+		selectors: new Map(),
+		transactions: new Map(),
+		timelines: new Map(),
 
 		timelineAtoms: new Join({ relationType: `1:n` })
 			.from(`timelineKey`)
@@ -96,7 +94,7 @@ export const createStore = (name: string, store: Store | null = null): Store =>
 			selectorCreation: new Subject(),
 			transactionCreation: new Subject(),
 			timelineCreation: new Subject(),
-			...store?.subject,
+			operationStatus: new Subject(),
 		},
 
 		operation: {
@@ -121,22 +119,22 @@ export const createStore = (name: string, store: Store | null = null): Store =>
 
 	store?.atoms.forEach((atom) => {
 		const copiedAtom = { ...atom, subject: new Subject() } satisfies Atom<any>
-		copiedStore.atoms = HAMT.set(atom.key, copiedAtom, copiedStore.atoms)
+		created.atoms.set(atom.key, copiedAtom)
 	})
 	store?.readonlySelectors.forEach((selector) => {
-		selector.install(copiedStore)
+		selector.install(created)
 	})
 	store?.selectors.forEach((selector) => {
-		selector.install(copiedStore)
+		selector.install(created)
 	})
 	store?.transactions.forEach((tx) => {
-		tx.install(copiedStore)
+		tx.install(created)
 	})
 	store?.timelines.forEach((timeline) => {
-		timeline.install(copiedStore)
+		timeline.install(created)
 	})
 
-	return copiedStore
+	return created
 }
 
 export const IMPLICIT = {

package/src/internal/subscribe-internal.ts

@@ -74,7 +74,13 @@ export const subscribeToRootAtoms = <T>(
 						)
 						const oldValue = recallState(state, store)
 						const newValue = getState__INTERNAL(state, store)
-						store.config.logger?.info(`   <- ${state.key} became`, newValue)
+						store.config.logger?.info(
+							`   <- "${state.key}" went (`,
+							oldValue,
+							`->`,
+							newValue,
+							`)`,
+						)
 						state.subject.next({ newValue, oldValue })
 					})
 			  })

package/src/internal/time-travel-internal.ts

@@ -39,6 +39,7 @@ export const redo__INTERNAL = (
 		}
 	}
 	++timelineData.at
+	timelineData.subject.next(`redo`)
 	timelineData.timeTraveling = false
 	store.config.logger?.info(
 		`⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`,
@@ -82,6 +83,7 @@ export const undo__INTERNAL = (
 			break
 		}
 	}
+	timelineData.subject.next(`undo`)
 	timelineData.timeTraveling = false
 	store.config.logger?.info(
 		`⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`,

package/src/internal/timeline/add-atom-to-timeline.ts

@@ -1,6 +1,5 @@
 import { IMPLICIT, withdraw } from ".."
 import type {
-	TimelineSelectorUpdate,
 	Timeline,
 	Store,
 	TimelineTransactionUpdate,
@@ -58,9 +57,6 @@ export const addAtomToTimeline = (
 						`Timeline "${tl.key}" has a selectorTime, but no history. This is most likely a bug in AtomIO.`,
 					)
 				}
-				if (mostRecentUpdate.type === `selector_update`) {
-					tl.subject.next(mostRecentUpdate)
-				}
 			}
 			if (
 				currentTransactionKey &&
@@ -83,6 +79,7 @@ export const addAtomToTimeline = (
 					}
 					tl.transactionKey = currentTransactionKey
 					const subscription = currentTransaction.subject.subscribe((update) => {
+						subscription.unsubscribe()
 						if (tl.timeTraveling === false && currentTransactionTime) {
 							if (tl.at !== tl.history.length) {
 								tl.history.splice(tl.at)
@@ -96,10 +93,9 @@ export const addAtomToTimeline = (
 								),
 							}
 							tl.history.push(timelineTransactionUpdate)
+							tl.at = tl.history.length
 							tl.subject.next(timelineTransactionUpdate)
 						}
-						tl.at = tl.history.length
-						subscription.unsubscribe()
 						tl.transactionKey = null
 						store.config.logger?.info(
 							`⌛ timeline "${tl.key}" got a transaction_update "${update.key}"`,
@@ -107,14 +103,16 @@ export const addAtomToTimeline = (
 					})
 				}
 			} else if (currentSelectorKey && currentSelectorTime) {
+				let latestUpdate: TimelineUpdate | undefined = tl.history.at(-1)
+
 				if (currentSelectorTime !== tl.selectorTime) {
-					const newSelectorUpdate: TimelineSelectorUpdate = {
+					latestUpdate = {
 						type: `selector_update`,
 						timestamp: currentSelectorTime,
 						key: currentSelectorKey,
 						atomUpdates: [],
 					}
-					newSelectorUpdate.atomUpdates.push({
+					latestUpdate.atomUpdates.push({
 						key: atom.key,
 						type: `atom_update`,
 						...update,
@@ -122,16 +120,16 @@ export const addAtomToTimeline = (
 					if (tl.at !== tl.history.length) {
 						tl.history.splice(tl.at)
 					}
-					tl.history.push(newSelectorUpdate)
+					tl.history.push(latestUpdate)
 
 					store.config.logger?.info(
 						`⌛ timeline "${tl.key}" got a selector_update "${currentSelectorKey}" with`,
-						newSelectorUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key),
+						latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key),
 					)
+
 					tl.at = tl.history.length
 					tl.selectorTime = currentSelectorTime
 				} else {
-					const latestUpdate = tl.history.at(-1)
 					if (latestUpdate?.type === `selector_update`) {
 						latestUpdate.atomUpdates.push({
 							key: atom.key,
@@ -144,6 +142,7 @@ export const addAtomToTimeline = (
 						)
 					}
 				}
+				if (latestUpdate) tl.subject.next(latestUpdate)
 			} else {
 				const timestamp = Date.now()
 				tl.selectorTime = null
@@ -160,7 +159,7 @@ export const addAtomToTimeline = (
 				tl.history.push(atomUpdate)
 				tl.subject.next(atomUpdate)
 				store.config.logger?.info(
-					`⌛ timeline "${tl.key}" got a state_update to "${atom.key}"`,
+					`⌛ timeline "${tl.key}" got an atom_update to "${atom.key}"`,
 				)
 				tl.at = tl.history.length
 			}

package/src/internal/timeline-internal.ts

@@ -1,5 +1,3 @@
-import HAMT from "hamt_plus"
-
 import type { ƒn } from "~/packages/anvl/src/function"
 
 import type { Store } from "."
@@ -39,7 +37,11 @@ export type Timeline = {
 	transactionKey: string | null
 	install: (store: Store) => void
 	subject: Subject<
-		TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate
+		| TimelineAtomUpdate
+		| TimelineSelectorUpdate
+		| TimelineTransactionUpdate
+		| `redo`
+		| `undo`
 	>
 }
 
@@ -95,7 +97,7 @@ export function timeline__INTERNAL(
 		})
 	}
 
-	store.timelines = HAMT.set(options.key, tl, store.timelines)
+	store.timelines.set(options.key, tl)
 	const token: TimelineToken = {
 		key: options.key,
 		type: `timeline`,

package/src/internal/transaction/apply-transaction.ts

@@ -1,5 +1,3 @@
-import HAMT from "hamt_plus"
-
 import type { ƒn } from "~/packages/anvl/src/function"
 
 import type { Store } from ".."
@@ -26,10 +24,15 @@ export const applyTransaction = <ƒ extends ƒn>(
 
 	for (const { key, newValue } of atomUpdates) {
 		const token: AtomToken<unknown> = { key, type: `atom` }
-		if (!HAMT.has(token.key, store.valueMap)) {
-			const newAtom = HAMT.get(token.key, store.transactionStatus.core.atoms)
-			store.atoms = HAMT.set(newAtom.key, newAtom, store.atoms)
-			store.valueMap = HAMT.set(newAtom.key, newAtom.default, store.valueMap)
+		if (!store.valueMap.has(token.key)) {
+			const newAtom = store.transactionStatus.core.atoms.get(token.key)
+			if (!newAtom) {
+				throw new Error(
+					`Absurd Error: Atom "${token.key}" not found while copying updates from transaction "${store.transactionStatus.key}" to store "${store.config.name}"`,
+				)
+			}
+			store.atoms.set(newAtom.key, newAtom)
+			store.valueMap.set(newAtom.key, newAtom.default)
 			store.config.logger?.info(`🔧`, `add atom "${newAtom.key}"`)
 		}
 		setState(token, newValue, store)

package/src/internal/transaction/build-transaction.ts

@@ -10,17 +10,17 @@ export const buildTransaction = (
 		phase: `building`,
 		time: Date.now(),
 		core: {
-			atoms: store.atoms,
+			atoms: new Map(store.atoms),
 			atomsThatAreDefault: store.atomsThatAreDefault,
 			operation: { open: false },
-			readonlySelectors: store.readonlySelectors,
-			timelines: store.timelines,
+			readonlySelectors: new Map(store.readonlySelectors),
+			timelines: new Map(store.timelines),
 			timelineAtoms: store.timelineAtoms,
-			transactions: store.transactions,
+			transactions: new Map(store.transactions),
 			selectorAtoms: store.selectorAtoms,
 			selectorGraph: store.selectorGraph,
-			selectors: store.selectors,
-			valueMap: store.valueMap,
+			selectors: new Map(store.selectors),
+			valueMap: new Map(store.valueMap),
 		},
 		atomUpdates: [],
 		params,

package/src/internal/transaction-internal.ts

@@ -1,5 +1,3 @@
-import HAMT from "hamt_plus"
-
 import type { ƒn } from "~/packages/anvl/src/function"
 
 import type { Store, StoreCore } from "."
@@ -51,11 +49,7 @@ export function transaction__INTERNAL<ƒ extends ƒn>(
 		subject: new Subject(),
 	}
 	const core = target(store)
-	core.transactions = HAMT.set(
-		newTransaction.key,
-		newTransaction,
-		core.transactions,
-	)
+	core.transactions.set(newTransaction.key, newTransaction)
 	const token = deposit(newTransaction)
 	store.subject.transactionCreation.next(token)
 	return token

package/src/introspection/attach-atom-index.ts

@@ -0,0 +1,73 @@
+import type { AtomToken, ReadonlySelectorToken } from "atom.io"
+import { __INTERNAL__ } from "atom.io"
+
+import type { StateTokenIndex } from "."
+
+export type AtomTokenIndex = StateTokenIndex<AtomToken<unknown>>
+
+export const attachAtomIndex = (
+	store: __INTERNAL__.Store = __INTERNAL__.IMPLICIT.STORE,
+): ReadonlySelectorToken<AtomTokenIndex> => {
+	const atomTokenIndexState__INTERNAL =
+		__INTERNAL__.atom__INTERNAL<AtomTokenIndex>(
+			{
+				key: `👁‍🗨 Atom Token Index (Internal)`,
+				default: () =>
+					[...store.atoms]
+						.filter(([key]) => !key.includes(`👁‍🗨`))
+						.reduce<AtomTokenIndex>((acc, [key]) => {
+							acc[key] = { key, type: `atom` }
+							return acc
+						}, {}),
+				effects: [
+					({ setSelf }) => {
+						store.subject.atomCreation.subscribe((atomToken) => {
+							if (store.operation.open) {
+								return
+							}
+							if (atomToken.key.includes(`👁‍🗨`)) {
+								return
+							}
+							setSelf((state) => {
+								const { key, family } = atomToken
+								if (family) {
+									const { key: familyKey, subKey } = family
+									const current = state[familyKey]
+									if (current === undefined || `familyMembers` in current) {
+										const familyKeyState = current || {
+											key: familyKey,
+											familyMembers: {},
+										}
+										return {
+											...state,
+											[familyKey]: {
+												...familyKeyState,
+												familyMembers: {
+													...familyKeyState.familyMembers,
+													[subKey]: atomToken,
+												},
+											},
+										}
+									}
+								}
+								return {
+									...state,
+									[key]: atomToken,
+								}
+							})
+						})
+					},
+				],
+			},
+			undefined,
+			store,
+		)
+	return __INTERNAL__.selector__INTERNAL(
+		{
+			key: `👁‍🗨 Atom Token Index`,
+			get: ({ get }) => get(atomTokenIndexState__INTERNAL),
+		},
+		undefined,
+		store,
+	)
+}