atom.io 0.40.6 → 0.40.7

package/src/internal/index.ts

@@ -1,30 +1,3 @@
-import type {
-	FamilyMetadata,
-	MutableAtomFamilyToken,
-	MutableAtomToken,
-	ReadonlyHeldSelectorFamilyToken,
-	ReadonlyHeldSelectorToken,
-	ReadonlyPureSelectorFamilyToken,
-	ReadonlyPureSelectorToken,
-	RegularAtomFamilyToken,
-	RegularAtomToken,
-	StateLifecycleEvent,
-	StateUpdate,
-	WritableHeldSelectorFamilyToken,
-	WritableHeldSelectorToken,
-	WritablePureSelectorFamilyToken,
-	WritablePureSelectorToken,
-} 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"
-import type { Timeline } from "./timeline"
-import type { RootStore, Transaction } from "./transaction"
-import type { Ctor, Flat } from "./utility-types"
-
 export * from "./arbitrary"
 export * from "./atom"
 export * from "./caching"
@@ -36,6 +9,7 @@ export * from "./get-environment-data"
 export * from "./get-state"
 export * from "./get-trace"
 export * from "./install-into-store"
+export * from "./is-fn"
 export * from "./join"
 export * from "./junction"
 export * from "./keys"
@@ -48,202 +22,10 @@ export * from "./overlays"
 export * from "./reserved-keys"
 export * from "./selector"
 export * from "./set-state"
+export type * from "./state-types"
 export * from "./store"
 export * from "./subject"
 export * from "./subscribe"
 export * from "./timeline"
 export * from "./transaction"
 export type * from "./utility-types"
-
-export type AtomIOState = {
-	key: string
-	family?: FamilyMetadata
-	install: (store: RootStore) => void
-	subject: Subject<StateUpdate<any>>
-}
-export type RegularAtom<T, E> = Flat<
-	AtomIOState & {
-		type: `atom`
-		default: T | (() => T)
-		cleanup?: () => void
-		internalRoles?: internalRole[]
-		catch?: readonly Ctor<E>[]
-	}
->
-export type MutableAtom<T extends Transceiver<any, any, any>> = Flat<
-	AtomIOState & {
-		type: `mutable_atom`
-		class: ConstructorOf<T>
-		cleanup?: () => void
-	}
->
-export type Atom<T, E> =
-	| RegularAtom<T, E>
-	| (T extends Transceiver<any, any, any> ? MutableAtom<T> : never)
-
-export type WritableHeldSelector<T> = Flat<
-	AtomIOState & {
-		type: `writable_held_selector`
-		const: T
-		getFrom: (target: Store) => T
-		setSelf: (newValue: T) => void
-	}
->
-export type ReadonlyHeldSelector<T> = Flat<
-	AtomIOState & {
-		type: `readonly_held_selector`
-		const: T
-		getFrom: (target: Store) => T
-	}
->
-export type WritablePureSelector<T, E> = Flat<
-	AtomIOState & {
-		type: `writable_pure_selector`
-		getFrom: (target: Store) => E | T
-		setSelf: (newValue: T) => void
-		catch?: readonly Ctor<E>[]
-	}
->
-export type ReadonlyPureSelector<T, E> = Flat<
-	AtomIOState & {
-		type: `readonly_pure_selector`
-		getFrom: (target: Store) => E | T
-		catch?: readonly Ctor<E>[]
-	}
->
-export type ReadonlySelector<T, E> =
-	| ReadonlyHeldSelector<T>
-	| ReadonlyPureSelector<T, E>
-export type WritableSelector<T, E> =
-	| WritableHeldSelector<T>
-	| WritablePureSelector<T, E>
-export type HeldSelector<T> = ReadonlyHeldSelector<T> | WritableHeldSelector<T>
-export type PureSelector<T, E> =
-	| ReadonlyPureSelector<T, E>
-	| WritablePureSelector<T, E>
-export type Selector<T, E> =
-	| ReadonlyHeldSelector<T>
-	| ReadonlyPureSelector<T, E>
-	| WritableHeldSelector<T>
-	| WritablePureSelector<T, E>
-
-export type WritableState<T, E> = Atom<T, E> | WritableSelector<T, E>
-export type ReadableState<T, E> = Atom<T, E> | Selector<T, E>
-
-// biome-ignore format: intersection
-export type RegularAtomFamily<T, K extends Canonical, E = never> =
-	& Flat<
-		& RegularAtomFamilyToken<T, K, E>
-		& {
-			create: <Key extends K>(key: Key) => RegularAtomToken<T, Key, E>
-			default: T | ((key: K) => T)
-			install: (store: RootStore) => void
-			internalRoles: string[] | undefined
-			subject: Subject<StateLifecycleEvent<RegularAtomToken<T, K, E>>>
-		}
-	>
-
-// biome-ignore format: intersection
-export type MutableAtomFamily<
-	T extends Transceiver<any, any, any>,
-	K extends Canonical,
-> =
-	& Flat<
-		& MutableAtomFamilyToken<T, K>
-		& {
-				create: <Key extends K>(key: Key) => MutableAtomToken<T, Key>
-				class: ConstructorOf<T>
-				install: (store: RootStore) => void
-				internalRoles: string[] | undefined
-				subject: Subject<StateLifecycleEvent<MutableAtomToken<T>>>
-			}
-	>
-
-export type AtomFamily<T, K extends Canonical, E> =
-	| MutableAtomFamily<T extends Transceiver<any, any, any> ? T : never, K>
-	| RegularAtomFamily<T, K, E>
-
-// biome-ignore format: intersection
-export type WritablePureSelectorFamily<T, K extends Canonical, E> =
-	& Flat<
-		& WritablePureSelectorFamilyToken<T, K, E>
-		& {
-			create: <Key extends K>(key: Key) => WritablePureSelectorToken<T, Key, E>
-			default: (key: K) => T,
-			install: (store: RootStore) => void
-			internalRoles: string[] | undefined
-			subject: Subject<StateLifecycleEvent<WritablePureSelectorToken<T, K, E>>>
-		}
-	>
-
-// biome-ignore format: intersection
-export type WritableHeldSelectorFamily<T , K extends Canonical> =
-	& Flat<
-		& WritableHeldSelectorFamilyToken<T, K>
-		& {
-			create: <Key extends K>(key: Key) => WritableHeldSelectorToken<T, Key>
-			default: (key: K) => T,
-			install: (store: RootStore) => void
-			internalRoles: string[] | undefined
-			subject: Subject<StateLifecycleEvent<WritableHeldSelectorToken<T, K>>>
-		}
-	>
-
-// biome-ignore format: intersection
-export type ReadonlyPureSelectorFamily<T, K extends Canonical, E> =
-	& Flat<
-		& ReadonlyPureSelectorFamilyToken<T, K, E>
-		& {
-			create: <Key extends K>(key: Key) => ReadonlyPureSelectorToken<T, Key, E>
-			default: (key: K) => T,
-			install: (store: RootStore) => void
-			internalRoles: string[] | undefined
-			subject: Subject<StateLifecycleEvent<ReadonlyPureSelectorToken<T, K, E>>>
-		}
-	>
-
-// biome-ignore format: intersection
-export type ReadonlyHeldSelectorFamily<T , K extends Canonical> =
-	& Flat<
-		& ReadonlyHeldSelectorFamilyToken<T, K>
-		& {
-			create: <Key extends K>(key: Key) => ReadonlyHeldSelectorToken<T, Key>
-			default: (key: K) => T,
-			install: (store: RootStore) => void
-			internalRoles: string[] | undefined
-			subject: Subject<StateLifecycleEvent<ReadonlyHeldSelectorToken<T>>>
-		}
-	>
-
-export type PureSelectorFamily<T, K extends Canonical, E> =
-	| ReadonlyPureSelectorFamily<T, K, E>
-	| WritablePureSelectorFamily<T, K, E>
-
-export type HeldSelectorFamily<T, K extends Canonical> =
-	| ReadonlyHeldSelectorFamily<T, K>
-	| WritableHeldSelectorFamily<T, K>
-
-export type ReadonlySelectorFamily<T, K extends Canonical, E> =
-	| ReadonlyHeldSelectorFamily<T, K>
-	| ReadonlyPureSelectorFamily<T, K, E>
-
-export type WritableSelectorFamily<T, K extends Canonical, E> =
-	| WritableHeldSelectorFamily<T, K>
-	| WritablePureSelectorFamily<T, K, E>
-
-export type SelectorFamily<T, K extends Canonical, E> =
-	| HeldSelectorFamily<T, K>
-	| PureSelectorFamily<T, K, E>
-
-export type WritableFamily<T, K extends Canonical, E> =
-	| AtomFamily<T, K, E>
-	| WritableSelectorFamily<T, K, E>
-export type ReadableFamily<T, K extends Canonical, E> =
-	| AtomFamily<T, K, E>
-	| SelectorFamily<T, K, E>
-
-export type AtomIOInternalResource =
-	| ReadableFamily<any, any, any>
-	| ReadableState<any, any>
-	| Timeline<any>
-	| Transaction<any>

