atom.io 0.40.1 → 0.40.3

package/src/main/atom.ts

@@ -1,4 +1,4 @@
-import type { ConstructorOf, Transceiver } from "atom.io/internal"
+import type { ConstructorOf, Ctor, Transceiver } from "atom.io/internal"
 import {
 	createMutableAtom,
 	createMutableAtomFamily,
@@ -17,13 +17,15 @@ import type {
 	RegularAtomToken,
 } from "./tokens"
 
-export type RegularAtomOptions<T> = {
+export type RegularAtomOptions<T, E = never> = {
 	/** The unique identifier of the atom */
 	key: string
 	/** The starting value of the atom */
 	default: T | (() => T)
 	/** Hooks used to run side effects when the atom is set */
-	effects?: AtomEffect<T>[]
+	effects?: readonly AtomEffect<T>[]
+	/** The classes of errors that might be thrown when deriving the atom's default value */
+	catch?: readonly Ctor<E>[]
 }
 /**
  * Create a regular atom, a global reactive variable in the implicit store
@@ -31,7 +33,9 @@ export type RegularAtomOptions<T> = {
  * @returns
  * A reference to the atom created: a {@link RegularAtomToken}
  */
-export function atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T> {
+export function atom<T, E = never>(
+	options: RegularAtomOptions<T, E>,
+): RegularAtomToken<T, any, E> {
 	return createRegularAtom(IMPLICIT.STORE, options, undefined)
 }
 
@@ -41,7 +45,7 @@ export type MutableAtomOptions<T extends Transceiver<any, any, any>> = {
 	/** A constructor for the atom's value */
 	class: ConstructorOf<T>
 	/** Hooks used to run side effects when the atom is set */
-	effects?: AtomEffect<T>[]
+	effects?: readonly AtomEffect<T>[]
 }
 /**
  * Create a mutable atom, a global reactive variable in the implicit store
@@ -79,13 +83,15 @@ export type Effectors<T> = {
 	onSet: (callback: (options: StateUpdate<T>) => void) => void
 }
 
-export type RegularAtomFamilyOptions<T, K extends Canonical> = {
+export type RegularAtomFamilyOptions<T, K extends Canonical, E = never> = {
 	/** The unique identifier of the atom family */
 	key: string
 	/** The starting value of the atom family */
 	default: T | ((key: K) => T)
 	/** Hooks used to run side effects when an atom in the family is set  */
 	effects?: (key: K) => AtomEffect<T>[]
+	/** The classes of errors that might be thrown when deriving the atom's default value */
+	catch?: readonly Ctor<E>[]
 }
 /**
  * Create a family of regular atoms, allowing for the dynamic creation and disposal of atoms.
@@ -93,9 +99,9 @@ export type RegularAtomFamilyOptions<T, K extends Canonical> = {
  * @returns
  * A reference to the atom family created: a {@link RegularAtomFamilyToken}
  */
-export function atomFamily<T, K extends Canonical>(
-	options: RegularAtomFamilyOptions<T, K>,
-): RegularAtomFamilyToken<T, K> {
+export function atomFamily<T, K extends Canonical, E = never>(
+	options: RegularAtomFamilyOptions<T, K, E>,
+): RegularAtomFamilyToken<T, K, E> {
 	return createRegularAtomFamily(IMPLICIT.STORE, options)
 }
 

package/src/main/events.ts

@@ -16,14 +16,14 @@ export type StateUpdate<T> = {
 	readonly newValue: ViewOf<T>
 }
 
-export type AtomUpdateEvent<A extends AtomToken<any>> = {
+export type AtomUpdateEvent<A extends AtomToken<any, any, any>> = {
 	type: `atom_update`
 	token: A
 	update: StateUpdate<TokenType<A>>
 	timestamp: number
 }
 
-export type SelectorUpdateSubEvent<A extends AtomToken<any>> =
+export type SelectorUpdateSubEvent<A extends AtomToken<any, any, any>> =
 	| AtomUpdateEvent<A>
 	| StateCreationEvent<any>
 export type TimelineSelectorUpdateEvent<A extends TimelineManageable> = {
@@ -33,36 +33,38 @@ export type TimelineSelectorUpdateEvent<A extends TimelineManageable> = {
 	timestamp: number
 }
 
-export type StateLifecycleEvent<R extends ReadableToken<any>> =
+export type StateLifecycleEvent<R extends ReadableToken<any, any, any>> =
 	| StateCreationEvent<R>
 	| StateDisposalEvent<R>
-export type StateCreationEvent<R extends ReadableToken<any>> =
+export type StateCreationEvent<R extends ReadableToken<any, any, any>> =
 	| ReadableStateCreationEvent<R>
 	| (R extends WritableToken<any> ? WritableStateCreationEvent<R> : never)
-export type ReadableStateCreationEvent<R extends ReadableToken<any>> = {
-	type: `state_creation`
-	subType: `readable`
-	token: R
-	timestamp: number
-}
-export type WritableStateCreationEvent<W extends WritableToken<any>> = {
-	type: `state_creation`
-	subType: `writable`
-	token: W
-	timestamp: number
-	value?: TokenType<W>
-}
-export type StateDisposalEvent<R extends ReadableToken<any>> =
+export type ReadableStateCreationEvent<R extends ReadableToken<any, any, any>> =
+	{
+		type: `state_creation`
+		subType: `readable`
+		token: R
+		timestamp: number
+	}
+export type WritableStateCreationEvent<W extends WritableToken<any, any, any>> =
+	{
+		type: `state_creation`
+		subType: `writable`
+		token: W
+		timestamp: number
+		value?: TokenType<W>
+	}
+export type StateDisposalEvent<R extends ReadableToken<any, any, any>> =
 	| AtomDisposalEvent<R>
 	| SelectorDisposalEvent<R>
-export type AtomDisposalEvent<R extends ReadableToken<any>> = {
+export type AtomDisposalEvent<R extends ReadableToken<any, any, any>> = {
 	type: `state_disposal`
 	subType: `atom`
 	token: R
 	value: TokenType<R>
 	timestamp: number
 }
-export type SelectorDisposalEvent<R extends ReadableToken<any>> = {
+export type SelectorDisposalEvent<R extends ReadableToken<any, any, any>> = {
 	type: `state_disposal`
 	subType: `selector`
 	token: R
@@ -94,12 +96,12 @@ export type MoleculeTransferEvent = {
 }
 
 export type TransactionSubEvent =
-	| AtomUpdateEvent<AtomToken<any>>
+	| AtomUpdateEvent<AtomToken<any, any, any>>
 	| MoleculeCreationEvent
 	| MoleculeDisposalEvent
 	| MoleculeTransferEvent
-	| StateCreationEvent<ReadableToken<unknown>>
-	| StateDisposalEvent<ReadableToken<unknown>>
+	| StateCreationEvent<ReadableToken<unknown, any, any>>
+	| StateDisposalEvent<ReadableToken<unknown, any, any>>
 	| TransactionOutcomeEvent<TransactionToken<any>>
 
 export type TransactionOutcomeEvent<T extends TransactionToken<any>> = {

package/src/main/get-state.ts

@@ -11,7 +11,9 @@ import type { ReadableFamilyToken, ReadableToken } from "."
  * @overload Default
  * @default
  */
-export function getState<T>(token: ReadableToken<T>): ViewOf<T>
+export function getState<T, E = never>(
+	token: ReadableToken<T, any, E>,
+): ViewOf<E | T>
 
 /**
  * Read or compute the current value of a state
@@ -20,15 +22,15 @@ export function getState<T>(token: ReadableToken<T>): ViewOf<T>
  * @return The current value of the state
  * @overload Streamlined
  */
-export function getState<T, K extends Canonical, Key extends K>(
-	token: ReadableFamilyToken<T, K>,
+export function getState<T, K extends Canonical, Key extends K, E = never>(
+	token: ReadableFamilyToken<T, K, E>,
 	key: Key,
-): ViewOf<T>
+): ViewOf<E | T>
 
-export function getState<T, K extends Canonical, Key extends K>(
+export function getState<T, K extends Canonical, Key extends K, E = never>(
 	...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> {
 	return getFromStore(IMPLICIT.STORE, ...params)
 }

package/src/main/reset-state.ts

@@ -9,7 +9,7 @@ import type { WritableFamilyToken, WritableToken } from "."
  * @overload Default
  * @default
  */
-export function resetState(token: WritableToken<any>): void
+export function resetState(token: WritableToken<any, any, any>): void
 /**
  * Set the value of a state into the implicit store back to its default value.
  * @param token - An atom family or writable selector family token.
@@ -17,13 +17,13 @@ export function resetState(token: WritableToken<any>): void
  * @overload Streamlined
  */
 export function resetState<K extends Canonical>(
-	token: WritableFamilyToken<any, K>,
+	token: WritableFamilyToken<any, K, any>,
 	key: K,
 ): void
 export function resetState(
 	...params:
-		| [token: WritableFamilyToken<any, Canonical>, key: Canonical]
-		| [token: WritableToken<any>]
+		| [token: WritableFamilyToken<any, Canonical, any>, key: Canonical]
+		| [token: WritableToken<any, any, any>]
 ): void {
 	resetInStore(IMPLICIT.STORE, ...params)
 }

package/src/main/selector.ts

@@ -1,3 +1,4 @@
+import type { Ctor } from "atom.io/internal"
 import {
 	createSelectorFamily,
 	createStandaloneSelector,
@@ -17,19 +18,23 @@ import type {
 } from "./tokens"
 import type { Read, Write } from "./transaction"
 
-export type WritablePureSelectorOptions<T> = {
+export type WritablePureSelectorOptions<T, E = never> = {
 	/** The unique identifier of the selector */
 	key: string
 	/** For each instantiated selector, a function that computes its value */
 	get: Read<() => T>
 	/** For each instantiated selector, a function that sets its value */
 	set: Write<(newValue: T) => void>
+	/** The classes of errors that might be thrown when deriving the atom's default value */
+	catch?: readonly Ctor<E>[]
 }
-export type ReadonlyPureSelectorOptions<T> = {
+export type ReadonlyPureSelectorOptions<T, E = never> = {
 	/** The unique identifier of the selector */
 	key: string
 	/** For each instantiated selector, a function that computes its value */
 	get: Read<() => T>
+	/** The classes of errors that might be thrown when deriving the atom's default value */
+	catch?: readonly Ctor<E>[]
 }
 export type ReadonlyHeldSelectorOptions<T extends object> = {
 	/** The unique identifier of the selector */
@@ -104,9 +109,9 @@ export function selector<T extends object>(
  * The token for your selector.
  * @overload WritablePure
  */
-export function selector<T>(
-	options: WritablePureSelectorOptions<T>,
-): WritablePureSelectorToken<T>
+export function selector<T, E = never>(
+	options: WritablePureSelectorOptions<T, E>,
+): WritablePureSelectorToken<T, any, E>
 /**
  * Declare a selector. The value of a selector should depend
  * on the value of atoms or other selectors in the store.
@@ -121,36 +126,48 @@ export function selector<T>(
  * The token for your selector.
  * @overload ReadonlyPure
  */
-export function selector<T>(
-	options: ReadonlyPureSelectorOptions<T>,
-): ReadonlyPureSelectorToken<T>
+export function selector<T, E = never>(
+	options: ReadonlyPureSelectorOptions<T, E>,
+): ReadonlyPureSelectorToken<T, any, E>
 export function selector(
 	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> {
 	return createStandaloneSelector(IMPLICIT.STORE, options)
 }
 
-export type WritablePureSelectorFamilyOptions<T, K extends Canonical> = {
+export type WritablePureSelectorFamilyOptions<
+	T,
+	K extends Canonical,
+	E = never,
+> = {
 	/** The unique identifier of the family */
 	key: string
 	/** For each instantiated family member, a function that computes its value */
 	get: (key: K) => Read<() => T>
 	/** For each instantiated family member, a function that sets its value */
 	set: (key: K) => Write<(newValue: T) => void>
+	/** The classes of errors that might be thrown when deriving the atom's default value */
+	catch?: readonly Ctor<E>[]
 }
-export type ReadonlyPureSelectorFamilyOptions<T, K extends Canonical> = {
+export type ReadonlyPureSelectorFamilyOptions<
+	T,
+	K extends Canonical,
+	E = never,
+> = {
 	/** The unique identifier of the family */
 	key: string
 	/** For each instantiated family member, a function that computes its value */
 	get: (key: K) => Read<() => T>
+	/** The classes of errors that might be thrown when deriving the atom's default value */
+	catch?: readonly Ctor<E>[]
 }
 export type WritableHeldSelectorFamilyOptions<
 	T extends object,
@@ -234,9 +251,9 @@ export function selectorFamily<T extends object, K extends Canonical>(
  * A reference to the selector family created: a {@link TransientWritableSelectorFamilyToken}
  * @overload WritablePure
  */
-export function selectorFamily<T, K extends Canonical>(
-	options: WritablePureSelectorFamilyOptions<T, K>,
-): WritablePureSelectorFamilyToken<T, K>
+export function selectorFamily<T, K extends Canonical, E = never>(
+	options: WritablePureSelectorFamilyOptions<T, K, E>,
+): WritablePureSelectorFamilyToken<T, K, E>
 /**
  * Create a family of selectors, allowing for the dynamic creation and disposal of selectors.
  *
@@ -252,19 +269,19 @@ export function selectorFamily<T, K extends Canonical>(
  * A reference to the selector family created: a {@link ReadonlyPureSelectorFamilyToken}
  * @overload ReadonlyPure
  */
-export function selectorFamily<T, K extends Canonical>(
-	options: ReadonlyPureSelectorFamilyOptions<T, K>,
-): ReadonlyPureSelectorFamilyToken<T, K>
+export function selectorFamily<T, K extends Canonical, E = never>(
+	options: ReadonlyPureSelectorFamilyOptions<T, K, E>,
+): ReadonlyPureSelectorFamilyToken<T, K, E>
 export function selectorFamily(
 	options:
 		| ReadonlyHeldSelectorFamilyOptions<any, any>
-		| ReadonlyPureSelectorFamilyOptions<any, any>
+		| ReadonlyPureSelectorFamilyOptions<any, any, any>
 		| WritableHeldSelectorFamilyOptions<any, any>
-		| WritablePureSelectorFamilyOptions<any, any>,
+		| WritablePureSelectorFamilyOptions<any, any, any>,
 ):
 	| ReadonlyHeldSelectorFamilyToken<any, any>
-	| ReadonlyPureSelectorFamilyToken<any, any>
+	| ReadonlyPureSelectorFamilyToken<any, any, any>
 	| WritableHeldSelectorFamilyToken<any, any>
-	| WritablePureSelectorFamilyToken<any, any> {
+	| WritablePureSelectorFamilyToken<any, any, any> {
 	return createSelectorFamily(IMPLICIT.STORE, options)
 }

package/src/main/set-state.ts

@@ -19,7 +19,7 @@ export type Setter<T, New extends T> = (oldValue: T) => New
  * @default
  */
 export function setState<T, New extends T>(
-	token: WritableToken<T>,
+	token: WritableToken<T, any, any>,
 	value: New | Setter<T, New>,
 ): void
 
@@ -31,15 +31,19 @@ export function setState<T, New extends T>(
  * @overload Streamlined
  */
 export function setState<T, K extends Canonical, New extends T, Key extends K>(
-	token: WritableFamilyToken<T, K>,
+	token: WritableFamilyToken<T, K, any>,
 	key: Key,
 	value: New | Setter<T, New>,
 ): void
 
 export function setState<T, K extends Canonical, New extends T, Key extends K>(
 	...params:
-		| [token: WritableFamilyToken<T, K>, key: Key, value: New | Setter<T, New>]
-		| [token: WritableToken<T>, value: New | Setter<T, New>]
+		| [
+				token: WritableFamilyToken<T, K, any>,
+				key: Key,
+				value: New | Setter<T, New>,
+		  ]
+		| [token: WritableToken<T, any, any>, value: New | Setter<T, New>]
 ): void {
 	setIntoStore(IMPLICIT.STORE, ...params)
 }

package/src/main/timeline.ts

@@ -2,13 +2,15 @@ import { createTimeline, IMPLICIT, timeTravel } from "atom.io/internal"
 
 import type { AtomFamilyToken, AtomToken, TimelineToken } from "."
 
-export type TimelineManageable = AtomFamilyToken<any, any> | AtomToken<any>
+export type TimelineManageable =
+	| AtomFamilyToken<any, any, any>
+	| AtomToken<any, any, any>
 export type AtomOnly<M extends TimelineManageable> = M extends AtomFamilyToken<
 	any,
 	any
 >
-	? AtomToken<any>
-	: M extends AtomToken<any>
+	? AtomToken<any, any, any>
+	: M extends AtomToken<any, any, any>
 		? M
 		: never
 

package/src/main/tokens.ts

@@ -13,31 +13,31 @@ import type { Canonical, stringified } from "atom.io/json"
  * Tokens are fully serializable, so they can be passed between processes.
  */
 export type AtomIOToken =
-	| ReadableFamilyToken<any, any>
-	| ReadableToken<any>
+	| ReadableFamilyToken<any, any, any>
+	| ReadableToken<any, any, any>
 	| TimelineToken<any>
 	| TransactionToken<any>
 
-export type ReadableToken<T, K extends Canonical = any> =
-	| AtomToken<T, K>
-	| SelectorToken<T, K>
+export type ReadableToken<T, K extends Canonical = any, E = never> =
+	| AtomToken<T, K, E>
+	| SelectorToken<T, K, E>
 
-export type WritableToken<T, K extends Canonical = any> =
-	| AtomToken<T, K>
-	| WritableSelectorToken<T, K>
+export type WritableToken<T, K extends Canonical = any, E = never> =
+	| AtomToken<T, K, E>
+	| WritableSelectorToken<T, K, E>
 
 /**
  * States belonging to this family can be read from the store.
  */
-export type ReadableFamilyToken<T, K extends Canonical> =
-	| AtomFamilyToken<T, K>
-	| SelectorFamilyToken<T, K>
+export type ReadableFamilyToken<T, K extends Canonical, E = never> =
+	| AtomFamilyToken<T, K, E>
+	| SelectorFamilyToken<T, K, E>
 /**
  * States belonging to this family can be written directly.
  */
-export type WritableFamilyToken<T, K extends Canonical> =
-	| AtomFamilyToken<T, K>
-	| WritableSelectorFamilyToken<T, K>
+export type WritableFamilyToken<T, K extends Canonical, E = never> =
+	| AtomFamilyToken<T, K, E>
+	| WritableSelectorFamilyToken<T, K, E>
 
 export type TimelineToken<M> = {
 	/** The unique identifier of the timeline */
@@ -57,10 +57,10 @@ export type TransactionToken<F extends Fn> = {
 	__F?: F
 }
 
-export type AtomToken<T, K extends Canonical = any> =
+export type AtomToken<T, K extends Canonical = any, E = never> =
 	| MutableAtomToken<T extends Transceiver<any, any, any> ? T : never, K>
-	| RegularAtomToken<T, K>
-export type RegularAtomToken<T, K extends Canonical = any> = {
+	| RegularAtomToken<T, K, E>
+export type RegularAtomToken<T, K extends Canonical = any, E = never> = {
 	/** The unique identifier of the atom. */
 	key: string
 	/** Discriminator. */
@@ -69,6 +69,8 @@ export type RegularAtomToken<T, K extends Canonical = any> = {
 	family?: FamilyMetadata<K>
 	/** Never present. This is a marker that preserves the type of the atom's value. */
 	__T?: T
+	/** Never present. This is a marker that preserves the type of errors this atom is capable of catching and setting as its value. */
+	__E?: E
 }
 export type MutableAtomToken<
 	T extends Transceiver<any, any, any>,
@@ -84,23 +86,27 @@ export type MutableAtomToken<
 	__J?: AsJSON<T>
 }
 
-export type SelectorToken<T, K extends Canonical = any> =
-	| ReadonlySelectorToken<T, K>
-	| WritableSelectorToken<T, K>
-export type ReadonlySelectorToken<T, K extends Canonical = any> =
+export type SelectorToken<T, K extends Canonical = any, E = never> =
+	| ReadonlySelectorToken<T, K, E>
+	| WritableSelectorToken<T, K, E>
+export type ReadonlySelectorToken<T, K extends Canonical = any, E = never> =
 	| ReadonlyHeldSelectorToken<T, K>
-	| ReadonlyPureSelectorToken<T, K>
-export type WritableSelectorToken<T, K extends Canonical = any> =
+	| ReadonlyPureSelectorToken<T, K, E>
+export type WritableSelectorToken<T, K extends Canonical = any, E = never> =
 	| WritableHeldSelectorToken<T, K>
-	| WritablePureSelectorToken<T, K>
-export type PureSelectorToken<T, K extends Canonical = any> =
-	| ReadonlyPureSelectorToken<T, K>
-	| WritablePureSelectorToken<T, K>
+	| WritablePureSelectorToken<T, K, E>
+export type PureSelectorToken<T, K extends Canonical = any, E = never> =
+	| ReadonlyPureSelectorToken<T, K, E>
+	| WritablePureSelectorToken<T, K, E>
 export type HeldSelectorToken<T, K extends Canonical = any> =
 	| ReadonlyHeldSelectorToken<T, K>
 	| WritableHeldSelectorToken<T, K>
 
-export type WritablePureSelectorToken<T, K extends Canonical = any> = {
+export type WritablePureSelectorToken<
+	T,
+	K extends Canonical = any,
+	E = never,
+> = {
 	/** The unique identifier of the selector. */
 	key: string
 	/** Discriminator. */
@@ -109,6 +115,8 @@ export type WritablePureSelectorToken<T, K extends Canonical = any> = {
 	family?: FamilyMetadata<K>
 	/** Never present. This is a marker that preserves the type of the selector's value. */
 	__T?: T
+	/** Never present. This is a marker that preserves the type of errors this selector is capable of catching and setting as its value. */
+	__E?: E
 }
 export type WritableHeldSelectorToken<T, K extends Canonical = any> = {
 	/** The unique identifier of the selector. */
@@ -120,7 +128,11 @@ export type WritableHeldSelectorToken<T, K extends Canonical = any> = {
 	/** Never present. This is a marker that preserves the type of the selector's value. */
 	__T?: T
 }
-export type ReadonlyPureSelectorToken<T, K extends Canonical = any> = {
+export type ReadonlyPureSelectorToken<
+	T,
+	K extends Canonical = any,
+	E = never,
+> = {
 	/** The unique identifier of the selector. */
 	key: string
 	/** Discriminator. */
@@ -129,6 +141,8 @@ export type ReadonlyPureSelectorToken<T, K extends Canonical = any> = {
 	family?: FamilyMetadata<K>
 	/** Never present. This is a marker that preserves the type of the selector's value. */
 	__T?: T
+	/** Never present. This is a marker that preserves the type of errors this selector is capable of catching and setting as its value. */
+	__E?: E
 }
 export type ReadonlyHeldSelectorToken<T, K extends Canonical = any> = {
 	/** The unique identifier of the selector. */
@@ -151,10 +165,10 @@ export type FamilyMetadata<K extends Canonical = any> = {
 	subKey: stringified<K>
 }
 
-export type AtomFamilyToken<T, K extends Canonical = Canonical> =
+export type AtomFamilyToken<T, K extends Canonical = Canonical, E = never> =
 	| MutableAtomFamilyToken<T extends Transceiver<any, any, any> ? T : never, K>
-	| RegularAtomFamilyToken<T, K>
-export type RegularAtomFamilyToken<T, K extends Canonical> = {
+	| RegularAtomFamilyToken<T, K, E>
+export type RegularAtomFamilyToken<T, K extends Canonical, E = never> = {
 	/** The unique identifier of the atom family */
 	key: string
 	/** Discriminator */
@@ -163,6 +177,8 @@ export type RegularAtomFamilyToken<T, K extends Canonical> = {
 	__T?: T
 	/** Never present. This is a marker that preserves the type of keys used for atoms in this family */
 	__K?: K
+	/** Never present. This is a marker that preserves the type of errors this family is capable of catching and setting as its value. */
+	__E?: E
 }
 export type MutableAtomFamilyToken<
 	T extends Transceiver<any, any, any>,
@@ -178,23 +194,27 @@ export type MutableAtomFamilyToken<
 	__K?: K
 }
 
-export type SelectorFamilyToken<T, K extends Canonical> =
-	| ReadonlySelectorFamilyToken<T, K>
-	| WritableSelectorFamilyToken<T, K>
-export type ReadonlySelectorFamilyToken<T, K extends Canonical> =
+export type SelectorFamilyToken<T, K extends Canonical, E = never> =
+	| ReadonlySelectorFamilyToken<T, K, E>
+	| WritableSelectorFamilyToken<T, K, E>
+export type ReadonlySelectorFamilyToken<T, K extends Canonical, E = never> =
 	| ReadonlyHeldSelectorFamilyToken<T, K>
-	| ReadonlyPureSelectorFamilyToken<T, K>
-export type WritableSelectorFamilyToken<T, K extends Canonical> =
+	| ReadonlyPureSelectorFamilyToken<T, K, E>
+export type WritableSelectorFamilyToken<T, K extends Canonical, E = never> =
 	| WritableHeldSelectorFamilyToken<T, K>
-	| WritablePureSelectorFamilyToken<T, K>
-export type PureSelectorFamilyToken<T, K extends Canonical> =
-	| ReadonlyPureSelectorFamilyToken<T, K>
-	| WritablePureSelectorFamilyToken<T, K>
+	| WritablePureSelectorFamilyToken<T, K, E>
+export type PureSelectorFamilyToken<T, K extends Canonical, E = never> =
+	| ReadonlyPureSelectorFamilyToken<T, K, E>
+	| WritablePureSelectorFamilyToken<T, K, E>
 export type HeldSelectorFamilyToken<T, K extends Canonical> =
 	| ReadonlyHeldSelectorFamilyToken<T, K>
 	| WritableHeldSelectorFamilyToken<T, K>
 
-export type WritablePureSelectorFamilyToken<T, K extends Canonical> = {
+export type WritablePureSelectorFamilyToken<
+	T,
+	K extends Canonical,
+	E = never,
+> = {
 	/** The unique identifier of the family */
 	key: string
 	/** Discriminator */
@@ -203,8 +223,14 @@ export type WritablePureSelectorFamilyToken<T, K extends Canonical> = {
 	__T?: T
 	/** Never present. This is a marker that preserves the type of keys used for each family member */
 	__K?: K
+	/** Never present. This is a marker that preserves the type of errors this family is capable of catching and setting as its value. */
+	__E?: E
 }
-export type ReadonlyPureSelectorFamilyToken<T, K extends Canonical> = {
+export type ReadonlyPureSelectorFamilyToken<
+	T,
+	K extends Canonical,
+	E = never,
+> = {
 	/** The unique identifier of the family */
 	key: string
 	/** Discriminator */
@@ -213,6 +239,8 @@ export type ReadonlyPureSelectorFamilyToken<T, K extends Canonical> = {
 	__T?: T
 	/** Never present. This is a marker that preserves the type of keys used for each family member */
 	__K?: K
+	/** Never present. This is a marker that preserves the type of errors this family is capable of catching and setting as its value. */
+	__E?: E
 }
 export type WritableHeldSelectorFamilyToken<T, K extends Canonical> = {
 	/** The unique identifier of the family */

package/src/main/validators.ts

@@ -16,8 +16,8 @@ import type {
 
 export type TokenType<
 	Comparison extends
-		| ReadableFamilyToken<any, any>
-		| ReadableToken<any>
+		| ReadableFamilyToken<any, any, any>
+		| ReadableToken<any, any, any>
 		| TransactionToken<any>,
 > = Comparison extends ReadableToken<infer RepresentedValue>
 	? RepresentedValue
@@ -27,9 +27,9 @@ export type TokenType<
 			? Fn
 			: never
 
-export function isToken<KnownToken extends RegularAtomToken<any>>(
+export function isToken<KnownToken extends RegularAtomToken<any, any, any>>(
 	knownToken: KnownToken,
-	unknownToken: ReadableToken<any>,
+	unknownToken: ReadableToken<any, any, any>,
 ): unknownToken is RegularAtomToken<TokenType<KnownToken>>
 export function isToken<KnownToken extends MutableAtomToken<any, any>>(
 	knownToken: KnownToken,