atom.io 0.40.1 → 0.40.3

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>

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/internal/utility-types.ts

@@ -1,5 +1,7 @@
 export type Fn = (...parameters: any[]) => any
 
+export type Ctor<T> = new (...args: any[]) => T
+
 export type Flat<R extends { [K in PropertyKey]: any }> = {
 	[K in keyof R]: R[K]
 }

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>