atom.io 0.40.0 → 0.40.2

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

@@ -1,5 +1,5 @@
 import type { ReadonlyPureSelectorFamilyToken } from "atom.io"
-import type { Store, Timeline } from "atom.io/internal"
+import type { RootStore, Timeline } from "atom.io/internal"
 import {
 	createRegularAtomFamily,
 	createSelectorFamily,
@@ -7,11 +7,12 @@ import {
 } from "atom.io/internal"
 
 export const attachTimelineFamily = (
-	store: Store,
+	store: RootStore,
 ): 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

@@ -3,18 +3,19 @@ import type {
 	TransactionOutcomeEvent,
 	TransactionToken,
 } from "atom.io"
-import type { Store } from "atom.io/internal"
+import type { RootStore } from "atom.io/internal"
 import { createRegularAtomFamily, createSelectorFamily } from "atom.io/internal"
 
 export const attachTransactionLogs = (
-	store: Store,
+	store: RootStore,
 ): ReadonlyPureSelectorFamilyToken<
 	TransactionOutcomeEvent<TransactionToken<any>>[],
 	string
 > => {
 	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

@@ -1,15 +1,16 @@
 import type { Loadable, ReadonlyPureSelectorFamilyToken } from "atom.io"
-import type { Store } from "atom.io/internal"
+import type { RootStore } from "atom.io/internal"
 import { createReadonlyPureSelectorFamily } from "atom.io/internal"
 
 import { discoverType } from "./refinery"
 
 export const attachTypeSelectors = (
-	store: Store,
+	store: RootStore,
 ): 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/dispose-state.ts

@@ -30,9 +30,5 @@ export function disposeState(
 		| [token: ReadableFamilyToken<any, any>, key: Canonical]
 		| [token: ReadableToken<any>]
 ): void {
-	if (params.length === 2) {
-		disposeFromStore(IMPLICIT.STORE, ...params)
-	} else {
-		disposeFromStore(IMPLICIT.STORE, ...params)
-	}
+	disposeFromStore(IMPLICIT.STORE, ...params)
 }

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>> = {
@@ -114,11 +116,9 @@ export type TransactionOutcomeEvent<T extends TransactionToken<any>> = {
 }
 
 export type TimelineEvent<ManagedAtom extends TimelineManageable> = {
-	write?: true
+	checkpoint?: true
 } & (
 	| AtomUpdateEvent<AtomOnly<ManagedAtom>>
-	| MoleculeCreationEvent
-	| MoleculeDisposalEvent
 	| StateCreationEvent<AtomOnly<ManagedAtom>>
 	| StateDisposalEvent<AtomOnly<ManagedAtom>>
 	| TimelineSelectorUpdateEvent<ManagedAtom>

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,18 +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(
+export function getState<T, K extends Canonical, Key extends K, E = never>(
 	...params:
-		| [token: ReadableFamilyToken<any, any>, key: Canonical]
-		| [token: ReadableToken<any>]
-): any {
-	if (params.length === 2) {
-		return getFromStore(IMPLICIT.STORE, ...params)
-	}
+		| [token: ReadableFamilyToken<T, K, E>, key: Key]
+		| [token: ReadableToken<T, any, E>]
+): ViewOf<E | T> {
 	return getFromStore(IMPLICIT.STORE, ...params)
 }

package/src/main/realm.ts

@@ -1,24 +1,39 @@
-import type { Each, Store } from "atom.io/internal"
+import type { Each, RootStore } from "atom.io/internal"
 import {
+	actUponStore,
 	allocateIntoStore,
+	arbitrary,
 	claimWithinStore,
-	deallocateFromStore,
+	createClaimTX,
+	createDeallocateTX,
 	fuseWithinStore,
 	IMPLICIT,
 	makeRootMoleculeInStore,
 } from "atom.io/internal"
 import type { Canonical } from "atom.io/json"
 
+import type { TransactionToken } from "./tokens"
+
 export const $claim: unique symbol = Symbol.for(`claim`)
 export type Claim<K extends Canonical> = K & { [$claim]?: true }
 
 export class Realm<H extends Hierarchy> {
-	public store: Store
+	public store: RootStore
+	public deallocateTX: TransactionToken<(claim: Claim<Vassal<H>>) => void>
+	public claimTX: TransactionToken<
+		<V extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V, H>>(
+			newProvenance: A,
+			claim: Claim<V>,
+			exclusive?: `exclusive`,
+		) => void
+	>
 	/**
 	 * @param store - The store to which the realm will be attached
 	 */
-	public constructor(store: Store = IMPLICIT.STORE) {
+	public constructor(store: RootStore = IMPLICIT.STORE) {
 		this.store = store
+		this.deallocateTX = createDeallocateTX(store)
+		this.claimTX = createClaimTX(store)
 		makeRootMoleculeInStore(`root`, store)
 	}
 	/**
@@ -66,7 +81,7 @@ export class Realm<H extends Hierarchy> {
 	 * @param claim - The subject to be deallocated
 	 */
 	public deallocate<V extends Vassal<H>>(claim: Claim<V>): void {
-		deallocateFromStore<H, V>(this.store, claim)
+		actUponStore(this.store, this.deallocateTX, arbitrary())(claim)
 	}
 	/**
 	 * Transfer a subject of the realm from one owner to another
@@ -79,21 +94,30 @@ export class Realm<H extends Hierarchy> {
 	public claim<
 		V extends Exclude<Vassal<H>, CompoundTypedKey>,
 		A extends Above<V, H>,
-	>(newProvenance: A, claim: Claim<V>, exclusive?: `exclusive`): Claim<V> {
-		return claimWithinStore<H, V, A>(this.store, newProvenance, claim, exclusive)
+	>(newProvenance: A, claim: Claim<V>, exclusive?: `exclusive`): void {
+		actUponStore(this.store, this.claimTX, arbitrary())(
+			newProvenance,
+			claim,
+			exclusive,
+		)
 	}
 }
 
 export class Anarchy {
-	public store: Store
-	public realm: Realm<any>
+	public store: RootStore
+	public deallocateTX: TransactionToken<(key: Canonical) => void>
+	public claimTX: TransactionToken<
+		(newProvenance: Canonical, key: Canonical, exclusive?: `exclusive`) => void
+	>
 
 	/**
 	 * @param store - The store to which the anarchy-realm will be attached
 	 */
-	public constructor(store: Store = IMPLICIT.STORE) {
+	public constructor(store: RootStore = IMPLICIT.STORE) {
 		this.store = store
-		this.realm = new Realm(store)
+		this.deallocateTX = createDeallocateTX(store)
+		this.claimTX = createClaimTX(store)
+		makeRootMoleculeInStore(`root`, store)
 	}
 	/**
 	 * Declare a new entity
@@ -118,7 +142,7 @@ export class Anarchy {
 	 * @param key - The entity to be deallocated
 	 */
 	public deallocate(key: Canonical): void {
-		deallocateFromStore<any, any>(this.store, key)
+		actUponStore(this.store, this.deallocateTX, arbitrary())(key)
 	}
 	/**
 	 * Transfer an entity from one owner to another

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,17 +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 {
-	if (params.length === 2) {
-		resetInStore(IMPLICIT.STORE, ...params)
-	} else {
-		resetInStore(IMPLICIT.STORE, ...params)
-	}
+	resetInStore(IMPLICIT.STORE, ...params)
 }

package/src/main/selector.ts

@@ -17,19 +17,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 (new () => 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 (new () => E)[]
 }
 export type ReadonlyHeldSelectorOptions<T extends object> = {
 	/** The unique identifier of the selector */
@@ -104,9 +108,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 +125,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 (new () => 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 (new () => E)[]
 }
 export type WritableHeldSelectorFamilyOptions<
 	T extends object,
@@ -234,9 +250,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 +268,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,22 +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, New extends T>(
+
+export function setState<T, K extends Canonical, New extends T, Key extends K>(
 	...params:
 		| [
-				token: WritableFamilyToken<T, Canonical>,
-				key: Canonical,
+				token: WritableFamilyToken<T, K, any>,
+				key: Key,
 				value: New | Setter<T, New>,
 		  ]
-		| [token: WritableToken<T>, value: New | Setter<T, New>]
+		| [token: WritableToken<T, any, any>, value: New | Setter<T, New>]
 ): void {
-	if (params.length === 2) {
-		setIntoStore(IMPLICIT.STORE, ...params)
-	} else {
-		setIntoStore(IMPLICIT.STORE, ...params)
-	}
+	setIntoStore(IMPLICIT.STORE, ...params)
 }