atom.io 0.40.1 → 0.40.3

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(
 			`👪`,
@@ -52,7 +52,7 @@ export function mintInStore<T, K extends Canonical, Key extends K>(
 			`adds member`,
 			typeof key === `string` ? `\`${key}\`` : key,
 		)
-		token = family(key)
+		token = family.create(key)
 		if (molecule) {
 			store.moleculeData.set(stringKey, family.key)
 		}

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`:

package/src/internal/get-state/get-fallback.ts

@@ -1,15 +1,15 @@
-import type { ReadableToken } from "atom.io"
+import type { ReadableToken, ViewOf } from "atom.io"
 import { type Canonical, stringifyJson } from "atom.io/json"
 
 import type { ReadableFamily } from ".."
 import type { Store } from "../store"
 
-export function getFallback<T, K extends Canonical>(
+export function getFallback<T, K extends Canonical, E>(
 	store: Store,
-	token: ReadableToken<T, K>,
-	family: ReadableFamily<T, K>,
+	token: ReadableToken<T, K, E>,
+	family: ReadableFamily<T, K, E>,
 	subKey: K,
-): T {
+): ViewOf<E | T> {
 	const disposal = store.disposalTraces.buffer.find(
 		(item) => item?.key === stringifyJson(subKey),
 	)
@@ -31,7 +31,7 @@ export function getFallback<T, K extends Canonical>(
 			}
 			const defaultValue = new family.class()
 			store.defaults.set(family.key, defaultValue)
-			return defaultValue
+			return defaultValue.READONLY_VIEW
 		}
 		case `atom_family`: {
 			if (store.defaults.has(family.key)) {
@@ -40,7 +40,7 @@ export function getFallback<T, K extends Canonical>(
 			const def = family.default as (key: K) => T
 			const defaultValue = def(subKey)
 			store.defaults.set(family.key, defaultValue)
-			return defaultValue
+			return defaultValue as ViewOf<T>
 		}
 		case `readonly_pure_selector_family`:
 		case `writable_pure_selector_family`:
@@ -51,7 +51,7 @@ export function getFallback<T, K extends Canonical>(
 			}
 			const defaultValue = family.default(subKey)
 			store.defaults.set(family.key, defaultValue)
-			return defaultValue
+			return defaultValue as ViewOf<T>
 		}
 	}
 }

package/src/internal/get-state/get-from-store.ts

@@ -1,4 +1,4 @@
-import type { ReadableFamilyToken, ReadableToken } from "atom.io"
+import type { ReadableFamilyToken, ReadableToken, ViewOf } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
 import { type Store, withdraw } from "../store"
@@ -8,25 +8,30 @@ import { reduceReference } from "./reduce-reference"
 
 export function getFromStore<T>(store: Store, token: ReadableToken<T>): T
 
-export function getFromStore<T, K extends Canonical>(
+export function getFromStore<T, E>(
 	store: Store,
-	token: ReadableFamilyToken<T, K>,
+	token: ReadableToken<T, any, E>,
+): E | T
+
+export function getFromStore<T, K extends Canonical, E>(
+	store: Store,
+	token: ReadableFamilyToken<T, K, E>,
 	key: K,
-): T
+): ViewOf<E | T>
 
-export function getFromStore<T, K extends Canonical, Key extends K>(
+export function getFromStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
 	...params:
-		| [token: ReadableFamilyToken<T, K>, key: Key]
-		| [token: ReadableToken<T>]
-): T
+		| [token: ReadableFamilyToken<T, K, E>, key: Key]
+		| [token: ReadableToken<T, any, E>]
+): ViewOf<E | T>
 
-export function getFromStore<T, K extends Canonical, Key extends K>(
+export function getFromStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
 	...params:
-		| [token: ReadableFamilyToken<T, K>, key: Key]
-		| [token: ReadableToken<T>]
-): any {
+		| [token: ReadableFamilyToken<T, K, E>, key: Key]
+		| [token: ReadableToken<T, any, E>]
+): ViewOf<E | T> {
 	const { token, family, subKey } = reduceReference(store, ...params)
 
 	if (`counterfeit` in token && family && subKey) {

package/src/internal/get-state/read-or-compute-value.ts

@@ -5,21 +5,21 @@ import { readFromCache, writeToCache } from "../caching"
 import { isFn } from "../is-fn"
 import type { Store } from "../store"
 
-export function readOrComputeValue<T>(
+export function readOrComputeValue<T, E>(
 	target: Store,
-	state: ReadableState<T>,
+	state: ReadableState<T, E>,
 	mut?: undefined,
-): ViewOf<T>
-export function readOrComputeValue<T>(
+): ViewOf<E | T>
+export function readOrComputeValue<T, E>(
 	target: Store,
-	state: ReadableState<T>,
+	state: ReadableState<T, E>,
 	mut: `mut`,
-): T
-export function readOrComputeValue<T>(
+): E | T
+export function readOrComputeValue<T, E>(
 	target: Store,
-	state: ReadableState<T>,
+	state: ReadableState<T, E>,
 	mut: `mut` | undefined,
-): T {
+): E | T {
 	if (target.valueMap.has(state.key)) {
 		return readFromCache(target, state, mut)
 	}
@@ -27,16 +27,80 @@ export function readOrComputeValue<T>(
 	const { key } = state
 	switch (state.type) {
 		case `readonly_held_selector`:
-		case `readonly_pure_selector`:
 		case `writable_held_selector`:
-		case `writable_pure_selector`:
 			target.logger.info(`🧮`, state.type, key, `computing value`)
 			return state.getFrom(target)
+		case `readonly_pure_selector`:
+		case `writable_pure_selector`: {
+			let val: E | T
+			target.logger.info(`🧮`, state.type, key, `computing value`)
+			try {
+				val = state.getFrom(target)
+				if (val instanceof Promise) {
+					return (val as Promise<E & T>).catch((e) => {
+						target.logger.error(`💥`, state.type, key, `rejected:`, e)
+						if (state.catch) {
+							for (const Class of state.catch) {
+								if (e instanceof Class) {
+									return writeToCache(target, state, e)
+								}
+							}
+						}
+						throw e
+					}) as E | T
+				}
+			} catch (e) {
+				target.logger.error(`💥`, state.type, key, `rejected:`, e)
+				if (state.catch) {
+					for (const Class of state.catch) {
+						if (e instanceof Class) {
+							return writeToCache(target, state, e)
+						}
+					}
+				}
+				throw e
+			}
+			const cachedValue = writeToCache(target, state, val)
+			return cachedValue
+		}
 		case `atom`: {
-			let def: T
+			let def: E | T
 			if (isFn(state.default)) {
-				def = state.default()
-				target.logger.info(`✨`, state.type, key, `computed default`, def)
+				try {
+					def = state.default()
+					if (def instanceof Promise) {
+						def = (def as Promise<T> & T).catch<E | T>((e) => {
+							target.logger.error(`💥`, state.type, key, `rejected:`, e)
+							if (state.catch) {
+								for (const Class of state.catch) {
+									if (e instanceof Class) {
+										def = writeToCache(target, state, e)
+										return def
+									}
+								}
+							}
+							throw e
+						}) as E | T
+					}
+				} catch (e) {
+					target.logger.error(`💥`, state.type, key, `rejected:`, e)
+					if (state.catch) {
+						for (const Class of state.catch) {
+							if (e instanceof Class) {
+								def = writeToCache(target, state, e)
+								target.logger.info(
+									`✨`,
+									state.type,
+									key,
+									`computed default`,
+									def,
+								)
+								return def
+							}
+						}
+					}
+					throw e
+				}
 			} else {
 				def = state.default
 				target.logger.info(`✨`, state.type, key, `using static default`, def)

package/src/internal/get-state/reduce-reference.ts

@@ -13,27 +13,27 @@ import { mintInStore, MUST_CREATE } from "../families/mint-in-store"
 import type { Store } from "../store"
 import { withdraw } from "../store"
 
-export function reduceReference<T, K extends Canonical>(
+export function reduceReference<T, K extends Canonical, E>(
 	store: Store,
 	...params:
-		| [token: ReadableFamilyToken<T, K>, key: K]
-		| [token: ReadableToken<T>]
+		| [token: ReadableFamilyToken<T, K, E>, key: K]
+		| [token: ReadableToken<T, K, E>]
 ): {
-	token: ReadableToken<T, K>
-	family: ReadableFamily<T, K> | undefined
+	token: ReadableToken<T, K, E>
+	family: ReadableFamily<T, K, E> | undefined
 	subKey: K | undefined
 	isNew: boolean
 } {
-	let existingToken: ReadableToken<T> | undefined
-	let brandNewToken: ReadableToken<T> | undefined
-	let family: ReadableFamily<T, K> | undefined
+	let existingToken: ReadableToken<T, K, E> | undefined
+	let brandNewToken: ReadableToken<T, K, E> | undefined
+	let family: ReadableFamily<T, K, E> | undefined
 	let subKey: K | undefined
-	let token: ReadableToken<T, K>
+	let token: ReadableToken<T, K, E>
 	if (params.length === 1) {
 		token = params[0]
 		if (`family` in token) {
 			const familyToken = getFamilyOfToken(store, token)
-			family = withdraw(store, familyToken) as ReadableFamily<T, K>
+			family = withdraw(store, familyToken) as ReadableFamily<T, K, E>
 			subKey = parseJson(token.family.subKey)
 			existingToken = seekInStore(store, familyToken, subKey)
 			if (`counterfeit` in token) {

package/src/internal/index.ts

@@ -23,7 +23,7 @@ import type { Store } from "./store"
 import type { Subject } from "./subject"
 import type { Timeline } from "./timeline"
 import type { RootStore, Transaction } from "./transaction"
-import type { Flat } from "./utility-types"
+import type { Ctor, Flat } from "./utility-types"
 
 export * from "./arbitrary"
 export * from "./atom"
@@ -61,12 +61,13 @@ export type AtomIOState = {
 	install: (store: RootStore) => void
 	subject: Subject<StateUpdate<any>>
 }
-export type RegularAtom<T> = Flat<
+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<
@@ -76,8 +77,8 @@ export type MutableAtom<T extends Transceiver<any, any, any>> = Flat<
 		cleanup?: () => void
 	}
 >
-export type Atom<T> =
-	| RegularAtom<T>
+export type Atom<T, E> =
+	| RegularAtom<T, E>
 	| (T extends Transceiver<any, any, any> ? MutableAtom<T> : never)
 
 export type WritableHeldSelector<T> = Flat<
@@ -95,48 +96,52 @@ export type ReadonlyHeldSelector<T> = Flat<
 		getFrom: (target: Store) => T
 	}
 >
-export type WritablePureSelector<T> = Flat<
+export type WritablePureSelector<T, E> = Flat<
 	AtomIOState & {
 		type: `writable_pure_selector`
-		getFrom: (target: Store) => T
+		getFrom: (target: Store) => E | T
 		setSelf: (newValue: T) => void
+		catch?: readonly Ctor<E>[]
 	}
 >
-export type ReadonlyPureSelector<T> = Flat<
+export type ReadonlyPureSelector<T, E> = Flat<
 	AtomIOState & {
 		type: `readonly_pure_selector`
-		getFrom: (target: Store) => T
+		getFrom: (target: Store) => E | T
+		catch?: readonly Ctor<E>[]
 	}
 >
-export type ReadonlySelector<T> =
+export type ReadonlySelector<T, E> =
 	| ReadonlyHeldSelector<T>
-	| ReadonlyPureSelector<T>
-export type WritableSelector<T> =
+	| ReadonlyPureSelector<T, E>
+export type WritableSelector<T, E> =
 	| WritableHeldSelector<T>
-	| WritablePureSelector<T>
+	| WritablePureSelector<T, E>
 export type HeldSelector<T> = ReadonlyHeldSelector<T> | WritableHeldSelector<T>
-export type PureSelector<T> = ReadonlyPureSelector<T> | WritablePureSelector<T>
-export type Selector<T> =
+export type PureSelector<T, E> =
+	| ReadonlyPureSelector<T, E>
+	| WritablePureSelector<T, E>
+export type Selector<T, E> =
 	| ReadonlyHeldSelector<T>
-	| ReadonlyPureSelector<T>
+	| ReadonlyPureSelector<T, E>
 	| WritableHeldSelector<T>
-	| WritablePureSelector<T>
+	| WritablePureSelector<T, E>
 
-export type WritableState<T> = Atom<T> | WritableSelector<T>
-export type ReadableState<T> = Atom<T> | Selector<T>
+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> =
+export type RegularAtomFamily<T, K extends Canonical, E = never> =
 	& Flat<
-		& RegularAtomFamilyToken<T, K>
+		& 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>>>
+			subject: Subject<StateLifecycleEvent<RegularAtomToken<T, K, E>>>
 		}
 	>
-	& ((key: K) => RegularAtomToken<T>)
 
 // biome-ignore format: intersection
 export type MutableAtomFamily<
@@ -146,99 +151,99 @@ export type MutableAtomFamily<
 	& 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>>>
 			}
 	>
-	& ((key: K) => MutableAtomToken<T>)
 
-export type AtomFamily<T, K extends Canonical = Canonical> =
+export type AtomFamily<T, K extends Canonical, E> =
 	| MutableAtomFamily<T extends Transceiver<any, any, any> ? T : never, K>
-	| RegularAtomFamily<T, K>
+	| RegularAtomFamily<T, K, E>
 
 // biome-ignore format: intersection
-export type WritablePureSelectorFamily<T, K extends Canonical> =
+export type WritablePureSelectorFamily<T, K extends Canonical, E> =
 	& Flat<
-		& WritablePureSelectorFamilyToken<T, K>
+		& 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>>>
+			subject: Subject<StateLifecycleEvent<WritablePureSelectorToken<T, K, E>>>
 		}
 	>
-	& ((key: K) => WritablePureSelectorToken<T>)
 
 // 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>>>
+			subject: Subject<StateLifecycleEvent<WritableHeldSelectorToken<T, K>>>
 		}
 	>
-	& ((key: K) => WritableHeldSelectorToken<T>)
 
 // biome-ignore format: intersection
-export type ReadonlyPureSelectorFamily<T, K extends Canonical> =
+export type ReadonlyPureSelectorFamily<T, K extends Canonical, E> =
 	& Flat<
-		& ReadonlyPureSelectorFamilyToken<T, K>
+		& 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>>>
+			subject: Subject<StateLifecycleEvent<ReadonlyPureSelectorToken<T, K, E>>>
 		}
 	>
-	& ((key: K) => ReadonlyPureSelectorToken<T>)
 
 // 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>>>
 		}
 	>
-	& ((key: K) => ReadonlyHeldSelectorToken<T>)
 
-export type PureSelectorFamily<T, K extends Canonical> =
-	| ReadonlyPureSelectorFamily<T, K>
-	| WritablePureSelectorFamily<T, K>
+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> =
+export type ReadonlySelectorFamily<T, K extends Canonical, E> =
 	| ReadonlyHeldSelectorFamily<T, K>
-	| ReadonlyPureSelectorFamily<T, K>
+	| ReadonlyPureSelectorFamily<T, K, E>
 
-export type WritableSelectorFamily<T, K extends Canonical> =
+export type WritableSelectorFamily<T, K extends Canonical, E> =
 	| WritableHeldSelectorFamily<T, K>
-	| WritablePureSelectorFamily<T, K>
+	| WritablePureSelectorFamily<T, K, E>
 
-export type SelectorFamily<T, K extends Canonical> =
+export type SelectorFamily<T, K extends Canonical, E> =
 	| HeldSelectorFamily<T, K>
-	| PureSelectorFamily<T, K>
+	| PureSelectorFamily<T, K, E>
 
-export type WritableFamily<T, K extends Canonical> =
-	| AtomFamily<T, K>
-	| WritablePureSelectorFamily<T, K>
-export type ReadableFamily<T, K extends Canonical> =
-	| AtomFamily<T, K>
-	| SelectorFamily<T, K>
+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>
-	| ReadableState<any>
+	| ReadableFamily<any, any, any>
+	| ReadableState<any, any>
 	| Timeline<any>
 	| Transaction<any>