atom.io 0.40.1 → 0.40.3

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

@@ -4,7 +4,10 @@ import type { Store, Subject } from ".."
 import { getUpdateToken, hasRole, isChildStore, newest, withdraw } from ".."
 import { getFamilyOfToken } from "../families/get-family-of-token"
 
-export function disposeAtom(store: Store, atomToken: AtomToken<any>): void {
+export function disposeAtom(
+	store: Store,
+	atomToken: AtomToken<any, any, any>,
+): void {
 	const target = newest(store)
 	const { key, family } = atomToken
 	const atom = withdraw(target, atomToken)
@@ -16,10 +19,10 @@ export function disposeAtom(store: Store, atomToken: AtomToken<any>): void {
 		const familyToken = getFamilyOfToken(store, atomToken)
 		const atomFamily = withdraw(store, familyToken)
 		const subject = atomFamily.subject as Subject<
-			StateLifecycleEvent<AtomToken<any>>
+			StateLifecycleEvent<AtomToken<any, any, any>>
 		>
 
-		const disposalEvent: AtomDisposalEvent<AtomToken<any>> = {
+		const disposalEvent: AtomDisposalEvent<AtomToken<any, any, any>> = {
 			type: `state_disposal`,
 			subType: `atom`,
 			token: atomToken,

package/src/internal/atom/has-role.ts

@@ -3,7 +3,7 @@ import type { Atom } from ".."
 export const INTERNAL_ROLES = [`tracker:signal`] as const
 export type internalRole = (typeof INTERNAL_ROLES)[number]
 
-export function hasRole(atom: Atom<any>, role: internalRole): boolean {
+export function hasRole(atom: Atom<any, any>, role: internalRole): boolean {
 	if (`internalRoles` in atom === false) {
 		return false
 	}

package/src/internal/caching.ts

@@ -7,21 +7,21 @@ import {
 } from "./set-state/evict-downstream"
 import type { Store } from "./store"
 
-export function writeToCache<T>(
+export function writeToCache<T, E>(
 	target: Store,
-	state: ReadableState<T>,
-	value: T,
-): T
-export function writeToCache<T extends Promise<any>>(
+	state: ReadableState<T, E>,
+	value: E | T,
+): E | T
+export function writeToCache<T extends Promise<any>, E>(
 	target: Store,
-	state: ReadableState<T>,
+	state: ReadableState<T, E>,
 	value: T,
-): Future<Awaited<T>>
-export function writeToCache<T>(
+): Future<Awaited<E | T>>
+export function writeToCache<T, E>(
 	target: Store,
-	state: ReadableState<T>,
-	value: T,
-): Future<T> | T {
+	state: ReadableState<T, E>,
+	value: E | T,
+): E | Future<E | T> | T {
 	const { key, subject, type } = state
 	const currentValue = target.valueMap.get(key)
 	if (currentValue instanceof Future && !currentValue.done) {
@@ -74,13 +74,13 @@ export function writeToCache<T>(
  * @param mut - whether the value is intended to be mutable
  * @returns the state's current value
  */
-export function readFromCache<T>(
+export function readFromCache<T, E>(
 	target: Store,
-	state: ReadableState<T>,
+	state: ReadableState<T, E>,
 	mut: `mut` | undefined,
-): T {
+): E | T {
 	target.logger.info(`📖`, state.type, state.key, `reading cached value`)
-	let value = target.valueMap.get(state.key) as T
+	let value = target.valueMap.get(state.key) as E | T
 
 	const mayNeedToBeCopied =
 		mut === `mut` && state.type === `mutable_atom` && isChildStore(target)

package/src/internal/events/ingest-creation-disposal.ts

@@ -37,7 +37,7 @@ export function ingestCreationEvent(
 
 export function ingestDisposalEvent(
 	store: Store,
-	event: StateDisposalEvent<ReadableToken<any>>,
+	event: StateDisposalEvent<ReadableToken<any, any, any>>,
 	applying: `newValue` | `oldValue`,
 ): void {
 	switch (applying) {

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

@@ -44,13 +44,13 @@ export function createReadonlyHeldSelectorFamily<
 		StateLifecycleEvent<ReadonlyHeldSelectorToken<T>>
 	>()
 
-	const familyFunction = (key: K): ReadonlyHeldSelectorToken<T> => {
+	const create = (key: K): ReadonlyHeldSelectorToken<T> => {
 		const subKey = stringifyJson(key)
 		const family: FamilyMetadata = { key: familyKey, subKey }
 		const fullKey = `${familyKey}(${subKey})`
 		const target = newest(store)
 
-		const token = createReadonlyHeldSelector(
+		return createReadonlyHeldSelector(
 			target,
 			{
 				key: fullKey,
@@ -59,17 +59,16 @@ export function createReadonlyHeldSelectorFamily<
 			},
 			family,
 		)
-
-		// subject.next({ type: `state_creation`, token, timestamp: Date.now() })
-		return token
 	}
 
-	const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
+	const readonlySelectorFamily: ReadonlyHeldSelectorFamily<T, K> = {
+		...familyToken,
+		create,
 		internalRoles,
 		subject,
 		install: (s: RootStore) => createReadonlyHeldSelectorFamily(s, options),
 		default: options.const,
-	}) satisfies ReadonlyHeldSelectorFamily<T, K>
+	}
 
 	store.families.set(familyKey, readonlySelectorFamily)
 	return familyToken

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

@@ -4,6 +4,7 @@ import type {
 	getState,
 	ReadonlyPureSelectorFamilyOptions,
 	ReadonlyPureSelectorFamilyToken,
+	ReadonlyPureSelectorOptions,
 	ReadonlyPureSelectorToken,
 	StateLifecycleEvent,
 } from "atom.io"
@@ -17,18 +18,18 @@ import { newest } from "../lineage"
 import { createReadonlyPureSelector } from "../selector"
 import { Subject } from "../subject"
 
-export function createReadonlyPureSelectorFamily<T, K extends Canonical>(
+export function createReadonlyPureSelectorFamily<T, K extends Canonical, E>(
 	store: RootStore,
-	options: ReadonlyPureSelectorFamilyOptions<T, K>,
+	options: ReadonlyPureSelectorFamilyOptions<T, K, E>,
 	internalRoles?: string[],
-): ReadonlyPureSelectorFamilyToken<T, K> {
+): ReadonlyPureSelectorFamilyToken<T, K, E> {
 	const familyKey = options.key
 	const type = `readonly_pure_selector_family`
 
 	const familyToken = {
 		key: familyKey,
 		type,
-	} as const satisfies ReadonlyPureSelectorFamilyToken<T, K>
+	} as const satisfies ReadonlyPureSelectorFamilyToken<T, K, E>
 
 	const existing = store.families.get(familyKey)
 	if (existing) {
@@ -41,29 +42,34 @@ export function createReadonlyPureSelectorFamily<T, K extends Canonical>(
 	}
 
 	const subject = new Subject<
-		StateLifecycleEvent<ReadonlyPureSelectorToken<T>>
+		StateLifecycleEvent<ReadonlyPureSelectorToken<T, K, E>>
 	>()
 
-	const familyFunction = (key: K): ReadonlyPureSelectorToken<T> => {
+	const create = <Key extends K>(
+		key: Key,
+	): ReadonlyPureSelectorToken<T, Key, E> => {
 		const subKey = stringifyJson(key)
-		const family: FamilyMetadata = { key: familyKey, subKey }
+		const family: FamilyMetadata<Key> = { key: familyKey, subKey }
 		const fullKey = `${familyKey}(${subKey})`
 		const target = newest(store)
+		const individualOptions: ReadonlyPureSelectorOptions<T, E> = {
+			key: fullKey,
+			get: options.get(key),
+		}
+		if (options.catch) {
+			individualOptions.catch = options.catch
+		}
 
-		const token = createReadonlyPureSelector(
+		return createReadonlyPureSelector<T, Key, E>(
 			target,
-			{
-				key: fullKey,
-				get: options.get(key),
-			},
+			individualOptions,
 			family,
 		)
-
-		// subject.next({ type: `state_creation`, token, timestamp: Date.now() })
-		return token
 	}
 
-	const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
+	const readonlySelectorFamily: ReadonlyPureSelectorFamily<T, K, E> = {
+		...familyToken,
+		create,
 		internalRoles,
 		subject,
 		install: (s: RootStore) => createReadonlyPureSelectorFamily(s, options),
@@ -77,7 +83,7 @@ export function createReadonlyPureSelectorFamily<T, K extends Canonical>(
 				json: (token) => getJsonToken(store, token),
 			})
 		},
-	}) satisfies ReadonlyPureSelectorFamily<T, K>
+	}
 
 	store.families.set(familyKey, readonlySelectorFamily)
 	return familyToken

package/src/internal/families/create-regular-atom-family.ts

@@ -16,15 +16,15 @@ import { isFn } from "../is-fn"
 import { newest } from "../lineage"
 import { Subject } from "../subject"
 
-export function createRegularAtomFamily<T, K extends Canonical>(
+export function createRegularAtomFamily<T, K extends Canonical, E>(
 	store: RootStore,
-	options: RegularAtomFamilyOptions<T, K>,
+	options: RegularAtomFamilyOptions<T, K, E>,
 	internalRoles?: string[],
-): RegularAtomFamilyToken<T, K> {
-	const familyToken = {
+): RegularAtomFamilyToken<T, K, E> {
+	const familyToken: RegularAtomFamilyToken<T, K, E> = {
 		key: options.key,
 		type: `atom_family`,
-	} as const satisfies RegularAtomFamilyToken<T, K>
+	}
 
 	const existing = store.families.get(options.key)
 	if (existing) {
@@ -36,35 +36,37 @@ export function createRegularAtomFamily<T, K extends Canonical>(
 		)
 	}
 
-	const subject = new Subject<StateLifecycleEvent<RegularAtomToken<T>>>()
+	const subject = new Subject<StateLifecycleEvent<RegularAtomToken<T, K, E>>>()
 
-	const familyFunction = (key: K): RegularAtomToken<any> => {
+	const create = <Key extends K>(key: Key): RegularAtomToken<T, Key, E> => {
 		const subKey = stringifyJson(key)
-		const family: FamilyMetadata = { key: options.key, subKey }
+		const family: FamilyMetadata<Key> = { key: options.key, subKey }
 		const fullKey = `${options.key}(${subKey})`
 		const target = newest(store)
 
 		const def = options.default
-		const individualOptions: RegularAtomOptions<T> = {
+		const individualOptions: RegularAtomOptions<T, E> = {
 			key: fullKey,
 			default: isFn(def) ? () => def(key) : def,
 		}
 		if (options.effects) {
 			individualOptions.effects = options.effects(key)
 		}
+		if (options.catch) {
+			individualOptions.catch = options.catch
+		}
 
-		const token = createRegularAtom(target, individualOptions, family)
-
-		// subject.next({ type: `state_creation`, token, timestamp: Date.now() })
-		return token
+		return createRegularAtom(target, individualOptions, family)
 	}
 
-	const atomFamily = Object.assign(familyFunction, familyToken, {
+	const atomFamily: RegularAtomFamily<T, K, E> = {
+		...familyToken,
+		create,
 		default: options.default,
 		subject,
 		install: (s: RootStore) => createRegularAtomFamily(s, options),
 		internalRoles,
-	}) satisfies RegularAtomFamily<T, K>
+	}
 
 	store.families.set(options.key, atomFamily)
 	if (isFn(options.default) === false) {

package/src/internal/families/create-selector-family.ts

@@ -25,22 +25,22 @@ export function createSelectorFamily<T extends object, K extends Canonical>(
 	store: RootStore,
 	options: ReadonlyHeldSelectorFamilyOptions<T, K>,
 ): ReadonlyHeldSelectorFamilyToken<T, K>
-export function createSelectorFamily<T, K extends Canonical>(
+export function createSelectorFamily<T, K extends Canonical, E>(
 	store: RootStore,
-	options: WritablePureSelectorFamilyOptions<T, K>,
-): WritablePureSelectorFamilyToken<T, K>
-export function createSelectorFamily<T, K extends Canonical>(
+	options: WritablePureSelectorFamilyOptions<T, K, E>,
+): WritablePureSelectorFamilyToken<T, K, E>
+export function createSelectorFamily<T, K extends Canonical, E>(
 	store: RootStore,
-	options: ReadonlyPureSelectorFamilyOptions<T, K>,
-): ReadonlyPureSelectorFamilyToken<T, K>
+	options: ReadonlyPureSelectorFamilyOptions<T, K, E>,
+): ReadonlyPureSelectorFamilyToken<T, K, E>
 export function createSelectorFamily(
 	store: RootStore,
 	options:
 		| ReadonlyHeldSelectorFamilyOptions<any, any>
-		| ReadonlyPureSelectorFamilyOptions<any, any>
+		| ReadonlyPureSelectorFamilyOptions<any, any, any>
 		| WritableHeldSelectorFamilyOptions<any, any>
-		| WritablePureSelectorFamilyOptions<any, any>,
-): SelectorFamilyToken<any, any> {
+		| WritablePureSelectorFamilyOptions<any, any, any>,
+): SelectorFamilyToken<any, any, any> {
 	const isWritable = `set` in options
 	const isHeld = `const` in options
 

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

@@ -44,13 +44,13 @@ export function createWritableHeldSelectorFamily<
 		StateLifecycleEvent<WritableHeldSelectorToken<T>>
 	>()
 
-	const familyFunction = (key: K): WritableHeldSelectorToken<T> => {
+	const create = (key: K): WritableHeldSelectorToken<T> => {
 		const subKey = stringifyJson(key)
 		const family: FamilyMetadata = { key: familyKey, subKey }
 		const fullKey = `${familyKey}(${subKey})`
 		const target = newest(store)
 
-		const token = createWritableHeldSelector(
+		return createWritableHeldSelector(
 			target,
 			{
 				key: fullKey,
@@ -60,17 +60,16 @@ export function createWritableHeldSelectorFamily<
 			},
 			family,
 		)
-
-		// subject.next({ type: `state_creation`, token, timestamp: Date.now() })
-		return token
 	}
 
-	const selectorFamily = Object.assign(familyFunction, familyToken, {
+	const selectorFamily: WritableHeldSelectorFamily<T, K> = {
+		...familyToken,
+		create,
 		internalRoles,
 		subject,
 		install: (s: RootStore) => createWritableHeldSelectorFamily(s, options),
 		default: options.const,
-	}) satisfies WritableHeldSelectorFamily<T, K>
+	}
 
 	store.families.set(familyKey, selectorFamily)
 	return familyToken

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

@@ -5,6 +5,7 @@ import type {
 	StateLifecycleEvent,
 	WritablePureSelectorFamilyOptions,
 	WritablePureSelectorFamilyToken,
+	WritablePureSelectorOptions,
 	WritablePureSelectorToken,
 } from "atom.io"
 import { PRETTY_TOKEN_TYPES } from "atom.io"
@@ -18,18 +19,18 @@ import { createWritablePureSelector } from "../selector"
 import type { Store } from "../store"
 import { Subject } from "../subject"
 
-export function createWritablePureSelectorFamily<T, K extends Canonical>(
+export function createWritablePureSelectorFamily<T, K extends Canonical, E>(
 	store: Store,
-	options: WritablePureSelectorFamilyOptions<T, K>,
+	options: WritablePureSelectorFamilyOptions<T, K, E>,
 	internalRoles?: string[],
-): WritablePureSelectorFamilyToken<T, K> {
+): WritablePureSelectorFamilyToken<T, K, E> {
 	const familyKey = options.key
 	const type = `writable_pure_selector_family`
 
 	const familyToken = {
 		key: familyKey,
 		type,
-	} as const satisfies WritablePureSelectorFamilyToken<T, K>
+	} as const satisfies WritablePureSelectorFamilyToken<T, K, E>
 
 	const existing = store.families.get(familyKey)
 	if (existing) {
@@ -41,30 +42,35 @@ export function createWritablePureSelectorFamily<T, K extends Canonical>(
 		)
 	}
 	const subject = new Subject<
-		StateLifecycleEvent<WritablePureSelectorToken<T>>
+		StateLifecycleEvent<WritablePureSelectorToken<T, K, E>>
 	>()
 
-	const familyFunction = (key: K): WritablePureSelectorToken<T> => {
+	const create = <Key extends K>(
+		key: Key,
+	): WritablePureSelectorToken<T, Key, E> => {
 		const subKey = stringifyJson(key)
-		const family: FamilyMetadata = { key: familyKey, subKey }
+		const family: FamilyMetadata<Key> = { key: familyKey, subKey }
 		const fullKey = `${familyKey}(${subKey})`
 		const target = newest(store)
+		const individualOptions: WritablePureSelectorOptions<T, E> = {
+			key: fullKey,
+			get: options.get(key),
+			set: options.set(key),
+		}
+		if (options.catch) {
+			individualOptions.catch = options.catch
+		}
 
-		const token = createWritablePureSelector(
+		return createWritablePureSelector<T, Key, E>(
 			target,
-			{
-				key: fullKey,
-				get: options.get(key),
-				set: options.set(key),
-			},
+			individualOptions,
 			family,
 		)
-
-		// subject.next({ type: `state_creation`, token, timestamp: Date.now() })
-		return token
 	}
 
-	const selectorFamily = Object.assign(familyFunction, familyToken, {
+	const selectorFamily: WritablePureSelectorFamily<T, K, E> = {
+		...familyToken,
+		create,
 		internalRoles,
 		subject,
 		install: (s: RootStore) => createWritablePureSelectorFamily(s, options),
@@ -78,7 +84,7 @@ export function createWritablePureSelectorFamily<T, K extends Canonical>(
 				json: (token) => getJsonToken(store, token),
 			})
 		},
-	}) satisfies WritablePureSelectorFamily<T, K>
+	}
 
 	store.families.set(familyKey, selectorFamily)
 	return familyToken

package/src/internal/families/dispose-from-store.ts

@@ -6,28 +6,31 @@ import { disposeSelector } from "../selector"
 import { type Store, withdraw } from "../store"
 import { findInStore } from "./find-in-store"
 
-export function disposeFromStore(store: Store, token: ReadableToken<any>): void
+export function disposeFromStore(
+	store: Store,
+	token: ReadableToken<any, any, any>,
+): void
 
 export function disposeFromStore<K extends Canonical, Key extends K>(
 	store: Store,
-	token: ReadableFamilyToken<any, K>,
+	token: ReadableFamilyToken<any, K, any>,
 	key: Key,
 ): void
 
 export function disposeFromStore<K extends Canonical, Key extends K>(
 	store: Store,
 	...params:
-		| [token: ReadableFamilyToken<any, K>, key: Key]
-		| [token: ReadableToken<any>]
+		| [token: ReadableFamilyToken<any, K, any>, key: Key]
+		| [token: ReadableToken<any, any, any>]
 ): void
 
 export function disposeFromStore(
 	store: Store,
 	...params:
-		| [token: ReadableFamilyToken<any, any>, key: Canonical]
-		| [token: ReadableToken<any>]
+		| [token: ReadableFamilyToken<any, any, any>, key: Canonical]
+		| [token: ReadableToken<any, any, any>]
 ): void {
-	let token: ReadableToken<any>
+	let token: ReadableToken<any, any, any>
 	if (params.length === 1) {
 		token = params[0]
 	} else {

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

@@ -38,53 +38,53 @@ export function findInStore<
 	key: Key,
 ): MutableAtomToken<T, K>
 
-export function findInStore<T, K extends Canonical, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	familyToken: RegularAtomFamilyToken<T, K>,
+	familyToken: RegularAtomFamilyToken<T, K, E>,
 	key: Key,
-): RegularAtomToken<T, K>
+): RegularAtomToken<T, K, E>
 
-export function findInStore<T, K extends Canonical, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	familyToken: AtomFamilyToken<T, K>,
+	familyToken: AtomFamilyToken<T, K, E>,
 	key: Key,
-): AtomToken<T, K>
+): AtomToken<T, K, E>
 
-export function findInStore<T, K extends Canonical, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	familyToken: WritablePureSelectorFamilyToken<T, K>,
+	familyToken: WritablePureSelectorFamilyToken<T, K, E>,
 	key: Key,
-): WritablePureSelectorToken<T, K>
+): WritablePureSelectorToken<T, K, E>
 
-export function findInStore<T, K extends Canonical, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	familyToken: ReadonlyPureSelectorFamilyToken<T, K>,
+	familyToken: ReadonlyPureSelectorFamilyToken<T, K, E>,
 	key: Key,
-): ReadonlyPureSelectorToken<T, K>
+): ReadonlyPureSelectorToken<T, K, E>
 
-export function findInStore<T, K extends Canonical, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	familyToken: SelectorFamilyToken<T, K>,
+	familyToken: SelectorFamilyToken<T, K, E>,
 	key: Key,
-): SelectorToken<T, K>
+): SelectorToken<T, K, E>
 
-export function findInStore<T, K extends Canonical, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	familyToken: WritableFamilyToken<T, K>,
+	familyToken: WritableFamilyToken<T, K, E>,
 	key: Key,
-): WritableToken<T, K>
+): WritableToken<T, K, E>
 
-export function findInStore<T, K extends Canonical, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	familyToken: ReadableFamilyToken<T, K>,
+	familyToken: ReadableFamilyToken<T, K, E>,
 	key: Key,
-): ReadableToken<T, K>
+): ReadableToken<T, K, E>
 
 export function findInStore(
 	store: Store,
-	familyToken: ReadableFamilyToken<any, any>,
+	familyToken: ReadableFamilyToken<any, any, any>,
 	key: Canonical,
-): ReadableToken<any> {
+): ReadableToken<any, any, any> {
 	const family = withdraw(store, familyToken)
 	const existingStateToken = seekInStore(store, familyToken, key)
 	if (existingStateToken) {

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

@@ -24,35 +24,35 @@ export function getFamilyOfToken<
 	K extends Canonical,
 >(store: Store, token: MutableAtomToken<T, K>): MutableAtomFamily<T, K>
 
-export function getFamilyOfToken<T, K extends Canonical>(
+export function getFamilyOfToken<T, K extends Canonical, E>(
 	store: Store,
-	token: RegularAtomToken<T, K>,
-): RegularAtomFamily<T, K>
+	token: RegularAtomToken<T, K, E>,
+): RegularAtomFamily<T, K, E>
 
-export function getFamilyOfToken<T, K extends Canonical>(
+export function getFamilyOfToken<T, K extends Canonical, E>(
 	store: Store,
-	token: WritablePureSelectorToken<T, K>,
-): WritablePureSelectorFamily<T, K>
+	token: WritablePureSelectorToken<T, K, E>,
+): WritablePureSelectorFamily<T, K, E>
 
-export function getFamilyOfToken<T, K extends Canonical>(
+export function getFamilyOfToken<T, K extends Canonical, E>(
 	store: Store,
-	token: ReadonlyPureSelectorToken<T, K>,
-): ReadonlyPureSelectorFamily<T, K>
+	token: ReadonlyPureSelectorToken<T, K, E>,
+): ReadonlyPureSelectorFamily<T, K, E>
 
-export function getFamilyOfToken<T, K extends Canonical>(
+export function getFamilyOfToken<T, K extends Canonical, E>(
 	store: Store,
-	token: WritableToken<T, K>,
-): WritableFamily<T, K>
+	token: WritableToken<T, K, E>,
+): WritableFamily<T, K, E>
 
-export function getFamilyOfToken<T, K extends Canonical>(
+export function getFamilyOfToken<T, K extends Canonical, E>(
 	store: Store,
-	token: ReadableToken<T, K>,
-): ReadableFamily<T, K>
+	token: ReadableToken<T, K, E>,
+): ReadableFamily<T, K, E>
 
 export function getFamilyOfToken(
 	store: Store,
-	token: ReadableToken<any, any>,
-): ReadableFamily<any, any> {
+	token: ReadableToken<any, any, any>,
+): ReadableFamily<any, any, any> {
 	return withdraw(store, {
 		// biome-ignore lint/style/noNonNullAssertion: family is required
 		key: token.family!.key,