atom.io 0.35.0 → 0.36.1

package/src/internal/mutable/create-mutable-atom-family.ts

@@ -7,30 +7,34 @@ import type {
 	StateCreation,
 	StateDisposal,
 } from "atom.io"
-import type { Canonical, Json } from "atom.io/json"
-import { selectJsonFamily, stringifyJson } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
+import { stringifyJson } from "atom.io/json"
 
-import { type MutableAtomFamily, prettyPrintTokenType } from ".."
+import {
+	createWritablePureSelectorFamily,
+	type MutableAtomFamily,
+	prettyPrintTokenType,
+} from ".."
 import { newest } from "../lineage"
 import { createMutableAtom } from "../mutable"
 import type { Store } from "../store"
 import { Subject } from "../subject"
 import { FamilyTracker } from "./tracker-family"
-import type { Transceiver } from "./transceiver"
+import type { AsJSON, Transceiver } from "./transceiver"
 
 export function createMutableAtomFamily<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any, any>,
 	K extends Canonical,
 >(
 	store: Store,
-	options: MutableAtomFamilyOptions<T, J, K>,
+	options: MutableAtomFamilyOptions<T, K>,
 	internalRoles?: string[],
-): MutableAtomFamilyToken<T, J, K> {
-	const familyToken = {
-		key: options.key,
-		type: `mutable_atom_family`,
-	} as const satisfies MutableAtomFamilyToken<T, J, K>
+): MutableAtomFamilyToken<T, K> {
+	const familyToken: MutableAtomFamilyToken<T & Transceiver<any, any, any>, K> =
+		{
+			key: options.key,
+			type: `mutable_atom_family`,
+		}
 
 	const existing = store.families.get(options.key)
 	if (existing) {
@@ -45,20 +49,18 @@ export function createMutableAtomFamily<
 	}
 
 	const subject = new Subject<
-		StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>
+		StateCreation<MutableAtomToken<T>> | StateDisposal<MutableAtomToken<T>>
 	>()
 
-	const familyFunction = (key: K): MutableAtomToken<T, J> => {
+	const familyFunction = (key: K): MutableAtomToken<T> => {
 		const subKey = stringifyJson(key)
 		const family: FamilyMetadata = { key: options.key, subKey }
 		const fullKey = `${options.key}(${subKey})`
 		const target = newest(store)
 
-		const individualOptions: MutableAtomOptions<T, J> = {
+		const individualOptions: MutableAtomOptions<T> = {
 			key: fullKey,
-			default: () => options.default(key),
-			toJson: options.toJson,
-			fromJson: options.fromJson,
+			class: options.class,
 		}
 		if (options.effects) {
 			individualOptions.effects = options.effects(key)
@@ -73,13 +75,29 @@ export function createMutableAtomFamily<
 	const atomFamily = Object.assign(familyFunction, familyToken, {
 		subject,
 		install: (s: Store) => createMutableAtomFamily(s, options),
-		toJson: options.toJson,
-		fromJson: options.fromJson,
 		internalRoles,
-	}) satisfies MutableAtomFamily<T, J, K>
+	}) satisfies MutableAtomFamily<T, K>
 
 	store.families.set(options.key, atomFamily)
-	selectJsonFamily(store, atomFamily, options)
+
+	createWritablePureSelectorFamily<AsJSON<T>, K>(
+		store,
+		{
+			key: `${options.key}:JSON`,
+			get:
+				(key) =>
+				({ get }) =>
+					get(familyToken, key).toJSON(),
+			set:
+				(key) =>
+				({ set }, newValue) => {
+					set(familyToken, key, options.class.fromJSON(newValue))
+				},
+		},
+		[`mutable`, `json`],
+	)
+
 	new FamilyTracker(atomFamily, store)
+
 	return familyToken
 }

package/src/internal/mutable/create-mutable-atom.ts

@@ -4,11 +4,9 @@ import type {
 	MutableAtomToken,
 	UpdateHandler,
 } from "atom.io"
-import type { Json } from "atom.io/json"
-import { selectJson } from "atom.io/json"
 
 import type { MutableAtom } from ".."
-import { resetInStore, setIntoStore } from ".."
+import { createStandaloneSelector, resetInStore, setIntoStore } from ".."
 import { newest } from "../lineage"
 import { deposit, type Store } from "../store"
 import { Subject } from "../subject"
@@ -16,14 +14,11 @@ import { subscribeToState } from "../subscribe"
 import { Tracker } from "./tracker"
 import type { Transceiver } from "./transceiver"
 
-export function createMutableAtom<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
->(
+export function createMutableAtom<T extends Transceiver<any, any, any>>(
 	store: Store,
-	options: MutableAtomOptions<T, J>,
+	options: MutableAtomOptions<T>,
 	family: FamilyMetadata | undefined,
-): MutableAtomToken<T, J> {
+): MutableAtomToken<T> {
 	store.logger.info(
 		`🔨`,
 		`atom`,
@@ -43,8 +38,11 @@ export function createMutableAtom<
 		)
 		return deposit(existing)
 	}
-	const subject = new Subject<{ newValue: T; oldValue: T }>()
-	const newAtom: MutableAtom<T, J> = {
+	const subject = new Subject<{
+		newValue: T
+		oldValue: T
+	}>()
+	const newAtom: MutableAtom<T> = {
 		...options,
 		type,
 		install: (s: Store) => {
@@ -86,7 +84,13 @@ export function createMutableAtom<
 
 	new Tracker(token, store)
 	if (!family) {
-		selectJson(token, options, store)
+		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

package/src/internal/mutable/get-json-family.ts

@@ -7,16 +7,17 @@ import type { Store } from "../store"
 import type { Transceiver } from "./transceiver"
 
 export const getJsonFamily = <
-	Core extends Transceiver<Json.Serializable>,
-	SerializableCore extends Json.Serializable,
+	Core extends Transceiver<any, Json.Serializable, Json.Serializable>,
 	Key extends Canonical,
 >(
-	mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>,
+	mutableAtomFamily: MutableAtomFamilyToken<Core, Key>,
 	store: Store,
-): WritablePureSelectorFamily<SerializableCore, Key> => {
+): WritablePureSelectorFamily<ReturnType<Core[`toJSON`]>, Key> => {
 	const target = newest(store)
 	const key = `${mutableAtomFamily.key}:JSON`
-	const jsonFamily: WritablePureSelectorFamily<SerializableCore, Key> =
-		target.families.get(key) as WritablePureSelectorFamily<SerializableCore, Key>
+	const jsonFamily = target.families.get(key) as WritablePureSelectorFamily<
+		ReturnType<Core[`toJSON`]>,
+		Key
+	>
 	return jsonFamily
 }

package/src/internal/mutable/get-json-token.ts

@@ -3,27 +3,20 @@ import type {
 	WritablePureSelectorFamilyToken,
 	WritablePureSelectorToken,
 } from "atom.io"
-import type { Json } from "atom.io/json"
 
 import { findInStore } from "../families"
 import { newest } from "../lineage"
 import { type Store, withdraw } from "../store"
-import type { Transceiver } from "./transceiver"
+import type { AsJSON, Transceiver } from "./transceiver"
 
-export const getJsonToken = <
-	Core extends Transceiver<any>,
-	SerializableCore extends Json.Serializable,
->(
+export const getJsonToken = <T extends Transceiver<any, any, any>>(
 	store: Store,
-	mutableAtomToken: MutableAtomToken<Core, SerializableCore>,
-): WritablePureSelectorToken<SerializableCore> => {
+	mutableAtomToken: MutableAtomToken<T>,
+): WritablePureSelectorToken<AsJSON<T>> => {
 	if (mutableAtomToken.family) {
 		const target = newest(store)
 		const jsonFamilyKey = `${mutableAtomToken.family.key}:JSON`
-		const jsonFamilyToken: WritablePureSelectorFamilyToken<
-			SerializableCore,
-			string
-		> = {
+		const jsonFamilyToken: WritablePureSelectorFamilyToken<AsJSON<T>, string> = {
 			key: jsonFamilyKey,
 			type: `writable_pure_selector_family`,
 		}
@@ -32,7 +25,7 @@ export const getJsonToken = <
 		const jsonToken = findInStore(store, family, subKey)
 		return jsonToken
 	}
-	const token: WritablePureSelectorToken<SerializableCore> = {
+	const token: WritablePureSelectorToken<AsJSON<T>> = {
 		type: `writable_pure_selector`,
 		key: `${mutableAtomToken.key}:JSON`,
 	}

package/src/internal/mutable/get-update-family.ts

@@ -4,20 +4,19 @@ import type { Json } from "atom.io/json"
 import type { AtomFamily } from ".."
 import { newest } from "../lineage"
 import type { Store } from "../store"
-import type { Signal, Transceiver } from "./transceiver"
+import type { SignalFrom, Transceiver } from "./transceiver"
 
 export const getUpdateFamily = <
-	Core extends Transceiver<Json.Serializable>,
-	SerializableCore extends Json.Serializable,
-	Key extends string,
+	T extends Transceiver<any, Json.Serializable, Json.Serializable>,
+	K extends string,
 >(
-	mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>,
+	mutableAtomFamily: MutableAtomFamilyToken<T, K>,
 	store: Store,
-): AtomFamily<Signal<Core>, Key> => {
+): AtomFamily<SignalFrom<T>, K> => {
 	const target = newest(store)
 	const key = `*${mutableAtomFamily.key}`
-	const updateFamily: AtomFamily<Signal<Core>, Key> = target.families.get(
+	const updateFamily: AtomFamily<SignalFrom<T>, K> = target.families.get(
 		key,
-	) as AtomFamily<Signal<Core>, Key>
+	) as AtomFamily<SignalFrom<T>, K>
 	return updateFamily
 }

package/src/internal/mutable/get-update-token.ts

@@ -1,16 +1,12 @@
 import type { MutableAtomToken, RegularAtomToken } from "atom.io"
-import type { Json } from "atom.io/json"
 
-import type { Signal, Transceiver } from "./transceiver"
+import type { SignalFrom, Transceiver } from "./transceiver"
 
-export const getUpdateToken = <
-	Core extends Transceiver<any>,
-	SerializableCore extends Json.Serializable,
->(
-	mutableAtomToken: MutableAtomToken<Core, SerializableCore>,
-): RegularAtomToken<Signal<Core>> => {
+export const getUpdateToken = <T extends Transceiver<any, any, any>>(
+	mutableAtomToken: MutableAtomToken<T>,
+): RegularAtomToken<SignalFrom<T>> => {
 	const key = `*${mutableAtomToken.key}`
-	const updateToken: RegularAtomToken<Signal<Core>> = { type: `atom`, key }
+	const updateToken: RegularAtomToken<SignalFrom<T>> = { type: `atom`, key }
 	if (mutableAtomToken.family) {
 		updateToken.family = {
 			key: `*${mutableAtomToken.family.key}`,

package/src/internal/mutable/tracker-family.ts

@@ -1,3 +1,4 @@
+import type { MutableAtomToken, StateLifecycleEvent } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { parseJson } from "atom.io/json"
 
@@ -5,28 +6,19 @@ import type { MutableAtomFamily, RegularAtomFamily } from ".."
 import { createRegularAtomFamily } from "../families"
 import { type Store, withdraw } from "../store"
 import { Tracker } from "./tracker"
-import type { Transceiver } from "./transceiver"
+import type { SignalFrom, Transceiver } from "./transceiver"
 
 export class FamilyTracker<
-	Core extends Transceiver<any>,
-	FamilyMemberKey extends Canonical,
+	T extends Transceiver<any, any, any>,
+	K extends Canonical,
 > {
-	private trackers: Map<FamilyMemberKey, Tracker<Core>> = new Map()
+	private trackers: Map<K, Tracker<T>> = new Map()
 
-	public readonly latestUpdateAtoms: RegularAtomFamily<
-		(Core extends Transceiver<infer Signal> ? Signal : never) | null,
-		FamilyMemberKey
-	>
-	public readonly mutableAtoms: MutableAtomFamily<Core, any, FamilyMemberKey>
+	public readonly latestSignalAtoms: RegularAtomFamily<SignalFrom<T> | null, K>
+	public readonly mutableAtoms: MutableAtomFamily<T, K>
 
-	public constructor(
-		mutableAtoms: MutableAtomFamily<Core, any, FamilyMemberKey>,
-		store: Store,
-	) {
-		const updateAtoms = createRegularAtomFamily<
-			(Core extends Transceiver<infer Signal> ? Signal : never) | null,
-			FamilyMemberKey
-		>(
+	public constructor(mutableAtoms: MutableAtomFamily<T, K>, store: Store) {
+		const latestSignalAtoms = createRegularAtomFamily<SignalFrom<T> | null, K>(
 			store,
 			{
 				key: `*${mutableAtoms.key}`,
@@ -34,30 +26,31 @@ export class FamilyTracker<
 			},
 			[`mutable`, `updates`],
 		)
-		this.latestUpdateAtoms = withdraw(store, updateAtoms)
+		this.latestSignalAtoms = withdraw(store, latestSignalAtoms)
 		this.mutableAtoms = mutableAtoms
-		this.mutableAtoms.subject.subscribe(
-			`store=${store.config.name}::tracker-atom-family`,
-			(event) => {
-				const { type, token } = event
-				if (token.family) {
-					const key = parseJson(token.family.subKey)
-					switch (type) {
-						case `state_creation`:
-							this.trackers.set(key, new Tracker<Core>(token, store))
-							break
-						case `state_disposal`:
-							{
-								const tracker = this.trackers.get(key)
-								if (tracker) {
-									tracker[Symbol.dispose]()
-									this.trackers.delete(key)
-								}
-							}
-							break
+		const trackerFamilyWatchesForCreationAndDisposalEvents = (
+			event: StateLifecycleEvent<MutableAtomToken<T>>,
+		) => {
+			const { type, token } = event
+			if (token.family) {
+				const key = parseJson(token.family.subKey)
+				switch (type) {
+					case `state_creation`:
+						this.trackers.set(key, new Tracker<T>(token, store))
+						break
+					case `state_disposal`: {
+						const tracker = this.trackers.get(key)
+						if (tracker) {
+							tracker[Symbol.dispose]()
+							this.trackers.delete(key)
+						}
 					}
 				}
-			},
+			}
+		}
+		this.mutableAtoms.subject.subscribe(
+			`store=${store.config.name}::tracker-atom-family`,
+			trackerFamilyWatchesForCreationAndDisposalEvents,
 		)
 	}
 }

package/src/internal/mutable/tracker.ts

@@ -1,5 +1,4 @@
 import type { FamilyMetadata, MutableAtomToken, RegularAtomToken } from "atom.io"
-import type { Json } from "atom.io/json"
 
 import type { Store } from ".."
 import {
@@ -11,89 +10,84 @@ import {
 } from ".."
 import { createRegularAtom } from "../atom"
 import { isChildStore } from "../transaction/is-root-store"
-import type { Transceiver } from "./transceiver"
+import type { SignalFrom, Transceiver } from "./transceiver"
 
 /**
  * @internal Give the tracker a transceiver state and a store, and it will
  * subscribe to the transceiver's inner value. When the inner value changes,
  * the tracker will update its own state to reflect the change.
  */
-export class Tracker<Mutable extends Transceiver<any>> {
-	private initializeState(
-		mutableState: MutableAtomToken<Mutable, Json.Serializable>,
+export class Tracker<T extends Transceiver<any, any, any>> {
+	private initializeSignalAtom(
+		mutableState: MutableAtomToken<T>,
 		store: Store,
-	): RegularAtomToken<
-		(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
-	> {
-		const latestUpdateStateKey = `*${mutableState.key}`
-		store.atoms.delete(latestUpdateStateKey)
-		store.valueMap.delete(latestUpdateStateKey)
+	): RegularAtomToken<SignalFrom<T> | null> {
+		const latestSignalStateKey = `*${mutableState.key}`
+		store.atoms.delete(latestSignalStateKey)
+		store.valueMap.delete(latestSignalStateKey)
 		const familyMetaData: FamilyMetadata | undefined = mutableState.family
 			? {
 					key: `*${mutableState.family.key}`,
 					subKey: mutableState.family.subKey,
 				}
 			: undefined
-		const latestUpdateState = createRegularAtom<
-			(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
-		>(
+		const latestSignalState = createRegularAtom<SignalFrom<T> | null>(
 			store,
 			{
-				key: latestUpdateStateKey,
+				key: latestSignalStateKey,
 				default: null,
 			},
 			familyMetaData,
+			[`tracker:signal`],
 		)
-		if (store.parent?.valueMap.has(latestUpdateStateKey)) {
-			const parentValue = store.parent.valueMap.get(latestUpdateStateKey)
-			store.valueMap.set(latestUpdateStateKey, parentValue)
+		if (store.parent?.valueMap.has(latestSignalStateKey)) {
+			const parentValue = store.parent.valueMap.get(latestSignalStateKey)
+			store.valueMap.set(latestSignalStateKey, parentValue)
 		}
 
-		return latestUpdateState
+		return latestSignalState
 	}
 
 	private unsubscribeFromInnerValue!: () => void
 	private unsubscribeFromState!: () => void
-	private observeCore(
-		mutableState: MutableAtomToken<Mutable, any>,
-		latestUpdateState: RegularAtomToken<
-			(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
-		>,
+	private captureSignalsFromCore(
+		mutableState: MutableAtomToken<T, any>,
+		latestSignalState: RegularAtomToken<SignalFrom<T> | null>,
 		target: Store,
 	): void {
-		const subscriptionKey = `tracker:${target.config.name}:${
-			isChildStore(target) ? target.transactionMeta.update.key : `main`
-		}:${mutableState.key}`
+		const stateKey = mutableState.key
+		const storeName = target.config.name
+		const storeStatus = isChildStore(target)
+			? target.transactionMeta.update.key
+			: `main`
+		const subscriptionKey = `tracker:${storeName}:${storeStatus}:${stateKey}`
+		const trackerCapturesOutboundSignal = (update: SignalFrom<T>) => {
+			setIntoStore(target, latestSignalState, update)
+		}
 		const originalInnerValue = getFromStore(target, mutableState)
 		this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
 			subscriptionKey,
-			(update) => {
-				setIntoStore(target, latestUpdateState, update)
-			},
+			trackerCapturesOutboundSignal,
 		)
 		this.unsubscribeFromState = subscribeToState(
 			target,
 			mutableState,
 			subscriptionKey,
-			(update) => {
+			function trackerLooksForNewReference(update: SignalFrom<T>) {
 				if (update.newValue !== update.oldValue) {
 					this.unsubscribeFromInnerValue()
 					this.unsubscribeFromInnerValue = update.newValue.subscribe(
 						subscriptionKey,
-						(transceiverUpdate) => {
-							setIntoStore(target, latestUpdateState, transceiverUpdate)
-						},
+						trackerCapturesOutboundSignal,
 					)
 				}
-			},
+			}.bind(this),
 		)
 	}
 
-	private updateCore<Core extends Transceiver<any>>(
-		mutableState: MutableAtomToken<Core, Json.Serializable>,
-		latestUpdateState: RegularAtomToken<
-			(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
-		>,
+	private supplySignalsToCore(
+		mutableState: MutableAtomToken<T>,
+		latestSignalState: RegularAtomToken<SignalFrom<T> | null>,
 		target: Store,
 	): void {
 		const subscriptionKey = `tracker:${target.config.name}:${
@@ -101,87 +95,75 @@ export class Tracker<Mutable extends Transceiver<any>> {
 		}:${mutableState.key}`
 		subscribeToState(
 			target,
-			latestUpdateState,
+			latestSignalState,
 			subscriptionKey,
-			({ newValue, oldValue }) => {
+			function trackerCapturesInboundSignal({ newValue, oldValue }) {
 				const timelineId = target.timelineTopics.getRelatedKey(
-					latestUpdateState.key,
+					latestSignalState.key,
 				)
 
-				if (timelineId) {
-					const timelineData = target.timelines.get(timelineId)
-					if (timelineData?.timeTraveling) {
-						const unsubscribe = subscribeToTimeline(
-							target,
-							{ key: timelineId, type: `timeline` },
-							subscriptionKey,
-							(update) => {
-								unsubscribe()
-								setIntoStore(target, mutableState, (transceiver) => {
-									if (update === `redo` && newValue) {
-										transceiver.do(newValue)
-									} else if (update === `undo` && oldValue) {
-										transceiver.undo(oldValue)
-									}
-									return transceiver
-								})
-							},
-						)
-						return
-					}
+				if (timelineId && target.timelines.get(timelineId)?.timeTraveling) {
+					const unsubscribe = subscribeToTimeline(
+						target,
+						{ key: timelineId, type: `timeline` },
+						subscriptionKey,
+						function trackerWaitsForTimeTravelToFinish(update) {
+							unsubscribe()
+							setIntoStore(target, mutableState, (transceiver) => {
+								if (update === `redo` && newValue) {
+									transceiver.do(newValue)
+								} else if (update === `undo` && oldValue) {
+									transceiver.undo(oldValue)
+								}
+								return transceiver
+							})
+						},
+					)
+					return
 				}
 
-				const unsubscribe = target.on.operationClose.subscribe(
-					subscriptionKey,
-					() => {
-						unsubscribe()
-						const mutable = getFromStore(target, mutableState)
-						const updateNumber =
-							newValue === null ? -1 : mutable.getUpdateNumber(newValue)
-						const eventOffset = updateNumber - mutable.cacheUpdateNumber
-						if (newValue && eventOffset === 1) {
-							setIntoStore(
-								target,
-								mutableState,
-								(transceiver) => (transceiver.do(newValue), transceiver),
-							)
-						} else {
-							target.logger.info(
-								`❌`,
-								`mutable_atom`,
-								mutableState.key,
-								`could not be updated. Expected update number ${
-									mutable.cacheUpdateNumber + 1
-								}, but got ${updateNumber}`,
-							)
-						}
-					},
-				)
+				const mutable = getFromStore(target, mutableState)
+				const updateNumber = mutable.getUpdateNumber(newValue)
+				const eventOffset = updateNumber - mutable.cacheUpdateNumber
+				if (newValue && eventOffset === 1) {
+					setIntoStore(
+						target,
+						mutableState,
+						(transceiver) => (transceiver.do(newValue), transceiver),
+					)
+				} else {
+					const expected = mutable.cacheUpdateNumber + 1
+					target.logger.info(
+						`❌`,
+						`mutable_atom`,
+						mutableState.key,
+						`could not be updated. Expected update number`,
+						expected,
+						`but got`,
+						updateNumber,
+					)
+				}
 			},
 		)
 	}
 
-	public mutableState: MutableAtomToken<Mutable, Json.Serializable>
-	public latestUpdateState: RegularAtomToken<
-		(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
-	>
+	public mutableAtomToken: MutableAtomToken<T>
+	public latestSignalToken: RegularAtomToken<SignalFrom<T> | null>
 
 	public [Symbol.dispose]!: () => void
 
-	public constructor(
-		mutableState: MutableAtomToken<Mutable, Json.Serializable>,
-		store: Store,
-	) {
-		this.mutableState = mutableState
+	public constructor(mutableAtomToken: MutableAtomToken<T>, store: Store) {
 		const target = newest(store)
-		this.latestUpdateState = this.initializeState(mutableState, target)
-		this.observeCore(mutableState, this.latestUpdateState, target)
-		this.updateCore(mutableState, this.latestUpdateState, target)
-		target.trackers.set(mutableState.key, this)
+		const latestSignalToken = this.initializeSignalAtom(mutableAtomToken, target)
+		this.mutableAtomToken = mutableAtomToken
+		this.latestSignalToken = latestSignalToken
+		this.captureSignalsFromCore(mutableAtomToken, latestSignalToken, target)
+		this.supplySignalsToCore(mutableAtomToken, latestSignalToken, target)
+		target.trackers.set(mutableAtomToken.key, this)
 		this[Symbol.dispose] = () => {
 			this.unsubscribeFromInnerValue()
 			this.unsubscribeFromState()
-			target.trackers.delete(mutableState.key)
+			target.trackers.delete(mutableAtomToken.key)
 		}
 	}
 }