atom.io 0.23.5 → 0.24.0

package/internal/dist/index.d.ts

@@ -1,9 +1,7 @@
-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 * as atom_io from 'atom.io';
+import { Func, TransactionToken, TransactionUpdate, TransactionOptions, TransactorsWithRunAndEnv, RegularAtomToken, MutableAtomToken, AtomToken, WritableSelectorToken, ReadonlySelectorToken, SelectorToken, WritableToken, MoleculeToken, MoleculeFamily, MoleculeFamilyToken, ReadableToken, TimelineManageable, Flat, StateUpdate, TokenType, FamilyMetadata, StateCreation, StateDisposal, MoleculeConstructor, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, TimelineToken, WritableSelectorFamily, MutableAtomFamily, RegularAtomFamily, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomFamily, ReadableFamily, SelectorFamily, WritableFamily, RegularAtomFamilyToken, MutableAtomFamilyToken, AtomFamilyToken, ReadonlySelectorFamilyToken, WritableSelectorFamilyToken, SelectorFamilyToken, ReadableFamilyToken, WritableFamilyToken, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, MoleculeKey, KeyedStateUpdate, MoleculeFamilyOptions, MK, MoleculeParams, 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';
+import { Join } from 'atom.io/data';
 
 type primitive = boolean | number | string | null;
 
@@ -152,68 +150,13 @@ 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>;
+}, P extends any[]>(state: Molecule<any>): MoleculeToken<any>;
 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>;
+}, P extends any[]>(state: MoleculeFamily<any>): MoleculeFamilyToken<any>;
 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;
-    protected [Symbol.dispose](): void;
-    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;
@@ -257,10 +200,10 @@ type TimelineStateCreation<T extends ReadableToken<any>> = Flat<StateCreation<T>
 type TimelineStateDisposal<T extends ReadableToken<any>> = Flat<StateDisposal<T> & {
     timestamp: number;
 }>;
