atom.io 0.21.1 → 0.23.0

package/internal/dist/index.d.ts

@@ -1,5 +1,9 @@
-import { Func, TransactionToken, TransactionUpdate, TransactionOptions, TransactorsWithRunAndEnv, RegularAtomToken, MutableAtomToken, AtomToken, WritableSelectorToken, ReadonlySelectorToken, SelectorToken, WritableToken, ReadableToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, TimelineUpdate, TimelineOptions, TimelineToken, WritableSelectorFamily, MutableAtomFamily, RegularAtomFamily, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomFamily, SelectorFamily, RegularAtomFamilyToken, MutableAtomFamilyToken, AtomFamilyToken, ReadonlySelectorFamilyToken, WritableSelectorFamilyToken, SelectorFamilyToken, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, WritableFamilyToken, ReadableFamilyToken, KeyedStateUpdate, ReadonlySelectorOptions, WritableSelectorOptions, Transactors, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
+import { Func, TransactionToken, TransactionUpdate, TransactionOptions, TransactorsWithRunAndEnv, RegularAtomToken, MutableAtomToken, AtomToken, WritableSelectorToken, ReadonlySelectorToken, SelectorToken, WritableToken, ReadableToken, StateCreation, StateDisposal, MutableAtomFamilyToken, RegularAtomFamilyToken, WritableSelectorFamilyToken, ReadonlySelectorFamilyToken, WritableFamilyToken, ReadableFamilyToken, Flat, MoleculeCreation, MoleculeDisposal, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, TimelineUpdate, TimelineOptions, TimelineToken, WritableSelectorFamily, MutableAtomFamily, RegularAtomFamily, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomFamily, SelectorFamily, AtomFamilyToken, SelectorFamilyToken, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, KeyedStateUpdate, ReadonlySelectorOptions, WritableSelectorOptions, Transactors, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
 import { Json, JsonInterface } from 'atom.io/json';
+import { Molecule as Molecule$1, MoleculeToken as MoleculeToken$1, MoleculeFamily as MoleculeFamily$1, MoleculeFamilyToken as MoleculeFamilyToken$1 } from 'atom.io/immortal';
+import * as Internal from 'atom.io/internal';
+import { Store as Store$1, Subject as Subject$1, Transceiver as Transceiver$1 } from 'atom.io/internal';
+import { Join, JoinToken } from 'atom.io/data';
 
 type primitive = boolean | number | string | null;
 
@@ -146,9 +150,70 @@ declare function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T
 declare function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>;
 declare function deposit<T>(state: Selector<T>): SelectorToken<T>;
 declare function deposit<T>(state: WritableState<T>): WritableToken<T>;
+declare function deposit<K extends Json.Serializable, S extends {
+    [key: string]: any;
+}, P extends any[]>(state: Molecule$1<K>): MoleculeToken$1<K, S, P>;
+declare function deposit<K extends Json.Serializable, S extends {
+    [key: string]: any;
+}, P extends any[]>(state: MoleculeFamily$1<K, S, P>): MoleculeFamilyToken$1<K, S, P>;
 declare function deposit<T extends Func>(state: Transaction<T>): TransactionToken<T>;
 declare function deposit<T>(state: ReadableState<T>): ReadableToken<T>;
 
+declare class Molecule<Key extends Json.Serializable> {
+    readonly store: Store$1;
+    readonly token: MoleculeToken<Key, any, any>;
+    readonly type = "molecule";
+    get key(): Key;
+    readonly family?: MoleculeFamilyToken<Key, any, any>;
+    readonly above: Molecule<any>[];
+    readonly below: Molecule<any>[];
+    readonly tokens: ReadableToken<any>[];
+    readonly joins: Join<any, any, any, any>[];
+    readonly subject: Subject$1<StateCreation<any> | StateDisposal<any>>;
+    constructor(store: Store$1, above: Molecule<any> | Molecule<any>[] | undefined, token: MoleculeToken<Key, any, any>);
+    bond<T extends Transceiver$1<any>, J extends Json.Serializable, K extends string>(token: MutableAtomFamilyToken<T, J, K>): MutableAtomToken<T, J>;
+    bond<T, K extends Key>(token: RegularAtomFamilyToken<T, K>): RegularAtomToken<T>;
+    bond<T, K extends Json.Serializable>(token: WritableSelectorFamilyToken<T, K>): WritableSelectorToken<T>;
+    bond<T, K extends Json.Serializable>(token: ReadonlySelectorFamilyToken<T, K>): ReadonlySelectorToken<T>;
+    bond<T, K extends Json.Serializable>(token: WritableFamilyToken<T, K>): WritableToken<T>;
+    bond<T, K extends Json.Serializable>(token: ReadableFamilyToken<T, K>): ReadableToken<T>;
+    spawn<K extends Json.Serializable>(key: K): Molecule<K>;
+    with(molecule: Molecule<any>): (key: string) => Molecule<any>;
+    detach(child: Molecule<any>): void;
+    claim(child: Molecule<any>): void;
+    clear(): void;
+    join(token: JoinToken<any, any, any, any>): void;
+    private [Symbol.dispose];
+    dispose: () => void;
+}
+
+type MoleculeConstructor<Key extends Json.Serializable, Struct extends {
+    [key: string]: any;
+}, Params extends any[]> = new (context: Molecule<any>[], token: MoleculeToken<Key, Struct, Params>, ...params: Params) => Molecule<Key> & Struct;
+type MoleculeFamilyToken<Key extends Json.Serializable, Struct extends {
+    [key: string]: any;
+}, Params extends any[]> = {
+    key: string;
+    type: `molecule_family`;
+    __K?: Key;
+    __S?: Struct;
+    __P?: Params;
+};
+type MoleculeFamily<Key extends Json.Serializable, Struct extends {
+    [key: string]: any;
+}, Params extends any[]> = Flat<MoleculeFamilyToken<Key, Struct, Params> & {
+    subject: Internal.Subject<MoleculeCreation<Key> | MoleculeDisposal<Key>>;
+}> & MoleculeConstructor<Key, Struct, Params>;
+type MoleculeToken<Key extends Json.Serializable, Struct extends {
+    [key: string]: any;
+}, Params extends any[]> = {
+    key: Key;
+    type: `molecule`;
+    family?: MoleculeFamilyToken<Key, Struct, Params>;
+    __S?: Struct;
+    __P?: Params;
+};
+
 interface Lineage {
     parent: typeof this | null;
     child: typeof this | null;
@@ -169,34 +234,47 @@ declare const closeOperation: (store: Store) => void;
 declare const isDone: (key: string, store: Store) => boolean;
 declare const markDone: (key: string, store: Store) => void;
 
-type TimelineAtomUpdate<ManagedAtom extends TimelineManageable> = StateUpdate<TokenType<ManagedAtom>> & {
+type TimelineAtomUpdate<ManagedAtom extends TimelineManageable> = Flat<StateUpdate<TokenType<ManagedAtom>> & {
     key: string;
     type: `atom_update`;
     timestamp: number;
     family?: FamilyMetadata;
-};
+}>;
 type TimelineSelectorUpdate<ManagedAtom extends TimelineManageable> = {
     key: string;
     type: `selector_update`;
     timestamp: number;
     atomUpdates: Omit<TimelineAtomUpdate<ManagedAtom>, `timestamp`>[];
 };
-type TimelineTransactionUpdate = TransactionUpdate<Func> & {
+type TimelineTransactionUpdate = Flat<TransactionUpdate<Func> & {
     key: string;
     type: `transaction_update`;
     timestamp: number;
-};
+}>;
+type TimelineStateCreation<T extends ReadableToken<any>> = Flat<StateCreation<T> & {
+    timestamp: number;
+}>;
+type TimelineStateDisposal<T extends ReadableToken<any>> = Flat<StateDisposal<T> & {
+    timestamp: number;
+}>;
+type TimelineMoleculeCreation<Key extends Json.Serializable> = Flat<MoleculeCreation<Key> & {
+    timestamp: number;
+}>;
+type TimelineMoleculeDisposal<Key extends Json.Serializable> = Flat<MoleculeDisposal<Key> & {
+    timestamp: number;
+}>;
 type Timeline<ManagedAtom extends TimelineManageable> = {
     type: `timeline`;
     key: string;
     at: number;
-    shouldCapture?: (update: TimelineUpdate<TimelineManageable>, timeline: Timeline<ManagedAtom>) => boolean;
+    shouldCapture?: (update: TimelineUpdate<ManagedAtom>, timeline: Timeline<ManagedAtom>) => boolean;
     timeTraveling: `into_future` | `into_past` | null;
     history: TimelineUpdate<ManagedAtom>[];
     selectorTime: number | null;
     transactionKey: string | null;
     install: (store: Store) => void;
-    subject: Subject<TimelineAtomUpdate<ManagedAtom> | TimelineSelectorUpdate<ManagedAtom> | TimelineTransactionUpdate | `redo` | `undo`>;
+    subject: Subject<TimelineUpdate<ManagedAtom> | `redo` | `undo`>;
+    subscriptions: Map<string, () => void>;
 };
 declare function createTimeline<ManagedAtom extends TimelineManageable>(options: TimelineOptions<ManagedAtom>, store: Store, data?: Timeline<ManagedAtom>): TimelineToken<ManagedAtom>;
 
@@ -221,6 +299,9 @@ declare class Store implements Lineage {
     selectorGraph: Junction<"upstreamSelectorKey", "downstreamSelectorKey", {
         source: string;
     }>;
+    molecules: Map<string, Molecule$1<any>>;
+    moleculeFamilies: Map<string, MoleculeFamily<any, any, any>>;
+    miscResources: Map<string, Disposable>;
     on: {
         atomCreation: Subject<AtomToken<unknown>>;
         atomDisposal: Subject<AtomToken<unknown>>;
@@ -230,15 +311,19 @@ declare class Store implements Lineage {
         transactionCreation: Subject<TransactionToken<Func>>;
         transactionApplying: StatefulSubject<TransactionProgress<Func> | null>;
         operationClose: Subject<OperationProgress>;
+        moleculeCreationStart: Subject<MoleculeToken<any, any, any>>;
+        moleculeCreationDone: Subject<MoleculeToken<any, any, any>>;
+        moleculeDisposal: Subject<MoleculeToken<any, any, any>>;
     };
     operation: OperationProgress;
     transactionMeta: TransactionEpoch | TransactionProgress<Func>;
     config: {
         name: string;
+        lifespan: `ephemeral` | `immortal`;
     };
     loggers: AtomIOLogger[];
     logger: Logger;
-    constructor(name: string, store?: Store | null);
+    constructor(config: Store[`config`], store?: Store | null);
 }
 declare const IMPLICIT: {
     STORE_INTERNAL: Store | undefined;
@@ -246,7 +331,7 @@ declare const IMPLICIT: {
 };
 declare const clearStore: (store: Store) => void;
 
-type Withdrawable = Atom<any> | AtomFamily<any, any> | MutableAtom<any, any> | MutableAtomFamily<any, any, any> | ReadableState<any> | ReadonlySelector<any> | ReadonlySelectorFamily<any, any> | RegularAtom<any> | RegularAtomFamily<any, any> | Selector<any> | SelectorFamily<any, any> | Timeline<any> | Transaction<any> | WritableSelector<any> | WritableSelectorFamily<any, any> | WritableState<any>;
+type Withdrawable = Atom<any> | AtomFamily<any, any> | Molecule$1<any> | MoleculeFamily$1<any, any, any> | MutableAtom<any, any> | MutableAtomFamily<any, any, any> | ReadableState<any> | ReadonlySelector<any> | ReadonlySelectorFamily<any, any> | RegularAtom<any> | RegularAtomFamily<any, any> | Selector<any> | SelectorFamily<any, any> | Timeline<any> | Transaction<any> | WritableSelector<any> | WritableSelectorFamily<any, any> | WritableState<any>;
 declare function withdraw<T>(token: RegularAtomToken<T>, store: Store): RegularAtom<T>;
 declare function withdraw<T extends Transceiver<any>>(token: MutableAtomToken<T, any>, store: Store): MutableAtom<T, any>;
 declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T>;
@@ -261,15 +346,15 @@ declare function withdraw<T, K extends Json.Serializable>(token: AtomFamilyToken
 declare function withdraw<T, K extends Json.Serializable>(token: ReadonlySelectorFamilyToken<T, K>, store: Store): ReadonlySelectorFamily<T, any>;
 declare function withdraw<T, K extends Json.Serializable>(token: WritableSelectorFamilyToken<T, K>, store: Store): WritableSelectorFamily<T, any>;
 declare function withdraw<T, K extends Json.Serializable>(token: SelectorFamilyToken<T, K>, store: Store): SelectorFamily<T, any>;
+declare function withdraw<K extends Json.Serializable, S extends {
+    [key: string]: any;
+}, P extends any[]>(token: MoleculeToken$1<K, S, P>, store: Store): Molecule$1<K> & S;
+declare function withdraw<K extends Json.Serializable, S extends {
+    [key: string]: any;
+}, P extends any[]>(token: MoleculeFamilyToken$1<K, S, P>, store: Store): MoleculeFamily$1<K, S, P>;
 declare function withdraw<T extends Func>(token: TransactionToken<T>, store: Store): Transaction<T extends Func ? T : never>;
 declare function withdraw<T>(token: TimelineToken<T>, store: Store): Timeline<T extends TimelineManageable ? T : never>;
 
-declare function withdrawOrCreate<T>(token: RegularAtomToken<T>, store: Store): Atom<T>;
-declare function withdrawOrCreate<T>(token: WritableSelectorToken<T>, store: Store): WritableSelector<T>;
-declare function withdrawOrCreate<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T>;
-declare function withdrawOrCreate<T>(token: WritableToken<T>, store: Store): WritableState<T>;
-declare function withdrawOrCreate<T>(token: ReadableToken<T>, store: Store): ReadableState<T>;
-
 interface Transceiver<Signal extends Json.Serializable> {
     do: (update: Signal) => number | `OUT_OF_RANGE` | null;
     undo: (update: Signal) => void;
@@ -285,9 +370,9 @@ declare function createMutableAtom<T extends Transceiver<any>, J extends Json.Se
 
 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 const getJsonFamily: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable, Key extends string>(mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>, store: Store) => WritableSelectorFamily<SerializableCore, Key>;
 
-declare const getJsonToken: <Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => WritableSelectorToken<SerializableCore>;
+declare const getJsonToken: <Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>, store: Store) => WritableSelectorToken<SerializableCore>;
 
 declare const getUpdateToken: <Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => RegularAtomToken<Signal<Core>>;
 
@@ -314,9 +399,9 @@ declare class Tracker<Mutable extends Transceiver<any>> {
 
 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);
+    readonly latestUpdateAtoms: RegularAtomFamily<typeof this.Update | null, FamilyMemberKey>;
+    readonly mutableAtoms: MutableAtomFamily<Core, any, FamilyMemberKey>;
+    constructor(mutableAtoms: MutableAtomFamily<Core, any, FamilyMemberKey>, store: Store);
 }
 
 declare function arbitrary(random?: () => number): string;
@@ -366,6 +451,8 @@ declare function createRegularAtomFamily<T, K extends Json.Serializable>(options
 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>;
 
+declare function disposeFromStore(token: MoleculeToken$1<any, any, any> | ReadableToken<any>, store?: Internal.Store): void;
+
 declare function findInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J>;
 declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T>;
 declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T>;
@@ -375,6 +462,27 @@ declare function findInStore<T, K extends Json.Serializable, Key extends K>(toke
 declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T>;
 declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T>;
 
+declare function initFamilyMember<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J>;
+declare function initFamilyMember<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T>;
+declare function initFamilyMember<T, K extends Json.Serializable, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T>;
+declare function initFamilyMember<T, K extends Json.Serializable, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key, store: Store): WritableSelectorToken<T>;
+declare function initFamilyMember<T, K extends Json.Serializable, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key, store: Store): ReadonlySelectorToken<T>;
+declare function initFamilyMember<T, K extends Json.Serializable, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T>;
+declare function initFamilyMember<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T>;
+declare function initFamilyMember<T, K extends Json.Serializable, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T>;
+
+declare function seekInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J> | undefined;
+declare function seekInStore<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T> | undefined;
+declare function seekInStore<T, K extends Json.Serializable, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T> | undefined;
+declare function seekInStore<T, K extends Json.Serializable, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key, store: Store): WritableSelectorToken<T> | undefined;
+declare function seekInStore<T, K extends Json.Serializable, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key, store: Store): ReadonlySelectorToken<T> | undefined;
+declare function seekInStore<T, K extends Json.Serializable, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T> | undefined;
+declare function seekInStore<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T> | undefined;
+declare function seekInStore<T, K extends Json.Serializable, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T> | undefined;
+declare function seekInStore<K extends Json.Serializable, S extends {
+    [key: string]: any;
+}>(token: MoleculeFamilyToken$1<K, S, any[]>, key: K, store: Store): MoleculeToken$1<K, S, any[]> | undefined;
+
 type EnvironmentData = {
     window: typeof window | undefined;
     global: typeof global | undefined;
@@ -388,6 +496,11 @@ declare const readOrComputeValue: <T>(state: ReadableState<T>, target: Store) =>
 
 declare function ingestAtomUpdate(applying: `newValue` | `oldValue`, atomUpdate: KeyedStateUpdate<any>, store: Store): void;
 
+declare function ingestCreationEvent(update: StateCreation<any>, applying: `newValue` | `oldValue`, store: Store): void;
+declare function ingestDisposalEvent(update: StateDisposal<any>, applying: `newValue` | `oldValue`, store: Store): void;
+declare function ingestMoleculeCreationEvent(update: MoleculeCreation<any>, applying: `newValue` | `oldValue`, store: Store): void;
+declare function ingestMoleculeDisposalEvent(update: MoleculeDisposal<any>, applying: `newValue` | `oldValue`, store: Store): void;
+
 declare function ingestSelectorUpdate(applying: `newValue` | `oldValue`, selectorUpdate: TimelineSelectorUpdate<any>, store: Store): void;
 
 declare function ingestTransactionUpdate(applying: `newValue` | `oldValue`, transactionUpdate: TransactionUpdate<any>, store: Store): void;
@@ -421,7 +534,7 @@ declare class LazyMap<K, V> extends Map<K, V> {
     delete(key: K): boolean;
 }
 
-type AtomIOToken = ReadableFamilyToken<any, any> | ReadableToken<any> | TimelineToken<any> | TransactionToken<any>;
+type AtomIOToken = MoleculeFamilyToken$1<any, any, any> | MoleculeToken$1<any, any, any> | ReadableFamilyToken<any, any> | ReadableToken<any> | TimelineToken<any> | TransactionToken<any>;
 declare class NotFoundError extends Error {
     constructor(token: AtomIOToken, store: Store);
 }
@@ -492,4 +605,4 @@ 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 AtomIOState, type AtomKey, type ChildStore, type EnvironmentData, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, type MutableAtom, NotFoundError, type OperationProgress, type ReadableState, type ReadonlySelector, type ReadonlySelectorKey, type RegularAtom, type RootStore, 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 TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableSelector, type WritableState, abortTransaction, actUponStore, addAtomToTimeline, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeSelector, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawOrCreate };
+export { type Atom, type AtomIOState, type AtomKey, type ChildStore, type EnvironmentData, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, type MutableAtom, NotFoundError, type OperationProgress, type ReadableState, type ReadonlySelector, type ReadonlySelectorKey, type RegularAtom, type RootStore, type Selector, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineMoleculeCreation, type TimelineMoleculeDisposal, type TimelineSelectorUpdate, type TimelineStateCreation, type TimelineStateDisposal, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableSelector, type WritableState, abortTransaction, actUponStore, addAtomToTimeline, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeSelector, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMember, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };