atom.io 0.27.4 → 0.27.5

package/internal/src/molecule/grow-molecule-in-store.ts

@@ -83,7 +83,7 @@ export function growMoleculeInStore(
 	family: ReadableFamilyToken<any, any>,
 	store: Store,
 ): ReadableToken<any> {
-	const stateToken = initFamilyMemberInStore(family, molecule.key, store)
+	const stateToken = initFamilyMemberInStore(store, family, molecule.key)
 	molecule.tokens.set(stateToken.key, stateToken)
 	const isTransaction =
 		isChildStore(store) && store.transactionMeta.phase === `building`

package/internal/src/molecule/make-molecule-in-store.ts

@@ -68,17 +68,17 @@ export function makeMoleculeInStore<M extends MoleculeConstructor>(
 
 	const toolkit = {
 		get: ((...ps: Parameters<typeof getState>) =>
-			getFromStore(...ps, newest(rootStore))) as typeof getState,
+			getFromStore(newest(rootStore), ...ps)) as typeof getState,
 		set: ((...ps: Parameters<typeof setState>) => {
-			setIntoStore(...ps, newest(rootStore))
+			setIntoStore(newest(rootStore), ...ps)
 		}) as typeof setState,
-		seek: ((t, k) => seekInStore(t, k, newest(rootStore))) as typeof seekState,
-		json: (t) => getJsonToken(t, newest(rootStore)),
+		seek: ((t, k) => seekInStore(newest(rootStore), t, k)) as typeof seekState,
+		json: (t) => getJsonToken(newest(rootStore), t),
 		run: (t, i = arbitrary()) => actUponStore(t, i, newest(store)),
 		make: (ctx, f, k, ...args) =>
 			makeMoleculeInStore(newest(rootStore), ctx, f, k, ...args),
 		dispose: (t) => {
-			disposeFromStore(t, newest(rootStore))
+			disposeFromStore(newest(rootStore), t)
 		},
 		env: () => getEnvironmentData(newest(rootStore)),
 		bond: ((

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

@@ -10,8 +10,7 @@ import type {
 import type { Json } from "atom.io/json"
 import { selectJsonFamily, stringifyJson } from "atom.io/json"
 
-import type { MutableAtomFamily } from ".."
-import { throwInCaseOfConflictingFamily } from "../families/throw-in-case-of-conflicting-family"
+import { type MutableAtomFamily, prettyPrintTokenType } from ".."
 import { newest } from "../lineage"
 import { createMutableAtom } from "../mutable"
 import type { Store } from "../store"
@@ -24,8 +23,8 @@ export function createMutableAtomFamily<
 	J extends Json.Serializable,
 	K extends string,
 >(
-	options: MutableAtomFamilyOptions<T, J, K>,
 	store: Store,
+	options: MutableAtomFamilyOptions<T, J, K>,
 	internalRoles?: string[],
 ): MutableAtomFamilyToken<T, J, K> {
 	const familyToken = {
@@ -33,7 +32,17 @@ export function createMutableAtomFamily<
 		type: `mutable_atom_family`,
 	} as const satisfies MutableAtomFamilyToken<T, J, K>
 
-	throwInCaseOfConflictingFamily(familyToken, store)
+	const existing = store.families.get(options.key)
+	if (existing) {
+		store.logger.error(
+			`❗`,
+			`mutable_atom_family`,
+			options.key,
+			`Overwriting an existing ${prettyPrintTokenType(
+				existing,
+			)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`,
+		)
+	}
 
 	const subject = new Subject<
 		StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>
@@ -56,7 +65,7 @@ export function createMutableAtomFamily<
 			individualOptions.effects = options.effects(key)
 		}
 
-		const token = createMutableAtom(individualOptions, family, target)
+		const token = createMutableAtom(target, individualOptions, family)
 
 		subject.next({ type: `state_creation`, token })
 		return token
@@ -64,7 +73,7 @@ export function createMutableAtomFamily<
 
 	const atomFamily = Object.assign(familyFunction, familyToken, {
 		subject,
-		install: (s: Store) => createMutableAtomFamily(options, s),
+		install: (s: Store) => createMutableAtomFamily(s, options),
 		toJson: options.toJson,
 		fromJson: options.fromJson,
 		internalRoles,

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

@@ -20,9 +20,9 @@ export function createMutableAtom<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
 >(
+	store: Store,
 	options: MutableAtomOptions<T, J>,
 	family: FamilyMetadata | undefined,
-	store: Store,
 ): MutableAtomToken<T, J> {
 	store.logger.info(
 		`🔨`,
@@ -52,7 +52,7 @@ export function createMutableAtom<
 				options.key,
 				`installing in store "${s.config.name}"`,
 			)
-			return createMutableAtom(options, family, s)
+			return createMutableAtom(s, options, family)
 		},
 		subject,
 	} as const
@@ -70,7 +70,7 @@ export function createMutableAtom<
 		for (const effect of options.effects) {
 			const cleanup = effect({
 				setSelf: (next) => {
-					setIntoStore(token, next, store)
+					setIntoStore(store, token, next)
 				},
 				onSet: (handle: UpdateHandler<T>) =>
 					subscribeToState(token, handle, `effect[${effectIndex}]`, store),

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

@@ -14,8 +14,8 @@ export const getJsonToken = <
 	Core extends Transceiver<any>,
 	SerializableCore extends Json.Serializable,
 >(
-	mutableAtomToken: MutableAtomToken<Core, SerializableCore>,
 	store: Store,
+	mutableAtomToken: MutableAtomToken<Core, SerializableCore>,
 ): WritableSelectorToken<SerializableCore> => {
 	if (mutableAtomToken.family) {
 		const target = newest(store)
@@ -29,7 +29,7 @@ export const getJsonToken = <
 		}
 		const family = withdraw(jsonFamilyToken, target)
 		const subKey = JSON.parse(mutableAtomToken.family.subKey)
-		const jsonToken = findInStore(family, subKey, store)
+		const jsonToken = findInStore(store, family, subKey)
 		return jsonToken
 	}
 	const token: WritableSelectorToken<SerializableCore> = {

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

@@ -29,11 +29,11 @@ export class FamilyTracker<
 			typeof this.Update | null,
 			FamilyMemberKey
 		>(
+			store,
 			{
 				key: `*${mutableAtoms.key}`,
 				default: null,
 			},
-			store,
 			[`mutable`, `updates`],
 		)
 		this.latestUpdateAtoms = withdraw(updateAtoms, store)
@@ -43,7 +43,7 @@ export class FamilyTracker<
 			(event) => {
 				if (event.token.family) {
 					const key = parseJson(event.token.family.subKey) as FamilyMemberKey
-					seekInStore(this.latestUpdateAtoms, key, store)
+					seekInStore(store, this.latestUpdateAtoms, key)
 					new Tracker<Core>(event.token, store)
 				}
 			},
@@ -53,7 +53,7 @@ export class FamilyTracker<
 			(event) => {
 				if (event.token.family) {
 					const key = parseJson(event.token.family.subKey) as FamilyMemberKey
-					const mutableAtomToken = seekInStore(this.mutableAtoms, key, store)
+					const mutableAtomToken = seekInStore(store, this.mutableAtoms, key)
 					if (mutableAtomToken) {
 						new Tracker<Core>(mutableAtomToken, store)
 					}

package/internal/src/mutable/tracker.ts

@@ -37,12 +37,12 @@ export class Tracker<Mutable extends Transceiver<any>> {
 		const latestUpdateState = createRegularAtom<
 			(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
 		>(
+			store,
 			{
 				key: latestUpdateStateKey,
 				default: null,
 			},
 			familyMetaData,
-			store,
 		)
 		if (store.parent?.valueMap.has(latestUpdateStateKey)) {
 			const parentValue = store.parent.valueMap.get(latestUpdateStateKey)
@@ -62,11 +62,11 @@ export class Tracker<Mutable extends Transceiver<any>> {
 		const subscriptionKey = `tracker:${target.config.name}:${
 			isChildStore(target) ? target.transactionMeta.update.key : `main`
 		}:${mutableState.key}`
-		const originalInnerValue = getFromStore(mutableState, target)
+		const originalInnerValue = getFromStore(target, mutableState)
 		this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
 			subscriptionKey,
 			(update) => {
-				setIntoStore(latestUpdateState, update, target)
+				setIntoStore(target, latestUpdateState, update)
 			},
 		)
 		this.unsubscribeFromState = subscribeToState(
@@ -77,7 +77,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 					this.unsubscribeFromInnerValue = update.newValue.subscribe(
 						subscriptionKey,
 						(transceiverUpdate) => {
-							setIntoStore(latestUpdateState, transceiverUpdate, target)
+							setIntoStore(target, latestUpdateState, transceiverUpdate)
 						},
 					)
 				}
@@ -109,18 +109,14 @@ export class Tracker<Mutable extends Transceiver<any>> {
 							{ key: timelineId, type: `timeline` },
 							(update) => {
 								unsubscribe()
-								setIntoStore(
-									mutableState,
-									(transceiver) => {
-										if (update === `redo` && newValue) {
-											transceiver.do(newValue)
-										} else if (update === `undo` && oldValue) {
-											transceiver.undo(oldValue)
-										}
-										return transceiver
-									},
-									target,
-								)
+								setIntoStore(target, mutableState, (transceiver) => {
+									if (update === `redo` && newValue) {
+										transceiver.do(newValue)
+									} else if (update === `undo` && oldValue) {
+										transceiver.undo(oldValue)
+									}
+									return transceiver
+								})
 							},
 							subscriptionKey,
 							target,
@@ -133,15 +129,15 @@ export class Tracker<Mutable extends Transceiver<any>> {
 					subscriptionKey,
 					() => {
 						unsubscribe()
-						const mutable = getFromStore(mutableState, target)
+						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),
-								target,
 							)
 						} else {
 							target.logger.info(

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

@@ -12,9 +12,9 @@ import { Subject } from "../subject"
 import { registerSelector } from "./register-selector"
 
 export const createReadonlySelector = <T>(
+	store: Store,
 	options: ReadonlySelectorOptions<T>,
 	family: FamilyMetadata | undefined,
-	store: Store,
 ): ReadonlySelectorToken<T> => {
 	const target = newest(store)
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
@@ -34,7 +34,7 @@ export const createReadonlySelector = <T>(
 	const readonlySelector: ReadonlySelector<T> = {
 		...options,
 		subject,
-		install: (s: Store) => createReadonlySelector(options, family, s),
+		install: (s: Store) => createReadonlySelector(s, options, family),
 		get: getSelf,
 		type: `readonly_selector`,
 		...(family && { family }),

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

@@ -10,25 +10,25 @@ import { createReadonlySelector } from "./create-readonly-selector"
 import { createWritableSelector } from "./create-writable-selector"
 
 export function createStandaloneSelector<T>(
-	options: WritableSelectorOptions<T>,
 	store: Store,
+	options: WritableSelectorOptions<T>,
 ): WritableSelectorToken<T>
 export function createStandaloneSelector<T>(
-	options: ReadonlySelectorOptions<T>,
 	store: Store,
+	options: ReadonlySelectorOptions<T>,
 ): ReadonlySelectorToken<T>
 export function createStandaloneSelector<T>(
-	options: ReadonlySelectorOptions<T> | WritableSelectorOptions<T>,
 	store: Store,
+	options: ReadonlySelectorOptions<T> | WritableSelectorOptions<T>,
 ): ReadonlySelectorToken<T> | WritableSelectorToken<T> {
 	const isWritable = `set` in options
 
 	if (isWritable) {
-		const state = createWritableSelector(options, undefined, store)
+		const state = createWritableSelector(store, options, undefined)
 		store.on.selectorCreation.next(state)
 		return state
 	}
-	const state = createReadonlySelector(options, undefined, store)
+	const state = createReadonlySelector(store, options, undefined)
 	store.on.selectorCreation.next(state)
 	return state
 }

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

@@ -15,9 +15,9 @@ import { isRootStore } from "../transaction"
 import { registerSelector } from "./register-selector"
 
 export const createWritableSelector = <T>(
+	store: Store,
 	options: WritableSelectorOptions<T>,
 	family: FamilyMetadata | undefined,
-	store: Store,
 ): WritableSelectorToken<T> => {
 	const target = newest(store)
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
@@ -57,7 +57,7 @@ export const createWritableSelector = <T>(
 	const mySelector: WritableSelector<T> = {
 		...options,
 		subject,
-		install: (s: Store) => createWritableSelector(options, family, s),
+		install: (s: Store) => createWritableSelector(s, options, family),
 		get: getSelf,
 		set: setSelf,
 		type: `selector`,

package/internal/src/selector/register-selector.ts

@@ -43,12 +43,12 @@ export const registerSelector = (
 			const [family, key] = params
 			switch (family.type) {
 				case `molecule_family`:
-					return getFromStore(family, key, store)
+					return getFromStore(store, family, key)
 				default:
 					if (store.config.lifespan === `ephemeral`) {
-						dependency = findInStore(family, key, store)
+						dependency = findInStore(store, family, key)
 					} else {
-						const maybeDependency = seekInStore(family, key, store)
+						const maybeDependency = seekInStore(store, family, key)
 						if (maybeDependency) {
 							dependency = maybeDependency
 						} else {
@@ -61,7 +61,7 @@ export const registerSelector = (
 		}
 
 		if (dependency.type === `molecule`) {
-			return getFromStore(dependency, store)
+			return getFromStore(store, dependency)
 		}
 
 		const dependencyState = withdraw(dependency, store)
@@ -108,8 +108,8 @@ export const registerSelector = (
 			value = params[2]
 			const maybeToken =
 				store.config.lifespan === `ephemeral`
-					? findInStore(family, key, store)
-					: seekInStore(family, key, store)
+					? findInStore(store, family, key)
+					: seekInStore(store, family, key)
 			if (!maybeToken) {
 				throw new NotFoundError(family, key, store)
 			}
@@ -119,7 +119,7 @@ export const registerSelector = (
 		const state = withdraw(token, target)
 		setAtomOrSelector(state, value, target)
 	}) as typeof setState,
-	find: ((token, key) => findInStore(token, key, store)) as typeof findState,
-	seek: ((token, key) => seekInStore(token, key, store)) as typeof seekState,
-	json: (token) => getJsonToken(token, store),
+	find: ((token, key) => findInStore(store, token, key)) as typeof findState,
+	seek: ((token, key) => seekInStore(store, token, key)) as typeof seekState,
+	json: (token) => getJsonToken(store, token),
 })

package/internal/src/set-state/set-into-store.ts

@@ -2,55 +2,47 @@ import type { WritableFamilyToken, WritableToken } from "atom.io"
 import { type Canonical, stringifyJson } from "atom.io/json"
 
 import { findInStore, seekInStore } from "../families"
-import { NotFoundError } from "../not-found-error"
 import { closeOperation, openOperation } from "../operation"
 import type { Store } from "../store"
 import { withdraw } from "../store"
 import { setAtomOrSelector } from "./set-atom-or-selector"
 
 export function setIntoStore<T, New extends T>(
+	store: Store,
 	token: WritableToken<T>,
 	value: New | ((oldValue: T) => New),
-	store: Store,
 ): void
 
 export function setIntoStore<T, K extends Canonical, New extends T>(
+	store: Store,
 	token: WritableFamilyToken<T, K>,
 	key: K,
 	value: New | ((oldValue: T) => New),
-	store: Store,
 ): void
 
 export function setIntoStore<T, New extends T>(
+	store: Store,
 	...params:
 		| [
 				token: WritableFamilyToken<T, Canonical>,
 				key: Canonical,
 				value: New | ((oldValue: T) => New),
-				store: Store,
-		  ]
-		| [
-				token: WritableToken<T>,
-				value: New | ((oldValue: T) => New),
-				store: Store,
 		  ]
+		| [token: WritableToken<T>, value: New | ((oldValue: T) => New)]
 ): void {
 	let token: WritableToken<T>
 	let value: New | ((oldValue: T) => New)
-	let store: Store
-	if (params.length === 3) {
+	if (params.length === 2) {
 		token = params[0]
 		value = params[1]
-		store = params[2]
 	} else {
 		const family = params[0]
 		const key = params[1]
 		value = params[2]
-		store = params[3]
 		const maybeToken =
 			store.config.lifespan === `ephemeral`
-				? findInStore(family, key, store)
-				: seekInStore(family, key, store)
+				? findInStore(store, family, key)
+				: seekInStore(store, family, key)
 		if (!maybeToken) {
 			store.logger.error(
 				`❗`,
@@ -80,7 +72,7 @@ export function setIntoStore<T, New extends T>(
 					token.key,
 					`resuming deferred setState from T-${rejectionTime}`,
 				)
-				setIntoStore(token, value, store)
+				setIntoStore(store, token, value)
 			},
 		)
 		return

package/internal/src/store/deposit.ts

@@ -1,31 +1,47 @@
 import type {
+	AtomFamilyToken,
 	AtomToken,
 	MoleculeConstructor,
 	MoleculeFamily,
 	MoleculeFamilyToken,
 	MoleculeToken,
+	MutableAtomFamilyToken,
 	MutableAtomToken,
+	ReadableFamilyToken,
 	ReadableToken,
+	ReadonlySelectorFamilyToken,
 	ReadonlySelectorToken,
+	RegularAtomFamilyToken,
 	RegularAtomToken,
+	SelectorFamilyToken,
 	SelectorToken,
 	TransactionToken,
+	WritableFamilyToken,
+	WritableSelectorFamilyToken,
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Canonical } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 
 import type {
 	Atom,
+	AtomFamily,
 	Func,
 	Molecule,
 	MutableAtom,
+	MutableAtomFamily,
+	ReadableFamily,
 	ReadableState,
 	ReadonlySelector,
+	ReadonlySelectorFamily,
 	RegularAtom,
+	RegularAtomFamily,
 	Selector,
+	SelectorFamily,
 	Transceiver,
+	WritableFamily,
 	WritableSelector,
+	WritableSelectorFamily,
 	WritableState,
 } from ".."
 import type { Transaction } from "../transaction"
@@ -39,37 +55,61 @@ export function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T>
 export function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>
 export function deposit<T>(state: Selector<T>): SelectorToken<T>
 export function deposit<T>(state: WritableState<T>): WritableToken<T>
+export function deposit<T>(state: ReadableState<T>): ReadableToken<T>
+
+export function deposit<T, K extends Canonical>(
+	state: RegularAtomFamily<T, K>,
+): RegularAtomFamilyToken<T, K>
+export function deposit<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+	K extends Canonical,
+>(state: MutableAtomFamily<T, J, K>): MutableAtomFamilyToken<T, J, K>
+export function deposit<T>(state: AtomFamily<T, any>): AtomFamilyToken<T, any>
+export function deposit<T>(
+	state: WritableSelectorFamily<T, any>,
+): WritableSelectorFamilyToken<T, any>
+export function deposit<T>(
+	state: ReadonlySelectorFamily<T, any>,
+): ReadonlySelectorFamilyToken<T, any>
+export function deposit<T>(
+	state: SelectorFamily<T, any>,
+): SelectorFamilyToken<T, any>
+export function deposit<T>(
+	state: WritableFamily<T, any>,
+): WritableFamilyToken<T, any>
+export function deposit<T>(
+	state: ReadableFamily<T, any>,
+): ReadableFamilyToken<T, any>
+
 export function deposit<M extends MoleculeConstructor>(
 	state: MoleculeFamily<M>,
 ): MoleculeFamilyToken<M>
 export function deposit<M extends MoleculeConstructor>(
 	state: Molecule<M>,
 ): MoleculeToken<M>
+
 export function deposit<T extends Func>(
 	state: Transaction<T>,
 ): TransactionToken<T>
-export function deposit<T>(state: ReadableState<T>): ReadableToken<T>
+
 export function deposit(
 	state: Molecule<any> | ReadableState<any>,
 ): MoleculeToken<any> | ReadableToken<any>
 
-export function deposit<T>(
+export function deposit(
 	state:
 		| Molecule<any>
 		| MoleculeFamily<any>
-		| ReadableState<T>
-		| ReadonlySelector<T>
-		| RegularAtom<T>
-		| Transaction<T extends Func ? T : never>
-		| WritableSelector<T>
-		| (T extends Transceiver<any> ? MutableAtom<T, any> : never),
+		| ReadableFamily<any, any>
+		| ReadableState<any>
+		| Transaction<Func>,
 ):
 	| MoleculeFamilyToken<any>
 	| MoleculeToken<any>
-	| MutableAtomToken<T extends Transceiver<any> ? T : never, any>
-	| RegularAtomToken<T>
-	| SelectorToken<T>
-	| TransactionToken<T extends Func ? T : never> {
+	| ReadableFamilyToken<any, any>
+	| ReadableToken<any>
+	| TransactionToken<Func> {
 	const token = {
 		key: state.key,
 		type: state.type,

package/internal/src/store/store.ts

@@ -176,7 +176,7 @@ export class Store implements Lineage {
 				}
 				atom.install(this)
 				if (atom.type === `mutable_atom`) {
-					const originalJsonToken = getJsonToken(atom, store)
+					const originalJsonToken = getJsonToken(store, atom)
 					const originalUpdateToken = getUpdateToken(atom)
 					mutableHelpers.add(originalJsonToken.key)
 					mutableHelpers.add(originalUpdateToken.key)

package/internal/src/subscribe/index.ts

@@ -1,3 +1,5 @@
+export * from "./recall-state"
+export * from "./subscribe-in-store"
 export * from "./subscribe-to-root-atoms"
 export * from "./subscribe-to-state"
 export * from "./subscribe-to-timeline"

package/internal/src/subscribe/subscribe-in-store.ts

@@ -0,0 +1,62 @@
+import type {
+	ReadableToken,
+	TimelineManageable,
+	TimelineToken,
+	TimelineUpdate,
+	TransactionToken,
+	TransactionUpdateHandler,
+	UpdateHandler,
+} from "atom.io"
+import type { Func, Store } from "atom.io/internal"
+import {
+	arbitrary,
+	subscribeToState,
+	subscribeToTimeline,
+	subscribeToTransaction,
+} from "atom.io/internal"
+
+export function subscribeInStore<T>(
+	store: Store,
+	token: ReadableToken<T>,
+	handleUpdate: UpdateHandler<T>,
+	key?: string,
+): () => void
+export function subscribeInStore<F extends Func>(
+	store: Store,
+	token: TransactionToken<F>,
+	handleUpdate: TransactionUpdateHandler<F>,
+	key?: string,
+): () => void
+export function subscribeInStore<M extends TimelineManageable>(
+	store: Store,
+	token: TimelineToken<M>,
+	handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void,
+	key?: string,
+): () => void
+export function subscribeInStore<M extends TimelineManageable>(
+	store: Store,
+	token: ReadableToken<any> | TimelineToken<M> | TransactionToken<any>,
+	handleUpdate:
+		| TransactionUpdateHandler<any>
+		| UpdateHandler<any>
+		| ((update: TimelineUpdate<M> | `redo` | `undo`) => void),
+	key?: string,
+): () => void
+export function subscribeInStore(
+	store: Store,
+	token: ReadableToken<any> | TimelineToken<any> | TransactionToken<any>,
+	handleUpdate: (update: any) => void,
+	key: string = arbitrary(),
+): () => void {
+	switch (token.type) {
+		case `atom`:
+		case `mutable_atom`:
+		case `readonly_selector`:
+		case `selector`:
+			return subscribeToState(token, handleUpdate, key, store)
+		case `transaction`:
+			return subscribeToTransaction(token, handleUpdate, key, store)
+		case `timeline`:
+			return subscribeToTimeline(token, handleUpdate, key, store)
+	}
+}

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

@@ -12,9 +12,9 @@ import {
 import type { Store } from "../store"
 
 export const timeTravel = (
+	store: Store,
 	action: `redo` | `undo`,
 	token: TimelineToken<any>,
-	store: Store,
 ): void => {
 	store.logger.info(
 		action === `redo` ? `⏩` : `⏪`,