atom.io 0.40.1 → 0.40.2

package/src/internal/store/withdraw.ts

@@ -72,15 +72,18 @@ import type { Timeline } from "../timeline"
 import type { Transaction } from "../transaction"
 import type { Store } from "./store"
 
-export function withdraw<T>(
+export function withdraw<T, E>(
 	store: Store,
-	token: RegularAtomToken<T>,
-): RegularAtom<T>
+	token: RegularAtomToken<T, any, E>,
+): RegularAtom<T, E>
 export function withdraw<T extends Transceiver<any, any, any>>(
 	store: Store,
 	token: MutableAtomToken<T, any>,
 ): MutableAtom<T>
-export function withdraw<T>(store: Store, token: AtomToken<T>): Atom<T>
+export function withdraw<T, E>(
+	store: Store,
+	token: AtomToken<T, any, E>,
+): Atom<T, E>
 export function withdraw<T>(
 	store: Store,
 	token: WritableHeldSelectorToken<T>,
@@ -89,52 +92,55 @@ export function withdraw<T>(
 	store: Store,
 	token: ReadonlyHeldSelectorToken<T>,
 ): ReadonlyHeldSelector<T>
-export function withdraw<T>(
+export function withdraw<T, E>(
 	store: Store,
-	token: WritablePureSelectorToken<T>,
-): WritablePureSelector<T>
-export function withdraw<T>(
+	token: WritablePureSelectorToken<T, any, E>,
+): WritablePureSelector<T, E>
+export function withdraw<T, E>(
 	store: Store,
-	token: ReadonlyPureSelectorToken<T>,
-): ReadonlyPureSelector<T>
-export function withdraw<T>(
+	token: ReadonlyPureSelectorToken<T, any, E>,
+): ReadonlyPureSelector<T, E>
+export function withdraw<T, E>(
 	store: Store,
-	token: ReadonlySelectorToken<T>,
-): ReadonlySelector<T>
-export function withdraw<T>(
+	token: ReadonlySelectorToken<T, any, E>,
+): ReadonlySelector<T, E>
+export function withdraw<T, E>(
 	store: Store,
-	token: WritableSelectorToken<T>,
-): WritableSelector<T>
+	token: WritableSelectorToken<T, any, E>,
+): WritableSelector<T, E>
 export function withdraw<T>(
 	store: Store,
 	token: HeldSelectorToken<T>,
 ): HeldSelector<T>
-export function withdraw<T>(
+export function withdraw<T, E>(
 	store: Store,
-	token: PureSelectorToken<T>,
-): PureSelector<T>
-export function withdraw<T>(store: Store, token: SelectorToken<T>): Selector<T>
-export function withdraw<T>(
+	token: PureSelectorToken<T, any, E>,
+): PureSelector<T, E>
+export function withdraw<T, E>(
 	store: Store,
-	token: WritableToken<T>,
-): WritableState<T>
-export function withdraw<T>(
+	token: SelectorToken<T, any, E>,
+): Selector<T, E>
+export function withdraw<T, E>(
 	store: Store,
-	token: ReadableToken<T>,
-): ReadableState<T>
+	token: WritableToken<T, any, E>,
+): WritableState<T, E>
+export function withdraw<T, E>(
+	store: Store,
+	token: ReadableToken<T, any, E>,
+): ReadableState<T, E>
 
-export function withdraw<T, K extends Canonical>(
+export function withdraw<T, K extends Canonical, E>(
 	store: Store,
-	token: RegularAtomFamilyToken<T, K>,
-): RegularAtomFamily<T, K>
+	token: RegularAtomFamilyToken<T, K, E>,
+): RegularAtomFamily<T, K, E>
 export function withdraw<
 	T extends Transceiver<any, any, any>,
 	K extends Canonical,
 >(store: Store, token: MutableAtomFamilyToken<T, K>): MutableAtomFamily<T, K>
-export function withdraw<T, K extends Canonical>(
+export function withdraw<T, K extends Canonical, E>(
 	store: Store,
-	token: AtomFamilyToken<T, K>,
-): AtomFamily<T, K>
+	token: AtomFamilyToken<T, K, E>,
+): AtomFamily<T, K, E>
 export function withdraw<T, K extends Canonical>(
 	store: Store,
 	token: ReadonlyHeldSelectorFamilyToken<T, K>,
@@ -143,42 +149,42 @@ export function withdraw<T, K extends Canonical>(
 	store: Store,
 	token: WritableHeldSelectorFamilyToken<T, K>,
 ): WritableHeldSelectorFamily<T, K>
-export function withdraw<T, K extends Canonical>(
+export function withdraw<T, K extends Canonical, E>(
 	store: Store,
-	token: ReadonlyPureSelectorFamilyToken<T, K>,
-): ReadonlyPureSelectorFamily<T, K>
-export function withdraw<T, K extends Canonical>(
+	token: ReadonlyPureSelectorFamilyToken<T, K, E>,
+): ReadonlyPureSelectorFamily<T, K, E>
+export function withdraw<T, K extends Canonical, E>(
 	store: Store,
-	token: WritablePureSelectorFamilyToken<T, K>,
-): WritablePureSelectorFamily<T, K>
-export function withdraw<T, K extends Canonical>(
+	token: WritablePureSelectorFamilyToken<T, K, E>,
+): WritablePureSelectorFamily<T, K, E>
+export function withdraw<T, K extends Canonical, E>(
 	store: Store,
-	token: ReadonlySelectorFamilyToken<T, K>,
-): ReadonlySelectorFamily<T, K>
-export function withdraw<T, K extends Canonical>(
+	token: ReadonlySelectorFamilyToken<T, K, E>,
+): ReadonlySelectorFamily<T, K, E>
+export function withdraw<T, K extends Canonical, E>(
 	store: Store,
-	token: WritableSelectorFamilyToken<T, K>,
-): WritableSelectorFamily<T, K>
+	token: WritableSelectorFamilyToken<T, K, E>,
+): WritableSelectorFamily<T, K, E>
 export function withdraw<T, K extends Canonical>(
 	store: Store,
 	token: HeldSelectorFamilyToken<T, K>,
 ): HeldSelectorFamily<T, K>
-export function withdraw<T, K extends Canonical>(
+export function withdraw<T, K extends Canonical, E>(
 	store: Store,
-	token: PureSelectorFamilyToken<T, K>,
-): PureSelectorFamily<T, K>
-export function withdraw<T, K extends Canonical>(
+	token: PureSelectorFamilyToken<T, K, E>,
+): PureSelectorFamily<T, K, E>
+export function withdraw<T, K extends Canonical, E>(
 	store: Store,
-	token: SelectorFamilyToken<T, K>,
-): SelectorFamily<T, K>
-export function withdraw<T, K extends Canonical>(
+	token: SelectorFamilyToken<T, K, E>,
+): SelectorFamily<T, K, E>
+export function withdraw<T, K extends Canonical, E>(
 	store: Store,
-	token: WritableFamilyToken<T, K>,
-): WritableFamily<T, K>
-export function withdraw<T, K extends Canonical>(
+	token: WritableFamilyToken<T, K, E>,
+): WritableFamily<T, K, E>
+export function withdraw<T, K extends Canonical, E>(
 	store: Store,
-	token: ReadableFamilyToken<T, K>,
-): ReadableFamily<T, K>
+	token: ReadableFamilyToken<T, K, E>,
+): ReadableFamily<T, K, E>
 
 export function withdraw<T extends Fn>(
 	store: Store,
@@ -189,14 +195,14 @@ export function withdraw<T>(
 	token: TimelineToken<T>,
 ): Timeline<T extends TimelineManageable ? T : never>
 
-export function withdraw<T>(
+export function withdraw<T, E>(
 	store: Store,
-	token: WritableToken<T>,
-): WritableState<T>
-export function withdraw<T>(
+	token: WritableToken<T, any, E>,
+): WritableState<T, E>
+export function withdraw<T, E>(
 	store: Store,
-	token: ReadableToken<T>,
-): ReadableState<T>
+	token: ReadableToken<T, any, E>,
+): ReadableState<T, E>
 
 export function withdraw(
 	store: Store,

package/src/internal/subscribe/recall-state.ts

@@ -2,7 +2,10 @@ import type { ReadableState } from ".."
 import { newest } from "../lineage"
 import type { Store } from "../store"
 
-export const recallState = <T>(store: Store, state: ReadableState<T>): T => {
+export const recallState = <T, E>(
+	store: Store,
+	state: ReadableState<T, E>,
+): T => {
 	const target = newest(store)
 	if (target.operation.open) {
 		return target.operation.prev.get(state.key)

package/src/internal/subscribe/subscribe-to-root-atoms.ts

@@ -5,8 +5,8 @@ import { recallState } from "./recall-state"
 
 export const subscribeToRootDependency = (
 	target: Store,
-	selector: Selector<any>,
-	atom: Atom<any>,
+	selector: Selector<any, any>,
+	atom: Atom<any, any>,
 ): (() => void) => {
 	return atom.subject.subscribe(
 		`${selector.type}:${selector.key}`,

package/src/internal/subscribe/subscribe-to-state.ts

@@ -7,11 +7,11 @@ import type { Store } from "../store"
 import { withdraw } from "../store"
 import { subscribeToRootDependency } from "./subscribe-to-root-atoms"
 
-export function subscribeToState<T>(
+export function subscribeToState<T, E>(
 	store: Store,
-	token: ReadableToken<T>,
+	token: ReadableToken<T, any, E>,
 	key: string,
-	handleUpdate: UpdateHandler<T>,
+	handleUpdate: UpdateHandler<E | T>,
 ): () => void {
 	function safelyHandleUpdate(update: StateUpdate<any>): void {
 		if (store.operation.open) {
@@ -33,7 +33,7 @@ export function subscribeToState<T>(
 		state.type === `writable_pure_selector` ||
 		state.type === `readonly_pure_selector`
 	const rootSubs = new Map<string, () => void>()
-	let updateHandler: UpdateHandler<T> = safelyHandleUpdate
+	let updateHandler: UpdateHandler<E | T> = safelyHandleUpdate
 	if (isSelector) {
 		readOrComputeValue(store, state)
 		for (const [atomKey, atom] of traceRootSelectorAtoms(store, state.key)) {

package/src/internal/timeline/create-timeline.ts

@@ -63,7 +63,7 @@ export function createTimeline<ManagedAtom extends TimelineManageable>(
 			case `atom`:
 			case `mutable_atom`:
 				{
-					const atomToken: AtomToken<ManagedAtom> = initialTopic
+					const atomToken: AtomToken<any, any, any> = initialTopic
 					const atomKey = atomToken.key
 					let existingTimelineKey = target.timelineTopics.getRelatedKey(atomKey)
 					if (`family` in atomToken) {
@@ -95,7 +95,7 @@ export function createTimeline<ManagedAtom extends TimelineManageable>(
 			case `atom_family`:
 			case `mutable_atom_family`:
 				{
-					const familyToken: AtomFamilyToken<any, any> = initialTopic
+					const familyToken: AtomFamilyToken<any, any, any> = initialTopic
 					const familyKey = familyToken.key
 					const existingTimelineKey =
 						target.timelineTopics.getRelatedKey(familyKey)
@@ -125,7 +125,7 @@ export function createTimeline<ManagedAtom extends TimelineManageable>(
 
 function addAtomToTimeline(
 	store: Store,
-	atomToken: AtomToken<any>,
+	atomToken: AtomToken<any, any, any>,
 	tl: Timeline<any>,
 ): void {
 	reduceReference(store, atomToken)
@@ -214,7 +214,7 @@ function addAtomToTimeline(
 
 function addAtomFamilyToTimeline(
 	store: Store,
-	atomFamilyToken: AtomFamilyToken<any, any>,
+	atomFamilyToken: AtomFamilyToken<any, any, any>,
 	tl: Timeline<any>,
 ): void {
 	const family = withdraw(store, atomFamilyToken)
@@ -283,7 +283,7 @@ function joinTransaction(
 function buildSelectorUpdate(
 	store: Store,
 	tl: Timeline<any>,
-	atomToken: AtomToken<any>,
+	atomToken: AtomToken<any, any, any>,
 	eventOrUpdate: StateCreationEvent<any> | StateUpdate<any>,
 	currentSelectorToken: WritablePureSelectorToken<any>,
 	currentSelectorTime: number,

package/src/introspection/attach-atom-index.ts

@@ -8,10 +8,10 @@ import {
 
 import type { WritableTokenIndex } from "."
 
-export type AtomTokenIndex = WritableTokenIndex<AtomToken<unknown>>
+export type AtomTokenIndex = WritableTokenIndex<AtomToken<unknown, any, unknown>>
 
 export const attachAtomIndex = (store: Store): AtomToken<AtomTokenIndex> => {
-	return createRegularAtom<AtomTokenIndex>(
+	return createRegularAtom<AtomTokenIndex, never, never>(
 		store,
 		{
 			key: `🔍 Atom Token Index`,

package/src/introspection/attach-selector-index.ts

@@ -8,12 +8,14 @@ import {
 
 import type { WritableTokenIndex } from "."
 
-export type SelectorTokenIndex = WritableTokenIndex<SelectorToken<unknown>>
+export type SelectorTokenIndex = WritableTokenIndex<
+	SelectorToken<unknown, any, any>
+>
 
 export const attachSelectorIndex = (
 	store: Store,
 ): AtomToken<SelectorTokenIndex> => {
-	return createRegularAtom<SelectorTokenIndex>(
+	return createRegularAtom<SelectorTokenIndex, never, never>(
 		store,
 		{
 			key: `🔍 Selector Token Index`,

package/src/introspection/attach-timeline-family.ts

@@ -11,7 +11,8 @@ export const attachTimelineFamily = (
 ): ReadonlyPureSelectorFamilyToken<Timeline<any>, string> => {
 	const findTimelineLogState__INTERNAL = createRegularAtomFamily<
 		Timeline<any>,
-		string
+		string,
+		never
 	>(store, {
 		key: `🔍 Timeline Update Log (Internal)`,
 		default: (key) =>
@@ -36,15 +37,16 @@ export const attachTimelineFamily = (
 			},
 		],
 	})
-	const findTimelineLogState = createSelectorFamily<Timeline<any>, string>(
-		store,
-		{
-			key: `🔍 Timeline Update Log`,
-			get:
-				(key) =>
-				({ get }) =>
-					get(findTimelineLogState__INTERNAL, key),
-		},
-	)
+	const findTimelineLogState = createSelectorFamily<
+		Timeline<any>,
+		string,
+		never
+	>(store, {
+		key: `🔍 Timeline Update Log`,
+		get:
+			(key) =>
+			({ get }) =>
+				get(findTimelineLogState__INTERNAL, key),
+	})
 	return findTimelineLogState
 }

package/src/introspection/attach-timeline-index.ts

@@ -5,7 +5,7 @@ import { createRegularAtom } from "atom.io/internal"
 export const attachTimelineIndex = (
 	store: Store,
 ): AtomToken<TimelineToken<any>[]> => {
-	return createRegularAtom<TimelineToken<any>[]>(
+	return createRegularAtom<TimelineToken<any>[], never, never>(
 		store,
 		{
 			key: `🔍 Timeline Token Index`,

package/src/introspection/attach-transaction-index.ts

@@ -5,7 +5,7 @@ import { createRegularAtom, isReservedIntrospectionKey } from "atom.io/internal"
 export const attachTransactionIndex = (
 	store: Store,
 ): AtomToken<TransactionToken<Fn>[]> => {
-	return createRegularAtom<TransactionToken<Fn>[]>(
+	return createRegularAtom<TransactionToken<Fn>[], never, never>(
 		store,
 		{
 			key: `🔍 Transaction Token Index`,

package/src/introspection/attach-transaction-logs.ts

@@ -14,7 +14,8 @@ export const attachTransactionLogs = (
 > => {
 	const transactionUpdateLogAtoms = createRegularAtomFamily<
 		TransactionOutcomeEvent<TransactionToken<any>>[],
-		string
+		string,
+		never
 	>(store, {
 		key: `🔍 Transaction Update Log (Internal)`,
 		default: () => [],
@@ -31,7 +32,8 @@ export const attachTransactionLogs = (
 	})
 	const findTransactionUpdateLogState = createSelectorFamily<
 		TransactionOutcomeEvent<TransactionToken<any>>[],
-		string
+		string,
+		never
 	>(store, {
 		key: `🔍 Transaction Update Log`,
 		get:

package/src/introspection/attach-type-selectors.ts

@@ -9,7 +9,8 @@ export const attachTypeSelectors = (
 ): ReadonlyPureSelectorFamilyToken<Loadable<string>, string> => {
 	const typeSelectors = createReadonlyPureSelectorFamily<
 		Loadable<string>,
-		string
+		string,
+		never
 	>(store, {
 		key: `🔍 State Type`,
 		get:

package/src/introspection/index.ts

@@ -6,12 +6,10 @@ export * from "./differ"
 export * from "./refinery"
 export * from "./sprawl"
 
-export type FamilyNode<Token extends ReadableToken<unknown>> = {
+export type FamilyNode<Token extends ReadableToken<unknown, any, any>> = {
 	key: string
 	familyMembers: Map<string, Token>
 }
 
-export type WritableTokenIndex<Token extends ReadableToken<unknown>> = Map<
-	string,
-	FamilyNode<Token> | Token
->
+export type WritableTokenIndex<Token extends ReadableToken<unknown, any, any>> =
+	Map<string, FamilyNode<Token> | Token>

package/src/main/atom.ts

@@ -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 (new () => 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 (new () => 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)
 }