atom.io 0.15.6 → 0.16.1

package/internal/dist/index.d.ts

@@ -1,11 +1,12 @@
-import { FamilyMetadata as FamilyMetadata$1, SelectorOptions, SelectorToken, ReadonlySelectorOptions, ReadonlySelectorToken, Transactors, WritableToken, ƒn as _n, TransactionUpdate, TransactionOptions, TransactionToken, TransactorsWithRunAndEnv, AtomToken, ReadableToken, MutableAtomOptions, MutableAtomToken, MutableAtomFamilyOptions, MutableAtomFamily, SelectorFamily, AtomFamily, TimelineManageable, StateUpdate, TokenType, TimelineUpdate, TimelineOptions, TimelineToken, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomOptions, AtomFamilyOptions, ReadonlySelectorFamilyOptions, SelectorFamilyOptions, KeyedStateUpdate, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
-import { Json } from 'atom.io/json';
+import { ƒn as _n, TransactionUpdate, TransactionOptions, TransactionToken, TransactorsWithRunAndEnv, RegularAtomToken, MutableAtomToken, WritableSelectorToken, ReadonlySelectorToken, WritableToken, ReadableToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, TimelineUpdate, TimelineOptions, TimelineToken, AtomToken, WritableSelectorFamily, MutableAtomFamily, RegularAtomFamily, ReadonlySelectorFamily, AtomIOLogger, Logger, SelectorToken, MutableAtomOptions, MutableAtomFamilyOptions, AtomFamily, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, KeyedStateUpdate, ReadonlySelectorOptions, WritableSelectorOptions, Transactors, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
+import { Json, JsonInterface } from 'atom.io/json';
 import { Store as Store$1 } from 'atom.io/internal';
 
-type FamilyMetadata = {
-    key: string;
-    subKey: string;
-};
+declare const abortTransaction: (store: Store) => void;
+
+declare const applyTransaction: <ƒ extends _n>(output: ReturnType<ƒ>, store: Store) => void;
+
+declare const buildTransaction: (key: string, params: any[], store: Store, id?: string) => void;
 
 declare class Subject<T> {
     Subscriber: (value: T) => void;
@@ -20,67 +21,6 @@ declare class StatefulSubject<T> extends Subject<T> {
     next(value: T): void;
 }
 
-type Selector<T> = {
-    key: string;
-    type: `selector`;
-    family?: FamilyMetadata$1;
-    install: (store: Store) => void;
-    subject: Subject<{
-        newValue: T;
-        oldValue: T;
-    }>;
-    get: () => T;
-    set: (newValue: T | ((oldValue: T) => T)) => void;
-};
-type ReadonlySelector<T> = {
-    key: string;
-    type: `readonly_selector`;
-    family?: FamilyMetadata$1;
-    install: (store: Store) => void;
-    subject: Subject<{
-        newValue: T;
-        oldValue: T;
-    }>;
-    get: () => T;
-};
-declare function createSelector<T>(options: SelectorOptions<T>, family: FamilyMetadata$1 | undefined, store: Store): SelectorToken<T>;
-declare function createSelector<T>(options: ReadonlySelectorOptions<T>, family: FamilyMetadata$1 | undefined, store: Store): ReadonlySelectorToken<T>;
-
-declare function deleteSelector(selectorToken: ReadonlySelectorToken<unknown> | SelectorToken<unknown>, store: Store): void;
-
-type AtomKey<T> = string & {
-    __atomKey?: never;
-    __brand?: T;
-};
-type SelectorKey<T> = string & {
-    __selectorKey?: never;
-    __brand?: T;
-};
-type ReadonlySelectorKey<T> = string & {
-    __readonlySelectorKey?: never;
-    __brand?: T;
-};
-declare const isAtomKey: (key: string, store: Store) => key is AtomKey<unknown>;
-declare const isSelectorKey: (key: string, store: Store) => key is SelectorKey<unknown>;
-declare const isReadonlySelectorKey: (key: string, store: Store) => key is ReadonlySelectorKey<unknown>;
-type StateKey<T> = AtomKey<T> | ReadonlySelectorKey<T> | SelectorKey<T>;
-declare const isStateKey: (key: string, store: Store) => key is StateKey<unknown>;
-
-declare const getSelectorDependencyKeys: (key: string, store: Store) => (AtomKey<unknown> | ReadonlySelectorKey<unknown> | SelectorKey<unknown>)[];
-
-declare const registerSelector: (selectorKey: string, store: Store) => Transactors;
-
-declare const traceSelectorAtoms: (selectorKey: string, directDependencyKey: StateKey<unknown>, store: Store) => AtomKey<unknown>[];
-declare const traceAllSelectorAtoms: (selectorKey: string, store: Store) => AtomKey<unknown>[];
-
-declare const updateSelectorAtoms: (selectorKey: string, dependency: ReadonlySelectorToken<unknown> | WritableToken<unknown>, store: Store) => void;
-
-declare const abortTransaction: (store: Store) => void;
-
-declare const applyTransaction: <ƒ extends _n>(output: ReturnType<ƒ>, store: Store) => void;
-
-declare const buildTransaction: (key: string, params: any[], store: Store, id?: string) => void;
-
 type Transaction<ƒ extends _n> = {
     key: string;
     type: `transaction`;
@@ -99,12 +39,13 @@ type TransactionMeta<ƒ extends _n> = {
     transactors: TransactorsWithRunAndEnv;
 };
 
-declare function deposit<T>(state: Atom<T>): AtomToken<T>;
-declare function deposit<T>(state: Selector<T>): SelectorToken<T>;
-declare function deposit<T>(state: Atom<T> | Selector<T>): WritableToken<T>;
+declare function deposit<T>(state: RegularAtom<T>): RegularAtomToken<T>;
+declare function deposit<T extends Transceiver<any>>(state: MutableAtom<T, any>): MutableAtomToken<T, any>;
+declare function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T>;
 declare function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>;
+declare function deposit<T>(state: WritableState<T>): WritableToken<T>;
 declare function deposit<T>(state: Transaction<T extends _n ? T : never>): TransactionToken<T>;
-declare function deposit<T>(state: StateNode<T>): ReadableToken<T>;
+declare function deposit<T>(state: ReadableState<T>): ReadableToken<T>;
 
 type primitive = boolean | number | string | null;
 
@@ -185,59 +126,6 @@ interface Lineage {
     child: typeof this | null;
 }
 declare function newest<T extends Lineage>(scion: T): T;
-declare function eldest<T extends Lineage>(scion: T): T;
-
-interface Transceiver<Signal extends Json.Serializable> {
-    do: (update: Signal) => void;
-    undo: (update: Signal) => void;
-    subscribe: (key: string, fn: (update: Signal) => void) => () => void;
-    cacheUpdateNumber: number;
-    getUpdateNumber: (update: Signal) => number;
-}
-declare function isTransceiver(value: unknown): value is Transceiver<Json.Serializable>;
-type TransceiverMode = `playback` | `record` | `transaction`;
-type Signal<TVR extends Transceiver<any>> = TVR extends Transceiver<infer Signal> ? Signal : never;
-
-declare function createMutableAtom<Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(options: MutableAtomOptions<Core, SerializableCore>, family: FamilyMetadata$1 | undefined, store: Store): MutableAtomToken<Core, SerializableCore>;
-
-declare function createMutableAtomFamily<Core extends Transceiver<any>, SerializableCore extends Json.Serializable, Key extends string>(options: MutableAtomFamilyOptions<Core, SerializableCore, Key>, store: Store): MutableAtomFamily<Core, SerializableCore, Key>;
-
-declare const getJsonFamily: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable, Key extends string>(mutableAtomFamily: MutableAtomFamily<Core, SerializableCore, Key>, store: Store) => SelectorFamily<SerializableCore, Key>;
-
-declare const getJsonToken: <Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => SelectorToken<SerializableCore>;
-
-declare const getUpdateToken: <Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => AtomToken<Signal<Core>>;
-
-declare const getUpdateFamily: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable, Key extends string>(mutableAtomFamily: MutableAtomFamily<Core, SerializableCore, Key>, store: Store) => AtomFamily<Signal<Core> | null, Key>;
-
-/**
- * @internal Give the tracker a transceiver state and a store, and it will
- * subscribe to the transceiver's inner value. When the inner value changes,
- * the tracker will update its own state to reflect the change.
- */
-declare class Tracker<Mutable extends Transceiver<any>> {
-    private Update;
-    private initializeState;
-    private unsubscribeFromInnerValue;
-    private unsubscribeFromState;
-    private observeCore;
-    private updateCore;
-    mutableState: MutableAtomToken<Mutable, Json.Serializable>;
-    latestUpdateState: AtomToken<typeof this.Update | null>;
-    dispose: () => void;
-    constructor(mutableState: MutableAtomToken<Mutable, Json.Serializable>, store: Store);
-}
-
-declare class FamilyTracker<Core extends Transceiver<any>, FamilyMemberKey extends Json.Serializable> {
-    private readonly Update;
-    readonly findLatestUpdateState: AtomFamily<typeof this.Update | null, FamilyMemberKey>;
-    readonly findMutableState: AtomFamily<Core, FamilyMemberKey>;
-    constructor(findMutableState: AtomFamily<Core, FamilyMemberKey>, store: Store);
-}
-
-interface MutableAtom<T> extends Atom<T> {
-    mutable: true;
-}
 
 type OperationProgress = {
     open: false;
@@ -257,7 +145,7 @@ type TimelineAtomUpdate<ManagedAtom extends TimelineManageable> = StateUpdate<To
     key: string;
     type: `atom_update`;
     timestamp: number;
-    family?: FamilyMetadata$1;
+    family?: FamilyMetadata;
 };
 type TimelineSelectorUpdate<ManagedAtom extends TimelineManageable> = {
     key: string;
@@ -292,11 +180,11 @@ declare class Store implements Lineage {
     parent: Store | null;
     child: Store | null;
     valueMap: Map<string, any>;
-    atoms: Map<string, Atom<any> | MutableAtom<any>>;
-    selectors: Map<string, Selector<any>>;
+    atoms: Map<string, Atom<any>>;
+    selectors: Map<string, WritableSelector<any>>;
     readonlySelectors: Map<string, ReadonlySelector<any>>;
     trackers: Map<string, Tracker<Transceiver<any>>>;
-    families: Map<string, AtomFamily<any, any> | ReadonlySelectorFamily<any, any> | SelectorFamily<any, any>>;
+    families: Map<string, WritableSelectorFamily<any, any> | MutableAtomFamily<any, any, any> | RegularAtomFamily<any, any> | ReadonlySelectorFamily<any, any>>;
     timelines: Map<string, Timeline<any>>;
     transactions: Map<string, Transaction<_n>>;
     atomsThatAreDefault: Set<string>;
@@ -307,7 +195,7 @@ declare class Store implements Lineage {
     }>;
     on: {
         atomCreation: Subject<AtomToken<unknown>>;
-        selectorCreation: Subject<ReadonlySelectorToken<unknown> | SelectorToken<unknown>>;
+        selectorCreation: Subject<ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>>;
         transactionCreation: Subject<TransactionToken<_n>>;
         timelineCreation: Subject<TimelineToken<unknown>>;
         transactionApplying: StatefulSubject<TransactionMeta<_n> | null>;
@@ -328,44 +216,84 @@ declare const IMPLICIT: {
 };
 declare const clearStore: (store: Store) => void;
 
+type Withdrawable = ReadableState<any> | Timeline<any> | Transaction<any>;
+declare function withdraw<T>(token: RegularAtomToken<T>, store: Store): RegularAtom<T> | undefined;
+declare function withdraw<T extends Transceiver<any>>(token: MutableAtomToken<T, any>, store: Store): MutableAtom<T, any> | undefined;
 declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T> | undefined;
-declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T> | undefined;
-declare function withdraw<T>(token: WritableToken<T>, store: Store): Atom<T> | Selector<T> | undefined;
+declare function withdraw<T>(token: WritableSelectorToken<T>, store: Store): WritableSelector<T> | undefined;
 declare function withdraw<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T> | undefined;
+declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T> | undefined;
+declare function withdraw<T>(token: WritableToken<T>, store: Store): WritableState<T> | undefined;
+declare function withdraw<T>(token: ReadableToken<T>, store: Store): ReadableState<T> | undefined;
 declare function withdraw<T>(token: TransactionToken<T>, store: Store): Transaction<T extends _n ? T : never> | undefined;
-declare function withdraw<T>(token: ReadableToken<T>, store: Store): StateNode<T> | undefined;
 declare function withdraw<T>(token: TimelineToken<T>, store: Store): Timeline<T extends TimelineManageable ? T : never> | undefined;
 
-declare function withdrawNewFamilyMember<T>(token: AtomToken<T>, store: Store): Atom<T> | undefined;
-declare function withdrawNewFamilyMember<T>(token: SelectorToken<T>, store: Store): Selector<T> | undefined;
+declare function withdrawNewFamilyMember<T>(token: RegularAtomToken<T>, store: Store): Atom<T> | undefined;
+declare function withdrawNewFamilyMember<T>(token: WritableSelectorToken<T>, store: Store): WritableSelector<T> | undefined;
 declare function withdrawNewFamilyMember<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T> | undefined;
-declare function withdrawNewFamilyMember<T>(token: WritableToken<T>, store: Store): Atom<T> | Selector<T> | undefined;
-declare function withdrawNewFamilyMember<T>(token: ReadableToken<T>, store: Store): StateNode<T> | undefined;
+declare function withdrawNewFamilyMember<T>(token: WritableToken<T>, store: Store): WritableState<T> | undefined;
+declare function withdrawNewFamilyMember<T>(token: ReadableToken<T>, store: Store): ReadableState<T> | undefined;
 
-declare function createAtom<T>(options: AtomOptions<T> | MutableAtomOptions<any, any>, family: FamilyMetadata$1 | undefined, store: Store): AtomToken<T>;
+interface Transceiver<Signal extends Json.Serializable> {
+    do: (update: Signal) => void;
+    undo: (update: Signal) => void;
+    subscribe: (key: string, fn: (update: Signal) => void) => () => void;
+    cacheUpdateNumber: number;
+    getUpdateNumber: (update: Signal) => number;
+}
+declare function isTransceiver(value: unknown): value is Transceiver<Json.Serializable>;
+type TransceiverMode = `playback` | `record` | `transaction`;
+type Signal<TVR extends Transceiver<any>> = TVR extends Transceiver<infer Signal> ? Signal : never;
+
+declare function createMutableAtom<T extends Transceiver<any>, J extends Json.Serializable>(options: MutableAtomOptions<T, J>, family: FamilyMetadata | undefined, store: Store): MutableAtomToken<T, J>;
+
+declare function createMutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends string>(options: MutableAtomFamilyOptions<T, J, K>, store: Store): MutableAtomFamily<T, J, K>;
+
+declare const getJsonFamily: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable, Key extends string>(mutableAtomFamily: MutableAtomFamily<Core, SerializableCore, Key>, store: Store) => WritableSelectorFamily<SerializableCore, Key>;
 
-declare function createRegularAtom<T>(options: AtomOptions<T> | MutableAtomOptions<any, any>, family: FamilyMetadata$1 | undefined, store: Store): AtomToken<T>;
+declare const getJsonToken: <Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => WritableSelectorToken<SerializableCore>;
 
-declare function deleteAtom(atomToken: AtomToken<unknown>, store: Store): void;
+declare const getUpdateToken: <Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => RegularAtomToken<Signal<Core>>;
+
+declare function isMutable(atom: Atom<any>): atom is MutableAtom<any, any>;
+declare function isMutable(family: AtomFamily<any, any>): family is MutableAtomFamily<any, any, any>;
+
+/**
+ * @internal Give the tracker a transceiver state and a store, and it will
+ * subscribe to the transceiver's inner value. When the inner value changes,
+ * the tracker will update its own state to reflect the change.
+ */
+declare class Tracker<Mutable extends Transceiver<any>> {
+    private Update;
+    private initializeState;
+    private unsubscribeFromInnerValue;
+    private unsubscribeFromState;
+    private observeCore;
+    private updateCore;
+    mutableState: MutableAtomToken<Mutable, Json.Serializable>;
+    latestUpdateState: RegularAtomToken<typeof this.Update | null>;
+    dispose: () => void;
+    constructor(mutableState: MutableAtomToken<Mutable, Json.Serializable>, store: Store);
+}
+
+declare class FamilyTracker<Core extends Transceiver<any>, FamilyMemberKey extends Json.Serializable> {
+    private readonly Update;
+    readonly findLatestUpdateState: RegularAtomFamily<typeof this.Update | null, FamilyMemberKey>;
+    readonly findMutableState: MutableAtomFamily<Core, any, FamilyMemberKey>;
+    constructor(findMutableState: MutableAtomFamily<Core, any, FamilyMemberKey>, store: Store);
+}
+
+declare function createStandaloneAtom<T>(options: RegularAtomOptions<T>, store: Store): RegularAtomToken<T>;
+declare function createStandaloneAtom<T extends Transceiver<any>, J extends Json.Serializable>(options: MutableAtomOptions<T, J>, store: Store): MutableAtomToken<T, J>;
+
+declare function createRegularAtom<T>(options: MutableAtomOptions<any, any> | RegularAtomOptions<T>, family: FamilyMetadata | undefined, store: Store): RegularAtomToken<T>;
+
+declare function deleteAtom(atomToken: RegularAtomToken<unknown>, store: Store): void;
 
 declare const isAtomDefault: (key: string, store: Store) => boolean;
 declare const markAtomAsDefault: (key: string, store: Store) => void;
 declare const markAtomAsNotDefault: (key: string, store: Store) => void;
 
-type Atom<T> = {
-    key: string;
-    type: `atom`;
-    mutable?: boolean;
-    family?: FamilyMetadata;
-    install: (store: Store) => void;
-    subject: Subject<{
-        newValue: T;
-        oldValue: T;
-    }>;
-    default: T | (() => T);
-    cleanup?: () => void;
-};
-
 /**
  * A Promise that can be canceled.
  * @internal
@@ -383,17 +311,17 @@ declare class Future<T> extends Promise<T> {
 
 declare function cacheValue<T>(key: string, value: T, subject: Subject<StateUpdate<unknown>>, store: Store): T;
 declare function cacheValue<T extends Promise<any>>(key: string, value: T, subject: Subject<StateUpdate<unknown>>, store: Store): Future<T>;
-declare const readCachedValue: <T>(token: StateNode<any>, target: Store) => T;
+declare const readCachedValue: <T>(token: ReadableState<any>, target: Store) => T;
 declare const evictCachedValue: (key: string, target: Store) => void;
 
 declare function createAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(options: MutableAtomFamilyOptions<T, J, K>, store: Store): MutableAtomFamily<T, J, K>;
-declare function createAtomFamily<T, K extends Json.Serializable>(options: AtomFamilyOptions<T, K>, store: Store): AtomFamily<T, K>;
+declare function createAtomFamily<T, K extends Json.Serializable>(options: RegularAtomFamilyOptions<T, K>, store: Store): RegularAtomFamily<T, K>;
 
-declare function createRegularAtomFamily<T, K extends Json.Serializable>(options: AtomFamilyOptions<T, K> | MutableAtomFamilyOptions<any, any, K>, store: Store): AtomFamily<T, K>;
+declare function createRegularAtomFamily<T, K extends Json.Serializable>(options: RegularAtomFamilyOptions<T, K>, store: Store): RegularAtomFamily<T, K>;
 
 declare function createReadonlySelectorFamily<T, K extends Json.Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamily<T, K>;
 
-declare function createSelectorFamily<T, K extends Json.Serializable>(options: SelectorFamilyOptions<T, K>, store: Store): SelectorFamily<T, K>;
+declare function createSelectorFamily<T, K extends Json.Serializable>(options: WritableSelectorFamilyOptions<T, K>, store: Store): WritableSelectorFamily<T, K>;
 declare function createSelectorFamily<T, K extends Json.Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamily<T, K>;
 
 type EnvironmentData = {
@@ -408,6 +336,24 @@ declare function ingestSelectorUpdate(applying: `newValue` | `oldValue`, selecto
 
 declare function ingestTransactionUpdate(applying: `newValue` | `oldValue`, transactionUpdate: TransactionUpdate<any>, store: Store): void;
 
+type AtomKey<T> = string & {
+    __atomKey?: never;
+    __brand?: T;
+};
+type SelectorKey<T> = string & {
+    __selectorKey?: never;
+    __brand?: T;
+};
+type ReadonlySelectorKey<T> = string & {
+    __readonlySelectorKey?: never;
+    __brand?: T;
+};
+declare const isAtomKey: (key: string, store: Store) => key is AtomKey<unknown>;
+declare const isSelectorKey: (key: string, store: Store) => key is SelectorKey<unknown>;
+declare const isReadonlySelectorKey: (key: string, store: Store) => key is ReadonlySelectorKey<unknown>;
+type StateKey<T> = AtomKey<T> | ReadonlySelectorKey<T> | SelectorKey<T>;
+declare const isStateKey: (key: string, store: Store) => key is StateKey<unknown>;
+
 declare class LazyMap<K, V> extends Map<K, V> {
     protected readonly source: Map<K, V>;
     deleted: Set<K>;
@@ -423,14 +369,32 @@ declare class NotFoundError extends Error {
     constructor(token: ReadableToken<any>, store: Store);
 }
 
-declare const readOrComputeValue: <T>(state: StateNode<T>, target: Store) => T;
+declare const readOrComputeValue: <T>(state: ReadableState<T>, target: Store) => T;
+
+declare const createReadonlySelector: <T>(options: ReadonlySelectorOptions<T>, family: FamilyMetadata | undefined, store: Store) => ReadonlySelectorToken<T>;
+
+declare function createStandaloneSelector<T>(options: WritableSelectorOptions<T>, store: Store): WritableSelectorToken<T>;
+declare function createStandaloneSelector<T>(options: ReadonlySelectorOptions<T>, store: Store): ReadonlySelectorToken<T>;
+
+declare const createWritableSelector: <T>(options: WritableSelectorOptions<T>, family: FamilyMetadata | undefined, store: Store) => WritableSelectorToken<T>;
+
+declare function deleteSelector(selectorToken: ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>, store: Store): void;
+
+declare const getSelectorDependencyKeys: (key: string, store: Store) => (AtomKey<unknown> | ReadonlySelectorKey<unknown> | SelectorKey<unknown>)[];
+
+declare const registerSelector: (selectorKey: string, store: Store) => Transactors;
+
+declare const traceSelectorAtoms: (selectorKey: string, directDependencyKey: StateKey<unknown>, store: Store) => AtomKey<unknown>[];
+declare const traceAllSelectorAtoms: (selector: Selector<any>, store: Store) => AtomKey<unknown>[];
+
+declare const updateSelectorAtoms: (selectorKey: string, dependency: ReadonlySelectorToken<unknown> | WritableToken<unknown>, store: Store) => void;
 
 type Modify<T> = (thing: T) => T;
 declare const become: <T>(nextVersionOfThing: T | Modify<T>) => (originalThing: T) => T;
 
-declare const setAtomOrSelector: <T>(state: Atom<T> | Selector<T>, value: T | ((oldValue: T) => T), store: Store) => void;
+declare const setAtomOrSelector: <T>(state: WritableState<T>, value: T | ((oldValue: T) => T), store: Store) => void;
 
-declare const subscribeToRootAtoms: <T>(state: ReadonlySelector<T> | Selector<T>, store: Store) => (() => void)[] | null;
+declare const subscribeToRootAtoms: <T>(selector: Selector<T>, store: Store) => (() => void)[] | null;
 
 declare function subscribeToState<T>(token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key: string, store: Store): () => void;
 
@@ -438,6 +402,37 @@ declare const subscribeToTimeline: <ManagedAtom extends TimelineManageable>(toke
 
 declare const subscribeToTransaction: <ƒ extends _n>(token: TransactionToken<ƒ>, handleUpdate: TransactionUpdateHandler<ƒ>, key: string, store: Store$1) => (() => void);
 
-type StateNode<T> = Atom<T> | ReadonlySelector<T> | Selector<T>;
+type BaseStateData = {
+    key: string;
+    family?: FamilyMetadata;
+    install: (store: Store) => void;
+    subject: Subject<{
+        newValue: any;
+        oldValue: any;
+    }>;
+};
+type RegularAtom<T> = BaseStateData & {
+    type: `atom`;
+    default: T | (() => T);
+    cleanup?: () => void;
+};
+type MutableAtom<T extends Transceiver<any>, J extends Json.Serializable> = BaseStateData & JsonInterface<T, J> & {
+    type: `mutable_atom`;
+    default: T | (() => T);
+    cleanup?: () => void;
+};
+type Atom<T> = RegularAtom<T> | (T extends Transceiver<any> ? MutableAtom<T, any> : never);
+type WritableSelector<T> = BaseStateData & {
+    type: `selector`;
+    get: () => T;
+    set: (newValue: T | ((oldValue: T) => T)) => void;
+};
+type ReadonlySelector<T> = BaseStateData & {
+    type: `readonly_selector`;
+    get: () => T;
+};
+type Selector<T> = ReadonlySelector<T> | WritableSelector<T>;
+type WritableState<T> = Atom<T> | WritableSelector<T>;
+type ReadableState<T> = Atom<T> | Selector<T>;
 
-export { type Atom, type AtomKey, type EnvironmentData, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, type MutableAtom, NotFoundError, type OperationProgress, type ReadonlySelector, type ReadonlySelectorKey, type Selector, type SelectorKey, type Signal, type StateKey, type StateNode, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineSelectorUpdate, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionMeta, type TransactionPhase, type Transceiver, type TransceiverMode, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelector, createSelectorFamily, createTimeline, createTransaction, deleteAtom, deleteSelector, deposit, eldest, evictCachedValue, getEnvironmentData, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isDone, isReadonlySelectorKey, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
+export { type Atom, type AtomKey, type BaseStateData, type EnvironmentData, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, type MutableAtom, NotFoundError, type OperationProgress, type ReadableState, type ReadonlySelector, type ReadonlySelectorKey, type RegularAtom, type Selector, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineSelectorUpdate, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionMeta, type TransactionPhase, type Transceiver, type TransceiverMode, type Withdrawable, type WritableSelector, type WritableState, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deleteAtom, deleteSelector, deposit, evictCachedValue, getEnvironmentData, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isDone, isMutable, isReadonlySelectorKey, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };