atom.io 0.36.0 → 0.36.2

package/src/internal/caching.ts

@@ -1,34 +1,31 @@
-import type { StateUpdate } from "atom.io"
-
-import type { ReadableState } from "."
-import { closeOperation, isChildStore, openOperation } from "."
+import type { ReadableState, Transceiver } from "."
+import { closeOperation, isChildStore, openOperation, Tracker } from "."
 import { Future } from "./future"
-import { copyMutableIfNeeded } from "./set-state/copy-mutable-if-needed"
 import {
-	evictDownStream,
-	evictDownStreamFromSelector,
+	evictDownstreamFromAtom,
+	evictDownstreamFromSelector,
 } from "./set-state/evict-downstream"
 import type { Store } from "./store"
-import type { Subject } from "./subject"
 
-export function cacheValue<T>(
-	store: Store,
-	key: string,
+export function writeToCache<T>(
+	target: Store,
+	state: ReadableState<T>,
 	value: T,
-	subject: Subject<StateUpdate<unknown>>,
+	// subject: Subject<StateUpdate<unknown>>,
 ): T
-export function cacheValue<T extends Promise<any>>(
-	store: Store,
-	key: string,
+export function writeToCache<T extends Promise<any>>(
+	target: Store,
+	state: ReadableState<T>,
 	value: T,
-	subject: Subject<StateUpdate<unknown>>,
-): Future<T>
-export function cacheValue<T>(
+	// subject: Subject<StateUpdate<unknown>>,
+): Future<Awaited<T>>
+export function writeToCache<T>(
 	target: Store,
-	key: string,
+	state: ReadableState<T>,
 	value: T,
-	subject: Subject<StateUpdate<unknown>>,
+	// subject: Subject<StateUpdate<unknown>>,
 ): Future<T> | T {
+	const { key, subject, type } = state
 	const currentValue = target.valueMap.get(key)
 	if (currentValue instanceof Future && !currentValue.done) {
 		const future = currentValue
@@ -46,22 +43,21 @@ export function cacheValue<T>(
 			.then(function handleResolvedFuture(resolved) {
 				const current = target.valueMap.get(key)
 				if (current === future) {
-					cacheValue(target, key, resolved, subject)
-					const atom = target.atoms.get(key)
-					if (atom) {
-						openOperation(target, atom)
-						evictDownStream(target, atom)
-						closeOperation(target)
-					} else {
-						const selector =
-							target.writableSelectors.get(key) ??
-							target.readonlySelectors.get(key)
-						if (selector) {
-							openOperation(target, selector)
-							evictDownStreamFromSelector(target, selector)
-							closeOperation(target)
-						}
+					openOperation(target, state)
+					writeToCache(target, state, resolved)
+					switch (type) {
+						case `atom`:
+						case `mutable_atom`:
+							evictDownstreamFromAtom(target, state)
+							break
+						case `readonly_held_selector`:
+						case `readonly_pure_selector`:
+						case `writable_held_selector`:
+						case `writable_pure_selector`:
+							evictDownstreamFromSelector(target, key)
+							break
 					}
+					closeOperation(target)
 					subject.next({ newValue: resolved, oldValue: future })
 				}
 			})
@@ -74,21 +70,44 @@ export function cacheValue<T>(
 	return value
 }
 
-export const readCachedValue = <T>(
-	state: ReadableState<any>,
+/**
+ * @param target - the newest layer of the store
+ * @param state - the state to read from cache
+ * @param mut - whether the value is intended to be mutable
+ * @returns the state's current value
+ */
+export function readFromCache<T>(
 	target: Store,
-): T => {
+	state: ReadableState<T>,
+	mut: `mut` | undefined,
+): T {
 	target.logger.info(`📖`, state.type, state.key, `reading cached value`)
 	let value = target.valueMap.get(state.key) as T
-	if (state.type === `mutable_atom` && isChildStore(target)) {
+
+	const mayNeedToBeCopied =
+		mut === `mut` && state.type === `mutable_atom` && isChildStore(target)
+	if (mayNeedToBeCopied) {
+		const mutableAtom = state
 		const { parent } = target
-		const copiedValue = copyMutableIfNeeded(target, state, parent)
+
+		if (target.valueMap.hasOwn(mutableAtom.key)) {
+			return value
+		}
+
+		const parentValue = parent.valueMap.get(mutableAtom.key) as T &
+			Transceiver<any, any, any>
+
+		target.logger.info(`📃`, `atom`, mutableAtom.key, `copying`)
+		const jsonValue = parentValue.toJSON()
+		const copiedValue = mutableAtom.class.fromJSON(jsonValue)
+		target.valueMap.set(mutableAtom.key, copiedValue)
+		new Tracker(mutableAtom, parent)
 		value = copiedValue
 	}
 	return value
 }
 
-export const evictCachedValue = (target: Store, key: string): void => {
+export function evictCachedValue(target: Store, key: string): void {
 	const currentValue = target.valueMap.get(key)
 	if (currentValue instanceof Future) {
 		const selector =

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

@@ -25,7 +25,7 @@ import { initFamilyMemberInStore } from "./init-family-member"
 import { seekInStore } from "./seek-in-store"
 
 export function findInStore<
-	T extends Transceiver<any, any>,
+	T extends Transceiver<any, any, any>,
 	K extends Canonical,
 	Key extends K,
 >(

package/src/internal/families/get-family-of-token.ts

@@ -18,7 +18,7 @@ import type { Transceiver } from "../mutable"
 import type { Store } from "../store"
 
 export function getFamilyOfToken<
-	T extends Transceiver<any, any>,
+	T extends Transceiver<any, any, any>,
 	K extends Canonical,
 >(
 	store: Store,

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

@@ -25,7 +25,7 @@ import type { Store } from "../store"
 import { isChildStore, isRootStore } from "../transaction"
 
 export function initFamilyMemberInStore<
-	T extends Transceiver<any, any>,
+	T extends Transceiver<any, any, any>,
 	K extends Canonical,
 	Key extends K,
 >(

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

@@ -25,7 +25,7 @@ import type { Transceiver } from "../mutable"
 import { deposit, type Store } from "../store"
 
 export function seekInStore<
-	T extends Transceiver<any, any>,
+	T extends Transceiver<any, any, any>,
 	K extends Canonical,
 	Key extends K,
 >(

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

@@ -1,48 +1,53 @@
-import type { ReadableState } from ".."
-import { cacheValue, readCachedValue } from "../caching"
+import type { ReadableState, ViewOf } from ".."
+import { readFromCache, writeToCache } from "../caching"
 import type { Store } from "../store"
 
-export const readOrComputeValue = <T>(
+export function readOrComputeValue<T>(
 	target: Store,
 	state: ReadableState<T>,
-): T => {
+	mut?: undefined,
+): ViewOf<T>
+export function readOrComputeValue<T>(
+	target: Store,
+	state: ReadableState<T>,
+	mut: `mut`,
+): T
+export function readOrComputeValue<T>(
+	target: Store,
+	state: ReadableState<T>,
+	mut: `mut` | undefined,
+): T {
 	if (target.valueMap.has(state.key)) {
-		return readCachedValue(state, target)
+		return readFromCache(target, state, mut)
 	}
+	const { key } = state
 	switch (state.type) {
 		case `readonly_held_selector`:
 		case `readonly_pure_selector`:
 		case `writable_held_selector`:
 		case `writable_pure_selector`:
-			target.logger.info(`🧮`, state.type, state.key, `computing value`)
+			target.logger.info(`🧮`, state.type, key, `computing value`)
 			return state.get()
 		case `atom`: {
-			const def = state.default
-			let defaultValue: T
-			if (def instanceof Function) {
-				defaultValue = def()
+			let def: T
+			if (state.default instanceof Function) {
+				def = state.default()
 			} else {
-				defaultValue = def
+				def = state.default
 			}
-			const cachedValue = cacheValue(
-				target,
-				state.key,
-				defaultValue,
-				state.subject,
-			)
+			const cachedValue = writeToCache(target, state, def)
 			target.logger.info(
 				`💁`,
 				`atom`,
 				state.key,
 				`could not find cached value; using default`,
-				defaultValue,
+				def,
 			)
 			return cachedValue
 		}
 		case `mutable_atom`: {
-			const Ctor = state.class
-			const instance = new Ctor()
-			const cachedValue = cacheValue(target, state.key, instance, state.subject)
+			const instance = new state.class()
+			const cachedValue = writeToCache(target, state, instance)
 			target.logger.info(
 				`💁`,
 				`mutable_atom`,

package/src/internal/index.ts

@@ -11,6 +11,7 @@ import type {
 	RegularAtomToken,
 	StateCreation,
 	StateDisposal,
+	StateLifecycleEvent,
 	WritableHeldSelectorFamilyToken,
 	WritableHeldSelectorToken,
 	WritablePureSelectorFamilyToken,
@@ -18,6 +19,7 @@ import type {
 } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
+import type { internalRole } from "./atom/has-role"
 import type { ConstructorOf, Transceiver } from "./mutable"
 import type { Store } from "./store"
 import type { Subject } from "./subject"
@@ -67,9 +69,10 @@ export type RegularAtom<T> = Flat<
 		type: `atom`
 		default: T | (() => T)
 		cleanup?: () => void
+		internalRoles?: internalRole[]
 	}
 >
-export type MutableAtom<T extends Transceiver<any, any>> = Flat<
+export type MutableAtom<T extends Transceiver<any, any, any>> = Flat<
 	AtomIOState & {
 		type: `mutable_atom`
 		class: ConstructorOf<T>
@@ -78,7 +81,7 @@ export type MutableAtom<T extends Transceiver<any, any>> = Flat<
 >
 export type Atom<T> =
 	| RegularAtom<T>
-	| (T extends Transceiver<any, any> ? MutableAtom<T> : never)
+	| (T extends Transceiver<any, any, any> ? MutableAtom<T> : never)
 
 export type WritableHeldSelector<T> = Flat<
 	AtomIOState & {
@@ -138,7 +141,7 @@ export type RegularAtomFamily<T, K extends Canonical> =
 // biome-ignore format: intersection
 export type MutableAtomFamily<
 	// C extends TransceiverConstructor<any,any>,
-	T extends Transceiver<any,any>,
+	T extends Transceiver<any, any, any>,
 	K extends Canonical,
 > =
 	& Flat<
@@ -146,16 +149,13 @@ export type MutableAtomFamily<
 		& {
 				install: (store: Store) => void
 				internalRoles: string[] | undefined
-				subject: Subject<
-					| StateCreation<MutableAtomToken<T>>
-					| StateDisposal<MutableAtomToken<T>>
-				>
+				subject: Subject<StateLifecycleEvent<MutableAtomToken<T>>>
 			}
 	>
 	& ((key: K) => MutableAtomToken<T>)
 
 export type AtomFamily<T, K extends Canonical = Canonical> =
-	| MutableAtomFamily<T extends Transceiver<any, any> ? T : never, K>
+	| MutableAtomFamily<T extends Transceiver<any, any, any> ? T : never, K>
 	| RegularAtomFamily<T, K>
 
 // biome-ignore format: intersection

package/src/internal/join/create-join.ts

@@ -1,8 +1,9 @@
 import type { JoinOptions, JoinToken } from "atom.io"
-import type { Store } from "atom.io/internal"
-import { Join } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 
+import type { Store } from "../store"
+import { Join } from "./join-internal"
+
 export function createJoin<
 	ASide extends string,
 	AType extends string,

package/src/internal/join/join-internal.ts

@@ -29,6 +29,7 @@ import type {
 } from "../junction"
 import { Junction } from "../junction"
 import type { Molecule } from "../molecule"
+import type { ViewOf } from "../mutable"
 import { createMutableAtomFamily, getJsonFamily, getJsonToken } from "../mutable"
 import { setIntoStore } from "../set-state"
 import type { Store } from "../store"
@@ -343,8 +344,10 @@ export class Join<
 				[`join`, `content`],
 			)
 
-			const getContent: Read<(key: string) => Content | null> = ({ get }, key) =>
-				get(contentAtoms, key)
+			const getContent: Read<(key: string) => ViewOf<Content> | null> = (
+				{ get },
+				key,
+			) => get(contentAtoms, key)
 			const setContent: Write<(key: string, content: Content) => void> = (
 				{ set },
 				key,
@@ -433,7 +436,7 @@ export class Join<
 			)
 		}
 		const createSingleEntrySelectorFamily = () =>
-			createReadonlyPureSelectorFamily<[string, Content] | null, string>(
+			createReadonlyPureSelectorFamily<[string, ViewOf<Content>] | null, string>(
 				store,
 				{
 					key: `${options.key}/singleRelatedEntry`,
@@ -456,7 +459,7 @@ export class Join<
 				[`join`, `entries`],
 			)
 		const getMultipleEntrySelectorFamily = () =>
-			createReadonlyPureSelectorFamily<[string, Content][], string>(
+			createReadonlyPureSelectorFamily<[string, ViewOf<Content>][], string>(
 				store,
 				{
 					key: `${options.key}/multipleRelatedEntries`,

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

@@ -23,17 +23,18 @@ import { FamilyTracker } from "./tracker-family"
 import type { AsJSON, Transceiver } from "./transceiver"
 
 export function createMutableAtomFamily<
-	T extends Transceiver<any, any>,
+	T extends Transceiver<any, any, any>,
 	K extends Canonical,
 >(
 	store: Store,
 	options: MutableAtomFamilyOptions<T, K>,
 	internalRoles?: string[],
 ): MutableAtomFamilyToken<T, K> {
-	const familyToken: MutableAtomFamilyToken<T & Transceiver<any, any>, K> = {
-		key: options.key,
-		type: `mutable_atom_family`,
-	}
+	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) {

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

@@ -14,7 +14,7 @@ import { subscribeToState } from "../subscribe"
 import { Tracker } from "./tracker"
 import type { Transceiver } from "./transceiver"
 
-export function createMutableAtom<T extends Transceiver<any, any>>(
+export function createMutableAtom<T extends Transceiver<any, any, any>>(
 	store: Store,
 	options: MutableAtomOptions<T>,
 	family: FamilyMetadata | undefined,

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

@@ -7,7 +7,7 @@ import type { Store } from "../store"
 import type { Transceiver } from "./transceiver"
 
 export const getJsonFamily = <
-	Core extends Transceiver<Json.Serializable, Json.Serializable>,
+	Core extends Transceiver<any, Json.Serializable, Json.Serializable>,
 	Key extends Canonical,
 >(
 	mutableAtomFamily: MutableAtomFamilyToken<Core, Key>,

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

@@ -9,7 +9,7 @@ import { newest } from "../lineage"
 import { type Store, withdraw } from "../store"
 import type { AsJSON, Transceiver } from "./transceiver"
 
-export const getJsonToken = <T extends Transceiver<any, any>>(
+export const getJsonToken = <T extends Transceiver<any, any, any>>(
 	store: Store,
 	mutableAtomToken: MutableAtomToken<T>,
 ): WritablePureSelectorToken<AsJSON<T>> => {

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

@@ -7,7 +7,7 @@ import type { Store } from "../store"
 import type { SignalFrom, Transceiver } from "./transceiver"
 
 export const getUpdateFamily = <
-	T extends Transceiver<Json.Serializable, Json.Serializable>,
+	T extends Transceiver<any, Json.Serializable, Json.Serializable>,
 	K extends string,
 >(
 	mutableAtomFamily: MutableAtomFamilyToken<T, K>,

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

@@ -2,7 +2,7 @@ import type { MutableAtomToken, RegularAtomToken } from "atom.io"
 
 import type { SignalFrom, Transceiver } from "./transceiver"
 
-export const getUpdateToken = <T extends Transceiver<any, any>>(
+export const getUpdateToken = <T extends Transceiver<any, any, any>>(
 	mutableAtomToken: MutableAtomToken<T>,
 ): RegularAtomToken<SignalFrom<T>> => {
 	const key = `*${mutableAtomToken.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,25 +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<
-	T extends Transceiver<any, any>,
+	T extends Transceiver<any, any, any>,
 	K extends Canonical,
 > {
 	private trackers: Map<K, Tracker<T>> = new Map()
 
-	public readonly latestUpdateAtoms: RegularAtomFamily<
-		(T extends Transceiver<infer Signal, any> ? Signal : never) | null,
-		K
-	>
+	public readonly latestSignalAtoms: RegularAtomFamily<SignalFrom<T> | null, K>
 	public readonly mutableAtoms: MutableAtomFamily<T, K>
 
 	public constructor(mutableAtoms: MutableAtomFamily<T, K>, store: Store) {
-		const updateAtoms = createRegularAtomFamily<
-			(T extends Transceiver<infer Signal, any> ? Signal : never) | null,
-			K
-		>(
+		const latestSignalAtoms = createRegularAtomFamily<SignalFrom<T> | null, K>(
 			store,
 			{
 				key: `*${mutableAtoms.key}`,
@@ -31,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<T>(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

@@ -17,48 +17,52 @@ import type { SignalFrom, Transceiver } from "./transceiver"
  * 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<T extends Transceiver<any, any>> {
-	private initializeState(
+export class Tracker<T extends Transceiver<any, any, any>> {
+	private initializeSignalAtom(
 		mutableState: MutableAtomToken<T>,
 		store: Store,
 	): RegularAtomToken<SignalFrom<T> | null> {
-		const latestUpdateStateKey = `*${mutableState.key}`
-		store.atoms.delete(latestUpdateStateKey)
-		store.valueMap.delete(latestUpdateStateKey)
+		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<SignalFrom<T> | 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 captureSignalsFromCore(
 		mutableState: MutableAtomToken<T, any>,
-		latestUpdateState: RegularAtomToken<SignalFrom<T> | null>,
+		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, latestUpdateState, update)
+			setIntoStore(target, latestSignalState, update)
 		}
 		const originalInnerValue = getFromStore(target, mutableState)
 		this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
@@ -83,7 +87,7 @@ export class Tracker<T extends Transceiver<any, any>> {
 
 	private supplySignalsToCore(
 		mutableState: MutableAtomToken<T>,
-		latestUpdateState: RegularAtomToken<SignalFrom<T> | null>,
+		latestSignalState: RegularAtomToken<SignalFrom<T> | null>,
 		target: Store,
 	): void {
 		const subscriptionKey = `tracker:${target.config.name}:${
@@ -91,11 +95,11 @@ export class Tracker<T extends Transceiver<any, any>> {
 		}:${mutableState.key}`
 		subscribeToState(
 			target,
-			latestUpdateState,
+			latestSignalState,
 			subscriptionKey,
 			function trackerCapturesInboundSignal({ newValue, oldValue }) {
 				const timelineId = target.timelineTopics.getRelatedKey(
-					latestUpdateState.key,
+					latestSignalState.key,
 				)
 
 				if (timelineId && target.timelines.get(timelineId)?.timeTraveling) {
@@ -128,13 +132,15 @@ export class Tracker<T extends Transceiver<any, any>> {
 						(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 ${
-							mutable.cacheUpdateNumber + 1
-						}, but got ${updateNumber}`,
+						`could not be updated. Expected update number`,
+						expected,
+						`but got`,
+						updateNumber,
 					)
 				}
 			},
@@ -148,7 +154,7 @@ export class Tracker<T extends Transceiver<any, any>> {
 
 	public constructor(mutableAtomToken: MutableAtomToken<T>, store: Store) {
 		const target = newest(store)
-		const latestSignalToken = this.initializeState(mutableAtomToken, target)
+		const latestSignalToken = this.initializeSignalAtom(mutableAtomToken, target)
 		this.mutableAtomToken = mutableAtomToken
 		this.latestSignalToken = latestSignalToken
 		this.captureSignalsFromCore(mutableAtomToken, latestSignalToken, target)