atom.io 0.30.7 → 0.31.1

package/dist/index.d.ts

@@ -1,48 +1,71 @@
-import { Transceiver, Func, EnvironmentData, Flat, Subject, Store, Each, Timeline, TimelineAtomUpdate, TimelineMoleculeCreation, TimelineMoleculeDisposal, TimelineSelectorUpdate, TimelineStateCreation, TimelineStateDisposal, TimelineTransactionUpdate } from 'atom.io/internal';
+import { Transceiver, Func, EnvironmentData, Timeline, TimelineAtomUpdate, TimelineMoleculeCreation, TimelineMoleculeDisposal, TimelineSelectorUpdate, TimelineStateCreation, TimelineStateDisposal, TimelineTransactionUpdate, Store, Each, Flat } from 'atom.io/internal';
 import { Json, JsonInterface, Canonical, stringified } from 'atom.io/json';
-import { MoleculeConstructor as MoleculeConstructor$1, MoleculeToken as MoleculeToken$1, MoleculeFamilyToken as MoleculeFamilyToken$1, MoleculeParams as MoleculeParams$1, getState as getState$1, setState as setState$1, makeMolecule as makeMolecule$1, ActorToolkit as ActorToolkit$1, MutableAtomFamilyToken as MutableAtomFamilyToken$1, MutableAtomToken as MutableAtomToken$1, RegularAtomFamilyToken as RegularAtomFamilyToken$1, RegularAtomToken as RegularAtomToken$1, WritableSelectorFamilyToken as WritableSelectorFamilyToken$1, WritableSelectorToken as WritableSelectorToken$1, ReadonlySelectorFamilyToken as ReadonlySelectorFamilyToken$1, ReadonlySelectorToken as ReadonlySelectorToken$1, WritableFamilyToken as WritableFamilyToken$1, WritableToken as WritableToken$1, ReadableFamilyToken as ReadableFamilyToken$1, ReadableToken as ReadableToken$1, MoleculeCreationClassic as MoleculeCreationClassic$1, MoleculeDisposalClassic as MoleculeDisposalClassic$1 } from 'atom.io';
+import { getState as getState$1, setState as setState$1, ReadableFamilyToken as ReadableFamilyToken$1, ReadableToken as ReadableToken$1, RegularAtomToken as RegularAtomToken$1, MutableAtomToken as MutableAtomToken$1, WritableSelectorToken as WritableSelectorToken$1, ReadonlySelectorToken as ReadonlySelectorToken$1, WritableToken as WritableToken$1, RegularAtomFamilyToken as RegularAtomFamilyToken$1, MutableAtomFamilyToken as MutableAtomFamilyToken$1, WritableSelectorFamilyToken as WritableSelectorFamilyToken$1, ReadonlySelectorFamilyToken as ReadonlySelectorFamilyToken$1, WritableFamilyToken as WritableFamilyToken$1 } from 'atom.io';
 import { findState } from 'atom.io/ephemeral';
 import { seekState } from 'atom.io/immortal';
-import { JoinToken } from 'atom.io/data';
 
+/**
+ * @public
+ * Create a mutable atom, a global reactive variable in the implicit store
+ *
+ * The value of a mutable atom must be some kind of {@link Transceiver}.
+ *
+ * @param options - {@link MutableAtomOptions}.
+ * @returns
+ * A reference to the atom created: a {@link MutableAtomToken}
+ * @overload Mutable
+ */
+declare function atom<T extends Transceiver<any>, J extends Json.Serializable>(options: MutableAtomOptions<T, J>): MutableAtomToken<T, J>;
+/**
+ * @public
+ * Create a regular atom, a global reactive variable in the implicit store
+ * @param options - {@link RegularAtomOptions}.
+ * @returns
+ * A reference to the atom created: a {@link RegularAtomToken}
+ * @overload Regular
+ */
+declare function atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T>;
+/** @public */
 type Effectors<T> = {
-    setSelf: <V extends T>(next: V | ((oldValue: T) => V)) => void;
+    /**
+     * Set the value of the atom
+     * @param next - The new value of the atom, or a setter function
+     */
+    setSelf: <New extends T>(next: New | Setter<T, New>) => void;
+    /** Subscribe to changes to the atom */
     onSet: (callback: (options: {
         newValue: T;
         oldValue: T;
     }) => void) => void;
 };
+/**
+ * @public
+ * A function that runs side effects when the atom is set
+ * @param tools - {@link Effectors} that can be used to run side effects
+ * @returns
+ * Optionally, a cleanup function that will be called when the atom is disposed
+ */
 type AtomEffect<T> = (tools: Effectors<T>) => (() => void) | void;
+/** @public */
 type RegularAtomOptions<T> = {
+    /** The unique identifier of the atom */
     key: string;
+    /** The starting value of the atom */
     default: T | (() => T);
+    /** Hooks used to run side effects when the atom is set */
     effects?: AtomEffect<T>[];
 };
 type MutableAtomOptions<T extends Transceiver<any>, J extends Json.Serializable> = JsonInterface<T, J> & Omit<RegularAtomOptions<T>, `default`> & {
     default: () => T;
     mutable: true;
 };
-/**
- * @public
- * Declare a mutable global reactive variable.
- * @param options - Configuration for this mutable atom.
- * @returns
- * The token for your mutable atom.
- * @overload Mutable
- */
-declare function atom<T extends Transceiver<any>, J extends Json.Serializable>(options: MutableAtomOptions<T, J>): MutableAtomToken<T, J>;
-/**
- * @public
- * Declare a regular global reactive variable.
- * @param options - Configuration for this regular atom.
- * @returns
- * The token for your regular atom.
- * @overload Regular
- */
-declare function atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T>;
+/** @public */
 type RegularAtomFamilyOptions<T, K extends Canonical> = {
+    /** The unique identifier of the atom family */
     key: string;
+    /** The starting value of the atom family */
     default: T | ((key: K) => T);
+    /** Hooks used to run side effects when an atom in the family is set  */
     effects?: (key: K) => AtomEffect<T>[];
 };
 type RegularAtomFamilyToken<T, K extends Canonical> = {
@@ -77,43 +100,36 @@ type StateCreation<Token extends ReadableToken<any>> = {
     type: `state_creation`;
     token: Token;
 };
-type StateDisposal<Token extends ReadableToken<any>> = {
+type AtomDisposal<Token extends ReadableToken<any>> = {
     type: `state_disposal`;
+    subType: `atom`;
     token: Token;
-    value?: TokenType<Token>;
+    value: TokenType<Token>;
 };
-type MoleculeCreationClassic<M extends MoleculeConstructor$1> = {
-    type: `molecule_creation`;
-    subType: `classic`;
-    token: MoleculeToken$1<M>;
-    family: MoleculeFamilyToken$1<M>;
-    context: MoleculeToken$1<any>[];
-    params: MoleculeParams$1<M>;
+type SelectorDisposal<Token extends ReadableToken<any>> = {
+    type: `state_disposal`;
+    subType: `selector`;
+    token: Token;
 };
-type MoleculeCreationModern = {
+type StateDisposal<Token extends ReadableToken<any>> = AtomDisposal<Token> | SelectorDisposal<Token>;
+type MoleculeCreation = {
     type: `molecule_creation`;
-    subType: `modern`;
     key: Canonical;
     provenance: Canonical;
 };
-type MoleculeCreation<M extends MoleculeConstructor$1> = MoleculeCreationClassic<M> | MoleculeCreationModern;
-type MoleculeDisposalClassic = {
+type MoleculeDisposal = {
     type: `molecule_disposal`;
-    subType: `classic`;
-    token: MoleculeToken$1<any>;
-    family: MoleculeFamilyToken$1<any>;
-    context: MoleculeToken$1<any>[];
+    key: Canonical;
+    provenance: stringified<Canonical>[];
     values: [key: string, value: any][];
 };
-type MoleculeDisposalModern = {
-    type: `molecule_disposal`;
-    subType: `modern`;
+type MoleculeTransfer = {
+    type: `molecule_transfer`;
     key: Canonical;
-    provenance: Canonical;
-    values: [key: string, value: any][];
+    from: Canonical[];
+    to: Canonical[];
 };
-type MoleculeDisposal = MoleculeDisposalClassic | MoleculeDisposalModern;
-type TransactionUpdateContent = KeyedStateUpdate<unknown> | MoleculeCreation<any> | MoleculeDisposal | StateCreation<ReadableToken<unknown>> | StateDisposal<ReadableToken<unknown>> | TransactionUpdate<Func>;
+type TransactionUpdateContent = KeyedStateUpdate<unknown> | MoleculeCreation | MoleculeDisposal | MoleculeTransfer | StateCreation<ReadableToken<unknown>> | StateDisposal<ReadableToken<unknown>> | TransactionUpdate<Func>;
 type TransactionUpdate<F extends Func> = {
     type: `transaction_update`;
     key: string;
@@ -137,7 +153,6 @@ type ActorToolkit = Readonly<{
     find: typeof findState;
     seek: typeof seekState;
     json: <T extends Transceiver<any>, J extends Json.Serializable>(state: MutableAtomToken<T, J>) => WritableSelectorToken<J>;
-    make: typeof makeMolecule$1;
     dispose: typeof disposeState;
     run: typeof runTransaction;
     env: () => EnvironmentData;
@@ -162,7 +177,26 @@ type ReadonlySelectorOptions<T> = {
     key: string;
     get: Read<() => T>;
 };
+/**
+ * @public
+ * Declare a selector. The value of a selector should depend
+ * on the value of atoms or other selectors in the store.
+ *
+ * A writable selector can be "set" to a new value.
+ * It is advised to set its dependencies to values
+ * that would produce the new value of the selector.
+ * @param options - {@link WritableSelectorOptions}.
+ * @returns
+ * The token for your selector.
+ * @overload Writable
+ */
 declare function selector<T>(options: WritableSelectorOptions<T>): WritableSelectorToken<T>;
+/**
+ * @public
+ * Declare a selector. The value of a selector should depend
+ * on the value of atoms or other selectors in the store.
+ * @param options - {@link ReadonlySelectorOptions}.
+ */
 declare function selector<T>(options: ReadonlySelectorOptions<T>): ReadonlySelectorToken<T>;
 type WritableSelectorFamilyOptions<T, K extends Canonical> = {
     key: string;
@@ -189,116 +223,56 @@ type SelectorFamilyToken<T, K extends Canonical> = ReadonlySelectorFamilyToken<T
 declare function selectorFamily<T, K extends Canonical>(options: WritableSelectorFamilyOptions<T, K>): WritableSelectorFamilyToken<T, K>;
 declare function selectorFamily<T, K extends Canonical>(options: ReadonlySelectorFamilyOptions<T, K>): ReadonlySelectorFamilyToken<T, K>;
 
-type CtorToolkit<K extends Canonical> = Flat<Omit<ActorToolkit$1, `find`> & {
-    bond<T extends Transceiver<any>, J extends Json.Serializable>(family: MutableAtomFamilyToken$1<T, J, K>): MutableAtomToken$1<T, J>;
-    bond<T>(family: RegularAtomFamilyToken$1<T, K>): RegularAtomToken$1<T>;
-    bond<T>(family: WritableSelectorFamilyToken$1<T, K>): WritableSelectorToken$1<T>;
-    bond<T>(family: ReadonlySelectorFamilyToken$1<T, K>): ReadonlySelectorToken$1<T>;
-    bond<T>(family: WritableFamilyToken$1<T, K>): WritableToken$1<T>;
-    bond<T>(family: ReadableFamilyToken$1<T, K>): ReadableToken$1<T>;
-    bond<J extends JoinToken<any, any, any, any, any, any>>(joinToken: J, role: {
-        as: J extends JoinToken<infer A, string, infer B, string, any, any> ? A | B : never;
-    }): J extends JoinToken<any, any, any, any, any, infer Content> ? Content extends null ? {
-        relatedKeys: ReadonlySelectorToken$1<string[]>;
-    } : {
-        relatedKeys: ReadonlySelectorToken$1<string[]>;
-        relatedEntries: ReadonlySelectorToken$1<[
-            key: string,
-            value: Content
-        ][]>;
-    } : never;
-    claim(below: MoleculeToken<any>, options: {
-        exclusive: boolean;
-    }): void;
-    spawn<Key extends Canonical, Ctor extends MoleculeConstructor>(family: MoleculeFamilyToken<Ctor>, key: Key, ...params: MoleculeParams<Ctor>): MoleculeToken<Ctor>;
-}>;
-type MoleculeConstructor = new (toolkit: CtorToolkit<any>, key: any, ...params: any) => any;
-type Tail<T extends any[]> = T extends [any, ...infer Rest] ? Rest : any[];
-type MoleculeParams<M extends MoleculeConstructor> = Tail<Tail<ConstructorParameters<M>>>;
-type MoleculeFamilyOptions<M extends MoleculeConstructor> = {
-    key: string;
-    dependsOn?: `all` | `any`;
-    new: M;
-};
-type MoleculeFamilyToken<M extends MoleculeConstructor> = {
+type TimelineManageable = AtomFamilyToken<any, any> | AtomToken<any>;
+type AtomOnly<M extends TimelineManageable> = M extends AtomFamilyToken<any, any> ? AtomToken<any> : M extends AtomToken<any> ? M : never;
+type TimelineToken<M> = {
     key: string;
-    type: `molecule_family`;
-    dependsOn: `all` | `any`;
-    __M?: M;
-};
-type MoleculeFamily<M extends MoleculeConstructor> = Flat<MoleculeFamilyToken<M> & {
-    subject: Subject<MoleculeCreationClassic$1<M> | MoleculeDisposalClassic$1>;
-    dependsOn: `all` | `any`;
-    new: M;
-}>;
-type MoleculeToken<M extends MoleculeConstructor> = {
-    key: MoleculeKey<M>;
-    type: `molecule`;
-    family?: MoleculeFamilyToken<M>;
+    type: `timeline`;
     __M?: M;
 };
-declare function moleculeFamily<M extends MoleculeConstructor>(options: MoleculeFamilyOptions<M>): MoleculeFamilyToken<M>;
-declare function makeMolecule<M extends MoleculeConstructor>(context: MoleculeToken<any> | MoleculeToken<any>[], family: MoleculeFamilyToken<M>, key: MoleculeKey<M>, ...params: MoleculeParams<M>): MoleculeToken<M>;
-type MoleculeType<T extends MoleculeFamilyToken<any>> = T extends MoleculeFamilyToken<infer M> ? M : T extends MoleculeToken<infer M> ? M : never;
-type MoleculeKey<M extends MoleculeConstructor> = InstanceType<M>[`key`];
-declare function makeRootMoleculeInStore(key: string, store?: Store): MoleculeToken<ObjectConstructor>;
-
-declare const $provenance: unique symbol;
-type Claim<H extends Hierarchy, V extends Vassal<H>, A extends Above<V, H>> = V & {
-    [$provenance]?: A;
-};
-declare function allocateIntoStore<H extends Hierarchy, V extends Vassal<H>, A extends Above<V, H>>(store: Store, provenance: A, key: V): Claim<H, V, A>;
-declare function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>, A extends Above<V, H>>(store: Store, claim: Claim<H, V, A>): void;
-declare function realm<H extends Hierarchy>(store: Store): {
-    root: MoleculeToken<ObjectConstructor>;
-    allocate: <V extends Vassal<H>, A extends Above<V, H>>(provenance: A, key: V) => Claim<H, V, A>;
-    deallocate: <V extends Vassal<H>, A extends Above<V, H>>(claim: Claim<H, V, A>) => void;
-};
-declare const T$ = "T$";
-type T$ = typeof T$;
-type TypeTag<T extends string> = `${T$}--${T}`;
-type SingularTypedKey<T extends string = string> = `${T}::${string}`;
-type CompoundTypedKey<A extends string = string, B extends string = string, C extends string = string> = `${TypeTag<A>}==${SingularTypedKey<B>}++${SingularTypedKey<C>}`;
-type TypedKey<A extends string = string, B extends string = string, C extends string = string> = CompoundTypedKey<A, B, C> | SingularTypedKey<A>;
-type Scope = SingularTypedKey[];
-type MutualFealty = {
-    above: Scope;
-    below: CompoundTypedKey;
-    style: `all` | `any`;
-};
-type ExclusiveFealty = {
-    above: TypedKey | `root`;
-    below: Scope;
+type TimelineOptions<ManagedAtom extends TimelineManageable> = {
+    key: string;
+    scope: ManagedAtom[];
+    shouldCapture?: (update: TimelineUpdate<ManagedAtom>, timeline: Timeline<TimelineManageable>) => boolean;
 };
-type Fealty = ExclusiveFealty | MutualFealty;
-type Hierarchy<F extends Fealty[] = Fealty[]> = Each<F>;
-type Vassal<H extends Hierarchy> = {
-    [K in keyof H]: H[K] extends MutualFealty ? H[K][`below`] : H[K] extends {
-        below: Array<infer V>;
-    } ? V extends TypedKey ? V : never : never;
-}[keyof H];
-type Above<TK extends TypedKey, H extends Hierarchy> = {
-    [K in keyof H]: H[K] extends MutualFealty ? TK extends H[K][`below`] ? H[K][`above`] : never : H[K] extends {
-        below: Array<infer V>;
-    } ? TK extends V ? H[K] extends ExclusiveFealty ? H[K][`above`] : never : never : never;
-}[keyof H];
-type Below<TK extends TypedKey | TypedKey[], H extends Hierarchy> = {
-    [K in keyof H]: H[K] extends MutualFealty ? TK extends H[K][`above`] ? H[K][`below`] : TK extends H[K][`above`][number] ? H[K][`below`] : never : H[K] extends {
-        above: infer V;
-    } ? TK extends V ? H[K] extends ExclusiveFealty ? H[K][`below`][number] : never : never : never;
-}[keyof H];
-type Mutuals<TK extends TypedKey | TypedKey[], H extends Hierarchy> = {
-    [K in keyof H]: H[K] extends MutualFealty ? TK extends H[K][`above`][number] ? [mutual: Exclude<H[K][`above`][number], TK>, below: H[K][`below`]] : never : never;
-}[keyof H];
+type TimelineUpdate<ManagedAtom extends TimelineManageable> = TimelineAtomUpdate<ManagedAtom> | TimelineMoleculeCreation | TimelineMoleculeDisposal | TimelineSelectorUpdate<ManagedAtom> | TimelineStateCreation<AtomOnly<ManagedAtom>> | TimelineStateDisposal<AtomOnly<ManagedAtom>> | TimelineTransactionUpdate;
+declare const timeline: <ManagedAtom extends TimelineManageable>(options: TimelineOptions<ManagedAtom>) => TimelineToken<ManagedAtom>;
+declare const redo: (tl: TimelineToken<any>) => void;
+declare const undo: (tl: TimelineToken<any>) => void;
 
-declare function disposeState(token: MoleculeToken<any> | ReadableToken<any>): void;
+/**
+ * @public
+ * Disposes of a state in the implicit store
+ * @param token - The token of the state to dispose
+ * @overload Default
+ */
+declare function disposeState(token: ReadableToken<any>): void;
+/**
+ * @public
+ * Disposes of a state family in the implicit store
+ * @param token - The token of the state family to dispose
+ * @param key - The unique key of the state to dispose
+ */
 declare function disposeState<K extends Canonical>(token: ReadableFamilyToken<any, K>, key: K): void;
-declare function disposeState<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>): void;
 
+/**
+ * @public
+ * Get the current value of a state
+ * @param token - The token of the state to get
+ * @return The current value of the state
+ * @overload Default
+ * @default
+ */
 declare function getState<T>(token: ReadableToken<T>): T;
-declare function getState<M extends MoleculeConstructor>(token: MoleculeToken<M>): InstanceType<M>;
+/**
+ * @public
+ * Get the current value of a state family
+ * @param token - The token of a state family
+ * @param key - The unique key of the state to get
+ * @return The current value of the state
+ * @overload Streamlined
+ */
 declare function getState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): T;
-declare function getState<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: Canonical): InstanceType<M>;
 
 declare const LoggerIconDictionary: {
     readonly "\u231B": "Timeline event fully captured";
@@ -370,24 +344,91 @@ declare class AtomIOLogger implements Logger {
     warn: LogFn;
 }
 
+declare const $claim: unique symbol;
+type Claim<K extends Canonical> = K & {
+    [$claim]?: true;
+};
+declare class Realm<H extends Hierarchy> {
+    store: Store;
+    constructor(store?: Store);
+    allocate<V extends Vassal<H>, A extends Above<V, H>>(provenance: A, key: V, attachmentStyle?: `all` | `any`): Claim<V>;
+    fuse<C extends CompoundFrom<H>, T extends C extends CompoundTypedKey<infer t, any, any> ? t : never, A extends C extends CompoundTypedKey<any, infer v, any> ? v : never, B extends C extends CompoundTypedKey<any, any, infer m> ? m : never>(type: T, reagentA: SingularTypedKey<A>, reagentB: SingularTypedKey<B>): Claim<CompoundTypedKey<T, A, B>>;
+    deallocate<V extends Vassal<H>>(claim: Claim<V>): void;
+    claim<V extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V, H>>(newProvenance: A, claim: Claim<V>, exclusive?: `exclusive`): Claim<V>;
+}
+declare class Anarchy {
+    store: Store;
+    realm: Realm<any>;
+    constructor(store?: Store);
+    allocate(provenance: Canonical, key: Canonical, attachmentStyle?: `all` | `any`): void;
+    deallocate(key: Canonical): void;
+    claim(newProvenance: Canonical, key: Canonical, exclusive?: `exclusive`): void;
+}
+declare const T$ = "T$";
+type T$ = typeof T$;
+type TypeTag<T extends string> = `${T$}--${T}`;
+type SingularTypedKey<T extends string = string> = `${T}::${string}`;
+type CompoundTypedKey<A extends string = string, B extends string = string, C extends string = string> = `${TypeTag<A>}==${SingularTypedKey<B>}++${SingularTypedKey<C>}`;
+type TypedKey<A extends string = string, B extends string = string, C extends string = string> = CompoundTypedKey<A, B, C> | SingularTypedKey<A>;
+type Scope = SingularTypedKey[];
+type MutualFealty = {
+    above: Scope;
+    below: CompoundTypedKey;
+};
+type ExclusiveFealty = {
+    above: TypedKey | `root`;
+    below: Scope;
+};
+type Fealty = ExclusiveFealty | MutualFealty;
+type Hierarchy<F extends Fealty[] = Fealty[]> = Each<F>;
+type Vassal<H extends Hierarchy> = {
+    [K in keyof H]: H[K] extends MutualFealty ? H[K][`below`] : H[K] extends {
+        below: Array<infer V>;
+    } ? V extends TypedKey ? V : never : never;
+}[keyof H];
+type Above<TK extends TypedKey, H extends Hierarchy> = {
+    [K in keyof H]: H[K] extends MutualFealty ? TK extends H[K][`below`] ? H[K][`above`] : never : H[K] extends {
+        below: Array<infer V>;
+    } ? TK extends V ? H[K] extends ExclusiveFealty ? H[K][`above`] : never : never : never;
+}[keyof H];
+type Below<TK extends TypedKey | TypedKey[], H extends Hierarchy> = {
+    [K in keyof H]: H[K] extends MutualFealty ? TK extends H[K][`above`] ? H[K][`below`] : TK extends H[K][`above`][number] ? H[K][`below`] : never : H[K] extends {
+        above: infer V;
+    } ? TK extends V ? H[K] extends ExclusiveFealty ? H[K][`below`][number] : never : never : never;
+}[keyof H];
+type Mutuals<TK extends TypedKey | TypedKey[], H extends Hierarchy> = {
+    [K in keyof H]: H[K] extends MutualFealty ? TK extends H[K][`above`][number] ? [mutual: Exclude<H[K][`above`][number], TK>, below: H[K][`below`]] : never : never;
+}[keyof H];
+type CompoundFrom<H extends Hierarchy> = {
+    [K in keyof H]: H[K] extends MutualFealty ? H[K][`below`] : never;
+}[keyof H];
+
+/**
+ * @public
+ * A function that sets the value of a state.
+ * @param oldValue - The current value of the state.
+ * @returns
+ * The new value of the state.
+ */
+type Setter<T, New extends T> = (oldValue: T) => New;
 /**
  * @public
  * Set the value of a state into the implicit store.
- * @param token - The unique identifier of the state to set.
+ * @param token - An atom or writable selector token.
  * @param value - The new value of the state.
  * @overload Default
  * @default
  */
-declare function setState<T, New extends T>(token: WritableToken<T>, value: New | ((oldValue: T) => New)): void;
+declare function setState<T, New extends T>(token: WritableToken<T>, value: New | Setter<T, New>): void;
 /**
  * @public
  * Set the value of a state into the implicit store.
- * @param token - The unique identifier of a state family.
- * @param key - The key of the state to set.
+ * @param token - An atom family or writable selector family token.
+ * @param key - The unique key of the state to set.
  * @param value - The new value of the state.
  * @overload Streamlined
  */
-declare function setState<T, K extends Canonical, New extends T, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, value: New | ((oldValue: T) => New)): void;
+declare function setState<T, K extends Canonical, New extends T, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, value: New | Setter<T, New>): void;
 
 declare class Silo {
     store: Store;
@@ -404,9 +445,8 @@ declare class Silo {
     subscribe: typeof subscribe;
     undo: typeof undo;
     redo: typeof redo;
-    moleculeFamily: typeof moleculeFamily;
-    makeMolecule: typeof makeMolecule;
     runTransaction: typeof runTransaction;
+    install: (tokens: AtomIOToken[], store?: Store) => void;
     constructor(config: Store[`config`], fromStore?: Store | null);
 }
 
@@ -425,23 +465,6 @@ declare function subscribe<T>(token: ReadableToken<T>, handleUpdate: UpdateHandl
 declare function subscribe<F extends Func>(token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key?: string): () => void;
 declare function subscribe<M extends TimelineManageable>(token: TimelineToken<M>, handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void, key?: string): () => void;
 
-type TimelineManageable = AtomFamilyToken<any, any> | AtomToken<any>;
-type AtomOnly<M extends TimelineManageable> = M extends AtomFamilyToken<any, any> ? AtomToken<any> : M extends AtomToken<any> ? M : never;
-type TimelineToken<M> = {
-    key: string;
-    type: `timeline`;
-    __M?: M;
-};
-type TimelineOptions<ManagedAtom extends TimelineManageable> = {
-    key: string;
-    scope: (ManagedAtom | MoleculeFamilyToken$1<any>)[];
-    shouldCapture?: (update: TimelineUpdate<ManagedAtom>, timeline: Timeline<TimelineManageable>) => boolean;
-};
-type TimelineUpdate<ManagedAtom extends TimelineManageable> = TimelineAtomUpdate<ManagedAtom> | TimelineMoleculeCreation<any> | TimelineMoleculeDisposal | TimelineSelectorUpdate<ManagedAtom> | TimelineStateCreation<AtomOnly<ManagedAtom>> | TimelineStateDisposal<AtomOnly<ManagedAtom>> | TimelineTransactionUpdate;
-declare const timeline: <ManagedAtom extends TimelineManageable>(options: TimelineOptions<ManagedAtom>) => TimelineToken<ManagedAtom>;
-declare const redo: (tl: TimelineToken<any>) => void;
-declare const undo: (tl: TimelineToken<any>) => void;
-
 type TokenType<Comparison extends ReadableFamilyToken$1<any, any> | ReadableToken$1<any>> = Comparison extends ReadableToken$1<infer RepresentedValue> ? RepresentedValue : Comparison extends ReadableFamilyToken$1<infer RepresentedValue, any> ? RepresentedValue : never;
 declare function isToken<KnownToken extends RegularAtomToken$1<any>>(knownToken: KnownToken, unknownToken: ReadableToken$1<any>): unknownToken is RegularAtomToken$1<TokenType<KnownToken>>;
 declare function isToken<KnownToken extends MutableAtomToken$1<any, any>>(knownToken: KnownToken, unknownToken: ReadableToken$1<any>): unknownToken is MutableAtomToken$1<TokenType<KnownToken>, any>;
@@ -456,40 +479,98 @@ declare function belongsTo<Family extends ReadonlySelectorFamilyToken$1<any, any
 declare function belongsTo<Family extends WritableFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is WritableToken$1<TokenType<Family>>;
 declare function belongsTo<Family extends ReadableFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is ReadableToken$1<TokenType<Family>>;
 
+/**
+ * @public
+ * A token is an object that uniquely identifies a particular state, family, timeline, or transaction.
+ *
+ * While they represent one of these resources, they are not the resource itself. Think of them like paper currency representing money in the bank.
+ *
+ * Tokens are returned from resource creation functions, such as {@link atom} and {@link transaction}.
+ *
+ * Tokens can be used as parameters to functions that take a token, such as {@link getState}, {@link setState}, or {@link runTransaction}.
+ *
+ * Tokens are fully serializable, so they can be passed between processes.
+ */
+type AtomIOToken = ReadableFamilyToken<any, any> | ReadableToken<any> | TimelineToken<any> | TransactionToken<any>;
+/** @public */
 type RegularAtomToken<T, K extends Canonical = any> = {
+    /** The unique identifier of the atom. */
     key: string;
+    /** Discriminator. */
     type: `atom`;
+    /** Present if the atom belongs to a family. */
     family?: FamilyMetadata<K>;
+    /** Never present. This is a marker that preserves the type of the atom's value. */
     __T?: T;
 };
+/** @public */
 type MutableAtomToken<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical = any> = {
+    /** The unique identifier of the atom. */
     key: string;
+    /** Discriminator. */
     type: `mutable_atom`;
+    /** Present if the atom belongs to a family. */
     family?: FamilyMetadata<K>;
+    /** Never present. This is a marker that preserves the JSON form of the atom's transceiver value. */
     __J?: J;
+    /** Never present. This is a marker that preserves the type of the atom's transceiver value. */
     __U?: T extends Transceiver<infer Update> ? Update : never;
 };
+/** @public */
 type AtomToken<T, K extends Canonical = any> = MutableAtomToken<T extends Transceiver<any> ? T : never, any, K> | RegularAtomToken<T, K>;
+/** @public */
 type WritableSelectorToken<T, K extends Canonical = any> = {
+    /** The unique identifier of the selector. */
     key: string;
+    /** Discriminator. */
     type: `selector`;
+    /** Present if the selector belongs to a family. */
     family?: FamilyMetadata<K>;
+    /** Never present. This is a marker that preserves the type of the selector's value. */
     __T?: T;
 };
+/** @public */
 type ReadonlySelectorToken<T, K extends Canonical = any> = {
+    /** The unique identifier of the selector. */
     key: string;
+    /** Discriminator. */
     type: `readonly_selector`;
+    /** Present if the selector belongs to a family. */
     family?: FamilyMetadata<K>;
+    /** Never present. This is a marker that preserves the type of the selector's value. */
     __T?: T;
 };
+/** @public */
 type SelectorToken<T, K extends Canonical = any> = ReadonlySelectorToken<T, K> | WritableSelectorToken<T, K>;
+/**
+ * @public
+ * These states can be set.
+ */
 type WritableToken<T, K extends Canonical = any> = AtomToken<T, K> | WritableSelectorToken<T, K>;
+/**
+ * @public
+ * These states cannot be set.
+ */
 type ReadableToken<T, K extends Canonical = any> = AtomToken<T, K> | SelectorToken<T, K>;
+/**
+ * @public
+ * States belonging to this family can be set.
+ */
 type WritableFamilyToken<T, K extends Canonical> = AtomFamilyToken<T, K> | WritableSelectorFamilyToken<T, K>;
+/**
+ * @public
+ * States belonging to this family cannot be set.
+ */
 type ReadableFamilyToken<T, K extends Canonical> = AtomFamilyToken<T, K> | SelectorFamilyToken<T, K>;
+/**
+ * @public
+ * Identifies a state's connection to its family.
+ */
 type FamilyMetadata<K extends Canonical = any> = {
+    /** The family's unique key. */
     key: string;
+    /** The family member's unique identifier, in the form of a string. */
     subKey: stringified<K>;
 };
 
-export { $provenance, type Above, type ActorToolkit, type AtomEffect, type AtomFamilyToken, AtomIOLogger, type AtomOnly, type AtomToken, type Below, type Claim, type CompoundTypedKey, type CtorToolkit, type Effectors, type FamilyMetadata, type GetterToolkit, type Hierarchy, type KeyedStateUpdate, LOG_LEVELS, type LogFilter, type LogFn, type LogLevel, type Logger, type LoggerIcon, type MoleculeConstructor, type MoleculeCreation, type MoleculeCreationClassic, type MoleculeCreationModern, type MoleculeDisposal, type MoleculeDisposalClassic, type MoleculeDisposalModern, type MoleculeFamily, type MoleculeFamilyOptions, type MoleculeFamilyToken, type MoleculeKey, type MoleculeParams, type MoleculeToken, type MoleculeType, type MutableAtomFamilyOptions, type MutableAtomFamilyToken, type MutableAtomOptions, type MutableAtomToken, type Mutuals, type Read, type ReadableFamilyToken, type ReadableToken, type ReadonlySelectorFamilyOptions, type ReadonlySelectorFamilyToken, type ReadonlySelectorOptions, type ReadonlySelectorToken, type RegularAtomFamilyOptions, type RegularAtomFamilyToken, type RegularAtomOptions, type RegularAtomToken, type SelectorFamilyToken, type SelectorToken, type SetterToolkit, Silo, type SingularTypedKey, type StateCreation, type StateDisposal, type StateUpdate, T$, type TimelineManageable, type TimelineOptions, type TimelineToken, type TimelineUpdate, type TokenDenomination, type TokenType, type Transact, type TransactionIO, type TransactionOptions, type TransactionToken, type TransactionUpdate, type TransactionUpdateContent, type TransactionUpdateHandler, type TypeTag, type TypedKey, type UpdateHandler, type Vassal, type WritableFamilyToken, type WritableSelectorFamilyOptions, type WritableSelectorFamilyToken, type WritableSelectorOptions, type WritableSelectorToken, type WritableToken, type Write, allocateIntoStore, atom, atomFamily, belongsTo, deallocateFromStore, disposeState, getState, isToken, makeMolecule, makeRootMoleculeInStore, moleculeFamily, realm, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };
+export { $claim, type Above, type ActorToolkit, Anarchy, type AtomDisposal, type AtomEffect, type AtomFamilyToken, AtomIOLogger, type AtomIOToken, type AtomOnly, type AtomToken, type Below, type Claim, type CompoundFrom, type CompoundTypedKey, type Effectors, type FamilyMetadata, type GetterToolkit, type Hierarchy, type KeyedStateUpdate, LOG_LEVELS, type LogFilter, type LogFn, type LogLevel, type Logger, type LoggerIcon, type MoleculeCreation, type MoleculeDisposal, type MoleculeTransfer, type MutableAtomFamilyOptions, type MutableAtomFamilyToken, type MutableAtomOptions, type MutableAtomToken, type Mutuals, type Read, type ReadableFamilyToken, type ReadableToken, type ReadonlySelectorFamilyOptions, type ReadonlySelectorFamilyToken, type ReadonlySelectorOptions, type ReadonlySelectorToken, Realm, type RegularAtomFamilyOptions, type RegularAtomFamilyToken, type RegularAtomOptions, type RegularAtomToken, type SelectorDisposal, type SelectorFamilyToken, type SelectorToken, type Setter, type SetterToolkit, Silo, type SingularTypedKey, type StateCreation, type StateDisposal, type StateUpdate, T$, type TimelineManageable, type TimelineOptions, type TimelineToken, type TimelineUpdate, type TokenDenomination, type TokenType, type Transact, type TransactionIO, type TransactionOptions, type TransactionToken, type TransactionUpdate, type TransactionUpdateContent, type TransactionUpdateHandler, type TypeTag, type TypedKey, type UpdateHandler, type Vassal, type WritableFamilyToken, type WritableSelectorFamilyOptions, type WritableSelectorFamilyToken, type WritableSelectorOptions, type WritableSelectorToken, type WritableToken, type Write, atom, atomFamily, belongsTo, disposeState, getState, isToken, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };