atom.io 0.8.0 → 0.8.2

package/internal/src/caching.ts

@@ -1,4 +1,4 @@
-import type { StateUpdate } from "../../src"
+import type { StateUpdate } from "atom.io"
 import { Future } from "./future"
 import type { Store } from "./store"
 import { IMPLICIT } from "./store"
@@ -18,10 +18,17 @@ export const cacheValue = (
 	if (value instanceof Promise) {
 		const future = new Future(value)
 		target(store).valueMap.set(key, future)
-		future.then((value) => {
-			cacheValue(key, value, subject, store)
-			subject.next({ newValue: value, oldValue: value })
-		})
+		future
+			.then((value) => {
+				cacheValue(key, value, subject, store)
+				subject.next({ newValue: value, oldValue: value })
+			})
+			.catch((error) => {
+				store.config.logger?.error(
+					`Promised value for "${key}" rejected:`,
+					error,
+				)
+			})
 	} else {
 		target(store).valueMap.set(key, value)
 	}

package/internal/src/future.ts

@@ -1,7 +1,5 @@
-import { E } from "vitest/dist/reporters-5f784f42"
-
-export type Eventual<T> = Promise<T> | T
-export type Fated<T, E extends Error = Error> = Eventual<E | T>
+export type Loadable<T> = Promise<T> | T
+export type Fated<T, E extends Error = Error> = Loadable<E | T>
 
 /**
  * A Promise that can be canceled.

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

@@ -1,4 +1,4 @@
-import type * as AtomIO from "atom.io"
+import type { MutableAtomFamily, MutableAtomFamilyOptions } from "atom.io"
 import type { Json } from "atom.io/json"
 import { selectJsonFamily } from "atom.io/json"
 
@@ -12,13 +12,13 @@ export function createMutableAtomFamily<
 	SerializableCore extends Json.Serializable,
 	Key extends string,
 >(
-	options: AtomIO.MutableAtomFamilyOptions<Core, SerializableCore, Key>,
+	options: MutableAtomFamilyOptions<Core, SerializableCore, Key>,
 	store: Store = IMPLICIT.STORE,
-): AtomIO.MutableAtomFamily<Core, SerializableCore, Key> {
+): MutableAtomFamily<Core, SerializableCore, Key> {
 	const coreFamily = Object.assign(
 		createAtomFamily<Core, Key>(options, store),
 		options,
-	) as AtomIO.MutableAtomFamily<Core, SerializableCore, Key>
+	) as MutableAtomFamily<Core, SerializableCore, Key>
 	selectJsonFamily(coreFamily, options)
 	new FamilyTracker(coreFamily, store)
 	return coreFamily

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

@@ -1,4 +1,5 @@
-import * as AtomIO from "atom.io"
+import type { MutableAtomOptions, MutableAtomToken } from "atom.io"
+import { subscribe } from "atom.io"
 import type { Json } from "atom.io/json"
 import { selectJson } from "atom.io/json"
 
@@ -13,16 +14,16 @@ export function createMutableAtom<
 	Core extends Transceiver<any>,
 	SerializableCore extends Json.Serializable,
 >(
-	options: AtomIO.MutableAtomOptions<Core, SerializableCore>,
+	options: MutableAtomOptions<Core, SerializableCore>,
 	store: Store = IMPLICIT.STORE,
-): AtomIO.MutableAtomToken<Core, SerializableCore> {
+): MutableAtomToken<Core, SerializableCore> {
 	store.config.logger?.info(
 		`🔧 creating mutable atom "${options.key}" in store "${store.config.name}"`,
 	)
 	const coreState = createAtom<Core>(options, undefined, store)
 	new Tracker(coreState, store)
 	const jsonState = selectJson(coreState, options, store)
-	AtomIO.subscribe(
+	subscribe(
 		jsonState,
 		() => {
 			store.config.logger?.info(
@@ -45,5 +46,5 @@ export function createMutableAtom<
 				: store.transactionStatus.key
 		}`,
 	)
-	return coreState as AtomIO.MutableAtomToken<Core, SerializableCore>
+	return coreState as MutableAtomToken<Core, SerializableCore>
 }

package/internal/src/mutable/is-atom-token-mutable.ts

@@ -1,7 +1,7 @@
-import type * as AtomIO from "atom.io"
+import type { AtomToken, MutableAtomToken } from "atom.io"
 
 export function isAtomTokenMutable(
-	token: AtomIO.AtomToken<any>,
-): token is AtomIO.MutableAtomToken<any, any> {
+	token: AtomToken<any>,
+): token is MutableAtomToken<any, any> {
 	return token.key.endsWith(`::mutable`)
 }

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

@@ -1,4 +1,4 @@
-import type * as AtomIO from "atom.io"
+import type { AtomFamily } from "atom.io"
 import type { Json } from "atom.io/json"
 import { parseJson } from "atom.io/json"
 
@@ -16,14 +16,14 @@ export class FamilyTracker<
 		? Signal
 		: never
 
-	public readonly findLatestUpdateState: AtomIO.AtomFamily<
+	public readonly findLatestUpdateState: AtomFamily<
 		typeof this.Update | null,
 		FamilyMemberKey
 	>
-	public readonly findMutableState: AtomIO.AtomFamily<Core, FamilyMemberKey>
+	public readonly findMutableState: AtomFamily<Core, FamilyMemberKey>
 
 	public constructor(
-		findMutableState: AtomIO.AtomFamily<Core, FamilyMemberKey>,
+		findMutableState: AtomFamily<Core, FamilyMemberKey>,
 		store: Store = IMPLICIT.STORE,
 	) {
 		this.findLatestUpdateState = createAtomFamily<

package/internal/src/mutable/tracker.ts

@@ -1,4 +1,5 @@
-import * as AtomIO from "atom.io"
+import type { AtomToken, FamilyMetadata, MutableAtomToken } from "atom.io"
+import { getState, setState, subscribe, subscribeToTimeline } from "atom.io"
 import type { Json } from "atom.io/json"
 
 import type { Store } from ".."
@@ -16,12 +17,12 @@ export class Tracker<Mutable extends Transceiver<any>> {
 	private Update: Mutable extends Transceiver<infer Signal> ? Signal : never
 
 	private initializeState(
-		mutableState: AtomIO.MutableAtomToken<Mutable, Json.Serializable>,
+		mutableState: MutableAtomToken<Mutable, Json.Serializable>,
 		store: Store = IMPLICIT.STORE,
-	): AtomIO.AtomToken<typeof this.Update | null> {
+	): AtomToken<typeof this.Update | null> {
 		const latestUpdateStateKey = `*${mutableState.key}`
 		deleteAtom(latestUpdateStateKey, target(store))
-		const familyMetaData: AtomIO.FamilyMetadata | undefined = mutableState.family
+		const familyMetaData: FamilyMetadata | undefined = mutableState.family
 			? {
 					key: `*${mutableState.family.key}`,
 					subKey: mutableState.family.subKey,
@@ -43,11 +44,11 @@ export class Tracker<Mutable extends Transceiver<any>> {
 
 	private unsubscribeFromInnerValue: (() => void) | null = null
 	private observeCore(
-		mutableState: AtomIO.MutableAtomToken<Mutable, Json.Serializable>,
-		latestUpdateState: AtomIO.AtomToken<typeof this.Update | null>,
+		mutableState: MutableAtomToken<Mutable, Json.Serializable>,
+		latestUpdateState: AtomToken<typeof this.Update | null>,
 		store: Store = IMPLICIT.STORE,
 	): void {
-		const originalInnerValue = AtomIO.getState(mutableState, store)
+		const originalInnerValue = getState(mutableState, store)
 		this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
 			`tracker:${store.config.name}:${
 				store.transactionStatus.phase === `idle`
@@ -59,12 +60,12 @@ export class Tracker<Mutable extends Transceiver<any>> {
 					mutableState.key,
 					() => {
 						unsubscribe()
-						AtomIO.setState(latestUpdateState, update, store)
+						setState(latestUpdateState, update, store)
 					},
 				)
 			},
 		)
-		AtomIO.subscribe(
+		subscribe(
 			mutableState,
 			(update) => {
 				if (update.newValue !== update.oldValue) {
@@ -80,7 +81,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 								mutableState.key,
 								() => {
 									unsubscribe()
-									AtomIO.setState(latestUpdateState, update, store)
+									setState(latestUpdateState, update, store)
 								},
 							)
 						},
@@ -93,11 +94,11 @@ export class Tracker<Mutable extends Transceiver<any>> {
 	}
 
 	private updateCore<Core extends Transceiver<any>>(
-		mutableState: AtomIO.MutableAtomToken<Core, Json.Serializable>,
-		latestUpdateState: AtomIO.AtomToken<typeof this.Update | null>,
+		mutableState: MutableAtomToken<Core, Json.Serializable>,
+		latestUpdateState: AtomToken<typeof this.Update | null>,
 		store: Store = IMPLICIT.STORE,
 	): void {
-		AtomIO.subscribe(
+		subscribe(
 			latestUpdateState,
 			({ newValue, oldValue }) => {
 				const timelineId = store.timelineAtoms.getRelatedKey(
@@ -106,11 +107,11 @@ export class Tracker<Mutable extends Transceiver<any>> {
 				if (timelineId) {
 					const timelineData = store.timelines.get(timelineId)
 					if (timelineData?.timeTraveling) {
-						const unsubscribe = AtomIO.subscribeToTimeline(
+						const unsubscribe = subscribeToTimeline(
 							{ key: timelineId, type: `timeline` },
 							(update) => {
 								unsubscribe()
-								AtomIO.setState(
+								setState(
 									mutableState,
 									(transceiver) => {
 										if (update === `redo` && newValue) {
@@ -133,7 +134,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 					() => {
 						unsubscribe()
 						if (newValue) {
-							AtomIO.setState(
+							setState(
 								mutableState,
 								(transceiver) => (transceiver.do(newValue), transceiver),
 								store,
@@ -147,11 +148,11 @@ export class Tracker<Mutable extends Transceiver<any>> {
 		)
 	}
 
-	public mutableState: AtomIO.MutableAtomToken<Mutable, Json.Serializable>
-	public latestUpdateState: AtomIO.AtomToken<typeof this.Update | null>
+	public mutableState: MutableAtomToken<Mutable, Json.Serializable>
+	public latestUpdateState: AtomToken<typeof this.Update | null>
 
 	public constructor(
-		mutableState: AtomIO.MutableAtomToken<Mutable, Json.Serializable>,
+		mutableState: MutableAtomToken<Mutable, Json.Serializable>,
 		store: Store = IMPLICIT.STORE,
 	) {
 		this.mutableState = mutableState

package/internal/src/operation.ts

@@ -16,13 +16,16 @@ export type OperationProgress =
 			token: StateToken<any>
 	  }
 
-export const openOperation = (token: StateToken<any>, store: Store): void => {
+export const openOperation = (
+	token: StateToken<any>,
+	store: Store,
+): `rejection` | undefined => {
 	const core = target(store)
 	if (core.operation.open) {
 		store.config.logger?.error(
 			`❌ failed to setState to "${token.key}" during a setState for "${core.operation.token.key}"`,
 		)
-		throw Symbol(`violation`)
+		return `rejection`
 	}
 	core.operation = {
 		open: true,

package/internal/src/selector/create-read-write-selector.ts

@@ -26,14 +26,14 @@ export const createReadWriteSelector = <T>(
 
 	const setSelf = (next: T | ((oldValue: T) => T)): void => {
 		const oldValue = getSelf()
+		const newValue = become(next)(oldValue)
 		store.config.logger?.info(
 			`   <- "${options.key}" went (`,
 			oldValue,
 			`->`,
-			next,
+			newValue,
 			`)`,
 		)
-		const newValue = become(next)(oldValue)
 		cacheValue(options.key, newValue, subject, store)
 		markDone(options.key, store)
 		if (store.transactionStatus.phase === `idle`) {

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

@@ -18,7 +18,7 @@ export const registerSelector = (
 			.some(([_, { source }]) => source === dependency.key)
 
 		const dependencyState = withdraw(dependency, store)
-		if (dependencyState === null) {
+		if (dependencyState === undefined) {
 			throw new Error(
 				`State "${dependency.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`,
 			)
@@ -51,7 +51,7 @@ export const registerSelector = (
 	},
 	set: (stateToken, newValue) => {
 		const state = withdraw(stateToken, store)
-		if (state === null) {
+		if (state === undefined) {
 			throw new Error(
 				`State "${stateToken.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`,
 			)

package/internal/src/set-state/{set-atom-state.ts → set-atom.ts}

@@ -11,7 +11,7 @@ import { emitUpdate } from "./emit-update"
 import { evictDownStream } from "./evict-downstream"
 import { stowUpdate } from "./stow-update"
 
-export const setAtomState = <T>(
+export const setAtom = <T>(
 	atom: Atom<T>,
 	next: T | ((oldValue: T) => T),
 	store: Store = IMPLICIT.STORE,

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

@@ -1,19 +1,8 @@
-import { getState__INTERNAL } from "../get-state-internal"
 import type { Selector } from "../selector"
-import type { Store } from "../store"
-import { IMPLICIT } from "../store"
-import { become } from "./become"
 
 export const setSelectorState = <T>(
 	selector: Selector<T>,
 	next: T | ((oldValue: T) => T),
-	store: Store = IMPLICIT.STORE,
 ): void => {
-	const oldValue = getState__INTERNAL(selector, store)
-	const newValue = become(next)(oldValue)
-
-	store.config.logger?.info(`<< setting selector "${selector.key}" to`, newValue)
-	store.config.logger?.info(`   || propagating change made to "${selector.key}"`)
-
-	selector.set(newValue)
+	selector.set(next)
 }

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

@@ -2,17 +2,16 @@ import type { Atom } from "../atom"
 import type { Selector } from "../selector"
 import type { Store } from "../store"
 import { IMPLICIT } from "../store"
-import { setAtomState } from "./set-atom-state"
-import { setSelectorState } from "./set-selector-state"
+import { setAtom } from "./set-atom"
 
 export const setState__INTERNAL = <T>(
 	state: Atom<T> | Selector<T>,
 	value: T | ((oldValue: T) => T),
 	store: Store = IMPLICIT.STORE,
 ): void => {
-	if (`set` in state) {
-		setSelectorState(state, value, store)
+	if (state.type === `selector`) {
+		state.set(value)
 	} else {
-		setAtomState(state, value, store)
+		setAtom(state, value, store)
 	}
 }

package/internal/src/store/withdraw-new-family-member.ts

@@ -11,23 +11,23 @@ import { target } from "../transaction"
 export function withdrawNewFamilyMember<T>(
 	token: AtomToken<T>,
 	store: Store,
-): Atom<T> | null
+): Atom<T> | undefined
 export function withdrawNewFamilyMember<T>(
 	token: SelectorToken<T>,
 	store: Store,
-): Selector<T> | null
+): Selector<T> | undefined
 export function withdrawNewFamilyMember<T>(
 	token: ReadonlySelectorToken<T>,
 	store: Store,
-): ReadonlySelector<T> | null
+): ReadonlySelector<T> | undefined
 export function withdrawNewFamilyMember<T>(
 	token: StateToken<T>,
 	store: Store,
-): Atom<T> | Selector<T> | null
+): Atom<T> | Selector<T> | undefined
 export function withdrawNewFamilyMember<T>(
 	token: ReadonlySelectorToken<T> | StateToken<T>,
 	store: Store,
-): Atom<T> | ReadonlySelector<T> | Selector<T> | null
+): Atom<T> | ReadonlySelector<T> | Selector<T> | undefined
 export function withdrawNewFamilyMember<T>(
 	token:
 		| AtomToken<T>
@@ -35,7 +35,7 @@ export function withdrawNewFamilyMember<T>(
 		| SelectorToken<T>
 		| StateToken<T>,
 	store: Store,
-): Atom<T> | ReadonlySelector<T> | Selector<T> | null {
+): Atom<T> | ReadonlySelector<T> | Selector<T> | undefined {
 	store.config.logger?.info(
 		`👪 creating new family member "${token.key}" in store "${store.config.name}"`,
 	)
@@ -49,5 +49,5 @@ export function withdrawNewFamilyMember<T>(
 			return state
 		}
 	}
-	return null
+	return undefined
 }

package/internal/src/store/withdraw.ts

@@ -16,28 +16,34 @@ import type { Transaction } from "../transaction"
 import { target } from "../transaction"
 import type { Store } from "./store"
 
-export function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T> | null
+export function withdraw<T>(
+	token: AtomToken<T>,
+	store: Store,
+): Atom<T> | undefined
 export function withdraw<T>(
 	token: SelectorToken<T>,
 	store: Store,
-): Selector<T> | null
+): Selector<T> | undefined
 export function withdraw<T>(
 	token: StateToken<T>,
 	store: Store,
-): Atom<T> | Selector<T> | null
+): Atom<T> | Selector<T> | undefined
 export function withdraw<T>(
 	token: ReadonlySelectorToken<T>,
 	store: Store,
-): ReadonlySelector<T> | null
+): ReadonlySelector<T> | undefined
 export function withdraw<T>(
 	token: TransactionToken<T>,
 	store: Store,
-): Transaction<T extends ƒn ? T : never> | null
+): Transaction<T extends ƒn ? T : never> | undefined
 export function withdraw<T>(
 	token: ReadonlySelectorToken<T> | StateToken<T>,
 	store: Store,
-): Atom<T> | ReadonlySelector<T> | Selector<T> | null
-export function withdraw<T>(token: TimelineToken, store: Store): Timeline | null
+): Atom<T> | ReadonlySelector<T> | Selector<T> | undefined
+export function withdraw<T>(
+	token: TimelineToken,
+	store: Store,
+): Timeline | undefined
 export function withdraw<T>(
 	token:
 		| ReadonlySelectorToken<T>
@@ -51,7 +57,7 @@ export function withdraw<T>(
 	| Selector<T>
 	| Timeline
 	| Transaction<T extends ƒn ? T : never>
-	| null {
+	| undefined {
 	let core = target(store)
 	let state =
 		core.atoms.get(token.key) ??
@@ -109,5 +115,5 @@ export function withdraw<T>(
 			return state
 		}
 	}
-	return null
+	return undefined
 }

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

@@ -14,7 +14,7 @@ export const subscribeToRootAtoms = <T>(
 			? null
 			: traceAllSelectorAtoms(state.key, store).map((atomToken) => {
 					const atom = withdraw(atomToken, store)
-					if (atom === null) {
+					if (atom === undefined) {
 						throw new Error(
 							`Atom "${atomToken.key}", a dependency of selector "${state.key}", not found in store "${store.config.name}".`,
 						)

package/internal/src/timeline/add-atom-to-timeline.ts

@@ -15,7 +15,7 @@ export const addAtomToTimeline = (
 	store: Store = IMPLICIT.STORE,
 ): void => {
 	const atom = withdraw(atomToken, store)
-	if (atom === null) {
+	if (atom === undefined) {
 		throw new Error(
 			`Cannot subscribe to atom "${atomToken.key}" because it has not been initialized in store "${store.config.name}"`,
 		)
@@ -67,7 +67,7 @@ export const addAtomToTimeline = (
 					{ key: currentTransactionKey, type: `transaction` },
 					store,
 				)
-				if (currentTransaction === null) {
+				if (currentTransaction === undefined) {
 					throw new Error(
 						`Transaction "${currentTransactionKey}" not found in store "${store.config.name}". This is surprising, because we are in the application phase of "${currentTransactionKey}".`,
 					)

package/internal/src/transaction/apply-transaction.ts

@@ -48,7 +48,7 @@ export const applyTransaction = <ƒ extends ƒn>(
 		{ key: store.transactionStatus.key, type: `transaction` },
 		store,
 	)
-	if (myTransaction === null) {
+	if (myTransaction === undefined) {
 		throw new Error(
 			`Transaction "${store.transactionStatus.key}" not found. Absurd. How is this running?`,
 		)

package/internal/src/transaction/redo-transaction.ts

@@ -12,7 +12,7 @@ export const redoTransactionUpdate = <ƒ extends ƒn>(
 	for (const { key, newValue } of update.atomUpdates) {
 		const token: AtomToken<unknown> = { key, type: `atom` }
 		const state = withdraw(token, store)
-		if (state === null) {
+		if (state === undefined) {
 			throw new Error(
 				`State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`,
 			)

package/internal/src/transaction/undo-transaction.ts

@@ -12,7 +12,7 @@ export const undoTransactionUpdate = <ƒ extends ƒn>(
 	for (const { key, oldValue } of update.atomUpdates) {
 		const token: AtomToken<unknown> = { key, type: `atom` }
 		const state = withdraw(token, store)
-		if (state === null) {
+		if (state === undefined) {
 			throw new Error(
 				`State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`,
 			)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "Reactive state graph for React, Preact, and vanilla",
   "peerDependencies": {
     "@floating-ui/react": ">=0.25.0",
@@ -38,13 +38,13 @@
     "@emotion/react": "11.11.1",
     "@testing-library/react": "14.0.0",
     "@types/mock-fs": "4.13.2",
-    "@types/react": "18.2.25",
+    "@types/react": "18.2.28",
     "@types/tmp": "0.2.4",
     "@vitest/coverage-v8": "0.34.6",
     "concurrently": "8.2.1",
-    "eslint": "8.50.0",
+    "eslint": "8.51.0",
     "framer-motion": "10.16.4",
-    "happy-dom": "12.8.0",
+    "happy-dom": "12.9.1",
     "preact": "10.18.1",
     "react": "18.2.0",
     "react-dom": "18.2.0",
@@ -78,9 +78,12 @@
     "react-devtools/dist",
     "react-devtools/package.json",
     "react-devtools/src",
-    "realtime/dist",
-    "realtime/package.json",
-    "realtime/src",
+    "realtime-client/dist",
+    "realtime-client/package.json",
+    "realtime-client/src",
+    "realtime-server/dist",
+    "realtime-server/package.json",
+    "realtime-server/src",
     "realtime-react/dist",
     "realtime-react/package.json",
     "realtime-react/src",
@@ -198,6 +201,6 @@
     "lint:eslint": "eslint .",
     "lint": "npm run lint:biome && npm run lint:eslint",
     "test": "vitest",
-    "test:once": "cross-env LIB=dist vitest run"
+    "test:once": "cross-env IMPORT=dist vitest run"
   }
 }

package/react-devtools/dist/index.d.mts

@@ -1,5 +1,5 @@
 import * as atom_io from 'atom.io';
-import { FamilyMetadata, ƒn, TransactionUpdate, StateToken, TimelineUpdate, StateUpdate, AtomFamily, ReadonlySelectorFamily, SelectorFamily, AtomToken, ReadonlySelectorToken, SelectorToken, TransactionToken, TimelineToken, Logger } from 'atom.io';
+import { FamilyMetadata, ƒn, TransactionUpdate, MutableAtomToken, AtomToken, StateToken, TimelineUpdate, StateUpdate, AtomFamily, ReadonlySelectorFamily, SelectorFamily, ReadonlySelectorToken, SelectorToken, TransactionToken, TimelineToken, Logger } from 'atom.io';
 import { Json } from 'atom.io/json';
 
 type ClassSignature = abstract new (...args: any) => any;
@@ -156,9 +156,9 @@ declare class Tracker<Mutable extends Transceiver<any>> {
     private unsubscribeFromInnerValue;
     private observeCore;
     private updateCore;
-    mutableState: atom_io.MutableAtomToken<Mutable, Json.Serializable>;
-    latestUpdateState: atom_io.AtomToken<typeof this$1.Update | null>;
-    constructor(mutableState: atom_io.MutableAtomToken<Mutable, Json.Serializable>, store?: Store);
+    mutableState: MutableAtomToken<Mutable, Json.Serializable>;
+    latestUpdateState: AtomToken<typeof this$1.Update | null>;
+    constructor(mutableState: MutableAtomToken<Mutable, Json.Serializable>, store?: Store);
 }
 
 interface MutableAtom<T> extends Atom<T> {

package/react-devtools/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as atom_io from 'atom.io';
-import { FamilyMetadata, ƒn, TransactionUpdate, StateToken, TimelineUpdate, StateUpdate, AtomFamily, ReadonlySelectorFamily, SelectorFamily, AtomToken, ReadonlySelectorToken, SelectorToken, TransactionToken, TimelineToken, Logger } from 'atom.io';
+import { FamilyMetadata, ƒn, TransactionUpdate, MutableAtomToken, AtomToken, StateToken, TimelineUpdate, StateUpdate, AtomFamily, ReadonlySelectorFamily, SelectorFamily, ReadonlySelectorToken, SelectorToken, TransactionToken, TimelineToken, Logger } from 'atom.io';
 import { Json } from 'atom.io/json';
 
 type ClassSignature = abstract new (...args: any) => any;
@@ -156,9 +156,9 @@ declare class Tracker<Mutable extends Transceiver<any>> {
     private unsubscribeFromInnerValue;
     private observeCore;
     private updateCore;
-    mutableState: atom_io.MutableAtomToken<Mutable, Json.Serializable>;
-    latestUpdateState: atom_io.AtomToken<typeof this$1.Update | null>;
-    constructor(mutableState: atom_io.MutableAtomToken<Mutable, Json.Serializable>, store?: Store);
+    mutableState: MutableAtomToken<Mutable, Json.Serializable>;
+    latestUpdateState: AtomToken<typeof this$1.Update | null>;
+    constructor(mutableState: MutableAtomToken<Mutable, Json.Serializable>, store?: Store);
 }
 
 interface MutableAtom<T> extends Atom<T> {

package/react-devtools/dist/index.js

@@ -1784,9 +1784,9 @@ var StringEditor = ({
   ) });
 };
 var DefaultFallback = ({ error, errorInfo }) => {
-  var _a2, _b;
-  const component = errorInfo == null ? void 0 : errorInfo.componentStack.split(` `).filter(Boolean)[2];
-  const message = (_b = (_a2 = error == null ? void 0 : error.toString()) != null ? _a2 : errorInfo == null ? void 0 : errorInfo.componentStack) != null ? _b : `Unknown error`;
+  var _a2, _b, _c;
+  const component = (_a2 = errorInfo == null ? void 0 : errorInfo.componentStack) == null ? void 0 : _a2.split(` `).filter(Boolean)[2];
+  const message = (_c = (_b = error == null ? void 0 : error.toString()) != null ? _b : errorInfo == null ? void 0 : errorInfo.componentStack) != null ? _c : `Unknown error`;
   return /* @__PURE__ */ jsxRuntime.jsx(
     "div",
     {