atom.io 0.36.3 → 0.37.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.36.3",
+  "version": "0.37.0",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -72,9 +72,9 @@
     "@types/npmlog": "7.0.0",
     "@types/react": "19.1.10",
     "@types/tmp": "0.2.6",
-    "@typescript-eslint/parser": "8.39.1",
-    "@typescript-eslint/rule-tester": "8.39.1",
-    "@typescript-eslint/utils": "8.39.1",
+    "@typescript-eslint/parser": "8.40.0",
+    "@typescript-eslint/rule-tester": "8.40.0",
+    "@typescript-eslint/utils": "8.40.0",
     "@vitest/coverage-v8": "3.2.4",
     "@vitest/ui": "3.2.4",
     "concurrently": "9.2.0",
@@ -87,7 +87,7 @@
     "npmlog": "7.0.1",
     "nyc": "17.1.0",
     "postgres": "3.4.7",
-    "preact": "10.27.0",
+    "preact": "10.27.1",
     "react": "19.1.1",
     "react-dom": "19.1.1",
     "react-router-dom": "7.8.1",

package/src/internal/atom/dispose-atom.ts

@@ -1,4 +1,4 @@
-import type { AtomDisposal, AtomToken } from "atom.io"
+import type { AtomDisposalEvent, AtomToken } from "atom.io"
 
 import type { Store } from ".."
 import { getUpdateToken, isChildStore, newest, withdraw } from ".."
@@ -14,11 +14,12 @@ export function disposeAtom(store: Store, atomToken: AtomToken<unknown>): void {
 		const lastValue = store.valueMap.get(atom.key)
 		const atomFamily = withdraw(store, { key: family.key, type: `atom_family` })
 
-		const disposal: AtomDisposal<AtomToken<unknown>> = {
+		const disposal: AtomDisposalEvent<AtomToken<unknown>> = {
 			type: `state_disposal`,
 			subType: `atom`,
 			token: atomToken,
 			value: lastValue,
+			timestamp: Date.now(),
 		}
 
 		atomFamily.subject.next(disposal)
@@ -39,14 +40,14 @@ export function disposeAtom(store: Store, atomToken: AtomToken<unknown>): void {
 		}
 		store.logger.info(`🔥`, `atom`, key, `deleted`)
 		if (isChild && target.transactionMeta.phase === `building`) {
-			const mostRecentUpdate = target.transactionMeta.update.updates.at(-1)
+			const mostRecentUpdate = target.transactionMeta.update.subEvents.at(-1)
 			const wasMoleculeDisposal = mostRecentUpdate?.type === `molecule_disposal`
 			const updateAlreadyCaptured =
 				wasMoleculeDisposal &&
 				mostRecentUpdate.values.some(([k]) => k === atom.family?.key)
 
 			if (!updateAlreadyCaptured) {
-				target.transactionMeta.update.updates.push(disposal)
+				target.transactionMeta.update.subEvents.push(disposal)
 			}
 		} else {
 			store.on.atomDisposal.next(atomToken)

package/src/internal/caching.ts

@@ -113,7 +113,7 @@ export function evictCachedValue(target: Store, key: string): void {
 		const selector =
 			target.writableSelectors.get(key) ?? target.readonlySelectors.get(key)
 		if (selector) {
-			selector.get()
+			selector.getFrom(target)
 		}
 		return
 	}

package/src/internal/families/create-readonly-held-selector-family.ts

@@ -3,8 +3,7 @@ import type {
 	ReadonlyHeldSelectorFamilyOptions,
 	ReadonlyHeldSelectorFamilyToken,
 	ReadonlyHeldSelectorToken,
-	StateCreation,
-	StateDisposal,
+	StateLifecycleEvent,
 } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
@@ -45,8 +44,7 @@ export function createReadonlyHeldSelectorFamily<
 	}
 
 	const subject = new Subject<
-		| StateCreation<ReadonlyHeldSelectorToken<T>>
-		| StateDisposal<ReadonlyHeldSelectorToken<T>>
+		StateLifecycleEvent<ReadonlyHeldSelectorToken<T>>
 	>()
 
 	const familyFunction = (key: K): ReadonlyHeldSelectorToken<T> => {
@@ -65,7 +63,7 @@ export function createReadonlyHeldSelectorFamily<
 			family,
 		)
 
-		subject.next({ type: `state_creation`, token })
+		subject.next({ type: `state_creation`, token, timestamp: Date.now() })
 		return token
 	}
 

package/src/internal/families/create-readonly-pure-selector-family.ts

@@ -5,8 +5,7 @@ import type {
 	ReadonlyPureSelectorFamilyOptions,
 	ReadonlyPureSelectorFamilyToken,
 	ReadonlyPureSelectorToken,
-	StateCreation,
-	StateDisposal,
+	StateLifecycleEvent,
 } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
@@ -49,8 +48,7 @@ export function createReadonlyPureSelectorFamily<T, K extends Canonical>(
 	}
 
 	const subject = new Subject<
-		| StateCreation<ReadonlyPureSelectorToken<T>>
-		| StateDisposal<ReadonlyPureSelectorToken<T>>
+		StateLifecycleEvent<ReadonlyPureSelectorToken<T>>
 	>()
 
 	const familyFunction = (key: K): ReadonlyPureSelectorToken<T> => {
@@ -68,7 +66,7 @@ export function createReadonlyPureSelectorFamily<T, K extends Canonical>(
 			family,
 		)
 
-		subject.next({ type: `state_creation`, token })
+		subject.next({ type: `state_creation`, token, timestamp: Date.now() })
 		return token
 	}
 

package/src/internal/families/create-regular-atom-family.ts

@@ -4,8 +4,7 @@ import type {
 	RegularAtomFamilyToken,
 	RegularAtomOptions,
 	RegularAtomToken,
-	StateCreation,
-	StateDisposal,
+	StateLifecycleEvent,
 } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
@@ -38,9 +37,7 @@ export function createRegularAtomFamily<T, K extends Canonical>(
 		)
 	}
 
-	const subject = new Subject<
-		StateCreation<RegularAtomToken<T>> | StateDisposal<RegularAtomToken<T>>
-	>()
+	const subject = new Subject<StateLifecycleEvent<RegularAtomToken<T>>>()
 
 	const familyFunction = (key: K): RegularAtomToken<any> => {
 		const subKey = stringifyJson(key)
@@ -59,7 +56,7 @@ export function createRegularAtomFamily<T, K extends Canonical>(
 
 		const token = createRegularAtom(target, individualOptions, family)
 
-		subject.next({ type: `state_creation`, token })
+		subject.next({ type: `state_creation`, token, timestamp: Date.now() })
 		return token
 	}
 

package/src/internal/families/create-writable-held-selector-family.ts

@@ -1,7 +1,6 @@
 import type {
 	FamilyMetadata,
-	StateCreation,
-	StateDisposal,
+	StateLifecycleEvent,
 	WritableHeldSelectorFamilyOptions,
 	WritableHeldSelectorFamilyToken,
 	WritableHeldSelectorToken,
@@ -43,8 +42,7 @@ export function createWritableHeldSelectorFamily<
 		)
 	}
 	const subject = new Subject<
-		| StateCreation<WritableHeldSelectorToken<T>>
-		| StateDisposal<WritableHeldSelectorToken<T>>
+		StateLifecycleEvent<WritableHeldSelectorToken<T>>
 	>()
 
 	const familyFunction = (key: K): WritableHeldSelectorToken<T> => {
@@ -64,7 +62,7 @@ export function createWritableHeldSelectorFamily<
 			family,
 		)
 
-		subject.next({ type: `state_creation`, token })
+		subject.next({ type: `state_creation`, token, timestamp: Date.now() })
 		return token
 	}
 

package/src/internal/families/create-writable-pure-selector-family.ts

@@ -2,8 +2,7 @@ import type {
 	FamilyMetadata,
 	findState,
 	getState,
-	StateCreation,
-	StateDisposal,
+	StateLifecycleEvent,
 	WritablePureSelectorFamilyOptions,
 	WritablePureSelectorFamilyToken,
 	WritablePureSelectorToken,
@@ -48,8 +47,7 @@ export function createWritablePureSelectorFamily<T, K extends Canonical>(
 		)
 	}
 	const subject = new Subject<
-		| StateCreation<WritablePureSelectorToken<T>>
-		| StateDisposal<WritablePureSelectorToken<T>>
+		StateLifecycleEvent<WritablePureSelectorToken<T>>
 	>()
 
 	const familyFunction = (key: K): WritablePureSelectorToken<T> => {
@@ -68,7 +66,7 @@ export function createWritablePureSelectorFamily<T, K extends Canonical>(
 			family,
 		)
 
-		subject.next({ type: `state_creation`, token })
+		subject.next({ type: `state_creation`, token, timestamp: Date.now() })
 		return token
 	}
 

package/src/internal/families/find-in-store.ts

@@ -16,12 +16,11 @@ import type {
 	WritablePureSelectorToken,
 	WritableToken,
 } from "atom.io"
-import { type Canonical, stringifyJson } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
-import { newest } from "../lineage"
 import type { Transceiver } from "../mutable"
-import { counterfeit, type Store } from "../store"
-import { initFamilyMemberInStore } from "./init-family-member"
+import type { Store } from "../store"
+import { mintInStore } from "./mint-in-store"
 import { seekInStore } from "./seek-in-store"
 
 export function findInStore<
@@ -30,77 +29,61 @@ export function findInStore<
 	Key extends K,
 >(
 	store: Store,
-	token: MutableAtomFamilyToken<T, K>,
+	familyToken: MutableAtomFamilyToken<T, K>,
 	key: Key,
 ): MutableAtomToken<T, K>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
-	token: RegularAtomFamilyToken<T, K>,
+	familyToken: RegularAtomFamilyToken<T, K>,
 	key: Key,
 ): RegularAtomToken<T, K>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
-	token: AtomFamilyToken<T, K>,
+	familyToken: AtomFamilyToken<T, K>,
 	key: Key,
 ): AtomToken<T, K>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
-	token: WritablePureSelectorFamilyToken<T, K>,
+	familyToken: WritablePureSelectorFamilyToken<T, K>,
 	key: Key,
 ): WritablePureSelectorToken<T, K>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
-	token: ReadonlyPureSelectorFamilyToken<T, K>,
+	familyToken: ReadonlyPureSelectorFamilyToken<T, K>,
 	key: Key,
 ): ReadonlyPureSelectorToken<T, K>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
-	token: SelectorFamilyToken<T, K>,
+	familyToken: SelectorFamilyToken<T, K>,
 	key: Key,
 ): SelectorToken<T, K>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
-	token: WritableFamilyToken<T, K>,
+	familyToken: WritableFamilyToken<T, K>,
 	key: Key,
 ): WritableToken<T, K>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
-	token: ReadableFamilyToken<T, K>,
+	familyToken: ReadableFamilyToken<T, K>,
 	key: Key,
 ): ReadableToken<T, K>
 
 export function findInStore(
 	store: Store,
-	token: ReadableFamilyToken<any, any>,
+	familyToken: ReadableFamilyToken<any, any>,
 	key: Canonical,
 ): ReadableToken<any> {
-	let state = seekInStore(store, token, key)
-	if (state) {
-		return state
+	const existingStateToken = seekInStore(store, familyToken, key)
+	if (existingStateToken) {
+		return existingStateToken
 	}
-	const stringKey = stringifyJson(key)
-	const molecule = store.molecules.get(stringKey)
-	if (!molecule && store.config.lifespan === `immortal`) {
-		const fakeToken = counterfeit(token, key)
-		store.logger.error(
-			`❌`,
-			fakeToken.type,
-			fakeToken.key,
-			`was not found in store "${store.config.name}"; returned a counterfeit token.`,
-		)
-		return fakeToken
-	}
-	state = initFamilyMemberInStore(store, token, key)
-	if (molecule) {
-		const target = newest(store)
-		target.moleculeData.set(stringKey, token.key)
-	}
-	return state
+	const newStateToken = mintInStore(store, familyToken, key)
+	return newStateToken
 }

package/src/internal/families/init-family-member.ts

@@ -1,68 +1,13 @@
 import type {
-	AtomFamilyToken,
-	AtomToken,
-	MutableAtomFamilyToken,
-	MutableAtomToken,
 	ReadableFamilyToken,
 	ReadableToken,
-	ReadonlyPureSelectorFamilyToken,
-	ReadonlyPureSelectorToken,
-	RegularAtomFamilyToken,
-	RegularAtomToken,
-	SelectorFamilyToken,
-	SelectorToken,
 	WritableFamilyToken,
-	WritablePureSelectorFamilyToken,
-	WritablePureSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
-import { newest } from "../lineage"
-import type { Transceiver } from "../mutable"
-import { NotFoundError } from "../not-found-error"
 import type { Store } from "../store"
-import { isChildStore, isRootStore } from "../transaction"
-
-export function initFamilyMemberInStore<
-	T extends Transceiver<any, any, any>,
-	K extends Canonical,
-	Key extends K,
->(
-	store: Store,
-	token: MutableAtomFamilyToken<T, K>,
-	key: Key,
-): MutableAtomToken<T, K>
-
-export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
-	store: Store,
-	token: RegularAtomFamilyToken<T, K>,
-	key: Key,
-): RegularAtomToken<T, K>
-
-export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
-	store: Store,
-	token: AtomFamilyToken<T, K>,
-	key: Key,
-): AtomToken<T, K>
-
-export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
-	store: Store,
-	token: WritablePureSelectorFamilyToken<T, K>,
-	key: Key,
-): WritablePureSelectorToken<T, K>
-
-export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
-	store: Store,
-	token: ReadonlyPureSelectorFamilyToken<T, K>,
-	key: Key,
-): ReadonlyPureSelectorToken<T, K>
-
-export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
-	store: Store,
-	token: SelectorFamilyToken<T, K>,
-	key: Key,
-): SelectorToken<T, K>
+import { withdraw } from "../store"
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
@@ -79,37 +24,10 @@ export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 export function initFamilyMemberInStore(
 	store: Store,
 	token: ReadableFamilyToken<any, any>,
-	key: Json.Serializable,
+	key: Canonical,
 ): ReadableToken<any> {
-	const family = store.families.get(token.key)
-	if (family === undefined) {
-		throw new NotFoundError(token, store)
-	}
+	const family = withdraw(store, token)
 	const state = family(key)
-	const target = newest(store)
-	if (state.family) {
-		if (isRootStore(target)) {
-			switch (state.type) {
-				case `atom`:
-				case `mutable_atom`:
-					store.on.atomCreation.next(state)
-					break
-				case `writable_pure_selector`:
-				case `readonly_pure_selector`:
-				case `writable_held_selector`:
-				case `readonly_held_selector`:
-					store.on.selectorCreation.next(state)
-					break
-			}
-		} else if (
-			isChildStore(target) &&
-			target.on.transactionApplying.state === null
-		) {
-			target.transactionMeta.update.updates.push({
-				type: `state_creation`,
-				token: state,
-			})
-		}
-	}
+
 	return state
 }

package/src/internal/families/mint-in-store.ts

@@ -0,0 +1,74 @@
+import type {
+	ReadableFamilyToken,
+	ReadableToken,
+	WritableFamilyToken,
+	WritableToken,
+} from "atom.io"
+import type { Canonical } from "atom.io/json"
+import { stringifyJson } from "atom.io/json"
+
+import { newest } from "../lineage"
+import type { Store } from "../store"
+import { counterfeit } from "../store"
+import { isChildStore, isRootStore } from "../transaction"
+import { initFamilyMemberInStore } from "./init-family-member"
+
+export function mintInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
+	familyToken: WritableFamilyToken<T, K>,
+	key: Key,
+): WritableToken<T, K>
+export function mintInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
+	familyToken: ReadableFamilyToken<T, K>,
+	key: Key,
+): ReadableToken<T, K>
+export function mintInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
+	familyToken: ReadableFamilyToken<T, K>,
+	key: Key,
+): ReadableToken<T, K> {
+	const stringKey = stringifyJson(key)
+	const molecule = store.molecules.get(stringKey)
+	if (!molecule && store.config.lifespan === `immortal`) {
+		const fakeToken = counterfeit(familyToken, key)
+		store.logger.error(
+			`❌`,
+			fakeToken.type,
+			fakeToken.key,
+			`was not found in store "${store.config.name}"; returned a counterfeit token.`,
+		)
+		return fakeToken
+	}
+	const newStateToken = initFamilyMemberInStore(store, familyToken, key)
+	const target = newest(store)
+	if (newStateToken.family) {
+		if (isRootStore(target)) {
+			switch (newStateToken.type) {
+				case `atom`:
+				case `mutable_atom`:
+					store.on.atomCreation.next(newStateToken)
+					break
+				case `writable_pure_selector`:
+				case `readonly_pure_selector`:
+				case `writable_held_selector`:
+				case `readonly_held_selector`:
+					store.on.selectorCreation.next(newStateToken)
+					break
+			}
+		} else if (
+			isChildStore(target) &&
+			target.on.transactionApplying.state === null
+		) {
+			target.transactionMeta.update.subEvents.push({
+				type: `state_creation`,
+				token: newStateToken,
+				timestamp: Date.now(),
+			})
+		}
+	}
+	if (molecule) {
+		target.moleculeData.set(stringKey, familyToken.key)
+	}
+	return newStateToken
+}

package/src/internal/get-state/read-or-compute-value.ts

@@ -1,4 +1,6 @@
-import type { ReadableState, ViewOf } from ".."
+import type { ViewOf } from "atom.io"
+
+import type { ReadableState } from ".."
 import { readFromCache, writeToCache } from "../caching"
 import type { Store } from "../store"
 
@@ -27,7 +29,7 @@ export function readOrComputeValue<T>(
 		case `writable_held_selector`:
 		case `writable_pure_selector`:
 			target.logger.info(`🧮`, state.type, key, `computing value`)
-			return state.get()
+			return state.getFrom(target)
 		case `atom`: {
 			let def: T
 			if (state.default instanceof Function) {

package/src/internal/index.ts

@@ -9,9 +9,10 @@ import type {
 	ReadonlyPureSelectorToken,
 	RegularAtomFamilyToken,
 	RegularAtomToken,
-	StateCreation,
-	StateDisposal,
+	StateCreationEvent,
+	StateDisposalEvent,
 	StateLifecycleEvent,
+	StateUpdate,
 	WritableHeldSelectorFamilyToken,
 	WritableHeldSelectorToken,
 	WritablePureSelectorFamilyToken,
@@ -62,7 +63,7 @@ export type AtomIOState = {
 	key: string
 	family?: FamilyMetadata
 	install: (store: Store) => void
-	subject: Subject<{ newValue: any; oldValue: any }>
+	subject: Subject<StateUpdate<any>>
 }
 export type RegularAtom<T> = Flat<
 	AtomIOState & {
@@ -87,28 +88,28 @@ export type WritableHeldSelector<T> = Flat<
 	AtomIOState & {
 		type: `writable_held_selector`
 		const: T
-		get: () => T
-		set: (newValue: T | ((oldValue: T) => T)) => void
+		getFrom: (target: Store) => T
+		setSelf: (newValue: T) => void
 	}
 >
 export type ReadonlyHeldSelector<T> = Flat<
 	AtomIOState & {
 		type: `readonly_held_selector`
 		const: T
-		get: () => T
+		getFrom: (target: Store) => T
 	}
 >
 export type WritablePureSelector<T> = Flat<
 	AtomIOState & {
 		type: `writable_pure_selector`
-		get: () => T
-		set: (newValue: T | ((oldValue: T) => T)) => void
+		getFrom: (target: Store) => T
+		setSelf: (newValue: T) => void
 	}
 >
 export type ReadonlyPureSelector<T> = Flat<
 	AtomIOState & {
 		type: `readonly_pure_selector`
-		get: () => T
+		getFrom: (target: Store) => T
 	}
 >
 export type ReadonlySelector<T> =
@@ -135,7 +136,7 @@ export type RegularAtomFamily<T, K extends Canonical> =
 		(key: K): RegularAtomToken<T>
 		install: (store: Store) => void
 		internalRoles: string[] | undefined
-		subject: Subject<StateCreation<AtomToken<T>> | StateDisposal<AtomToken<T>>>
+		subject: Subject<StateCreationEvent<AtomToken<T>> | StateDisposalEvent<AtomToken<T>>>
 	}
 
 // biome-ignore format: intersection
@@ -167,8 +168,8 @@ export type WritablePureSelectorFamily<T, K extends Canonical> =
 			install: (store: Store) => void
 			internalRoles: string[] | undefined
 			subject: Subject<
-				| StateCreation<WritablePureSelectorToken<T>>
-				| StateDisposal<WritablePureSelectorToken<T>>
+				| StateCreationEvent<WritablePureSelectorToken<T>>
+				| StateDisposalEvent<WritablePureSelectorToken<T>>
 			>
 		}
 	>
@@ -183,8 +184,8 @@ export type WritableHeldSelectorFamily<T , K extends Canonical> =
 			install: (store: Store) => void
 			internalRoles: string[] | undefined
 			subject: Subject<
-				| StateCreation<WritableHeldSelectorToken<T>>
-				| StateDisposal<WritableHeldSelectorToken<T>>
+				| StateCreationEvent<WritableHeldSelectorToken<T>>
+				| StateDisposalEvent<WritableHeldSelectorToken<T>>
 			>
 		}
 	>
@@ -199,8 +200,8 @@ export type ReadonlyPureSelectorFamily<T, K extends Canonical> =
 			install: (store: Store) => void
 			internalRoles: string[] | undefined
 			subject: Subject<
-				| StateCreation<ReadonlyPureSelectorToken<T>>
-				| StateDisposal<ReadonlyPureSelectorToken<T>>
+				| StateCreationEvent<ReadonlyPureSelectorToken<T>>
+				| StateDisposalEvent<ReadonlyPureSelectorToken<T>>
 			>
 		}
 	>
@@ -215,8 +216,8 @@ export type ReadonlyHeldSelectorFamily<T , K extends Canonical> =
 			install: (store: Store) => void
 			internalRoles: string[] | undefined
 			subject: Subject<
-				| StateCreation<ReadonlyHeldSelectorToken<T>>
-				| StateDisposal<ReadonlyHeldSelectorToken<T>>
+				| StateCreationEvent<ReadonlyHeldSelectorToken<T>>
+				| StateDisposalEvent<ReadonlyHeldSelectorToken<T>>
 			>
 		}
 	>

package/src/internal/ingest-updates/ingest-atom-update.ts

@@ -1,18 +1,18 @@
-import type { KeyedStateUpdate, RegularAtomToken } from "atom.io"
+import type { AtomUpdateEvent } from "atom.io"
 
 import { setIntoStore } from "../set-state"
 import type { Store } from "../store"
 
 export function ingestAtomUpdate(
 	applying: `newValue` | `oldValue`,
-	atomUpdate: KeyedStateUpdate<any>,
+	atomUpdate: AtomUpdateEvent<any>,
 	store: Store,
 ): void {
-	const { key, newValue, oldValue } = atomUpdate
+	const {
+		token,
+		update: { newValue, oldValue },
+	} = atomUpdate
 	const value = applying === `newValue` ? newValue : oldValue
-	const token: RegularAtomToken<unknown> = { key, type: `atom` }
-	if (atomUpdate.family) {
-		Object.assign(token, { family: atomUpdate.family })
-	}
+
 	setIntoStore(store, token, value)
 }