-type TimelineMoleculeCreation<Key extends Json.Serializable> = Flat<MoleculeCreation<Key> & {
+type TimelineMoleculeCreation<M extends MoleculeConstructor> = Flat<MoleculeCreation<M> & {
     timestamp: number;
 }>;
-type TimelineMoleculeDisposal<Key extends Json.Serializable> = Flat<MoleculeDisposal<Key> & {
+type TimelineMoleculeDisposal = Flat<MoleculeDisposal & {
     timestamp: number;
 }>;
 type Timeline<ManagedAtom extends TimelineManageable> = {
@@ -299,8 +242,12 @@ declare class Store implements Lineage {
     selectorGraph: Junction<"upstreamSelectorKey", "downstreamSelectorKey", {
         source: string;
     }>;
-    molecules: Map<string, Molecule$1<any>>;
-    moleculeFamilies: Map<string, MoleculeFamily<any, any, any>>;
+    molecules: Map<string, Molecule<any>>;
+    moleculeFamilies: Map<string, atom_io.Flat<atom_io.MoleculeFamilyToken<any> & {
+        subject: Subject<atom_io.MoleculeDisposal | atom_io.MoleculeCreation<any>>;
+        dependsOn: "all" | "any";
+        new: any;
+    }>>;
     miscResources: Map<string, Disposable>;
     on: {
         atomCreation: Subject<AtomToken<unknown>>;
@@ -311,9 +258,9 @@ 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>>;
+        moleculeCreationStart: Subject<MoleculeToken<any>>;
+        moleculeCreationDone: Subject<MoleculeToken<any>>;
+        moleculeDisposal: Subject<MoleculeToken<any>>;
     };
     operation: OperationProgress;
     transactionMeta: TransactionEpoch | TransactionProgress<Func>;
@@ -331,7 +278,7 @@ declare const IMPLICIT: {
 };
 declare const clearStore: (store: Store) => void;
 
-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>;
+type Withdrawable = Atom<any> | AtomFamily<any, any> | Molecule<any> | MoleculeFamily<any> | MutableAtom<any, any> | MutableAtomFamily<any, any, any> | ReadableFamily<any, any> | ReadableState<any> | ReadonlySelector<any> | ReadonlySelectorFamily<any, any> | RegularAtom<any> | RegularAtomFamily<any, any> | Selector<any> | SelectorFamily<any, any> | Timeline<any> | Transaction<any> | WritableFamily<any, 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>;
@@ -346,12 +293,10 @@ 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, K extends Json.Serializable>(token: ReadableFamilyToken<T, K>, store: Store): ReadableFamily<T, any>;
+declare function withdraw<T, K extends Json.Serializable>(token: WritableFamilyToken<T, K>, store: Store): WritableFamily<T, any>;
+declare function withdraw<M extends MoleculeConstructor>(token: MoleculeToken<M>, store: Store): Molecule<M>;
+declare function withdraw<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, store: Store): MoleculeFamily<M>;
 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>;
 
@@ -451,7 +396,7 @@ 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 disposeFromStore(token: MoleculeToken<any> | ReadableToken<any>, store?: 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>;
@@ -462,14 +407,14 @@ 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 initFamilyMemberInStore<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 initFamilyMemberInStore<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T>;
+declare function initFamilyMemberInStore<T, K extends Json.Serializable, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T>;
+declare function initFamilyMemberInStore<T, K extends Json.Serializable, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key, store: Store): WritableSelectorToken<T>;
+declare function initFamilyMemberInStore<T, K extends Json.Serializable, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key, store: Store): ReadonlySelectorToken<T>;
+declare function initFamilyMemberInStore<T, K extends Json.Serializable, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T>;
+declare function initFamilyMemberInStore<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T>;
+declare function initFamilyMemberInStore<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;
@@ -479,13 +424,9 @@ declare function seekInStore<T, K extends Json.Serializable, Key extends K>(toke
 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;
+declare function seekInStore<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>, store: Store): MoleculeKey<M> | undefined;
 
 type EnvironmentData = {
-    window: typeof window | undefined;
-    global: typeof global | undefined;
     store: Store;
 };
 declare function getEnvironmentData(store: Store): EnvironmentData;
@@ -499,7 +440,7 @@ declare function ingestAtomUpdate(applying: `newValue` | `oldValue`, atomUpdate:
 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 ingestMoleculeDisposalEvent(update: MoleculeDisposal, applying: `newValue` | `oldValue`, store: Store): void;
 
 declare function ingestSelectorUpdate(applying: `newValue` | `oldValue`, selectorUpdate: TimelineSelectorUpdate<any>, store: Store): void;
 
@@ -534,7 +475,36 @@ declare class LazyMap<K, V> extends Map<K, V> {
     delete(key: K): boolean;
 }
 
-type AtomIOToken = MoleculeFamilyToken$1<any, any, any> | MoleculeToken$1<any, any, any> | ReadableFamilyToken<any, any> | ReadableToken<any> | TimelineToken<any> | TransactionToken<any>;
+declare function createMoleculeFamily<M extends MoleculeConstructor>(options: MoleculeFamilyOptions<M>, store: Store): MoleculeFamilyToken<M>;
+
+declare function disposeMolecule<M extends MoleculeConstructor>(token: MoleculeToken<M>, store: Store): void;
+
+declare class Molecule<M extends MoleculeConstructor> implements MoleculeToken<M> {
+    readonly key: MK<M>;
+    readonly type = "molecule";
+    stringKey: string;
+    family?: MoleculeFamilyToken<M>;
+    readonly subject: Subject<StateCreation<any> | StateDisposal<any>>;
+    tokens: Map<string, ReadableToken<any>>;
+    above: Map<string, Molecule<any>>;
+    below: Map<string, Molecule<any>>;
+    joins: Map<string, Join<any, any, any, any>>;
+    instance: InstanceType<M>;
+    constructor(ctx: Molecule<any> | Molecule<any>[] | undefined, key: MK<M>, family?: MoleculeFamilyToken<M>);
+}
+
+declare function growMoleculeInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(molecule: Molecule<any>, family: MutableAtomFamily<T, J, K>, store: Store): MutableAtomToken<T, J>;
+declare function growMoleculeInStore<T, K extends Json.Serializable>(molecule: Molecule<any>, family: RegularAtomFamily<T, K>, store: Store): RegularAtomToken<T>;
+declare function growMoleculeInStore<T, K extends Json.Serializable>(molecule: Molecule<any>, family: AtomFamily<T, K>, store: Store): AtomToken<T>;
+declare function growMoleculeInStore<T, K extends Json.Serializable>(molecule: Molecule<any>, family: WritableSelectorFamily<T, K>, store: Store): WritableSelectorToken<T>;
+declare function growMoleculeInStore<T, K extends Json.Serializable>(molecule: Molecule<any>, family: ReadonlySelectorFamily<T, K>, store: Store): ReadonlySelectorToken<T>;
+declare function growMoleculeInStore<T, K extends Json.Serializable>(molecule: Molecule<any>, family: SelectorFamily<T, K>, store: Store): SelectorToken<T>;
+declare function growMoleculeInStore<T, K extends Json.Serializable>(molecule: Molecule<any>, family: WritableFamily<T, K>, store: Store): WritableToken<T>;
+declare function growMoleculeInStore<T, K extends Json.Serializable>(molecule: Molecule<any>, family: ReadableFamily<T, K>, store: Store): ReadableToken<T>;
+
+declare function makeMoleculeInStore<M extends MoleculeConstructor>(store: Store, context: MoleculeToken<M> | MoleculeToken<M>[], familyToken: MoleculeFamilyToken<M>, key: MoleculeKey<M>, ...params: MoleculeParams<M>): MoleculeToken<M>;
+
+type AtomIOToken = MoleculeFamilyToken<any> | MoleculeToken<any> | ReadableFamilyToken<any, any> | ReadableToken<any> | TimelineToken<any> | TransactionToken<any>;
 declare class NotFoundError extends Error {
     constructor(token: AtomIOToken, store: Store);
 }
@@ -605,4 +575,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 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 };
+export { type Atom, type AtomIOState, type AtomKey, type ChildStore, type EnvironmentData, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, Molecule, 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, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };