atom.io 0.40.1 → 0.40.2

package/src/internal/selector/create-standalone-selector.ts

@@ -23,26 +23,26 @@ export function createStandaloneSelector<T extends object>(
 	store: Store,
 	options: ReadonlyHeldSelectorOptions<T>,
 ): ReadonlyHeldSelectorToken<T>
-export function createStandaloneSelector<T>(
+export function createStandaloneSelector<T, E>(
 	store: Store,
-	options: WritablePureSelectorOptions<T>,
-): WritablePureSelectorToken<T>
-export function createStandaloneSelector<T>(
+	options: WritablePureSelectorOptions<T, E>,
+): WritablePureSelectorToken<T, any, E>
+export function createStandaloneSelector<T, E>(
 	store: Store,
-	options: ReadonlyPureSelectorOptions<T>,
-): ReadonlyPureSelectorToken<T>
+	options: ReadonlyPureSelectorOptions<T, E>,
+): ReadonlyPureSelectorToken<T, any, E>
 export function createStandaloneSelector(
 	store: Store,
 	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> {
 	const isWritable = `set` in options
 	const isHeld = `const` in options
 

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

@@ -1,8 +1,10 @@
 import type {
 	FamilyMetadata,
+	StateUpdate,
 	WritablePureSelectorOptions,
 	WritablePureSelectorToken,
 } from "atom.io"
+import type { Canonical } from "atom.io/json"
 
 import type { RootStore, WritablePureSelector } 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 createWritablePureSelector<T>(
+export function createWritablePureSelector<T, K extends Canonical, E>(
 	store: Store,
-	options: WritablePureSelectorOptions<T>,
-	family: FamilyMetadata | undefined,
-): WritablePureSelectorToken<T> {
+	options: WritablePureSelectorOptions<T, E>,
+	family: FamilyMetadata<K> | undefined,
+): WritablePureSelectorToken<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 = `writable_pure_selector` as const
@@ -27,7 +29,7 @@ export function createWritablePureSelector<T>(
 	const { find, get, json } = setterToolkit
 	const getterToolkit = { find, get, json }
 
-	const getFrom = (innerTarget: Store): T => {
+	const getFrom = (innerTarget: Store): E | T => {
 		const upstreamStates = innerTarget.selectorGraph.getRelationEntries({
 			downstreamSelectorKey: key,
 		})
@@ -48,7 +50,7 @@ export function createWritablePureSelector<T>(
 		options.set(setterToolkit, newValue)
 	}
 
-	const mySelector: WritablePureSelector<T> = {
+	const mySelector: WritablePureSelector<T, E> = {
 		...options,
 		type,
 		subject,

package/src/internal/selector/dispose-selector.ts

@@ -5,7 +5,7 @@ import { isChildStore, newest, withdraw } from ".."
 
 export function disposeSelector(
 	store: Store,
-	selectorToken: SelectorToken<unknown>,
+	selectorToken: SelectorToken<unknown, any, any>,
 ): void {
 	const target = newest(store)
 	const { key, type, family: familyMeta } = selectorToken
@@ -21,7 +21,7 @@ export function disposeSelector(
 		if (molecule) {
 			target.moleculeData.delete(familyMeta.subKey, familyMeta.key)
 		}
-		let familyToken: SelectorFamilyToken<any, any>
+		let familyToken: SelectorFamilyToken<any, any, any>
 		switch (selectorToken.type) {
 			case `writable_held_selector`:
 				{

package/src/internal/selector/register-selector.ts

@@ -33,8 +33,8 @@ export function registerSelector(
 	return {
 		get: (
 			...params:
-				| [ReadableFamilyToken<any, any>, Canonical]
-				| [ReadableToken<any>]
+				| [ReadableFamilyToken<any, any, any>, Canonical]
+				| [ReadableToken<any, any, any>]
 		) => {
 			const target = newest(store)
 			const { token, family, subKey } = reduceReference(store, ...params)

package/src/internal/selector/trace-selector-atoms.ts

@@ -6,10 +6,10 @@ export function traceRootSelectorAtoms(
 	store: Store,
 	selectorKey: string,
 	covered: Set<string> = new Set<string>(),
-): Map<string, Atom<unknown>> {
+): Map<string, Atom<any, any>> {
 	const dependencies = getSelectorDependencyKeys(store, selectorKey)
 
-	const roots = new Map<string, Atom<unknown>>()
+	const roots = new Map<string, Atom<unknown, unknown>>()
 
 	while (dependencies.length > 0) {
 		// biome-ignore lint/style/noNonNullAssertion: just checked length ^^^
@@ -19,7 +19,7 @@ export function traceRootSelectorAtoms(
 		}
 		covered.add(dependencyKey)
 		if (isAtomKey(store, dependencyKey)) {
-			const atom = store.atoms.get(dependencyKey) as Atom<unknown>
+			const atom = store.atoms.get(dependencyKey) as Atom<unknown, unknown>
 			roots.set(atom.key, atom)
 		} else {
 			dependencies.push(...getSelectorDependencyKeys(store, dependencyKey))

package/src/internal/selector/update-selector-atoms.ts

@@ -12,7 +12,7 @@ export function updateSelectorAtoms(
 		| `writable_held_selector`
 		| `writable_pure_selector`,
 	selectorKey: string,
-	dependency: ReadableToken<unknown>,
+	dependency: ReadableToken<unknown, any, unknown>,
 	covered: Set<string>,
 ): void {
 	const target = newest(store)

package/src/internal/set-state/dispatch-state-update.ts

@@ -17,12 +17,12 @@ import { isChildStore, isRootStore } from "../transaction"
 import { evictDownstreamFromAtom } from "./evict-downstream"
 import type { ProtoUpdate } from "./operate-on-store"
 
-export function dispatchOrDeferStateUpdate<T>(
+export function dispatchOrDeferStateUpdate<T, E>(
 	target: Store & { operation: OpenOperation<any> },
-	state: WritableState<T>,
-	{ oldValue, newValue }: ProtoUpdate<T>,
+	state: WritableState<T, E>,
+	{ oldValue, newValue }: ProtoUpdate<E | T>,
 	stateIsNewlyCreated: boolean,
-	family?: WritableFamily<T, any>,
+	family?: WritableFamily<T, any, E>,
 ): void {
 	const token = deposit(state)
 	if (stateIsNewlyCreated && family) {
@@ -128,7 +128,11 @@ export function dispatchOrDeferStateUpdate<T>(
 			const mutable = target.atoms.get(keyOfMutable) as MutableAtom<
 				Transceiver<unknown, any, any>
 			>
-			const transceiver = readOrComputeValue(target, mutable, `mut`)
+			const transceiver = readOrComputeValue<Transceiver<any, any, any>, never>(
+				target,
+				mutable,
+				`mut`,
+			)
 			const accepted = transceiver.do(update.newValue) === null
 			if (accepted === true) {
 				evictDownstreamFromAtom(target, mutable)

package/src/internal/set-state/evict-downstream.ts

@@ -4,7 +4,10 @@ import { newest } from "../lineage"
 import { isDone, markDone } from "../operation"
 import type { Store } from "../store"
 
-export function evictDownstreamFromAtom(store: Store, atom: Atom<any>): void {
+export function evictDownstreamFromAtom(
+	store: Store,
+	atom: Atom<any, any>,
+): void {
 	const target = newest(store)
 	const { key, type } = atom
 	const downstreamKeys = target.selectorAtoms.getRelatedKeys(key)

package/src/internal/set-state/operate-on-store.ts

@@ -18,25 +18,31 @@ export type ProtoUpdate<T> = { oldValue: T; newValue: T }
 export const OWN_OP: unique symbol = Symbol(`OWN_OP`)
 export const JOIN_OP: unique symbol = Symbol(`JOIN_OP`)
 
-export function operateOnStore<T, New extends T>(
+export function operateOnStore<
+	T,
+	K extends Canonical,
+	New extends T,
+	Key extends K,
+	E,
+>(
 	store: Store,
 	opMode: typeof JOIN_OP | typeof OWN_OP,
 	...params:
 		| [
-				token: WritableFamilyToken<T, Canonical>,
-				key: Canonical,
+				token: WritableFamilyToken<T, K, E>,
+				key: Key,
 				value: New | typeof RESET_STATE | ((oldValue: T) => New),
 		  ]
 		| [
-				token: WritableToken<T>,
+				token: WritableToken<T, Key, E>,
 				value: New | typeof RESET_STATE | ((oldValue: T) => New),
 		  ]
 ): void {
-	let existingToken: WritableToken<T> | undefined
-	let brandNewToken: WritableToken<T> | undefined
-	let token: WritableToken<T>
-	let family: WritableFamily<T, Canonical> | undefined
-	let key: Canonical | null
+	let existingToken: WritableToken<T, Key, E> | undefined
+	let brandNewToken: WritableToken<T, Key, E> | undefined
+	let token: WritableToken<T, Key, E>
+	let family: WritableFamily<T, K, E> | undefined
+	let key: Key | null
 	let value: New | typeof RESET_STATE | ((oldValue: T) => New)
 	if (params.length === 2) {
 		token = params[0]
@@ -116,7 +122,7 @@ export function operateOnStore<T, New extends T>(
 	}
 
 	const state = withdraw(target, token)
-	let protoUpdate: ProtoUpdate<T>
+	let protoUpdate: ProtoUpdate<E | T>
 	if (value === RESET_STATE) {
 		protoUpdate = resetAtomOrSelector(target, state)
 	} else {

package/src/internal/set-state/reset-atom-or-selector.ts

@@ -5,10 +5,10 @@ import { dispatchOrDeferStateUpdate } from "./dispatch-state-update"
 import type { ProtoUpdate } from "./operate-on-store"
 import { setAtom } from "./set-atom"
 
-function resetAtom<T>(
+function resetAtom<T, E>(
 	target: Store & { operation: OpenOperation },
-	atom: Atom<T>,
-): ProtoUpdate<T> {
+	atom: Atom<T, E>,
+): ProtoUpdate<E | T> {
 	switch (atom.type) {
 		case `mutable_atom`:
 			return setAtom(target, atom, new atom.class())
@@ -20,11 +20,11 @@ function resetAtom<T>(
 	}
 }
 
-export function resetAtomOrSelector<T>(
+export function resetAtomOrSelector<T, E>(
 	target: Store & { operation: OpenOperation },
-	state: WritableState<T>,
-): ProtoUpdate<T> {
-	let protoUpdate: ProtoUpdate<T>
+	state: WritableState<T, E>,
+): ProtoUpdate<E | T> {
+	let protoUpdate: ProtoUpdate<E | T>
 	switch (state.type) {
 		case `atom`:
 		case `mutable_atom`:

package/src/internal/set-state/reset-in-store.ts

@@ -6,26 +6,29 @@ import { setIntoStore } from "./set-into-store"
 
 export const RESET_STATE: unique symbol = Symbol(`RESET`)
 
-export function resetInStore(store: Store, token: WritableToken<any>): void
+export function resetInStore(
+	store: Store,
+	token: WritableToken<any, any, any>,
+): void
 
 export function resetInStore<K extends Canonical>(
 	store: Store,
-	token: WritableFamilyToken<any, K>,
+	token: WritableFamilyToken<any, K, any>,
 	key: K,
 ): void
 
 export function resetInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	...params:
-		| [token: WritableFamilyToken<T, K>, key: Key]
-		| [token: WritableToken<T>]
+		| [token: WritableFamilyToken<T, K, any>, key: Key]
+		| [token: WritableToken<T, any, any>]
 ): void
 
 export function resetInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	...params:
-		| [token: WritableFamilyToken<T, K>, key: Key]
-		| [token: WritableToken<T>]
+		| [token: WritableFamilyToken<T, K, any>, key: Key]
+		| [token: WritableToken<T, any, any>]
 ): void {
 	const subParams = [...params, RESET_STATE] as const
 	setIntoStore(store, ...subParams)

package/src/internal/set-state/set-atom-or-selector.ts

@@ -7,7 +7,7 @@ import { setSelector } from "./set-selector"
 
 export const setAtomOrSelector = <T>(
 	target: Store & { operation: OpenOperation },
-	state: WritableState<T>,
+	state: WritableState<T, any>,
 	value: T | ((oldValue: T) => T),
 ): ProtoUpdate<T> => {
 	let protoUpdate: ProtoUpdate<T>

package/src/internal/set-state/set-atom.ts

@@ -8,7 +8,7 @@ import type { ProtoUpdate } from "./operate-on-store"
 
 export const setAtom = <T>(
 	target: Store & { operation: OpenOperation<any> },
-	atom: Atom<T>,
+	atom: Atom<T, any>,
 	next: T | ((oldValue: T) => T),
 ): ProtoUpdate<T> => {
 	const oldValue = readOrComputeValue(target, atom, `mut`)

package/src/internal/set-state/set-into-store.ts

@@ -5,9 +5,9 @@ import type { Store } from "../store"
 import { operateOnStore, OWN_OP } from "./operate-on-store"
 import type { RESET_STATE } from "./reset-in-store"
 
-export function setIntoStore<T, New extends T>(
+export function setIntoStore<T, New extends T, E>(
 	store: Store,
-	token: WritableToken<T>,
+	token: WritableToken<T, any, E>,
 	value: New | typeof RESET_STATE | ((oldValue: T) => New),
 ): void
 
@@ -16,9 +16,10 @@ export function setIntoStore<
 	K extends Canonical,
 	New extends T,
 	Key extends K,
+	E,
 >(
 	store: Store,
-	token: WritableFamilyToken<T, K>,
+	token: WritableFamilyToken<T, K, E>,
 	key: Key,
 	value: New | typeof RESET_STATE | ((oldValue: T) => New),
 ): void
@@ -28,16 +29,17 @@ export function setIntoStore<
 	K extends Canonical,
 	New extends T,
 	Key extends K,
+	E,
 >(
 	store: Store,
 	...params:
 		| [
-				token: WritableFamilyToken<T, K>,
+				token: WritableFamilyToken<T, K, E>,
 				key: Key,
 				value: New | typeof RESET_STATE | ((oldValue: T) => New),
 		  ]
 		| [
-				token: WritableToken<T>,
+				token: WritableToken<T, any, E>,
 				value: New | typeof RESET_STATE | ((oldValue: T) => New),
 		  ]
 ): void
@@ -47,16 +49,17 @@ export function setIntoStore<
 	K extends Canonical,
 	New extends T,
 	Key extends K,
+	E,
 >(
 	store: Store,
 	...params:
 		| [
-				token: WritableFamilyToken<T, K>,
+				token: WritableFamilyToken<T, K, E>,
 				key: Key,
 				value: New | typeof RESET_STATE | ((oldValue: T) => New),
 		  ]
 		| [
-				token: WritableToken<T>,
+				token: WritableToken<T, any, E>,
 				value: New | typeof RESET_STATE | ((oldValue: T) => New),
 		  ]
 ): void {

package/src/internal/set-state/set-selector.ts

@@ -7,7 +7,7 @@ import type { ProtoUpdate } from "./operate-on-store"
 
 export function setSelector<T>(
 	target: Store & { operation: OpenOperation<any> },
-	selector: WritableSelector<T>,
+	selector: WritableSelector<T, any>,
 	next: T | ((oldValue: T) => T),
 ): ProtoUpdate<T> {
 	let oldValue: T

package/src/internal/store/deposit.ts

@@ -46,44 +46,52 @@ import type {
 } from ".."
 import type { Transaction } from "../transaction"
 
-export function deposit<T>(state: RegularAtom<T>): RegularAtomToken<T>
+export function deposit<T, E>(
+	state: RegularAtom<T, E>,
+): RegularAtomToken<T, Canonical, E>
 export function deposit<T extends Transceiver<any, any, any>>(
 	state: MutableAtom<T>,
 ): MutableAtomToken<T>
-export function deposit<T>(state: Atom<T>): AtomToken<T>
-export function deposit<T>(
-	state: WritablePureSelector<T>,
-): WritablePureSelectorToken<T>
-export function deposit<T>(
-	state: ReadonlyPureSelector<T>,
-): ReadonlyPureSelectorToken<T>
-export function deposit<T>(state: Selector<T>): SelectorToken<T>
-export function deposit<T>(state: WritableState<T>): WritableToken<T>
-export function deposit<T>(state: ReadableState<T>): ReadableToken<T>
+export function deposit<T, E>(state: Atom<T, E>): AtomToken<T, Canonical, E>
+export function deposit<T, E>(
+	state: WritablePureSelector<T, E>,
+): WritablePureSelectorToken<T, any, E>
+export function deposit<T, E>(
+	state: ReadonlyPureSelector<T, E>,
+): ReadonlyPureSelectorToken<T, any, E>
+export function deposit<T, E>(state: Selector<T, E>): SelectorToken<T, any, E>
+export function deposit<T, E>(
+	state: WritableState<T, E>,
+): WritableToken<T, any, E>
+export function deposit<T, E>(
+	state: ReadableState<T, E>,
+): ReadableToken<T, any, E>
 
-export function deposit<T, K extends Canonical>(
-	state: RegularAtomFamily<T, K>,
-): RegularAtomFamilyToken<T, K>
+export function deposit<T, K extends Canonical, E>(
+	state: RegularAtomFamily<T, K, E>,
+): RegularAtomFamilyToken<T, K, E>
 export function deposit<
 	T extends Transceiver<any, any, any>,
 	K extends Canonical,
 >(state: MutableAtomFamily<T, K>): MutableAtomFamilyToken<T, K>
-export function deposit<T>(state: AtomFamily<T, any>): AtomFamilyToken<T, any>
-export function deposit<T>(
-	state: WritablePureSelectorFamily<T, any>,
-): WritablePureSelectorFamilyToken<T, any>
-export function deposit<T>(
-	state: ReadonlyPureSelectorFamily<T, any>,
-): ReadonlyPureSelectorFamilyToken<T, any>
-export function deposit<T>(
-	state: SelectorFamily<T, any>,
-): SelectorFamilyToken<T, any>
-export function deposit<T>(
-	state: WritableFamily<T, any>,
-): WritableFamilyToken<T, any>
-export function deposit<T>(
-	state: ReadableFamily<T, any>,
-): ReadableFamilyToken<T, any>
+export function deposit<T, E>(
+	state: AtomFamily<T, any, E>,
+): AtomFamilyToken<T, any, E>
+export function deposit<T, E>(
+	state: WritablePureSelectorFamily<T, any, E>,
+): WritablePureSelectorFamilyToken<T, any, E>
+export function deposit<T, E>(
+	state: ReadonlyPureSelectorFamily<T, any, E>,
+): ReadonlyPureSelectorFamilyToken<T, any, E>
+export function deposit<T, E>(
+	state: SelectorFamily<T, any, E>,
+): SelectorFamilyToken<T, any, E>
+export function deposit<T, E>(
+	state: WritableFamily<T, any, E>,
+): WritableFamilyToken<T, any, E>
+export function deposit<T, E>(
+	state: ReadableFamily<T, any, E>,
+): ReadableFamilyToken<T, any, E>
 
 export function deposit<T extends Fn>(state: Transaction<T>): TransactionToken<T>
 export function deposit<M extends TimelineManageable>(

package/src/internal/store/mint-or-counterfeit.ts

@@ -39,53 +39,53 @@ export function mint<
 	Key extends K,
 >(token: MutableAtomFamilyToken<T, K>, key: Key): MutableAtomToken<T>
 
-export function mint<T, K extends Canonical, Key extends K>(
-	token: RegularAtomFamilyToken<T, K>,
+export function mint<T, K extends Canonical, Key extends K, E>(
+	token: RegularAtomFamilyToken<T, K, E>,
 	key: Key,
 	counterfeit?: typeof COUNTERFEIT,
-): RegularAtomToken<T>
+): RegularAtomToken<T, Key, E>
 
-export function mint<T, K extends Canonical, Key extends K>(
-	token: AtomFamilyToken<T, K>,
+export function mint<T, K extends Canonical, Key extends K, E>(
+	token: AtomFamilyToken<T, K, E>,
 	key: Key,
 	counterfeit?: typeof COUNTERFEIT,
-): AtomToken<T>
+): AtomToken<T, Key, E>
 
-export function mint<T, K extends Canonical, Key extends K>(
-	token: WritablePureSelectorFamilyToken<T, K>,
+export function mint<T, K extends Canonical, Key extends K, E>(
+	token: WritablePureSelectorFamilyToken<T, K, E>,
 	key: Key,
 	counterfeit?: typeof COUNTERFEIT,
-): WritablePureSelectorToken<T>
+): WritablePureSelectorToken<T, Key, E>
 
-export function mint<T, K extends Canonical, Key extends K>(
-	token: ReadonlyPureSelectorFamilyToken<T, K>,
+export function mint<T, K extends Canonical, Key extends K, E>(
+	token: ReadonlyPureSelectorFamilyToken<T, K, E>,
 	key: Key,
 	counterfeit?: typeof COUNTERFEIT,
-): ReadonlyPureSelectorToken<T>
+): ReadonlyPureSelectorToken<T, Key, E>
 
-export function mint<T, K extends Canonical, Key extends K>(
-	token: SelectorFamilyToken<T, K>,
+export function mint<T, K extends Canonical, Key extends K, E>(
+	token: SelectorFamilyToken<T, K, E>,
 	key: Key,
 	counterfeit?: typeof COUNTERFEIT,
-): SelectorToken<T>
+): SelectorToken<T, Key, E>
 
-export function mint<T, K extends Canonical, Key extends K>(
-	token: WritableFamilyToken<T, K>,
+export function mint<T, K extends Canonical, Key extends K, E>(
+	token: WritableFamilyToken<T, K, E>,
 	key: Key,
 	counterfeit?: typeof COUNTERFEIT,
-): WritableToken<T>
+): WritableToken<T, Key, E>
 
-export function mint<T, K extends Canonical, Key extends K>(
-	token: ReadableFamilyToken<T, K>,
+export function mint<T, K extends Canonical, Key extends K, E>(
+	token: ReadableFamilyToken<T, K, E>,
 	key: Key,
 	counterfeit?: typeof COUNTERFEIT,
-): ReadableToken<T>
+): ReadableToken<T, Key, E>
 
 export function mint(
-	token: ReadableFamilyToken<any, any>,
+	token: ReadableFamilyToken<any, any, any>,
 	key: Canonical,
 	counterfeit?: typeof COUNTERFEIT,
-): ReadableToken<any> {
+): ReadableToken<any, any, any> {
 	const subKey = stringifyJson(key)
 	const fullKey = `${token.key}(${subKey})`
 	const type = FAMILY_MEMBER_TOKEN_TYPES[token.type]

package/src/internal/store/store.ts

@@ -47,9 +47,9 @@ export class Store implements Lineage {
 	public valueMap: Map<string, any> = new Map()
 	public defaults: Map<string, any> = new Map()
 
-	public atoms: Map<string, Atom<any>> = new Map()
-	public writableSelectors: Map<string, WritableSelector<any>> = new Map()
-	public readonlySelectors: Map<string, ReadonlySelector<any>> = new Map()
+	public atoms: Map<string, Atom<any, any>> = new Map()
+	public writableSelectors: Map<string, WritableSelector<any, any>> = new Map()
+	public readonlySelectors: Map<string, ReadonlySelector<any, any>> = new Map()
 
 	public atomsThatAreDefault: Set<string> = new Set()
 	public selectorAtoms: Junction<`selectorKey`, string, `atomKey`, string> =
@@ -77,8 +77,8 @@ export class Store implements Lineage {
 		string,
 		| HeldSelectorFamily<any, any>
 		| MutableAtomFamily<any, any>
-		| PureSelectorFamily<any, any>
-		| RegularAtomFamily<any, any>
+		| PureSelectorFamily<any, any, any>
+		| RegularAtomFamily<any, any, any>
 	> = new Map()
 	public joins: Map<string, Join<any, any, any, any, any, any>> = new Map()
 
@@ -247,10 +247,10 @@ export class Store implements Lineage {
 }
 
 export type StoreEventCarrier = {
-	atomCreation: Subject<AtomToken<unknown>>
-	atomDisposal: Subject<AtomToken<unknown>>
-	selectorCreation: Subject<SelectorToken<unknown>>
-	selectorDisposal: Subject<SelectorToken<unknown>>
+	atomCreation: Subject<AtomToken<unknown, any, any>>
+	atomDisposal: Subject<AtomToken<unknown, any, any>>
+	selectorCreation: Subject<SelectorToken<unknown, any, any>>
+	selectorDisposal: Subject<SelectorToken<unknown, any, any>>
 	timelineCreation: Subject<TimelineToken<unknown>>
 	transactionCreation: Subject<TransactionToken<Fn>>
 	transactionApplying: StatefulSubject<TransactionProgress<Fn> | null>