atom.io 0.11.0 → 0.12.1

package/internal/dist/index.d.ts

@@ -1,28 +1,6 @@
-import { Transactors, FamilyMetadata as FamilyMetadata$1, SelectorOptions, SelectorToken, ReadonlySelectorOptions, ReadonlySelectorToken, StateToken, ƒn, TransactionUpdate, TransactionOptions, TransactionToken, AtomToken as AtomToken$1, MutableAtomOptions, MutableAtomToken, MutableAtomFamilyOptions, MutableAtomFamily, AtomFamily, StateUpdate, TimelineUpdate, TimelineOptions, TimelineToken, ReadonlySelectorFamily, SelectorFamily, AtomIOLogger, Logger, AtomOptions, AtomFamilyOptions, ReadonlySelectorFamilyOptions, SelectorFamilyOptions } from 'atom.io';
+import { FamilyMetadata, SelectorOptions, SelectorToken, ReadonlySelectorOptions, ReadonlySelectorToken, Transactors, StateToken, ƒn, TransactionUpdate, TransactionOptions, TransactionToken, AtomToken, MutableAtomOptions, MutableAtomToken, MutableAtomFamilyOptions, MutableAtomFamily, SelectorFamily, AtomFamily, StateUpdate, TimelineUpdate, TimelineOptions, TimelineToken, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomOptions, AtomFamilyOptions, ReadonlySelectorFamilyOptions, SelectorFamilyOptions } from 'atom.io';
 import { Json } from 'atom.io/json';
 
-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 class Subject<T> {
     Subscriber: (value: T) => void;
     subscribers: Map<string, this[`Subscriber`]>;
@@ -34,7 +12,7 @@ declare class Subject<T> {
 type Selector<T> = {
     key: string;
     type: `selector`;
-    family?: FamilyMetadata$1;
+    family?: FamilyMetadata;
     install: (store: Store) => void;
     subject: Subject<{
         newValue: T;
@@ -46,7 +24,7 @@ type Selector<T> = {
 type ReadonlySelector<T> = {
     key: string;
     type: `readonly_selector`;
-    family?: FamilyMetadata$1;
+    family?: FamilyMetadata;
     install: (store: Store) => void;
     subject: Subject<{
         newValue: T;
@@ -54,14 +32,44 @@ type ReadonlySelector<T> = {
     }>;
     get: () => T;
 };
-declare function createSelector<T>(options: SelectorOptions<T>, family?: FamilyMetadata$1, store?: Store): SelectorToken<T>;
-declare function createSelector<T>(options: ReadonlySelectorOptions<T>, family?: FamilyMetadata$1, store?: Store): ReadonlySelectorToken<T>;
+declare function createSelector<T>(options: SelectorOptions<T>, family: FamilyMetadata | undefined, store: Store): SelectorToken<T>;
+declare function createSelector<T>(options: ReadonlySelectorOptions<T>, family: FamilyMetadata | 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> | StateToken<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) => void;
+
 type Transaction<ƒ extends ƒn> = {
     key: string;
     type: `transaction`;
@@ -69,21 +77,15 @@ type Transaction<ƒ extends ƒn> = {
     subject: Subject<TransactionUpdate<ƒ>>;
     run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
 };
-declare function transaction__INTERNAL<ƒ extends ƒn>(options: TransactionOptions<ƒ>, store?: Store): TransactionToken<ƒ>;
-declare const target: (store?: Store) => StoreCore;
-
-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) => void;
+declare function createTransaction<ƒ extends ƒn>(options: TransactionOptions<ƒ>, store: Store): TransactionToken<ƒ>;
+declare const target: (store: Store) => StoreCore;
 
 declare const redoTransactionUpdate: <ƒ extends ƒn>(update: TransactionUpdate<ƒ>, store: Store) => void;
 
 declare const undoTransactionUpdate: <ƒ extends ƒn>(update: TransactionUpdate<ƒ>, store: Store) => void;
 
 declare const TRANSACTION_PHASES: readonly ["idle", "building", "applying"];
-type TransactionPhase = typeof TRANSACTION_PHASES[number];
+type TransactionPhase = (typeof TRANSACTION_PHASES)[number];
 type TransactionUpdateInProgress<ƒ extends ƒn> = TransactionUpdate<ƒ> & {
     phase: `applying` | `building`;
     time: number;
@@ -94,7 +96,7 @@ type TransactionIdle = {
 };
 type TransactionStatus<ƒ extends ƒn> = TransactionIdle | TransactionUpdateInProgress<ƒ>;
 
-declare function deposit<T>(state: Atom<T>): AtomToken$1<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>): ReadonlySelectorToken<T>;
@@ -119,26 +121,30 @@ interface JunctionSchema<ASide extends string, BSide extends string> extends Obj
     readonly between: [a: ASide, b: BSide];
     readonly cardinality: Cardinality;
 }
+type BaseExternalStoreConfiguration = {
+    addRelation: (a: string, b: string) => void;
+    deleteRelation: (a: string, b: string) => void;
+    replaceRelationsSafely: (a: string, bs: string[]) => void;
+    replaceRelationsUnsafely: (a: string, bs: string[]) => void;
+    getRelatedKeys: (key: string) => Set<string> | undefined;
+    has: (a: string, b?: string) => boolean;
+};
+type ExternalStoreWithContentConfiguration<Content extends Object$1> = {
+    getContent: (contentKey: string) => Content | undefined;
+    setContent: (contentKey: string, content: Content) => void;
+    deleteContent: (contentKey: string) => void;
+};
+type Empty<Obj extends object> = {
+    [Key in keyof Obj]?: undefined;
+};
+type ExternalStoreConfiguration<Content extends Object$1 | null> = Content extends Object$1 ? BaseExternalStoreConfiguration & ExternalStoreWithContentConfiguration<Content> : BaseExternalStoreConfiguration & Empty<ExternalStoreWithContentConfiguration<Object$1>>;
 type JunctionAdvancedConfiguration<Content extends Object$1 | null> = {
-    externalStore?: (Content extends null ? {
-        getContent?: undefined;
-        setContent?: undefined;
-        deleteContent?: undefined;
-    } : {
-        getContent: (contentKey: string) => Content | undefined;
-        setContent: (contentKey: string, content: Content) => void;
-        deleteContent: (contentKey: string) => void;
-    }) & {
-        addRelation: (a: string, b: string) => void;
-        deleteRelation: (a: string, b: string) => void;
-        getRelatedKeys: (key: string) => Set<string> | undefined;
-        has: (a: string, b?: string) => boolean;
-    };
+    externalStore?: ExternalStoreConfiguration<Content>;
     isContent?: Refinement<unknown, Content>;
     makeContentKey?: (a: string, b: string) => string;
 };
 type JunctionJSON<ASide extends string, BSide extends string, Content extends Object$1 | null> = JunctionEntries<Content> & JunctionSchema<ASide, BSide>;
-declare class Junction<ASide extends string, BSide extends string, Content extends Object$1 | null = null> {
+declare class Junction<const ASide extends string, const BSide extends string, const Content extends Object$1 | null = null> {
     readonly a: ASide;
     readonly b: BSide;
     readonly cardinality: Cardinality;
@@ -149,6 +155,8 @@ declare class Junction<ASide extends string, BSide extends string, Content exten
     getRelatedKeys(key: string): Set<string> | undefined;
     protected addRelation(a: string, b: string): void;
     protected deleteRelation(a: string, b: string): void;
+    protected replaceRelationsUnsafely(a: string, bs: string[]): void;
+    protected replaceRelationsSafely(a: string, bs: string[]): void;
     protected getContentInternal(contentKey: string): Content | undefined;
     protected setContent(contentKey: string, content: Content): void;
     protected deleteContent(contentKey: string): void;
@@ -161,6 +169,9 @@ declare class Junction<ASide extends string, BSide extends string, Content exten
     delete(a: string, b?: string): this;
     delete(relation: Record<ASide | BSide, string> | Record<ASide, string> | Record<BSide, string>, b?: undefined): this;
     getRelatedKey(key: string): string | undefined;
+    replaceRelations(a: string, relations: Content extends null ? string[] : Record<string, Content>, config?: {
+        reckless: boolean;
+    }): this;
     getContent(a: string, b: string): Content | undefined;
     getRelationEntries(input: Record<ASide, string> | Record<BSide, string>): [string, Content][];
     has(a: string, b?: string): boolean;
@@ -170,20 +181,24 @@ 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>, store?: Store): MutableAtomToken<Core, SerializableCore>;
+declare function createMutableAtom<Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(options: MutableAtomOptions<Core, SerializableCore>, 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 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<Json.Serializable>, SerializableCore extends Json.Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => SelectorToken<SerializableCore>;
 
-declare const getUpdateToken: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => AtomToken$1<Signal<Core>>;
+declare const getUpdateToken: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => AtomToken<Signal<Core>>;
 
-declare function isAtomTokenMutable(token: AtomToken$1<any>): token is MutableAtomToken<any, any>;
+declare function isAtomTokenMutable(token: AtomToken<any>): token is MutableAtomToken<any, any>;
 
 /**
  * @internal Give the tracker a transceiver state and a store, and it will
@@ -197,15 +212,15 @@ declare class Tracker<Mutable extends Transceiver<any>> {
     private observeCore;
     private updateCore;
     mutableState: MutableAtomToken<Mutable, Json.Serializable>;
-    latestUpdateState: AtomToken$1<typeof this.Update | null>;
-    constructor(mutableState: MutableAtomToken<Mutable, Json.Serializable>, store?: Store);
+    latestUpdateState: AtomToken<typeof this.Update | null>;
+    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);
+    constructor(findMutableState: AtomFamily<Core, FamilyMemberKey>, store: Store);
 }
 
 interface MutableAtom<T> extends Atom<T> {
@@ -224,14 +239,14 @@ type OperationProgress = {
 };
 declare const openOperation: (token: StateToken<any>, store: Store) => `rejection` | undefined;
 declare const closeOperation: (store: Store) => void;
-declare const isDone: (key: string, store?: Store) => boolean;
-declare const markDone: (key: string, store?: Store) => void;
+declare const isDone: (key: string, store: Store) => boolean;
+declare const markDone: (key: string, store: Store) => void;
 
 type TimelineAtomUpdate = StateUpdate<unknown> & {
     key: string;
     type: `atom_update`;
     timestamp: number;
-    family?: FamilyMetadata$1;
+    family?: FamilyMetadata;
 };
 type TimelineSelectorUpdate = {
     key: string;
@@ -256,12 +271,11 @@ type Timeline = {
     install: (store: Store) => void;
     subject: Subject<TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate | `redo` | `undo`>;
 };
-declare function timeline__INTERNAL(options: TimelineOptions, store?: Store, data?: Timeline | null): TimelineToken;
+declare function createTimeline(options: TimelineOptions, store: Store, data?: Timeline): TimelineToken;
 
-declare const addAtomToTimeline: (atomToken: AtomToken$1<any>, tl: Timeline, store?: Store) => void;
+declare const addAtomToTimeline: (atomToken: AtomToken<any>, tl: Timeline, store: Store) => void;
 
-declare const redo__INTERNAL: (token: TimelineToken, store?: Store) => void;
-declare const undo__INTERNAL: (token: TimelineToken, store?: Store) => void;
+declare const timeTravel: (direction: `backward` | `forward`, token: TimelineToken, store: Store) => void;
 
 type StoreCore = Pick<Store, `atoms` | `atomsThatAreDefault` | `families` | `operation` | `readonlySelectors` | `selectorAtoms` | `selectorGraph` | `selectors` | `timelineAtoms` | `timelines` | `trackers` | `transactions` | `valueMap`>;
 declare class Store {
@@ -280,8 +294,8 @@ declare class Store {
         source: string;
     }>;
     subject: {
-        atomCreation: Subject<AtomToken$1<unknown>>;
-        selectorCreation: Subject<SelectorToken<unknown> | ReadonlySelectorToken<unknown>>;
+        atomCreation: Subject<AtomToken<unknown>>;
+        selectorCreation: Subject<ReadonlySelectorToken<unknown> | SelectorToken<unknown>>;
         transactionCreation: Subject<TransactionToken<ƒn>>;
         timelineCreation: Subject<TimelineToken>;
         operationStatus: Subject<OperationProgress>;
@@ -299,9 +313,9 @@ declare const IMPLICIT: {
     STORE_INTERNAL: Store | undefined;
     readonly STORE: Store;
 };
-declare const clearStore: (store?: Store) => void;
+declare const clearStore: (store: Store) => void;
 
-declare function withdraw<T>(token: AtomToken$1<T>, store: Store): Atom<T> | 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: StateToken<T>, store: Store): Atom<T> | Selector<T> | undefined;
 declare function withdraw<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T> | undefined;
@@ -309,7 +323,7 @@ declare function withdraw<T>(token: TransactionToken<T>, store: Store): Transact
 declare function withdraw<T>(token: ReadonlySelectorToken<T> | StateToken<T>, store: Store): Atom<T> | ReadonlySelector<T> | Selector<T> | undefined;
 declare function withdraw<T>(token: TimelineToken, store: Store): Timeline | undefined;
 
-declare function withdrawNewFamilyMember<T>(token: AtomToken$1<T>, store: Store): Atom<T> | 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: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T> | undefined;
 declare function withdrawNewFamilyMember<T>(token: StateToken<T>, store: Store): Atom<T> | Selector<T> | undefined;
@@ -318,45 +332,23 @@ declare function withdrawNewFamilyMember<T>(token: ReadonlySelectorToken<T> | St
 type Atom<T> = {
     key: string;
     type: `atom`;
-    family?: FamilyMetadata$1;
+    family?: FamilyMetadata;
     install: (store: Store) => void;
     subject: Subject<{
         newValue: T;
         oldValue: T;
     }>;
-    default: T;
-};
-declare function createAtom<T>(options: AtomOptions<T> | MutableAtomOptions<any, any>, family?: FamilyMetadata$1, store?: Store): AtomToken$1<T>;
-
-type AtomToken<_> = {
-    key: string;
-    type: `atom`;
-    family?: FamilyMetadata;
-    __brand?: _;
-};
-type FamilyMetadata = {
-    key: string;
-    subKey: string;
+    default: T | (() => T);
+    cleanup?: () => void;
 };
+declare function createAtom<T>(options: AtomOptions<T> | MutableAtomOptions<any, any>, family: FamilyMetadata | undefined, store: Store): AtomToken<T>;
 
-declare function deleteAtom(atomToken: AtomToken<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;
-declare const isSelectorDefault: (key: string, store?: Store) => boolean;
-
-declare const cacheValue: (key: string, value: unknown, subject: Subject<StateUpdate<unknown>>, store?: Store) => void;
-declare const readCachedValue: <T>(key: string, store?: Store) => T;
-declare const isValueCached: (key: string, store?: Store) => boolean;
-declare const evictCachedValue: (key: string, store?: Store) => void;
+declare function deleteAtom(atomToken: AtomToken<unknown>, store: Store): void;
 
-declare function createAtomFamily<T, K extends Json.Serializable>(options: AtomFamilyOptions<T, K>, store?: Store): AtomFamily<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: ReadonlySelectorFamilyOptions<T, K>, store?: Store): ReadonlySelectorFamily<T, K>;
+declare const isAtomDefault: (key: string, store: Store) => boolean;
+declare const markAtomAsDefault: (key: string, store: Store) => void;
+declare const markAtomAsNotDefault: (key: string, store: Store) => void;
+declare const isSelectorDefault: (key: string, store: Store) => boolean;
 
 /**
  * A Promise that can be canceled.
@@ -373,13 +365,40 @@ declare class Future<T> extends Promise<T> {
     cancel(): void;
 }
 
-declare const getState__INTERNAL: <T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>, store?: Store) => 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>(key: string, store: Store) => T;
+declare const isValueCached: (key: string, store: Store) => boolean;
+declare const evictCachedValue: (key: string, store: Store) => void;
+
+declare function createAtomFamily<T, K extends Json.Serializable>(options: AtomFamilyOptions<T, K>, store: Store): AtomFamily<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: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamily<T, K>;
+
+declare class LazyMap<K, V> extends Map<K, V> {
+    protected readonly source: Map<K, V>;
+    deleted: Set<K>;
+    constructor(source: Map<K, V>);
+    get(key: K): V | undefined;
+    _has(key: K): boolean;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+}
+
+declare class NotFoundError extends Error {
+    constructor(token: ReadonlySelectorToken<any> | StateToken<any>, store: Store);
+}
+
+declare const readOrComputeValue: <T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>, store: Store) => T;
 
 type Modify<T> = (thing: T) => T;
 declare const become: <T>(nextVersionOfThing: T | Modify<T>) => (originalThing: T) => T;
 
-declare const setState__INTERNAL: <T>(state: Atom<T> | Selector<T>, value: T | ((oldValue: T) => T), store?: Store) => void;
+declare const setAtomOrSelector: <T>(state: Atom<T> | Selector<T>, value: T | ((oldValue: T) => T), store: Store) => void;
 
 declare const subscribeToRootAtoms: <T>(state: ReadonlySelector<T> | Selector<T>, store: Store) => (() => void)[] | null;
 
-export { type Atom, type AtomKey, FamilyTracker, Future, IMPLICIT, type Modify, type MutableAtom, type OperationProgress, type ReadonlySelector, type ReadonlySelectorKey, type Selector, type SelectorKey, type Signal, type StateKey, Store, type StoreCore, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineSelectorUpdate, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionIdle, type TransactionPhase, type TransactionStatus, type TransactionUpdateInProgress, type Transceiver, type TransceiverMode, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createSelector, createSelectorFamily, deleteAtom, deposit, evictCachedValue, getJsonToken, getSelectorDependencyKeys, getState__INTERNAL, getUpdateToken, isAtomDefault, isAtomKey, isAtomMutable, isAtomTokenMutable, isDone, isReadonlySelectorKey, isSelectorDefault, isSelectorKey, isStateKey, isTransceiver, isValueCached, markAtomAsDefault, markAtomAsNotDefault, markDone, openOperation, readCachedValue, redoTransactionUpdate, redo__INTERNAL, registerSelector, setState__INTERNAL, subscribeToRootAtoms, target, timeline__INTERNAL, traceAllSelectorAtoms, traceSelectorAtoms, transaction__INTERNAL, undoTransactionUpdate, undo__INTERNAL, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
+export { type Atom, type AtomKey, FamilyTracker, Future, IMPLICIT, LazyMap, type Modify, type MutableAtom, NotFoundError, type OperationProgress, type ReadonlySelector, type ReadonlySelectorKey, type Selector, type SelectorKey, type Signal, type StateKey, Store, type StoreCore, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineSelectorUpdate, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionIdle, type TransactionPhase, type TransactionStatus, type TransactionUpdateInProgress, type Transceiver, type TransceiverMode, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createSelector, createSelectorFamily, createTimeline, createTransaction, deleteAtom, deleteSelector, deposit, evictCachedValue, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, isAtomDefault, isAtomKey, isAtomMutable, isAtomTokenMutable, isDone, isReadonlySelectorKey, isSelectorDefault, isSelectorKey, isStateKey, isTransceiver, isValueCached, markAtomAsDefault, markAtomAsNotDefault, markDone, openOperation, readCachedValue, readOrComputeValue, redoTransactionUpdate, registerSelector, setAtomOrSelector, subscribeToRootAtoms, target, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, undoTransactionUpdate, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };