atom.io 0.3.0 → 0.4.0

package/README.md

@@ -14,18 +14,21 @@
 - [x] atom default as function
 - [x] check whether an atom is "default" (never set)
 - [x] customizable logging
+- [x] subscribe to transactions
+- [x] timelines
+- [x] subscribe to families
 
 # atom.io
 ## upcoming features
-- [ ] subscribe to token creation
-- [ ] subscribe to transactions
-- [ ] timelines
+- [ ] store observation api
+- [x] subscribe to creation of atom tokens
+- [x] subscribe to creation of selector tokens
+- [x] subscribe to creation of readonly selector tokens
+- [ ] subscribe to creation of transaction tokens
+- [ ] subscribe to creation of timeline tokens
+- [ ] subscribe to changes in store configuration
 - [ ] resettable atoms
 - [ ] resettable selectors
-- [ ] store observation api
-
-## fixes & improvements
-- [ ] apply and emit transactions all at once
 
 ## documentation
 - [ ] document atom and selector families
@@ -34,8 +37,11 @@
 
 # /react
 ## features
-- [x] useSubject
 - [x] useStore
+- [x] useI, useO, useIO
+- [ ] useTimeline
+- [ ] useStoreIndex
+- [ ] useTransactionIO 
 
 # /effects
 ## features

package/dist/index.d.ts

