atom.io 0.40.1 → 0.40.2

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

@@ -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 (new () => 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 (new () => 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 (new () => 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>
 		& {
 			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>)
+	& (<Key extends K>(key: Key) => RegularAtomToken<T, Key, E>)
 
 // biome-ignore format: intersection
 export type MutableAtomFamily<
@@ -152,24 +157,24 @@ export type MutableAtomFamily<
 				subject: Subject<StateLifecycleEvent<MutableAtomToken<T>>>
 			}
 	>
-	& ((key: K) => MutableAtomToken<T>)
+	& (<Key extends K>(key: Key) => MutableAtomToken<T, Key>)
 
-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>
 		& {
 			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>)
+	& (<Key extends K>(key: Key) => WritablePureSelectorToken<T, Key, E>)
 
 // biome-ignore format: intersection
 export type WritableHeldSelectorFamily<T , K extends Canonical> =
@@ -179,23 +184,23 @@ export type WritableHeldSelectorFamily<T , K extends Canonical> =
 			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>)
+	& (<Key extends K>(key: Key) => WritableHeldSelectorToken<T, Key>)
 
 // 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>
 		& {
 			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>)
+	& (<Key extends K>(key: Key) => ReadonlyPureSelectorToken<T, Key, E>)
 
 // biome-ignore format: intersection
 export type ReadonlyHeldSelectorFamily<T , K extends Canonical> =
@@ -208,37 +213,37 @@ export type ReadonlyHeldSelectorFamily<T , K extends Canonical> =
 			subject: Subject<StateLifecycleEvent<ReadonlyHeldSelectorToken<T>>>
 		}
 	>
-	& ((key: K) => ReadonlyHeldSelectorToken<T>)
+	& (<Key extends K>(key: Key) => ReadonlyHeldSelectorToken<T, Key>)
 
-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>

package/src/internal/join/join-internal.ts

@@ -199,7 +199,8 @@ export class Join<
 		this.core = { relatedKeysAtoms }
 		const getRelatedKeys: Read<
 			(key: string) => SetRTX<AType> | SetRTX<BType>
-		> = ({ get }, key) => get(relatedKeysAtoms, key) as any
+		> = ({ get }, key) =>
+			get(relatedKeysAtoms, key) as SetRTX<AType> | SetRTX<BType>
 		const addRelation: Write<(a: string, b: string) => void> = (
 			{ set },
 			a,
@@ -331,7 +332,7 @@ export class Join<
 		let contentAtoms: RegularAtomFamilyToken<Content, string>
 
 		if (defaultContent) {
-			contentAtoms = createRegularAtomFamily<Content, ContentKey>(
+			contentAtoms = createRegularAtomFamily<Content, ContentKey, never>(
 				store,
 				{
 					key: `${options.key}/content`,
@@ -398,7 +399,7 @@ export class Join<
 		)
 
 		const createSingleKeySelectorFamily = () =>
-			createReadonlyPureSelectorFamily<string | null, string>(
+			createReadonlyPureSelectorFamily<string | null, string, never>(
 				store,
 				{
 					key: `${options.key}/singleRelatedKey`,
@@ -415,7 +416,7 @@ export class Join<
 				[`join`, `keys`],
 			)
 		const getMultipleKeySelectorFamily = () => {
-			return createReadonlyPureSelectorFamily<string[], string>(
+			return createReadonlyPureSelectorFamily<string[], string, never>(
 				store,
 				{
 					key: `${options.key}/multipleRelatedKeys`,
@@ -431,7 +432,11 @@ export class Join<
 			)
 		}
 		const createSingleEntrySelectorFamily = () =>
-			createReadonlyPureSelectorFamily<[string, ViewOf<Content>] | null, string>(
+			createReadonlyPureSelectorFamily<
+				[string, ViewOf<Content>] | null,
+				string,
+				never
+			>(
 				store,
 				{
 					key: `${options.key}/singleRelatedEntry`,
@@ -454,7 +459,11 @@ export class Join<
 				[`join`, `entries`],
 			)
 		const getMultipleEntrySelectorFamily = () =>
-			createReadonlyPureSelectorFamily<[string, ViewOf<Content>][], string>(
+			createReadonlyPureSelectorFamily<
+				[string, ViewOf<Content>][],
+				string,
+				never
+			>(
 				store,
 				{
 					key: `${options.key}/multipleRelatedEntries`,

package/src/internal/mutable/create-mutable-atom-family.ts

@@ -73,7 +73,7 @@ export function createMutableAtomFamily<
 
 	store.families.set(options.key, atomFamily)
 
-	createWritablePureSelectorFamily<AsJSON<T>, K>(
+	createWritablePureSelectorFamily<AsJSON<T>, K, never>(
 		store,
 		{
 			key: `${options.key}:JSON`,

package/src/internal/mutable/get-json-family.ts

@@ -12,12 +12,13 @@ export const getJsonFamily = <
 >(
 	mutableAtomFamily: MutableAtomFamilyToken<Core, Key>,
 	store: Store,
-): WritablePureSelectorFamily<ReturnType<Core[`toJSON`]>, Key> => {
+): WritablePureSelectorFamily<ReturnType<Core[`toJSON`]>, Key, never> => {
 	const target = newest(store)
 	const key = `${mutableAtomFamily.key}:JSON`
 	const jsonFamily = target.families.get(key) as WritablePureSelectorFamily<
 		ReturnType<Core[`toJSON`]>,
-		Key
+		Key,
+		never
 	>
 	return jsonFamily
 }

package/src/internal/mutable/get-update-family.ts

@@ -1,7 +1,7 @@
 import type { MutableAtomFamilyToken } from "atom.io"
 import type { Json } from "atom.io/json"
 
-import type { AtomFamily } from ".."
+import type { RegularAtomFamily } from ".."
 import { newest } from "../lineage"
 import type { Store } from "../store"
 import type { SignalFrom, Transceiver } from "./transceiver"
@@ -12,11 +12,13 @@ export const getUpdateFamily = <
 >(
 	mutableAtomFamily: MutableAtomFamilyToken<T, K>,
 	store: Store,
-): AtomFamily<SignalFrom<T>, K> => {
+): RegularAtomFamily<SignalFrom<T>, K, never> => {
 	const target = newest(store)
 	const key = `*${mutableAtomFamily.key}`
-	const updateFamily: AtomFamily<SignalFrom<T>, K> = target.families.get(
-		key,
-	) as AtomFamily<SignalFrom<T>, K>
+	const updateFamily = target.families.get(key) as RegularAtomFamily<
+		SignalFrom<T>,
+		K,
+		never
+	>
 	return updateFamily
 }

package/src/internal/mutable/tracker-family.ts

@@ -18,7 +18,11 @@ export class FamilyTracker<
 	public readonly mutableAtoms: MutableAtomFamily<T, K>
 
 	public constructor(mutableAtoms: MutableAtomFamily<T, K>, store: RootStore) {
-		const latestSignalAtoms = createRegularAtomFamily<SignalFrom<T> | null, K>(
+		const latestSignalAtoms = createRegularAtomFamily<
+			SignalFrom<T> | null,
+			K,
+			never
+		>(
 			store,
 			{
 				key: `*${mutableAtoms.key}`,

package/src/internal/mutable/tracker.ts

@@ -31,7 +31,11 @@ export class Tracker<T extends Transceiver<any, any, any>> {
 					subKey: mutableState.family.subKey,
 				}
 			: undefined
-		const latestSignalState = createRegularAtom<SignalFrom<T> | null>(
+		const latestSignalState = createRegularAtom<
+			SignalFrom<T> | null,
+			any,
+			never
+		>(
 			store,
 			{
 				key: latestSignalStateKey,

package/src/internal/operation.ts

@@ -8,7 +8,9 @@ export type OperationProgress =
 	| {
 			open: false
 	  }
-export type OpenOperation<R extends ReadableToken<any> = ReadableToken<any>> = {
+export type OpenOperation<
+	R extends ReadableToken<any, any> = ReadableToken<any, any>,
+> = {
 	open: true
 	token: R
 	done: Set<string>
@@ -19,7 +21,7 @@ export type OpenOperation<R extends ReadableToken<any> = ReadableToken<any>> = {
 
 export function openOperation(
 	store: Store,
-	token: ReadableToken<any>,
+	token: ReadableToken<any, any, any>,
 ): number | (Store & { operation: OpenOperation }) {
 	if (store.operation.open) {
 		const rejectionTime = performance.now()

package/src/internal/selector/create-readonly-pure-selector.ts

@@ -2,7 +2,9 @@ import type {
 	FamilyMetadata,
 	ReadonlyPureSelectorOptions,
 	ReadonlyPureSelectorToken,
+	StateUpdate,
 } from "atom.io"
+import type { Canonical } from "atom.io/json"
 
 import type { ReadonlyPureSelector, RootStore } from ".."
 import { writeToCache } from "../caching"
@@ -11,13 +13,13 @@ import type { Store } from "../store"
 import { Subject } from "../subject"
 import { registerSelector } from "./register-selector"
 
-export function createReadonlyPureSelector<T>(
+export function createReadonlyPureSelector<T, K extends Canonical, E>(
 	store: Store,
-	options: ReadonlyPureSelectorOptions<T>,
-	family: FamilyMetadata | undefined,
-): ReadonlyPureSelectorToken<T> {
+	options: ReadonlyPureSelectorOptions<T, E>,
+	family: FamilyMetadata<K> | undefined,
+): ReadonlyPureSelectorToken<T, K, E> {
 	const target = newest(store)
-	const subject = new Subject<{ newValue: T; oldValue: T }>()
+	const subject = new Subject<StateUpdate<E | T>>()
 	const covered = new Set<string>()
 	const key = options.key
 	const type = `readonly_pure_selector` as const
@@ -43,7 +45,7 @@ export function createReadonlyPureSelector<T>(
 		return cached
 	}
 
-	const readonlySelector: ReadonlyPureSelector<T> = {
+	const readonlySelector: ReadonlyPureSelector<T, E> = {
 		...options,
 		type,
 		subject,