package/src/internal/molecule.ts

@@ -19,7 +19,6 @@ import { getFromStore } from "./get-state"
 import { getTrace } from "./get-trace"
 import { newest } from "./lineage"
 import type { Store } from "./store"
-import { IMPLICIT } from "./store"
 import type { RootStore } from "./transaction"
 import { createTransaction, isChildStore } from "./transaction"
 
@@ -30,8 +29,8 @@ export type Molecule<K extends Canonical> = {
 }
 
 export function makeRootMoleculeInStore<S extends string>(
+	store: Store,
 	key: S,
-	store: Store = IMPLICIT.STORE,
 ): S {
 	const molecule = {
 		key,

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

@@ -10,11 +10,12 @@ import { PRETTY_TOKEN_TYPES } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
-import type { MutableAtomFamily, RootStore } from ".."
-import { createWritablePureSelectorFamily } from ".."
+import { createWritablePureSelectorFamily } from "../families"
 import { newest } from "../lineage"
 import { createMutableAtom } from "../mutable"
+import type { MutableAtomFamily } from "../state-types"
 import { Subject } from "../subject"
+import type { RootStore } from "../transaction"
 import { FamilyTracker } from "./tracker-family"
 import type { AsJSON, Transceiver } from "./transceiver"
 

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

@@ -5,12 +5,14 @@ import type {
 	UpdateHandler,
 } from "atom.io"
 
-import type { MutableAtom, RootStore } from ".."
-import { createStandaloneSelector, resetInStore, setIntoStore } from ".."
 import { newest } from "../lineage"
+import { createStandaloneSelector } from "../selector"
+import { resetInStore, setIntoStore } from "../set-state"
+import type { MutableAtom } from "../state-types"
 import { deposit, type Store } from "../store"
 import { Subject } from "../subject"
 import { subscribeToState } from "../subscribe"
+import type { RootStore } from "../transaction"
 import { Tracker } from "./tracker"
 import type { Transceiver } from "./transceiver"
 

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

@@ -1,8 +1,8 @@
 import type { MutableAtomFamilyToken } from "atom.io"
 import type { Canonical, Json } from "atom.io/json"
 
-import type { WritablePureSelectorFamily } from ".."
 import { newest } from "../lineage"
+import type { WritablePureSelectorFamily } from "../state-types"
 import type { Store } from "../store"
 import type { Transceiver } from "./transceiver"
 

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

@@ -1,8 +1,8 @@
 import type { MutableAtomFamilyToken } from "atom.io"
 import type { Json } from "atom.io/json"
 
-import type { RegularAtomFamily } from ".."
 import { newest } from "../lineage"
+import type { RegularAtomFamily } from "../state-types"
 import type { Store } from "../store"
 import type { SignalFrom, Transceiver } from "./transceiver"
 

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

@@ -2,9 +2,10 @@ import type { MutableAtomToken, StateLifecycleEvent } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { parseJson } from "atom.io/json"
 
-import type { MutableAtomFamily, RegularAtomFamily, RootStore } from ".."
 import { createRegularAtomFamily } from "../families"
+import type { MutableAtomFamily, RegularAtomFamily } from "../state-types"
 import { withdraw } from "../store"
+import type { RootStore } from "../transaction"
 import { Tracker } from "./tracker"
 import type { SignalFrom, Transceiver } from "./transceiver"
 

package/src/internal/mutable/tracker.ts

@@ -1,14 +1,11 @@
 import type { FamilyMetadata, MutableAtomToken, RegularAtomToken } from "atom.io"
 
-import type { Store } from ".."
-import {
-	getFromStore,
-	newest,
-	setIntoStore,
-	subscribeToState,
-	subscribeToTimeline,
-} from ".."
 import { createRegularAtom } from "../atom"
+import { getFromStore } from "../get-state"
+import { newest } from "../lineage"
+import { setIntoStore } from "../set-state"
+import type { Store } from "../store"
+import { subscribeToState, subscribeToTimeline } from "../subscribe"
 import { isChildStore } from "../transaction/is-root-store"
 import type { SignalFrom, Transceiver } from "./transceiver"
 

package/src/internal/safe-compute.ts

@@ -1,6 +1,6 @@
-import type { PureSelector, RegularAtom } from "."
 import { writeToCache } from "./caching"
 import { isFn } from "./is-fn"
+import type { PureSelector, RegularAtom } from "./state-types"
 import type { Store } from "./store"
 
 export function safeCompute<T, E>(

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

@@ -4,11 +4,12 @@ import type {
 	ReadonlyHeldSelectorToken,
 } from "atom.io"
 
-import type { ReadonlyHeldSelector, RootStore } from ".."
 import { writeToCache } from "../caching"
 import { newest } from "../lineage"
+import type { ReadonlyHeldSelector } from "../state-types"
 import type { Store } from "../store"
 import { Subject } from "../subject"
+import type { RootStore } from "../transaction"
 import { registerSelector } from "./register-selector"
 
 export function createReadonlyHeldSelector<T extends object>(

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

@@ -6,11 +6,12 @@ import type {
 } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
-import type { ReadonlyPureSelector, RootStore } from ".."
 import { writeToCache } from "../caching"
 import { newest } from "../lineage"
+import type { ReadonlyPureSelector } from "../state-types"
 import type { Store } from "../store"
 import { Subject } from "../subject"
+import type { RootStore } from "../transaction"
 import { registerSelector } from "./register-selector"
 
 export function createReadonlyPureSelector<T, K extends Canonical, E>(

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

@@ -4,11 +4,12 @@ import type {
 	WritableHeldSelectorToken,
 } from "atom.io"
 
-import type { RootStore, WritableHeldSelector } from ".."
 import { writeToCache } from "../caching"
 import { newest } from "../lineage"
+import type { WritableHeldSelector } from "../state-types"
 import type { Store } from "../store"
 import { Subject } from "../subject"
+import type { RootStore } from "../transaction"
 import { registerSelector } from "./register-selector"
 
 export function createWritableHeldSelector<T extends object>(

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

@@ -6,11 +6,12 @@ import type {
 } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
-import type { RootStore, WritablePureSelector } from ".."
 import { writeToCache } from "../caching"
 import { newest } from "../lineage"
+import type { WritablePureSelector } from "../state-types"
 import type { Store } from "../store"
 import { Subject } from "../subject"
+import type { RootStore } from "../transaction"
 import { registerSelector } from "./register-selector"
 
 export function createWritablePureSelector<T, K extends Canonical, E>(

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

@@ -1,7 +1,8 @@
 import type { SelectorFamilyToken, SelectorToken } from "atom.io"
 
-import type { Store } from ".."
-import { isChildStore, newest, withdraw } from ".."
+import { newest } from "../lineage"
+import { type Store, withdraw } from "../store"
+import { isChildStore } from "../transaction"
 
 export function disposeSelector(
 	store: Store,

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

@@ -67,17 +67,20 @@ export function registerSelector(
 			updateSelectorAtoms(store, selectorType, selectorKey, token, covered)
 			return dependencyValue
 		},
-		set: (<T, K extends Canonical, New extends T, Key extends K>(
+		set: (<T, K extends Canonical>(
 			...params:
 				| [
 						token: WritableFamilyToken<T, K>,
-						key: Key,
-						value: New | ((oldValue: any) => New),
+						key: NoInfer<K>,
+						value: NoInfer<T> | ((oldValue: T) => NoInfer<T>),
+				  ]
+				| [
+						token: WritableToken<T>,
+						value: NoInfer<T> | ((oldValue: T) => NoInfer<T>),
 				  ]
-				| [token: WritableToken<T>, value: New | ((oldValue: T) => New)]
 		) => {
 			const target = newest(store)
-			operateOnStore(target, JOIN_OP, ...params)
+			operateOnStore(JOIN_OP, target, ...params)
 		}) as typeof setState,
 		find: ((...args: Parameters<typeof findState>) =>
 			findInStore(store, ...args)) as typeof findState,

package/src/internal/selector/trace-selector-atoms.ts

@@ -1,5 +1,6 @@
-import type { Atom, Store } from ".."
 import { isAtomKey } from "../keys"
+import type { Atom } from "../state-types"
+import type { Store } from "../store"
 import { getSelectorDependencyKeys } from "./get-selector-dependency-keys"
 
 export function traceRootSelectorAtoms(

package/src/internal/set-state/dispatch-state-update.ts

@@ -5,14 +5,15 @@ import type {
 	TimelineEvent,
 } from "atom.io"
 
-import type { MutableAtom, Subject, WritableFamily, WritableState } from ".."
-import { newest } from ".."
 import { hasRole } from "../atom"
 import { readOrComputeValue } from "../get-state"
+import { newest } from "../lineage"
 import type { Transceiver } from "../mutable"
 import { isTransceiver } from "../mutable"
 import type { OpenOperation } from "../operation"
+import type { MutableAtom, WritableFamily, WritableState } from "../state-types"
 import { deposit, type Store } from "../store"
+import type { Subject } from "../subject"
 import { isChildStore, isRootStore } from "../transaction"
 import { evictDownstreamFromAtom } from "./evict-downstream"
 import type { ProtoUpdate } from "./operate-on-store"

package/src/internal/set-state/evict-downstream.ts

@@ -1,7 +1,7 @@
-import type { Atom } from ".."
 import { evictCachedValue } from "../caching"
 import { newest } from "../lineage"
 import { isDone, markDone } from "../operation"
+import type { Atom } from "../state-types"
 import type { Store } from "../store"
 
 export function evictDownstreamFromAtom(

package/src/internal/set-state/operate-on-store.ts

@@ -1,12 +1,12 @@
-import type { WritableFamilyToken, WritableToken } from "atom.io"
+import type { Setter, WritableFamilyToken, WritableToken } from "atom.io"
 import { type Canonical, parseJson } from "atom.io/json"
 
-import type { WritableFamily } from ".."
 import { seekInStore } from "../families"
 import { getFamilyOfToken } from "../families/get-family-of-token"
 import { mintInStore, MUST_CREATE } from "../families/mint-in-store"
 import type { OpenOperation } from "../operation"
 import { closeOperation, openOperation } from "../operation"
+import type { WritableFamily } from "../state-types"
 import { type Store, withdraw } from "../store"
 import { dispatchOrDeferStateUpdate } from "./dispatch-state-update"
 import { resetAtomOrSelector } from "./reset-atom-or-selector"
@@ -18,32 +18,26 @@ export type ProtoUpdate<T> = { oldValue: T; newValue: T }
 export const OWN_OP: unique symbol = Symbol(`OWN_OP`)
 export const JOIN_OP: unique symbol = Symbol(`JOIN_OP`)
 
-export function operateOnStore<
-	T,
-	K extends Canonical,
-	New extends T,
-	Key extends K,
-	E,
->(
-	store: Store,
+export function operateOnStore<T, TT extends T, K extends Canonical, E>(
 	opMode: typeof JOIN_OP | typeof OWN_OP,
+	store: Store,
 	...params:
 		| [
 				token: WritableFamilyToken<T, K, E>,
-				key: Key,
-				value: New | typeof RESET_STATE | ((oldValue: T) => New),
+				key: NoInfer<K>,
+				value: Setter<TT> | TT | typeof RESET_STATE,
 		  ]
 		| [
-				token: WritableToken<T, Key, E>,
-				value: New | typeof RESET_STATE | ((oldValue: T) => New),
+				token: WritableToken<T, any, E>,
+				value: Setter<TT> | TT | typeof RESET_STATE,
 		  ]
 ): void {
-	let existingToken: WritableToken<T, Key, E> | undefined
-	let brandNewToken: WritableToken<T, Key, E> | undefined
-	let token: WritableToken<T, Key, E>
+	let existingToken: WritableToken<T, K, E> | undefined
+	let brandNewToken: WritableToken<T, K, E> | undefined
+	let token: WritableToken<T, K, E>
 	let family: WritableFamily<T, K, E> | undefined
-	let key: Key | null
-	let value: New | typeof RESET_STATE | ((oldValue: T) => New)
+	let key: K | null
+	let value: Setter<TT> | TT | typeof RESET_STATE
 	if (params.length === 2) {
 		token = params[0]
 		value = params[1]
@@ -52,7 +46,7 @@ export function operateOnStore<
 			key = parseJson(token.family.subKey)
 			existingToken = seekInStore(store, family, key)
 			if (!existingToken) {
-				token = brandNewToken = mintInStore(store, family, key, MUST_CREATE)
+				token = brandNewToken = mintInStore(MUST_CREATE, store, family, key)
 			} else {
 				token = existingToken
 			}
@@ -63,7 +57,7 @@ export function operateOnStore<
 		value = params[2]
 		existingToken = seekInStore(store, family, key)
 		if (!existingToken) {
-			token = brandNewToken = mintInStore(store, family, key, MUST_CREATE)
+			token = brandNewToken = mintInStore(MUST_CREATE, store, family, key)
 		} else {
 			token = existingToken
 		}
@@ -90,7 +84,7 @@ export function operateOnStore<
 						action,
 						`from T-${rejectionTime}`,
 					)
-					operateOnStore(store, opMode, token, value)
+					operateOnStore(opMode, store, token, value)
 				},
 			)
 			return

package/src/internal/set-state/reset-atom-or-selector.ts

@@ -1,7 +1,9 @@
-import type { Atom, OpenOperation, Store, WritableState } from ".."
-import { traceRootSelectorAtoms } from ".."
 import { isFn } from "../is-fn"
+import type { OpenOperation } from "../operation"
 import { safeCompute } from "../safe-compute"
+import { traceRootSelectorAtoms } from "../selector"
+import type { Atom, WritableState } from "../state-types"
+import type { Store } from "../store"
 import { dispatchOrDeferStateUpdate } from "./dispatch-state-update"
 import type { ProtoUpdate } from "./operate-on-store"
 import { setAtom } from "./set-atom"
@@ -17,7 +19,7 @@ function resetAtom<T, E>(
 			let def: E | T
 			if (isFn(atom.default)) def = safeCompute(target, atom)
 			else def = atom.default
-			return setAtom(target, atom, def)
+			return setAtom<E | T>(target, atom, def)
 		}
 	}
 }

package/src/internal/set-state/reset-in-store.ts

@@ -14,20 +14,20 @@ export function resetInStore(
 export function resetInStore<K extends Canonical>(
 	store: Store,
 	token: WritableFamilyToken<any, K, any>,
-	key: K,
+	key: NoInfer<K>,
 ): void
 
-export function resetInStore<T, K extends Canonical, Key extends K>(
+export function resetInStore<T, K extends Canonical>(
 	store: Store,
 	...params:
-		| [token: WritableFamilyToken<T, K, any>, key: Key]
+		| [token: WritableFamilyToken<T, K, any>, key: NoInfer<K>]
 		| [token: WritableToken<T, any, any>]
 ): void
 
-export function resetInStore<T, K extends Canonical, Key extends K>(
+export function resetInStore<T, K extends Canonical>(
 	store: Store,
 	...params:
-		| [token: WritableFamilyToken<T, K, any>, key: Key]
+		| [token: WritableFamilyToken<T, K, any>, key: NoInfer<K>]
 		| [token: WritableToken<T, any, any>]
 ): void {
 	const subParams = [...params, RESET_STATE] as const

package/src/internal/set-state/set-atom-or-selector.ts

@@ -1,5 +1,5 @@
-import type { WritableState } from ".."
 import type { OpenOperation } from "../operation"
+import type { WritableState } from "../state-types"
 import type { Store } from "../store"
 import type { ProtoUpdate } from "./operate-on-store"
 import { setAtom } from "./set-atom"
@@ -8,7 +8,7 @@ import { setSelector } from "./set-selector"
 export const setAtomOrSelector = <T>(
 	target: Store & { operation: OpenOperation },
 	state: WritableState<T, any>,
-	value: T | ((oldValue: T) => T),
+	value: NoInfer<T> | ((oldValue: T) => NoInfer<T>),
 ): ProtoUpdate<T> => {
 	let protoUpdate: ProtoUpdate<T>
 	switch (state.type) {

package/src/internal/set-state/set-atom.ts

@@ -1,7 +1,9 @@
-import type { Atom, OpenOperation, Store } from ".."
 import { writeToCache } from "../caching"
 import { readOrComputeValue } from "../get-state/read-or-compute-value"
+import type { OpenOperation } from "../operation"
 import { markDone } from "../operation"
+import type { Atom } from "../state-types"
+import type { Store } from "../store"
 import { become } from "./become"
 import { evictDownstreamFromAtom } from "./evict-downstream"
 import type { ProtoUpdate } from "./operate-on-store"
@@ -9,7 +11,7 @@ import type { ProtoUpdate } from "./operate-on-store"
 export const setAtom = <T>(
 	target: Store & { operation: OpenOperation<any> },
 	atom: Atom<T, any>,
-	next: T | ((oldValue: T) => T),
+	next: NoInfer<T> | ((oldValue: T) => NoInfer<T>),
 ): ProtoUpdate<T> => {
 	const oldValue = readOrComputeValue(target, atom, `mut`)
 	let newValue = become(next, oldValue)