@@ -16,22 +16,28 @@ type Identified = {
 
 declare const RELATION_TYPES: readonly ["1:1", "1:n", "n:n"];
 type RelationType = (typeof RELATION_TYPES)[number];
-type RelationData<CONTENT extends JsonObj | null = null> = {
+type RelationData<CONTENT extends JsonObj | null = null, A extends string = `from`, B extends string = `to`> = {
     contents: JsonObj<string, CONTENT>;
     relations: JsonObj<string, string[]>;
     relationType: RelationType;
+    a: A;
+    b: B;
 };
 
 type NullSafeUnion<Base, Extension> = Extension extends null ? Base : Base & Extension;
 type NullSafeRest<MaybeArg> = MaybeArg extends null ? [] | [undefined] : [MaybeArg];
 
-declare class Join<CONTENT extends JsonObj | null = null> implements RelationData<CONTENT> {
+declare class Join<CONTENT extends JsonObj | null = null, A extends string = `from`, B extends string = `to`> implements RelationData<CONTENT, A, B> {
     readonly relationType: `1:1` | `1:n` | `n:n`;
+    readonly a: A;
+    readonly b: B;
     readonly relations: Record<string, string[]>;
     readonly contents: Record<string, CONTENT>;
-    constructor(json?: Partial<RelationData<CONTENT>>);
-    toJSON(): RelationData<CONTENT>;
-    static fromJSON<CONTENT extends JsonObj | null = null>(json: Json, isContent?: Refinement<unknown, CONTENT>): Join<CONTENT>;
+    constructor(json?: Partial<RelationData<CONTENT, A, B>>);
+    toJSON(): RelationData<CONTENT, A, B>;
+    static fromJSON<CONTENT extends JsonObj | null, A extends string, B extends string>(json: Json, isContent?: Refinement<unknown, CONTENT>, a?: A, b?: B): Join<CONTENT, A, B>;
+    from<AA extends string>(newA: AA): Join<CONTENT, AA, B>;
+    to<BB extends string>(newB: BB): Join<CONTENT, A, BB>;
     getRelatedId(id: string): string | undefined;
     getRelatedIds(id: string): string[];
     getContent(idA: string, idB: string): CONTENT | undefined;
@@ -39,9 +45,15 @@ declare class Join<CONTENT extends JsonObj | null = null> implements RelationDat
     getRelationRecord(id: string): Record<string, CONTENT>;
     getRelation(id: string): NullSafeUnion<Identified, CONTENT> | undefined;
     getRelations(id: string): NullSafeUnion<Identified, CONTENT>[];
-    setRelations(id: string, relations: NullSafeUnion<Identified, CONTENT>[]): Join<CONTENT>;
-    set(idA: string, idB: string, ...rest: NullSafeRest<CONTENT>): Join<CONTENT>;
-    remove(idA: string, idB?: string): Join<CONTENT>;
+    setRelations(subject: {
+        [from in A]: string;
+    } | {
+        [to in B]: string;
+    }, relations: NullSafeUnion<Identified, CONTENT>[]): Join<CONTENT, A, B>;
+    set(relation: {
+        [key in A | B]: string;
+    }, ...rest: NullSafeRest<CONTENT>): Join<CONTENT, A, B>;
+    remove(relation: Partial<Record<A | B, string>>): Join<CONTENT, A, B>;
 }
 
 type StoreCore = Pick<Store, `atoms` | `atomsThatAreDefault` | `operation` | `readonlySelectors` | `selectorAtoms` | `selectorGraph` | `selectors` | `timelineAtoms` | `timelines` | `transactions` | `valueMap`>;
@@ -49,16 +61,22 @@ interface Store {
     atoms: Hamt<Atom<any>, string>;
     atomsThatAreDefault: Set<string>;
     readonlySelectors: Hamt<ReadonlySelector<any>, string>;
-    selectorAtoms: Join;
+    selectorAtoms: Join<null, `selectorKey`, `atomKey`>;
     selectorGraph: Join<{
         source: string;
     }>;
     selectors: Hamt<Selector<any>, string>;
     timelines: Hamt<Timeline, string>;
-    timelineAtoms: Join;
+    timelineAtoms: Join<null, `timelineKey`, `atomKey`>;
     timelineStore: Hamt<TimelineData, string>;
     transactions: Hamt<Transaction<any>, string>;
     valueMap: Hamt<any, string>;
+    subject: {
+        atomCreation: Rx.Subject<AtomToken<unknown>>;
+        selectorCreation: Rx.Subject<ReadonlySelectorToken<unknown> | SelectorToken<unknown>>;
+        transactionCreation: Rx.Subject<TransactionToken<unknown>>;
+        timelineCreation: Rx.Subject<TimelineToken>;
+    };
     operation: OperationProgress;
     transactionStatus: TransactionStatus<ƒn>;
     config: {
@@ -118,19 +136,19 @@ declare function selectorFamily__INTERNAL<T, K extends Serializable>(options: Se
 declare function selectorFamily__INTERNAL<T, K extends Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store?: Store): ReadonlySelectorFamily<T, K>;
 
 declare const computeSelectorState: <T>(selector: ReadonlySelector<T> | Selector<T>) => T;
-declare function lookup(key: string, store: Store): AtomToken<unknown> | ReadonlyValueToken<unknown> | SelectorToken<unknown>;
+declare function lookup(key: string, store: Store): AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>;
 declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T>;
 declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T>;
 declare function withdraw<T>(token: StateToken<T>, store: Store): Atom<T> | Selector<T>;
-declare function withdraw<T>(token: ReadonlyValueToken<T>, store: Store): ReadonlySelector<T>;
+declare function withdraw<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T>;
 declare function withdraw<T>(token: TransactionToken<T>, store: Store): Transaction<T extends ƒn ? T : never>;
-declare function withdraw<T>(token: ReadonlyValueToken<T> | StateToken<T>, store: Store): Atom<T> | ReadonlySelector<T> | Selector<T>;
+declare function withdraw<T>(token: ReadonlySelectorToken<T> | StateToken<T>, store: Store): Atom<T> | ReadonlySelector<T> | Selector<T>;
 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>): StateToken<T>;
-declare function deposit<T>(state: ReadonlySelector<T>): ReadonlyValueToken<T>;
+declare function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>;
 declare function deposit<T>(state: Transaction<T extends ƒn ? T : never>): TransactionToken<T>;
-declare function deposit<T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>): ReadonlyValueToken<T> | StateToken<T>;
+declare function deposit<T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>): ReadonlySelectorToken<T> | StateToken<T>;
 declare const getState__INTERNAL: <T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>, store?: Store) => T;
 
 declare const isAtomDefault: (key: string, store?: Store) => boolean;
@@ -138,10 +156,36 @@ declare const markAtomAsDefault: (key: string, store?: Store) => void;
 declare const markAtomAsNotDefault: (key: string, store?: Store) => void;
 declare const isSelectorDefault: (key: string, store?: Store) => boolean;
 
-type Logger = Pick<Console, `error` | `info` | `warn`>;
-declare const LOG_LEVELS: ReadonlyArray<keyof Logger>;
-declare const setLogLevel: (preferredLevel: `error` | `info` | `warn` | null, store?: Store) => void;
-declare const useLogger: (logger: Logger, store?: Store) => void;
+type StateTokenIndex<Token extends AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>> = Record<string, Token | {
+    key: string;
+    familyMembers: Record<string, Token>;
+}>;
+type AtomTokenIndex = StateTokenIndex<AtomToken<unknown>>;
+type SelectorTokenIndex = StateTokenIndex<ReadonlySelectorToken<unknown> | SelectorToken<unknown>>;
+declare const attachMetaAtoms: (store?: Store) => ReadonlySelectorToken<AtomTokenIndex>;
+declare const attachMetaSelectors: (store?: Store) => ReadonlySelectorToken<SelectorTokenIndex>;
+
+declare const attachMetaState: (store?: Store) => {
+    atomTokenIndexState: ReadonlySelectorToken<AtomTokenIndex>;
+    selectorTokenIndexState: ReadonlySelectorToken<SelectorTokenIndex>;
+};
+
+type index$1_AtomTokenIndex = AtomTokenIndex;
+type index$1_SelectorTokenIndex = SelectorTokenIndex;
+type index$1_StateTokenIndex<Token extends AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>> = StateTokenIndex<Token>;
+declare const index$1_attachMetaAtoms: typeof attachMetaAtoms;
+declare const index$1_attachMetaSelectors: typeof attachMetaSelectors;
+declare const index$1_attachMetaState: typeof attachMetaState;
+declare namespace index$1 {
+  export {
+    index$1_AtomTokenIndex as AtomTokenIndex,
+    index$1_SelectorTokenIndex as SelectorTokenIndex,
+    index$1_StateTokenIndex as StateTokenIndex,
+    index$1_attachMetaAtoms as attachMetaAtoms,
+    index$1_attachMetaSelectors as attachMetaSelectors,
+    index$1_attachMetaState as attachMetaState,
+  };
+}
 
 type OperationProgress = {
     open: false;
@@ -149,8 +193,10 @@ type OperationProgress = {
     open: true;
     done: Set<string>;
     prev: Hamt<any, string>;
+    time: number;
+    token: StateToken<any>;
 };
-declare const openOperation: (store: Store) => void;
+declare const openOperation: (token: StateToken<any>, store: Store) => void;
 declare const closeOperation: (store: Store) => void;
 declare const isDone: (key: string, store?: Store) => boolean;
 declare const markDone: (key: string, store?: Store) => void;
@@ -166,14 +212,15 @@ declare const hasKeyBeenUsed: (key: string, store?: Store) => boolean;
 
 type ƒn = (...parameters: any[]) => any;
 type Transactors = {
-    get: <S>(state: ReadonlyValueToken<S> | StateToken<S>) => S;
+    get: <S>(state: ReadonlySelectorToken<S> | StateToken<S>) => S;
     set: <S>(state: StateToken<S>, newValue: S | ((oldValue: S) => S)) => void;
 };
 type ReadonlyTransactors = Pick<Transactors, `get`>;
-type Action<ƒ extends ƒn> = (transactors: Transactors, ...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+type Read<ƒ extends ƒn> = (transactors: ReadonlyTransactors, ...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+type Write<ƒ extends ƒn> = (transactors: Transactors, ...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
 type TransactionOptions<ƒ extends ƒn> = {
     key: string;
-    do: Action<ƒ>;
+    do: Write<ƒ>;
 };
 type Transaction<ƒ extends ƒn> = {
     key: string;
@@ -205,13 +252,13 @@ type ReadonlySelector<T> = {
     }>;
     get: () => T;
 };
-declare const lookupSelectorSources: (key: string, store: Store) => (AtomToken<unknown> | ReadonlyValueToken<unknown> | SelectorToken<unknown>)[];
-declare const traceSelectorAtoms: (selectorKey: string, dependency: ReadonlyValueToken<unknown> | StateToken<unknown>, store: Store) => AtomToken<unknown>[];
+declare const lookupSelectorSources: (key: string, store: Store) => (AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>)[];
+declare const traceSelectorAtoms: (selectorKey: string, dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>, store: Store) => AtomToken<unknown>[];
 declare const traceAllSelectorAtoms: (selectorKey: string, store: Store) => AtomToken<unknown>[];
-declare const updateSelectorAtoms: (selectorKey: string, dependency: ReadonlyValueToken<unknown> | StateToken<unknown>, store: Store) => void;
+declare const updateSelectorAtoms: (selectorKey: string, dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>, store: Store) => void;
 declare const registerSelector: (selectorKey: string, store?: Store) => Transactors;
 declare function selector__INTERNAL<T>(options: SelectorOptions<T>, family?: FamilyMetadata, store?: Store): SelectorToken<T>;
-declare function selector__INTERNAL<T>(options: ReadonlySelectorOptions<T>, family?: FamilyMetadata, store?: Store): ReadonlyValueToken<T>;
+declare function selector__INTERNAL<T>(options: ReadonlySelectorOptions<T>, family?: FamilyMetadata, store?: Store): ReadonlySelectorToken<T>;
 
 declare const evictDownStream: <T>(state: Atom<T>, store?: Store) => void;
 declare const setAtomState: <T>(atom: Atom<T>, next: T | ((oldValue: T) => T), store?: Store) => void;
@@ -225,14 +272,22 @@ declare const subscribeToRootAtoms: <T>(state: ReadonlySelector<T> | Selector<T>
     unsubscribe: () => void;
 }[] | null;
 
+declare const redo__INTERNAL: (token: TimelineToken, store?: Store) => void;
+declare const undo__INTERNAL: (token: TimelineToken, store?: Store) => void;
+
 type Timeline = {
     key: string;
     type: `timeline`;
     next: () => void;
     prev: () => void;
 };
-type TimelineStateUpdate = KeyedStateUpdate<unknown> & {
-    type: `state_update`;
+type TimelineAtomUpdate = KeyedStateUpdate<unknown> & {
+    type: `atom_update`;
+};
+type TimelineSelectorUpdate = {
+    key: string;
+    type: `selector_update`;
+    atomUpdates: TimelineAtomUpdate[];
 };
 type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
     type: `transaction_update`;
@@ -240,11 +295,11 @@ type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
 type TimelineData = {
     at: number;
     timeTraveling: boolean;
-    history: (TimelineStateUpdate | TimelineTransactionUpdate)[];
+    history: (TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate)[];
+    selectorTime: number | null;
+    transactionKey: string | null;
 };
 declare function timeline__INTERNAL(options: TimelineOptions, store?: Store): TimelineToken;
-declare const redo__INTERNAL: (token: TimelineToken, store?: Store) => void;
-declare const undo__INTERNAL: (token: TimelineToken, store?: Store) => void;
 
 declare const TRANSACTION_PHASES: readonly ["idle", "building", "applying"];
 type TransactionPhase = (typeof TRANSACTION_PHASES)[number];
@@ -276,8 +331,6 @@ declare const target: (store?: Store) => StoreCore;
 type index_Atom<T> = Atom<T>;
 declare const index_IMPLICIT: typeof IMPLICIT;
 type index_KeyedStateUpdate<T> = KeyedStateUpdate<T>;
-declare const index_LOG_LEVELS: typeof LOG_LEVELS;
-type index_Logger = Logger;
 type index_OperationProgress = OperationProgress;
 type index_ReadonlySelector<T> = ReadonlySelector<T>;
 type index_Selector<T> = Selector<T>;
@@ -285,8 +338,9 @@ type index_Store = Store;
 type index_StoreCore = StoreCore;
 declare const index_TRANSACTION_PHASES: typeof TRANSACTION_PHASES;
 type index_Timeline = Timeline;
+type index_TimelineAtomUpdate = TimelineAtomUpdate;
 type index_TimelineData = TimelineData;
-type index_TimelineStateUpdate = TimelineStateUpdate;
+type index_TimelineSelectorUpdate = TimelineSelectorUpdate;
 type index_TimelineTransactionUpdate = TimelineTransactionUpdate;
 type index_TransactionIdle = TransactionIdle;
 type index_TransactionPhase = TransactionPhase;
@@ -329,7 +383,6 @@ declare const index_registerSelector: typeof registerSelector;
 declare const index_selectorFamily__INTERNAL: typeof selectorFamily__INTERNAL;
 declare const index_selector__INTERNAL: typeof selector__INTERNAL;
 declare const index_setAtomState: typeof setAtomState;
-declare const index_setLogLevel: typeof setLogLevel;
 declare const index_setSelectorState: typeof setSelectorState;
 declare const index_setState__INTERNAL: typeof setState__INTERNAL;
 declare const index_storeAtom: typeof storeAtom;
@@ -345,15 +398,13 @@ declare const index_transaction__INTERNAL: typeof transaction__INTERNAL;
 declare const index_undoTransactionUpdate: typeof undoTransactionUpdate;
 declare const index_undo__INTERNAL: typeof undo__INTERNAL;
 declare const index_updateSelectorAtoms: typeof updateSelectorAtoms;
-declare const index_useLogger: typeof useLogger;
 declare const index_withdraw: typeof withdraw;
 declare namespace index {
   export {
     index_Atom as Atom,
     index_IMPLICIT as IMPLICIT,
     index_KeyedStateUpdate as KeyedStateUpdate,
-    index_LOG_LEVELS as LOG_LEVELS,
-    index_Logger as Logger,
+    index$1 as META,
     index_OperationProgress as OperationProgress,
     index_ReadonlySelector as ReadonlySelector,
     index_Selector as Selector,
@@ -361,8 +412,9 @@ declare namespace index {
     index_StoreCore as StoreCore,
     index_TRANSACTION_PHASES as TRANSACTION_PHASES,
     index_Timeline as Timeline,
+    index_TimelineAtomUpdate as TimelineAtomUpdate,
     index_TimelineData as TimelineData,
-    index_TimelineStateUpdate as TimelineStateUpdate,
+    index_TimelineSelectorUpdate as TimelineSelectorUpdate,
     index_TimelineTransactionUpdate as TimelineTransactionUpdate,
     index_TransactionIdle as TransactionIdle,
     index_TransactionPhase as TransactionPhase,
@@ -405,7 +457,6 @@ declare namespace index {
     index_selectorFamily__INTERNAL as selectorFamily__INTERNAL,
     index_selector__INTERNAL as selector__INTERNAL,
     index_setAtomState as setAtomState,
-    index_setLogLevel as setLogLevel,
     index_setSelectorState as setSelectorState,
     index_setState__INTERNAL as setState__INTERNAL,
     index_storeAtom as storeAtom,
@@ -421,23 +472,27 @@ declare namespace index {
     index_undoTransactionUpdate as undoTransactionUpdate,
     index_undo__INTERNAL as undo__INTERNAL,
     index_updateSelectorAtoms as updateSelectorAtoms,
-    index_useLogger as useLogger,
     index_withdraw as withdraw,
   };
 }
 
+type Logger = Pick<Console, `error` | `info` | `warn`>;
+declare const LOG_LEVELS: ReadonlyArray<keyof Logger>;
+declare const setLogLevel: (preferredLevel: `error` | `info` | `warn` | null, store?: Store) => void;
+declare const useLogger: (logger: Logger, store?: Store) => void;
+
 type SelectorOptions<T> = {
     key: string;
-    get: (readonlyTransactors: ReadonlyTransactors) => T;
-    set: (transactors: Transactors, newValue: T) => void;
+    get: Read<() => T>;
+    set: Write<(newValue: T) => void>;
 };
 type ReadonlySelectorOptions<T> = Omit<SelectorOptions<T>, `set`>;
+declare function selector<T>(options: ReadonlySelectorOptions<T>): ReadonlySelectorToken<T>;
 declare function selector<T>(options: SelectorOptions<T>): SelectorToken<T>;
-declare function selector<T>(options: ReadonlySelectorOptions<T>): ReadonlyValueToken<T>;
 type SelectorFamilyOptions<T, K extends Serializable> = {
     key: string;
-    get: (key: K) => (readonlyTransactors: ReadonlyTransactors) => T;
-    set: (key: K) => (transactors: Transactors, newValue: T) => void;
+    get: (key: K) => Read<() => T>;
+    set: (key: K) => Write<(newValue: T) => void>;
 };
 type ReadonlySelectorFamilyOptions<T, K extends Serializable> = Omit<SelectorFamilyOptions<T, K>, `set`>;
 type SelectorFamily<T, K extends Serializable = Serializable> = ((key: K) => SelectorToken<T>) & {
@@ -445,14 +500,23 @@ type SelectorFamily<T, K extends Serializable = Serializable> = ((key: K) => Sel
     type: `selector_family`;
     subject: Rx.Subject<SelectorToken<T>>;
 };
-type ReadonlySelectorFamily<T, K extends Serializable = Serializable> = ((key: K) => ReadonlyValueToken<T>) & {
+type ReadonlySelectorFamily<T, K extends Serializable = Serializable> = ((key: K) => ReadonlySelectorToken<T>) & {
     key: string;
     type: `readonly_selector_family`;
-    subject: Rx.Subject<ReadonlyValueToken<T>>;
+    subject: Rx.Subject<ReadonlySelectorToken<T>>;
 };
 declare function selectorFamily<T, K extends Serializable>(options: SelectorFamilyOptions<T, K>): SelectorFamily<T, K>;
 declare function selectorFamily<T, K extends Serializable>(options: ReadonlySelectorFamilyOptions<T, K>): ReadonlySelectorFamily<T, K>;
 
+type StateUpdate<T> = {
+    newValue: T;
+    oldValue: T;
+};
+type UpdateHandler<T> = (update: StateUpdate<T>) => void;
+declare const subscribe: <T>(token: ReadonlySelectorToken<T> | StateToken<T>, handleUpdate: UpdateHandler<T>, store?: Store) => (() => void);
+type TransactionUpdateHandler<ƒ extends ƒn> = (data: TransactionUpdate<ƒ>) => void;
+declare const subscribeToTransaction: <ƒ extends ƒn>(token: TransactionToken<ƒ>, handleUpdate: TransactionUpdateHandler<ƒ>, store?: Store) => (() => void);
+
 type TimelineToken = {
     key: string;
     type: `timeline`;
@@ -465,15 +529,6 @@ declare const timeline: (options: TimelineOptions) => TimelineToken;
 declare const redo: (token: TimelineToken) => void;
 declare const undo: (token: TimelineToken) => void;
 
-type StateUpdate<T> = {
-    newValue: T;
-    oldValue: T;
-};
-type UpdateHandler<T> = (update: StateUpdate<T>) => void;
-declare const subscribe: <T>(token: ReadonlyValueToken<T> | StateToken<T>, handleUpdate: UpdateHandler<T>, store?: Store) => (() => void);
-type TransactionUpdateHandler<ƒ extends ƒn> = (data: TransactionUpdate<ƒ>) => void;
-declare const subscribeToTransaction: <ƒ extends ƒn>(token: TransactionToken<ƒ>, handleUpdate: TransactionUpdateHandler<ƒ>, store?: Store) => (() => void);
-
 type AtomToken<_> = {
     key: string;
     type: `atom`;
@@ -485,7 +540,7 @@ type SelectorToken<_> = {
     family?: FamilyMetadata;
 };
 type StateToken<T> = AtomToken<T> | SelectorToken<T>;
-type ReadonlyValueToken<_> = {
+type ReadonlySelectorToken<_> = {
     key: string;
     type: `readonly_selector`;
     family?: FamilyMetadata;
@@ -498,8 +553,8 @@ type TransactionToken<_> = {
     key: string;
     type: `transaction`;
 };
-declare const getState: <T>(token: ReadonlyValueToken<T> | StateToken<T>, store?: Store) => T;
+declare const getState: <T>(token: ReadonlySelectorToken<T> | StateToken<T>, store?: Store) => T;
 declare const setState: <T, New extends T>(token: StateToken<T>, value: New | ((oldValue: T) => New), store?: Store) => void;
-declare const isDefault: (token: ReadonlyValueToken<unknown> | StateToken<unknown>, store?: Store) => boolean;
+declare const isDefault: (token: ReadonlySelectorToken<unknown> | StateToken<unknown>, store?: Store) => boolean;
 
-export { Action, AtomEffect, AtomFamily, AtomFamilyOptions, AtomOptions, AtomToken, Effectors, FamilyMetadata, ReadonlySelectorFamily, ReadonlySelectorFamilyOptions, ReadonlySelectorOptions, ReadonlyTransactors, ReadonlyValueToken, SelectorFamily, SelectorFamilyOptions, SelectorOptions, SelectorToken, Serializable, StateToken, StateUpdate, TimelineOptions, TimelineToken, Transaction, TransactionOptions, TransactionToken, TransactionUpdateHandler, Transactors, UpdateHandler, index as __INTERNAL__, atom, atomFamily, getState, isDefault, redo, runTransaction, selector, selectorFamily, setLogLevel, setState, subscribe, subscribeToTransaction, timeline, transaction, undo, useLogger, ƒn };
+export { AtomEffect, AtomFamily, AtomFamilyOptions, AtomOptions, AtomToken, Effectors, FamilyMetadata, LOG_LEVELS, Logger, Read, ReadonlySelectorFamily, ReadonlySelectorFamilyOptions, ReadonlySelectorOptions, ReadonlySelectorToken, ReadonlyTransactors, SelectorFamily, SelectorFamilyOptions, SelectorOptions, SelectorToken, Serializable, StateToken, StateUpdate, TimelineOptions, TimelineToken, Transaction, TransactionOptions, TransactionToken, TransactionUpdateHandler, Transactors, UpdateHandler, Write, index as __INTERNAL__, atom, atomFamily, getState, isDefault, redo, runTransaction, selector, selectorFamily, setLogLevel, setState, subscribe, subscribeToTransaction, timeline, transaction, undo, useLogger, ƒn };