atom.io 0.40.1 → 0.40.3

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

@@ -199,7 +199,8 @@ export class Join<
 		this.core = { relatedKeysAtoms }
 		const getRelatedKeys: Read<
 			(key: string) => SetRTX<AType> | SetRTX<BType>
-		> = ({ get }, key) => get(relatedKeysAtoms, key) as any
+		> = ({ get }, key) =>
+			get(relatedKeysAtoms, key) as SetRTX<AType> | SetRTX<BType>
 		const addRelation: Write<(a: string, b: string) => void> = (
 			{ set },
 			a,
@@ -331,7 +332,7 @@ export class Join<
 		let contentAtoms: RegularAtomFamilyToken<Content, string>
 
 		if (defaultContent) {
-			contentAtoms = createRegularAtomFamily<Content, ContentKey>(
+			contentAtoms = createRegularAtomFamily<Content, ContentKey, never>(
 				store,
 				{
 					key: `${options.key}/content`,
@@ -398,7 +399,7 @@ export class Join<
 		)
 
 		const createSingleKeySelectorFamily = () =>
-			createReadonlyPureSelectorFamily<string | null, string>(
+			createReadonlyPureSelectorFamily<string | null, string, never>(
 				store,
 				{
 					key: `${options.key}/singleRelatedKey`,
@@ -415,7 +416,7 @@ export class Join<
 				[`join`, `keys`],
 			)
 		const getMultipleKeySelectorFamily = () => {
-			return createReadonlyPureSelectorFamily<string[], string>(
+			return createReadonlyPureSelectorFamily<string[], string, never>(
 				store,
 				{
 					key: `${options.key}/multipleRelatedKeys`,
@@ -431,7 +432,11 @@ export class Join<
 			)
 		}
 		const createSingleEntrySelectorFamily = () =>
-			createReadonlyPureSelectorFamily<[string, ViewOf<Content>] | null, string>(
+			createReadonlyPureSelectorFamily<
+				[string, ViewOf<Content>] | null,
+				string,
+				never
+			>(
 				store,
 				{
 					key: `${options.key}/singleRelatedEntry`,
@@ -454,7 +459,11 @@ export class Join<
 				[`join`, `entries`],
 			)
 		const getMultipleEntrySelectorFamily = () =>
-			createReadonlyPureSelectorFamily<[string, ViewOf<Content>][], string>(
+			createReadonlyPureSelectorFamily<
+				[string, ViewOf<Content>][],
+				string,
+				never
+			>(
 				store,
 				{
 					key: `${options.key}/multipleRelatedEntries`,

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

@@ -44,7 +44,7 @@ export function createMutableAtomFamily<
 
 	const subject = new Subject<StateLifecycleEvent<MutableAtomToken<T>>>()
 
-	const familyFunction = (key: K): MutableAtomToken<T> => {
+	const create = (key: K): MutableAtomToken<T> => {
 		const subKey = stringifyJson(key)
 		const family: FamilyMetadata = { key: options.key, subKey }
 		const fullKey = `${options.key}(${subKey})`
@@ -58,22 +58,21 @@ export function createMutableAtomFamily<
 			individualOptions.effects = options.effects(key)
 		}
 
-		const token = createMutableAtom(target, individualOptions, family)
-
-		// subject.next({ type: `state_creation`, token, timestamp: Date.now() })
-		return token
+		return createMutableAtom(target, individualOptions, family)
 	}
 
-	const atomFamily = Object.assign(familyFunction, familyToken, {
+	const atomFamily: MutableAtomFamily<T, K> = {
+		...familyToken,
+		create,
 		class: options.class,
 		subject,
 		install: (s: RootStore) => createMutableAtomFamily(s, options),
 		internalRoles,
-	}) satisfies MutableAtomFamily<T, K>
+	}
 
 	store.families.set(options.key, atomFamily)
 
-	createWritablePureSelectorFamily<AsJSON<T>, K>(
+	createWritablePureSelectorFamily<AsJSON<T>, K, never>(
 		store,
 		{
 			key: `${options.key}:JSON`,

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

@@ -12,12 +12,13 @@ export const getJsonFamily = <
 >(
 	mutableAtomFamily: MutableAtomFamilyToken<Core, Key>,
 	store: Store,
-): WritablePureSelectorFamily<ReturnType<Core[`toJSON`]>, Key> => {
+): WritablePureSelectorFamily<ReturnType<Core[`toJSON`]>, Key, never> => {
 	const target = newest(store)
 	const key = `${mutableAtomFamily.key}:JSON`
 	const jsonFamily = target.families.get(key) as WritablePureSelectorFamily<
 		ReturnType<Core[`toJSON`]>,
-		Key
+		Key,
+		never
 	>
 	return jsonFamily
 }

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

@@ -1,7 +1,7 @@
 import type { MutableAtomFamilyToken } from "atom.io"
 import type { Json } from "atom.io/json"
 
-import type { AtomFamily } from ".."
+import type { RegularAtomFamily } from ".."
 import { newest } from "../lineage"
 import type { Store } from "../store"
 import type { SignalFrom, Transceiver } from "./transceiver"
@@ -12,11 +12,13 @@ export const getUpdateFamily = <
 >(
 	mutableAtomFamily: MutableAtomFamilyToken<T, K>,
 	store: Store,
-): AtomFamily<SignalFrom<T>, K> => {
+): RegularAtomFamily<SignalFrom<T>, K, never> => {
 	const target = newest(store)
 	const key = `*${mutableAtomFamily.key}`
-	const updateFamily: AtomFamily<SignalFrom<T>, K> = target.families.get(
-		key,
-	) as AtomFamily<SignalFrom<T>, K>
+	const updateFamily = target.families.get(key) as RegularAtomFamily<
+		SignalFrom<T>,
+		K,
+		never
+	>
 	return updateFamily
 }

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

@@ -18,7 +18,11 @@ export class FamilyTracker<
 	public readonly mutableAtoms: MutableAtomFamily<T, K>
 
 	public constructor(mutableAtoms: MutableAtomFamily<T, K>, store: RootStore) {
-		const latestSignalAtoms = createRegularAtomFamily<SignalFrom<T> | null, K>(
+		const latestSignalAtoms = createRegularAtomFamily<
+			SignalFrom<T> | null,
+			K,
+			never
+		>(
 			store,
 			{
 				key: `*${mutableAtoms.key}`,

package/src/internal/mutable/tracker.ts

@@ -31,7 +31,11 @@ export class Tracker<T extends Transceiver<any, any, any>> {
 					subKey: mutableState.family.subKey,
 				}
 			: undefined
-		const latestSignalState = createRegularAtom<SignalFrom<T> | null>(
+		const latestSignalState = createRegularAtom<
+			SignalFrom<T> | null,
+			any,
+			never
+		>(
 			store,
 			{
 				key: latestSignalStateKey,

package/src/internal/operation.ts

@@ -8,7 +8,9 @@ export type OperationProgress =
 	| {
 			open: false
 	  }
-export type OpenOperation<R extends ReadableToken<any> = ReadableToken<any>> = {
+export type OpenOperation<
+	R extends ReadableToken<any, any> = ReadableToken<any, any>,
+> = {
 	open: true
 	token: R
 	done: Set<string>
@@ -19,7 +21,7 @@ export type OpenOperation<R extends ReadableToken<any> = ReadableToken<any>> = {
 
 export function openOperation(
 	store: Store,
-	token: ReadableToken<any>,
+	token: ReadableToken<any, any, any>,
 ): number | (Store & { operation: OpenOperation }) {
 	if (store.operation.open) {
 		const rejectionTime = performance.now()

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

@@ -2,7 +2,9 @@ import type {
 	FamilyMetadata,
 	ReadonlyPureSelectorOptions,
 	ReadonlyPureSelectorToken,
+	StateUpdate,
 } from "atom.io"
+import type { Canonical } from "atom.io/json"
 
 import type { ReadonlyPureSelector, RootStore } from ".."
 import { writeToCache } from "../caching"
@@ -11,13 +13,13 @@ import type { Store } from "../store"
 import { Subject } from "../subject"
 import { registerSelector } from "./register-selector"
 
-export function createReadonlyPureSelector<T>(
+export function createReadonlyPureSelector<T, K extends Canonical, E>(
 	store: Store,
-	options: ReadonlyPureSelectorOptions<T>,
-	family: FamilyMetadata | undefined,
-): ReadonlyPureSelectorToken<T> {
+	options: ReadonlyPureSelectorOptions<T, E>,
+	family: FamilyMetadata<K> | undefined,
+): ReadonlyPureSelectorToken<T, K, E> {
 	const target = newest(store)
-	const subject = new Subject<{ newValue: T; oldValue: T }>()
+	const subject = new Subject<StateUpdate<E | T>>()
 	const covered = new Set<string>()
 	const key = options.key
 	const type = `readonly_pure_selector` as const
@@ -43,7 +45,7 @@ export function createReadonlyPureSelector<T>(
 		return cached
 	}
 
-	const readonlySelector: ReadonlyPureSelector<T> = {
+	const readonlySelector: ReadonlyPureSelector<T, E> = {
 		...options,
 		type,
 		subject,

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

@@ -23,26 +23,26 @@ export function createStandaloneSelector<T extends object>(
 	store: Store,
 	options: ReadonlyHeldSelectorOptions<T>,
 ): ReadonlyHeldSelectorToken<T>
-export function createStandaloneSelector<T>(
+export function createStandaloneSelector<T, E>(
 	store: Store,
-	options: WritablePureSelectorOptions<T>,
-): WritablePureSelectorToken<T>
-export function createStandaloneSelector<T>(
+	options: WritablePureSelectorOptions<T, E>,
+): WritablePureSelectorToken<T, any, E>
+export function createStandaloneSelector<T, E>(
 	store: Store,
-	options: ReadonlyPureSelectorOptions<T>,
-): ReadonlyPureSelectorToken<T>
+	options: ReadonlyPureSelectorOptions<T, E>,
+): ReadonlyPureSelectorToken<T, any, E>
 export function createStandaloneSelector(
 	store: Store,
 	options:
 		| ReadonlyHeldSelectorOptions<any>
-		| ReadonlyPureSelectorOptions<any>
+		| ReadonlyPureSelectorOptions<any, any>
 		| WritableHeldSelectorOptions<any>
-		| WritablePureSelectorOptions<any>,
+		| WritablePureSelectorOptions<any, any>,
 ):
 	| ReadonlyHeldSelectorToken<any>
-	| ReadonlyPureSelectorToken<any>
+	| ReadonlyPureSelectorToken<any, any, any>
 	| WritableHeldSelectorToken<any>
-	| WritablePureSelectorToken<any> {
+	| WritablePureSelectorToken<any, any, any> {
 	const isWritable = `set` in options
 	const isHeld = `const` in options
 

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

@@ -1,8 +1,10 @@
 import type {
 	FamilyMetadata,
+	StateUpdate,
 	WritablePureSelectorOptions,
 	WritablePureSelectorToken,
 } from "atom.io"
+import type { Canonical } from "atom.io/json"
 
 import type { RootStore, WritablePureSelector } from ".."
 import { writeToCache } from "../caching"
@@ -11,13 +13,13 @@ import type { Store } from "../store"
 import { Subject } from "../subject"
 import { registerSelector } from "./register-selector"
 
-export function createWritablePureSelector<T>(
+export function createWritablePureSelector<T, K extends Canonical, E>(
 	store: Store,
-	options: WritablePureSelectorOptions<T>,
-	family: FamilyMetadata | undefined,
-): WritablePureSelectorToken<T> {
+	options: WritablePureSelectorOptions<T, E>,
+	family: FamilyMetadata<K> | undefined,
+): WritablePureSelectorToken<T, K, E> {
 	const target = newest(store)
-	const subject = new Subject<{ newValue: T; oldValue: T }>()
+	const subject = new Subject<StateUpdate<E | T>>()
 	const covered = new Set<string>()
 	const key = options.key
 	const type = `writable_pure_selector` as const
@@ -27,7 +29,7 @@ export function createWritablePureSelector<T>(
 	const { find, get, json } = setterToolkit
 	const getterToolkit = { find, get, json }
 
-	const getFrom = (innerTarget: Store): T => {
+	const getFrom = (innerTarget: Store): E | T => {
 		const upstreamStates = innerTarget.selectorGraph.getRelationEntries({
 			downstreamSelectorKey: key,
 		})
@@ -48,7 +50,7 @@ export function createWritablePureSelector<T>(
 		options.set(setterToolkit, newValue)
 	}
 
-	const mySelector: WritablePureSelector<T> = {
+	const mySelector: WritablePureSelector<T, E> = {
 		...options,
 		type,
 		subject,

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

@@ -5,7 +5,7 @@ import { isChildStore, newest, withdraw } from ".."
 
 export function disposeSelector(
 	store: Store,
-	selectorToken: SelectorToken<unknown>,
+	selectorToken: SelectorToken<unknown, any, any>,
 ): void {
 	const target = newest(store)
 	const { key, type, family: familyMeta } = selectorToken
@@ -21,7 +21,7 @@ export function disposeSelector(
 		if (molecule) {
 			target.moleculeData.delete(familyMeta.subKey, familyMeta.key)
 		}
-		let familyToken: SelectorFamilyToken<any, any>
+		let familyToken: SelectorFamilyToken<any, any, any>
 		switch (selectorToken.type) {
 			case `writable_held_selector`:
 				{

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

@@ -33,8 +33,8 @@ export function registerSelector(
 	return {
 		get: (
 			...params:
-				| [ReadableFamilyToken<any, any>, Canonical]
-				| [ReadableToken<any>]
+				| [ReadableFamilyToken<any, any, any>, Canonical]
+				| [ReadableToken<any, any, any>]
 		) => {
 			const target = newest(store)
 			const { token, family, subKey } = reduceReference(store, ...params)

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

@@ -6,10 +6,10 @@ export function traceRootSelectorAtoms(
 	store: Store,
 	selectorKey: string,
 	covered: Set<string> = new Set<string>(),
-): Map<string, Atom<unknown>> {
+): Map<string, Atom<any, any>> {
 	const dependencies = getSelectorDependencyKeys(store, selectorKey)
 
-	const roots = new Map<string, Atom<unknown>>()
+	const roots = new Map<string, Atom<unknown, unknown>>()
 
 	while (dependencies.length > 0) {
 		// biome-ignore lint/style/noNonNullAssertion: just checked length ^^^
@@ -19,7 +19,7 @@ export function traceRootSelectorAtoms(
 		}
 		covered.add(dependencyKey)
 		if (isAtomKey(store, dependencyKey)) {
-			const atom = store.atoms.get(dependencyKey) as Atom<unknown>
+			const atom = store.atoms.get(dependencyKey) as Atom<unknown, unknown>
 			roots.set(atom.key, atom)
 		} else {
 			dependencies.push(...getSelectorDependencyKeys(store, dependencyKey))

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

@@ -12,7 +12,7 @@ export function updateSelectorAtoms(
 		| `writable_held_selector`
 		| `writable_pure_selector`,
 	selectorKey: string,
-	dependency: ReadableToken<unknown>,
+	dependency: ReadableToken<unknown, any, unknown>,
 	covered: Set<string>,
 ): void {
 	const target = newest(store)

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

@@ -17,12 +17,12 @@ import { isChildStore, isRootStore } from "../transaction"
 import { evictDownstreamFromAtom } from "./evict-downstream"
 import type { ProtoUpdate } from "./operate-on-store"
 
-export function dispatchOrDeferStateUpdate<T>(
+export function dispatchOrDeferStateUpdate<T, E>(
 	target: Store & { operation: OpenOperation<any> },
-	state: WritableState<T>,
-	{ oldValue, newValue }: ProtoUpdate<T>,
+	state: WritableState<T, E>,
+	{ oldValue, newValue }: ProtoUpdate<E | T>,
 	stateIsNewlyCreated: boolean,
-	family?: WritableFamily<T, any>,
+	family?: WritableFamily<T, any, E>,
 ): void {
 	const token = deposit(state)
 	if (stateIsNewlyCreated && family) {
@@ -128,7 +128,11 @@ export function dispatchOrDeferStateUpdate<T>(
 			const mutable = target.atoms.get(keyOfMutable) as MutableAtom<
 				Transceiver<unknown, any, any>
 			>
-			const transceiver = readOrComputeValue(target, mutable, `mut`)
+			const transceiver = readOrComputeValue<Transceiver<any, any, any>, never>(
+				target,
+				mutable,
+				`mut`,
+			)
 			const accepted = transceiver.do(update.newValue) === null
 			if (accepted === true) {
 				evictDownstreamFromAtom(target, mutable)

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

@@ -4,7 +4,10 @@ import { newest } from "../lineage"
 import { isDone, markDone } from "../operation"
 import type { Store } from "../store"
 
-export function evictDownstreamFromAtom(store: Store, atom: Atom<any>): void {
+export function evictDownstreamFromAtom(
+	store: Store,
+	atom: Atom<any, any>,
+): void {
 	const target = newest(store)
 	const { key, type } = atom
 	const downstreamKeys = target.selectorAtoms.getRelatedKeys(key)

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

@@ -18,25 +18,31 @@ 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, New extends T>(
+export function operateOnStore<
+	T,
+	K extends Canonical,
+	New extends T,
+	Key extends K,
+	E,
+>(
 	store: Store,
 	opMode: typeof JOIN_OP | typeof OWN_OP,
 	...params:
 		| [
-				token: WritableFamilyToken<T, Canonical>,
-				key: Canonical,
+				token: WritableFamilyToken<T, K, E>,
+				key: Key,
 				value: New | typeof RESET_STATE | ((oldValue: T) => New),
 		  ]
 		| [
-				token: WritableToken<T>,
+				token: WritableToken<T, Key, E>,
 				value: New | typeof RESET_STATE | ((oldValue: T) => New),
 		  ]
 ): void {
-	let existingToken: WritableToken<T> | undefined
-	let brandNewToken: WritableToken<T> | undefined
-	let token: WritableToken<T>
-	let family: WritableFamily<T, Canonical> | undefined
-	let key: Canonical | null
+	let existingToken: WritableToken<T, Key, E> | undefined
+	let brandNewToken: WritableToken<T, Key, E> | undefined
+	let token: WritableToken<T, Key, E>
+	let family: WritableFamily<T, K, E> | undefined
+	let key: Key | null
 	let value: New | typeof RESET_STATE | ((oldValue: T) => New)
 	if (params.length === 2) {
 		token = params[0]
@@ -116,7 +122,7 @@ export function operateOnStore<T, New extends T>(
 	}
 
 	const state = withdraw(target, token)
-	let protoUpdate: ProtoUpdate<T>
+	let protoUpdate: ProtoUpdate<E | T>
 	if (value === RESET_STATE) {
 		protoUpdate = resetAtomOrSelector(target, state)
 	} else {

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

@@ -5,10 +5,10 @@ import { dispatchOrDeferStateUpdate } from "./dispatch-state-update"
 import type { ProtoUpdate } from "./operate-on-store"
 import { setAtom } from "./set-atom"
 
-function resetAtom<T>(
+function resetAtom<T, E>(
 	target: Store & { operation: OpenOperation },
-	atom: Atom<T>,
-): ProtoUpdate<T> {
+	atom: Atom<T, E>,
+): ProtoUpdate<E | T> {
 	switch (atom.type) {
 		case `mutable_atom`:
 			return setAtom(target, atom, new atom.class())
@@ -20,11 +20,11 @@ function resetAtom<T>(
 	}
 }
 
-export function resetAtomOrSelector<T>(
+export function resetAtomOrSelector<T, E>(
 	target: Store & { operation: OpenOperation },
-	state: WritableState<T>,
-): ProtoUpdate<T> {
-	let protoUpdate: ProtoUpdate<T>
+	state: WritableState<T, E>,
+): ProtoUpdate<E | T> {
+	let protoUpdate: ProtoUpdate<E | T>
 	switch (state.type) {
 		case `atom`:
 		case `mutable_atom`:

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

@@ -6,26 +6,29 @@ import { setIntoStore } from "./set-into-store"
 
 export const RESET_STATE: unique symbol = Symbol(`RESET`)
 
-export function resetInStore(store: Store, token: WritableToken<any>): void
+export function resetInStore(
+	store: Store,
+	token: WritableToken<any, any, any>,
+): void
 
 export function resetInStore<K extends Canonical>(
 	store: Store,
-	token: WritableFamilyToken<any, K>,
+	token: WritableFamilyToken<any, K, any>,
 	key: K,
 ): void
 
 export function resetInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	...params:
-		| [token: WritableFamilyToken<T, K>, key: Key]
-		| [token: WritableToken<T>]
+		| [token: WritableFamilyToken<T, K, any>, key: Key]
+		| [token: WritableToken<T, any, any>]
 ): void
 
 export function resetInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	...params:
-		| [token: WritableFamilyToken<T, K>, key: Key]
-		| [token: WritableToken<T>]
+		| [token: WritableFamilyToken<T, K, any>, key: Key]
+		| [token: WritableToken<T, any, any>]
 ): void {
 	const subParams = [...params, RESET_STATE] as const
 	setIntoStore(store, ...subParams)

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

@@ -7,7 +7,7 @@ import { setSelector } from "./set-selector"
 
 export const setAtomOrSelector = <T>(
 	target: Store & { operation: OpenOperation },
-	state: WritableState<T>,
+	state: WritableState<T, any>,
 	value: T | ((oldValue: T) => T),
 ): ProtoUpdate<T> => {
 	let protoUpdate: ProtoUpdate<T>

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

@@ -8,7 +8,7 @@ import type { ProtoUpdate } from "./operate-on-store"
 
 export const setAtom = <T>(
 	target: Store & { operation: OpenOperation<any> },
-	atom: Atom<T>,
+	atom: Atom<T, any>,
 	next: T | ((oldValue: T) => T),
 ): ProtoUpdate<T> => {
 	const oldValue = readOrComputeValue(target, atom, `mut`)

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

@@ -5,9 +5,9 @@ import type { Store } from "../store"
 import { operateOnStore, OWN_OP } from "./operate-on-store"
 import type { RESET_STATE } from "./reset-in-store"
 
-export function setIntoStore<T, New extends T>(
+export function setIntoStore<T, New extends T, E>(
 	store: Store,
-	token: WritableToken<T>,
+	token: WritableToken<T, any, E>,
 	value: New | typeof RESET_STATE | ((oldValue: T) => New),
 ): void
 
@@ -16,9 +16,10 @@ export function setIntoStore<
 	K extends Canonical,
 	New extends T,
 	Key extends K,
+	E,
 >(
 	store: Store,
-	token: WritableFamilyToken<T, K>,
+	token: WritableFamilyToken<T, K, E>,
 	key: Key,
 	value: New | typeof RESET_STATE | ((oldValue: T) => New),
 ): void
@@ -28,16 +29,17 @@ export function setIntoStore<
 	K extends Canonical,
 	New extends T,
 	Key extends K,
+	E,
 >(
 	store: Store,
 	...params:
 		| [
-				token: WritableFamilyToken<T, K>,
+				token: WritableFamilyToken<T, K, E>,
 				key: Key,
 				value: New | typeof RESET_STATE | ((oldValue: T) => New),
 		  ]
 		| [
-				token: WritableToken<T>,
+				token: WritableToken<T, any, E>,
 				value: New | typeof RESET_STATE | ((oldValue: T) => New),
 		  ]
 ): void
@@ -47,16 +49,17 @@ export function setIntoStore<
 	K extends Canonical,
 	New extends T,
 	Key extends K,
+	E,
 >(
 	store: Store,
 	...params:
 		| [
-				token: WritableFamilyToken<T, K>,
+				token: WritableFamilyToken<T, K, E>,
 				key: Key,
 				value: New | typeof RESET_STATE | ((oldValue: T) => New),
 		  ]
 		| [
-				token: WritableToken<T>,
+				token: WritableToken<T, any, E>,
 				value: New | typeof RESET_STATE | ((oldValue: T) => New),
 		  ]
 ): void {

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

@@ -7,7 +7,7 @@ import type { ProtoUpdate } from "./operate-on-store"
 
 export function setSelector<T>(
 	target: Store & { operation: OpenOperation<any> },
-	selector: WritableSelector<T>,
+	selector: WritableSelector<T, any>,
 	next: T | ((oldValue: T) => T),
 ): ProtoUpdate<T> {
 	let oldValue: T