atom.io 0.40.1 → 0.40.2

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-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,25 +42,30 @@ 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 familyFunction = <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(
+		const token = createReadonlyPureSelector<T, Key, E>(
 			target,
-			{
-				key: fullKey,
-				get: options.get(key),
-			},
+			individualOptions,
 			family,
 		)
 
-		// subject.next({ type: `state_creation`, token, timestamp: Date.now() })
 		return token
 	}
 
@@ -77,7 +83,8 @@ export function createReadonlyPureSelectorFamily<T, K extends Canonical>(
 				json: (token) => getJsonToken(store, token),
 			})
 		},
-	}) satisfies ReadonlyPureSelectorFamily<T, K>
+		...(options.catch ? { catch: options.catch } : {}),
+	}) satisfies ReadonlyPureSelectorFamily<T, K, E>
 
 	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,22 +36,27 @@ 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 familyFunction = <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)
 
@@ -59,12 +64,14 @@ export function createRegularAtomFamily<T, K extends Canonical>(
 		return token
 	}
 
-	const atomFamily = Object.assign(familyFunction, familyToken, {
+	const atomFamily: RegularAtomFamily<T, K, E> = Object.assign(familyFunction, {
+		...familyToken,
 		default: options.default,
 		subject,
 		install: (s: RootStore) => createRegularAtomFamily(s, options),
 		internalRoles,
-	}) satisfies RegularAtomFamily<T, K>
+		...(options.catch ? { catch: options.catch } : {}),
+	})
 
 	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-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,22 +42,28 @@ 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 familyFunction = <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(
+		const token = createWritablePureSelector<T, Key, E>(
 			target,
-			{
-				key: fullKey,
-				get: options.get(key),
-				set: options.set(key),
-			},
+			individualOptions,
 			family,
 		)
 
@@ -78,7 +85,8 @@ export function createWritablePureSelectorFamily<T, K extends Canonical>(
 				json: (token) => getJsonToken(store, token),
 			})
 		},
-	}) satisfies WritablePureSelectorFamily<T, K>
+		...(options.catch ? { catch: options.catch } : {}),
+	}) satisfies WritablePureSelectorFamily<T, K, E>
 
 	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,

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

@@ -8,24 +8,24 @@ import { COUNTERFEIT, mint } from "../store"
 
 export const MUST_CREATE: unique symbol = Symbol(`MUST_CREATE`)
 
-export function mintInStore<T, K extends Canonical, Key extends K>(
+export function mintInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	family: ReadableFamily<T, K>,
+	family: ReadableFamily<T, K, E>,
 	key: Key,
 	mustCreate?: typeof MUST_CREATE,
-): WritableToken<T, K>
-export function mintInStore<T, K extends Canonical, Key extends K>(
+): WritableToken<T, Key, E>
+export function mintInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	family: ReadableFamily<T, K>,
+	family: ReadableFamily<T, K, E>,
 	key: Key,
 	mustCreate?: typeof MUST_CREATE,
-): ReadableToken<T, K>
-export function mintInStore<T, K extends Canonical, Key extends K>(
+): ReadableToken<T, Key, E>
+export function mintInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	family: ReadableFamily<T, K>,
+	family: ReadableFamily<T, K, E>,
 	key: Key,
 	mustCreate?: typeof MUST_CREATE,
-): ReadableToken<T, K> {
+): ReadableToken<T, Key, E> {
 	const stringKey = stringifyJson(key)
 	const molecule = store.molecules.get(stringKey)
 
@@ -43,7 +43,7 @@ export function mintInStore<T, K extends Canonical, Key extends K>(
 		return mint(family, key, COUNTERFEIT)
 	}
 
-	let token: ReadableToken<T, K>
+	let token: ReadableToken<T, Key, E>
 	if (mustCreate === MUST_CREATE) {
 		store.logger.info(
 			`👪`,

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

@@ -19,7 +19,7 @@ import type {
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
-import type { Molecule, ReadableState } from ".."
+import type { ReadableState } from ".."
 import { newest } from "../lineage"
 import type { Transceiver } from "../mutable"
 import { deposit, type Store } from "../store"
@@ -32,59 +32,59 @@ export function seekInStore<
 	store: Store,
 	token: MutableAtomFamilyToken<T, K>,
 	key: Key,
-): MutableAtomToken<T, K> | undefined
+): MutableAtomToken<T, Key> | undefined
 
-export function seekInStore<T, K extends Canonical, Key extends K>(
+export function seekInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	token: RegularAtomFamilyToken<T, K>,
+	token: RegularAtomFamilyToken<T, K, E>,
 	key: Key,
-): RegularAtomToken<T, K> | undefined
+): RegularAtomToken<T, Key, E> | undefined
 
-export function seekInStore<T, K extends Canonical, Key extends K>(
+export function seekInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	token: AtomFamilyToken<T, K>,
+	token: AtomFamilyToken<T, K, E>,
 	key: Key,
-): AtomToken<T, K> | undefined
+): AtomToken<T, Key, E> | undefined
 
-export function seekInStore<T, K extends Canonical, Key extends K>(
+export function seekInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	token: WritablePureSelectorFamilyToken<T, K>,
+	token: WritablePureSelectorFamilyToken<T, K, E>,
 	key: Key,
-): WritablePureSelectorToken<T, K> | undefined
+): WritablePureSelectorToken<T, Key, E> | undefined
 
-export function seekInStore<T, K extends Canonical, Key extends K>(
+export function seekInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	token: ReadonlyPureSelectorFamilyToken<T, K>,
+	token: ReadonlyPureSelectorFamilyToken<T, K, E>,
 	key: Key,
-): ReadonlyPureSelectorToken<T, K> | undefined
+): ReadonlyPureSelectorToken<T, Key, E> | undefined
 
-export function seekInStore<T, K extends Canonical, Key extends K>(
+export function seekInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	token: SelectorFamilyToken<T, K>,
+	token: SelectorFamilyToken<T, K, E>,
 	key: Key,
-): SelectorToken<T, K> | undefined
+): SelectorToken<T, Key, E> | undefined
 
-export function seekInStore<T, K extends Canonical, Key extends K>(
+export function seekInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	token: WritableFamilyToken<T, K>,
+	token: WritableFamilyToken<T, K, E>,
 	key: Key,
-): WritableToken<T, K> | undefined
+): WritableToken<T, Key, E> | undefined
 
-export function seekInStore<T, K extends Canonical, Key extends K>(
+export function seekInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	token: ReadableFamilyToken<T, K>,
+	token: ReadableFamilyToken<T, K, E>,
 	key: Key,
-): ReadableToken<T, K> | undefined
+): ReadableToken<T, Key, E> | undefined
 
 export function seekInStore(
 	store: Store,
-	token: ReadableFamilyToken<any, any>,
+	token: ReadableFamilyToken<any, any, any>,
 	key: Canonical,
-): ReadableToken<any> | undefined {
+): ReadableToken<any, any, any> | undefined {
 	const subKey = stringifyJson(key)
 	const fullKey = `${token.key}(${subKey})`
 	const target = newest(store)
-	let state: Molecule<any> | ReadableState<any> | undefined
+	let state: ReadableState<any, any> | undefined
 	switch (token.type) {
 		case `atom_family`:
 		case `mutable_atom_family`: