atom.io 0.6.7 → 0.6.9

package/dist/index.d.mts

@@ -1,173 +1,78 @@
-import { Refinement } from 'fp-ts/Refinement';
+type primitive = boolean | number | string | null;
 
-type ƒn = (...parameters: any[]) => any;
-
-type JsonInterface<T, J extends Json = Json> = {
-    toJson: (t: T) => J;
-    fromJson: (json: J) => T;
-};
-
-type Primitive = boolean | number | string | null;
-type Serializable = Primitive | Readonly<{
+type Serializable = primitive | Readonly<{
     [key: string]: Serializable;
 }> | ReadonlyArray<Serializable>;
-type JsonObj<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
-type JsonArr<Element extends Serializable = Serializable> = ReadonlyArray<Element>;
-type Json = JsonArr | JsonObj | Primitive;
-
-type Identified = {
-    id: string;
-};
-
-declare const RELATION_TYPES: readonly ["1:1", "1:n", "n:n"];
-type RelationType = typeof RELATION_TYPES[number];
-type RelationData<CONTENT extends JsonObj | null = null, A extends string = `from`, B extends string = `to`> = {
-    contents: JsonObj<string, CONTENT>;
-    relations: JsonObj<string, string[]>;
-    relationType: RelationType;
-    a: A;
-    b: B;
-};
-type IsRelationDataOptions<CONTENT extends JsonObj | null = null, A extends string = `from`, B extends string = `to`> = {
-    from?: A;
-    to?: B;
-    isContent?: (json: Json) => json is CONTENT;
-};
-
-type NullSafeUnion<Base, Extension> = Extension extends null ? Base : Base & Extension;
-type NullSafeRest<MaybeArg> = MaybeArg extends null ? [] | [undefined] : [MaybeArg];
-
-declare class Join<CONTENT extends JsonObj | null = null, A extends string = `from`, B extends string = `to`> implements RelationData<CONTENT, A, B> {
-    readonly relationType: `1:1` | `1:n` | `n:n`;
-    readonly a: A;
-    readonly b: B;
-    readonly relations: Record<string, string[]>;
-    readonly contents: Record<string, CONTENT>;
-    constructor(json?: Partial<RelationData<CONTENT, A, B>>);
-    toJSON(): RelationData<CONTENT, A, B>;
-    static fromJSON<CONTENT extends JsonObj | null, A extends string, B extends string>(json: Json, options?: IsRelationDataOptions<CONTENT, A, B>): Join<CONTENT, A, B>;
-    from<AA extends string>(newA: AA): Join<CONTENT, AA, B>;
-    to<BB extends string>(newB: BB): Join<CONTENT, A, BB>;
-    makeJsonInterface: (...params: CONTENT extends null ? [
-    ] : [Refinement<unknown, CONTENT>]) => JsonInterface<Join<CONTENT, A, B>, RelationData<CONTENT, A, B>>;
-    getRelatedId(id: string): string | undefined;
-    getRelatedIds(id: string): string[];
-    getContent(idA: string, idB: string): CONTENT | undefined;
-    getRelationEntries(id: string): [string, CONTENT][];
-    getRelationRecord(id: string): Record<string, CONTENT>;
-    getRelation(id: string): NullSafeUnion<Identified, CONTENT> | undefined;
-    getRelations(id: string): NullSafeUnion<Identified, CONTENT>[];
-    setRelations(subject: {
-        [from in A]: string;
-    } | {
-        [to in B]: string;
-    }, relations: NullSafeUnion<Identified, CONTENT>[]): Join<CONTENT, A, B>;
-    set(relation: {
-        [key in A | B]: string;
-    }, ...rest: NullSafeRest<CONTENT>): Join<CONTENT, A, B>;
-    remove(relation: Partial<Record<A | B, string>>): Join<CONTENT, A, B>;
-}
+type Object$1<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
+type Array<Element extends Serializable = Serializable> = ReadonlyArray<Element>;
 
-type StoreCore = Pick<Store, `atoms` | `atomsThatAreDefault` | `operation` | `readonlySelectors` | `selectorAtoms` | `selectorGraph` | `selectors` | `timelineAtoms` | `timelines` | `transactions` | `valueMap`>;
-interface Store {
-    atoms: Map<string, Atom<any>>;
-    atomsThatAreDefault: Set<string>;
-    readonlySelectors: Map<string, ReadonlySelector<any>>;
-    selectorAtoms: Join<null, `selectorKey`, `atomKey`>;
-    selectorGraph: Join<{
-        source: string;
-    }>;
-    selectors: Map<string, Selector<any>>;
-    timelineAtoms: Join<null, `timelineKey`, `atomKey`>;
-    timelines: Map<string, Timeline>;
-    transactions: Map<string, Transaction<any>>;
-    valueMap: Map<string, any>;
-    subject: {
-        atomCreation: Subject<AtomToken<unknown>>;
-        selectorCreation: Subject<ReadonlySelectorToken<unknown> | SelectorToken<unknown>>;
-        transactionCreation: Subject<TransactionToken<ƒn>>;
-        timelineCreation: Subject<TimelineToken>;
-        operationStatus: Subject<OperationProgress>;
-    };
-    operation: OperationProgress;
-    transactionStatus: TransactionStatus<ƒn>;
-    config: {
-        name: string;
-        logger: Logger | null;
-        logger__INTERNAL: Logger;
-    };
+type json_Array<Element extends Serializable = Serializable> = Array<Element>;
+type json_Serializable = Serializable;
+declare namespace json {
+  export {
+    json_Array as Array,
+    Object$1 as Object,
+    json_Serializable as Serializable,
+  };
 }
-declare const createStore: (name: string, store?: Store | null) => Store;
-declare const IMPLICIT: {
-    STORE_INTERNAL: Store | undefined;
-    readonly STORE: Store;
-};
-declare const clearStore: (store?: Store) => void;
-
-type Effectors<T> = {
-    setSelf: <V extends T>(next: V | ((oldValue: T) => V)) => void;
-    onSet: (callback: (options: {
-        newValue: T;
-        oldValue: T;
-    }) => void) => void;
-};
-type AtomEffect<T> = (tools: Effectors<T>) => void;
-type AtomOptions<T> = {
-    key: string;
-    default: T | (() => T);
-    effects?: AtomEffect<T>[];
-};
-declare function atom<T>(options: AtomOptions<T>): AtomToken<T>;
-type AtomFamilyOptions<T, K extends Serializable> = {
-    key: string;
-    default: T | ((key: K) => T);
-    effects?: (key: K) => AtomEffect<T>[];
-};
-type AtomFamily<T, K extends Serializable = Serializable> = ((key: K) => AtomToken<T>) & {
-    key: string;
-    type: `atom_family`;
-    subject: Subject<AtomToken<T>>;
-};
-declare function atomFamily<T, K extends Serializable>(options: AtomFamilyOptions<T, K>): AtomFamily<T, K>;
 
-type Atom<T> = {
-    key: string;
-    type: `atom`;
-    family?: FamilyMetadata;
-    subject: Subject<{
-        newValue: T;
-        oldValue: T;
-    }>;
-    default: T;
-};
-declare function atom__INTERNAL<T>(options: AtomOptions<T>, family?: FamilyMetadata, store?: Store): AtomToken<T>;
+type Refinement<Unrefined, Refined extends Unrefined> = (value: Unrefined) => value is Refined;
+type Cardinality = `1:1` | `1:n` | `n:n`;
 
-declare function atomFamily__INTERNAL<T, K extends Serializable>(options: AtomFamilyOptions<T, K>, store?: Store): AtomFamily<T, K>;
-declare function readonlySelectorFamily__INTERNAL<T, K extends Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store?: Store): ReadonlySelectorFamily<T, K>;
-declare function selectorFamily__INTERNAL<T, K extends Serializable>(options: SelectorFamilyOptions<T, K>, store?: Store): SelectorFamily<T, K>;
-declare function selectorFamily__INTERNAL<T, K extends Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store?: Store): ReadonlySelectorFamily<T, K>;
-
-declare const computeSelectorState: <T>(selector: ReadonlySelector<T> | Selector<T>) => T;
-declare function lookup(key: string, store: Store): AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>;
-declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T> | null;
-declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T> | null;
-declare function withdraw<T>(token: StateToken<T>, store: Store): Atom<T> | Selector<T> | null;
-declare function withdraw<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T> | null;
-declare function withdraw<T>(token: TransactionToken<T>, store: Store): Transaction<T extends ƒn ? T : never> | null;
-declare function withdraw<T>(token: ReadonlySelectorToken<T> | StateToken<T>, store: Store): Atom<T> | ReadonlySelector<T> | Selector<T> | null;
-declare function withdraw<T>(token: TimelineToken, store: Store): Timeline | null;
-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>;
-declare function deposit<T>(state: Transaction<T extends ƒn ? T : never>): TransactionToken<T>;
-declare function deposit<T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>): ReadonlySelectorToken<T> | StateToken<T>;
-declare const getState__INTERNAL: <T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>, store?: Store) => T;
-
-declare const isAtomDefault: (key: string, store?: Store) => boolean;
-declare const markAtomAsDefault: (key: string, store?: Store) => void;
-declare const markAtomAsNotDefault: (key: string, store?: Store) => void;
-declare const isSelectorDefault: (key: string, store?: Store) => boolean;
+interface JunctionEntries<Content extends Object$1 | null> extends Object$1 {
+    readonly relations: [string, string[]][];
+    readonly contents: [string, Content][];
+}
+interface JunctionSchema<ASide extends string, BSide extends string> extends Object$1 {
+    readonly between: [a: ASide, b: BSide];
+    readonly cardinality: Cardinality;
+}
+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: (g: any) => 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;
+    };
+    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> {
+    readonly a: ASide;
+    readonly b: BSide;
+    readonly cardinality: Cardinality;
+    readonly relations: Map<string, Set<string>>;
+    readonly contents: Map<string, Content>;
+    isContent: Refinement<unknown, Content> | null;
+    makeContentKey: (a: string, b: string) => string;
+    getRelatedKeys(key: string): Set<string> | undefined;
+    protected addRelation(a: string, b: string): void;
+    protected deleteRelation(a: string, b: string): void;
+    protected getContentInternal(contentKey: string): Content | undefined;
+    protected setContent(contentKey: string, content: Content): void;
+    protected deleteContent(contentKey: string): void;
+    constructor(data: JunctionSchema<ASide, BSide> & Partial<JunctionEntries<Content>>, config?: JunctionAdvancedConfiguration<Content>);
+    toJSON(): JunctionJSON<ASide, BSide, Content>;
+    set(a: string, ...rest: Content extends null ? [b: string] : [b: string, content: Content]): this;
+    set(relation: {
+        [Key in ASide | BSide]: string;
+    }, ...rest: Content extends null ? [] | [b?: undefined] : [content: Content]): this;
+    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;
+    getContent(a: string, b: string): Content | undefined;
+    getRelationEntries(input: Record<ASide, string> | Record<BSide, string>): [string, Content][];
+    has(a: string, b?: string): boolean;
+}
 
 type OperationProgress = {
     open: false;
@@ -182,15 +87,18 @@ declare const openOperation: (token: StateToken<any>, store: Store) => void;
 declare const closeOperation: (store: Store) => void;
 declare const isDone: (key: string, store?: Store) => boolean;
 declare const markDone: (key: string, store?: Store) => void;
-declare const recallState: <T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>, store?: Store) => T;
-declare const cacheValue: (key: string, value: unknown, store?: Store) => void;
-declare const evictCachedValue: (key: string, store?: Store) => void;
-declare const readCachedValue: <T>(key: string, store?: Store) => T;
-declare const isValueCached: (key: string, store?: Store) => boolean;
-declare const storeAtom: (atom: Atom<any>, store?: Store) => void;
-declare const storeSelector: (selector: Selector<any>, store?: Store) => void;
-declare const storeReadonlySelector: (selector: ReadonlySelector<any>, store?: Store) => void;
-declare const hasKeyBeenUsed: (key: string, store?: Store) => boolean;
+
+declare const lookupSelectorSources: (key: string, store: Store) => (AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>)[];
+
+declare const registerSelector: (selectorKey: string, store?: Store) => Transactors;
+
+type Subscriber<T> = (value: T) => void;
+declare class Subject<T> {
+    subscribers: Map<string, Subscriber<T>>;
+    subscribe(key: string, subscriber: Subscriber<T>): () => void;
+    private unsubscribe;
+    next(value: T): void;
+}
 
 type Selector<T> = {
     key: string;
@@ -218,70 +126,16 @@ type ReadonlySelector<T> = {
 declare function selector__INTERNAL<T>(options: SelectorOptions<T>, family?: FamilyMetadata, store?: Store): SelectorToken<T>;
 declare function selector__INTERNAL<T>(options: ReadonlySelectorOptions<T>, family?: FamilyMetadata, store?: Store): ReadonlySelectorToken<T>;
 
-declare const lookupSelectorSources: (key: string, store: Store) => (AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>)[];
-
-type TransactionToken<_> = {
-    key: string;
-    type: `transaction`;
-    __brand?: _;
-};
-type TransactionUpdate<ƒ extends ƒn> = {
-    key: string;
-    atomUpdates: KeyedStateUpdate<unknown>[];
-    params: Parameters<ƒ>;
-    output: ReturnType<ƒ>;
-};
-type Transactors = {
-    get: <S>(state: ReadonlySelectorToken<S> | StateToken<S>) => S;
-    set: <S>(state: StateToken<S>, newValue: S | ((oldValue: S) => S)) => void;
-};
-type ReadonlyTransactors = Pick<Transactors, `get`>;
-type Read<ƒ extends ƒn> = (transactors: ReadonlyTransactors, ...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
-type Write<ƒ extends ƒn> = (transactors: Transactors, ...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
-type TransactionOptions<ƒ extends ƒn> = {
-    key: string;
-    do: Write<ƒ>;
-};
-type TransactionIO<Token extends TransactionToken<any>> = Token extends TransactionToken<infer ƒ> ? ƒ : never;
-declare function transaction<ƒ extends ƒn>(options: TransactionOptions<ƒ>): TransactionToken<ƒ>;
-declare const runTransaction: <ƒ extends ƒn>(token: TransactionToken<ƒ>, store?: Store) => (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
-
-declare const registerSelector: (selectorKey: string, store?: Store) => Transactors;
-
 declare const traceSelectorAtoms: (selectorKey: string, dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>, store: Store) => AtomToken<unknown>[];
 declare const traceAllSelectorAtoms: (selectorKey: string, store: Store) => AtomToken<unknown>[];
 
 declare const updateSelectorAtoms: (selectorKey: string, dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>, store: Store) => void;
 
-declare const evictDownStream: <T>(state: Atom<T>, store?: Store) => void;
-declare const setAtomState: <T>(atom: Atom<T>, next: T | ((oldValue: T) => T), store?: Store) => void;
-declare const setSelectorState: <T>(selector: Selector<T>, next: T | ((oldValue: T) => T), store?: Store) => void;
-declare const setState__INTERNAL: <T>(state: Atom<T> | Selector<T>, value: T | ((oldValue: T) => T), store?: Store) => void;
-
-type Subscriber<T> = (value: T) => void;
-declare class Subject<T> {
-    subscribers: Subscriber<T>[];
-    subscribe(subscriber: Subscriber<T>): {
-        unsubscribe: () => void;
-    };
-    private unsubscribe;
-    next(value: T): void;
-}
-
-declare const prepareUpdate: <T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>, store: Store) => StateUpdate<T>;
-declare const stowUpdate: <T>(state: Atom<T>, update: StateUpdate<T>, store: Store) => void;
-declare const emitUpdate: <T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>, update: StateUpdate<T>, store: Store) => void;
-declare const subscribeToRootAtoms: <T>(state: ReadonlySelector<T> | Selector<T>, store: Store) => {
-    unsubscribe: () => void;
-}[] | null;
-
-declare const redo__INTERNAL: (token: TimelineToken, store?: Store) => void;
-declare const undo__INTERNAL: (token: TimelineToken, store?: Store) => void;
-
 type TimelineAtomUpdate = StateUpdate<unknown> & {
     key: string;
     type: `atom_update`;
     timestamp: number;
+    family?: FamilyMetadata;
 };
 type TimelineSelectorUpdate = {
     key: string;
@@ -295,9 +149,10 @@ type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
     timestamp: number;
 };
 type Timeline = {
+    type: `timeline`;
     key: string;
     at: number;
-    timeTraveling: boolean;
+    timeTraveling: `into_future` | `into_past` | null;
     history: TimelineUpdate[];
     selectorTime: number | null;
     transactionKey: string | null;
@@ -306,6 +161,11 @@ type Timeline = {
 };
 declare function timeline__INTERNAL(options: TimelineOptions, store?: Store, data?: Timeline | null): TimelineToken;
 
+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;
+
 type Transaction<ƒ extends ƒn> = {
     key: string;
     type: `transaction`;
@@ -338,12 +198,100 @@ type TransactionIdle = {
 };
 type TransactionStatus<ƒ extends ƒn> = TransactionIdle | TransactionUpdateInProgress<ƒ>;
 
+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>;
+declare function deposit<T>(state: Transaction<T extends ƒn ? T : never>): TransactionToken<T>;
+declare function deposit<T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>): ReadonlySelectorToken<T> | StateToken<T>;
+
+declare function lookup(key: string, store: Store): AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>;
+
+declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T> | null;
+declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T> | null;
+declare function withdraw<T>(token: StateToken<T>, store: Store): Atom<T> | Selector<T> | null;
+declare function withdraw<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T> | null;
+declare function withdraw<T>(token: TransactionToken<T>, store: Store): Transaction<T extends ƒn ? T : never> | null;
+declare function withdraw<T>(token: ReadonlySelectorToken<T> | StateToken<T>, store: Store): Atom<T> | ReadonlySelector<T> | Selector<T> | null;
+declare function withdraw<T>(token: TimelineToken, store: Store): Timeline | null;
+
+type StoreCore = Pick<Store, `atoms` | `atomsThatAreDefault` | `operation` | `readonlySelectors` | `selectorAtoms` | `selectorGraph` | `selectors` | `timelineAtoms` | `timelines` | `transactions` | `valueMap`>;
+declare class Store {
+    valueMap: Map<string, any>;
+    atoms: Map<string, Atom<any>>;
+    selectors: Map<string, Selector<any>>;
+    readonlySelectors: Map<string, ReadonlySelector<any>>;
+    timelines: Map<string, Timeline>;
+    transactions: Map<string, Transaction<ƒn>>;
+    atomsThatAreDefault: Set<string>;
+    timelineAtoms: Junction<"timelineKey", "atomKey", null>;
+    selectorAtoms: Junction<"selectorKey", "atomKey", null>;
+    selectorGraph: Junction<"upstreamSelectorKey", "downstreamSelectorKey", {
+        source: string;
+    }>;
+    subject: {
+        atomCreation: Subject<AtomToken<unknown>>;
+        selectorCreation: Subject<ReadonlySelectorToken<unknown> | SelectorToken<unknown>>;
+        transactionCreation: Subject<TransactionToken<ƒn>>;
+        timelineCreation: Subject<TimelineToken>;
+        operationStatus: Subject<OperationProgress>;
+    };
+    operation: OperationProgress;
+    transactionStatus: TransactionStatus<ƒn>;
+    config: {
+        name: string;
+        logger: Logger | null;
+        logger__INTERNAL: Logger;
+    };
+    constructor(name: string, store?: Store | null);
+}
+declare const IMPLICIT: {
+    STORE_INTERNAL: Store | undefined;
+    readonly STORE: Store;
+};
+declare const clearStore: (store?: Store) => void;
+
+type Atom<T> = {
+    key: string;
+    type: `atom`;
+    family?: FamilyMetadata;
+    subject: Subject<{
+        newValue: T;
+        oldValue: T;
+    }>;
+    default: T;
+};
+declare function atom__INTERNAL<T>(options: AtomOptions<T>, family?: FamilyMetadata, store?: Store): AtomToken<T>;
+
+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, store?: Store) => void;
+declare const readCachedValue: <T>(key: string, store?: Store) => T;
+declare const isValueCached: (key: string, store?: Store) => boolean;
+
+declare function atomFamily__INTERNAL<T, K extends Serializable>(options: AtomFamilyOptions<T, K>, store?: Store): AtomFamily<T, K>;
+
+declare function readonlySelectorFamily__INTERNAL<T, K extends Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store?: Store): ReadonlySelectorFamily<T, K>;
+
+declare function selectorFamily__INTERNAL<T, K extends Serializable>(options: SelectorFamilyOptions<T, K>, store?: Store): SelectorFamily<T, K>;
+declare function selectorFamily__INTERNAL<T, K extends Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store?: Store): ReadonlySelectorFamily<T, K>;
+
+declare const getState__INTERNAL: <T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>, store?: Store) => T;
+
+declare const setState__INTERNAL: <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;
+
 type index_Atom<T> = Atom<T>;
 declare const index_IMPLICIT: typeof IMPLICIT;
 type index_OperationProgress = OperationProgress;
 type index_ReadonlySelector<T> = ReadonlySelector<T>;
 type index_Selector<T> = Selector<T>;
 type index_Store = Store;
+declare const index_Store: typeof Store;
 type index_StoreCore = StoreCore;
 type index_Subject<T> = Subject<T>;
 declare const index_Subject: typeof Subject;
@@ -358,6 +306,7 @@ type index_TransactionPhase = TransactionPhase;
 type index_TransactionStatus<ƒ extends ƒn> = TransactionStatus<ƒ>;
 type index_TransactionUpdateInProgress<ƒ extends ƒn> = TransactionUpdateInProgress<ƒ>;
 declare const index_abortTransaction: typeof abortTransaction;
+declare const index_addAtomToTimeline: typeof addAtomToTimeline;
 declare const index_applyTransaction: typeof applyTransaction;
 declare const index_atomFamily__INTERNAL: typeof atomFamily__INTERNAL;
 declare const index_atom__INTERNAL: typeof atom__INTERNAL;
@@ -365,14 +314,8 @@ declare const index_buildTransaction: typeof buildTransaction;
 declare const index_cacheValue: typeof cacheValue;
 declare const index_clearStore: typeof clearStore;
 declare const index_closeOperation: typeof closeOperation;
-declare const index_computeSelectorState: typeof computeSelectorState;
-declare const index_createStore: typeof createStore;
 declare const index_deposit: typeof deposit;
-declare const index_emitUpdate: typeof emitUpdate;
-declare const index_evictCachedValue: typeof evictCachedValue;
-declare const index_evictDownStream: typeof evictDownStream;
 declare const index_getState__INTERNAL: typeof getState__INTERNAL;
-declare const index_hasKeyBeenUsed: typeof hasKeyBeenUsed;
 declare const index_isAtomDefault: typeof isAtomDefault;
 declare const index_isDone: typeof isDone;
 declare const index_isSelectorDefault: typeof isSelectorDefault;
@@ -383,22 +326,14 @@ declare const index_markAtomAsDefault: typeof markAtomAsDefault;
 declare const index_markAtomAsNotDefault: typeof markAtomAsNotDefault;
 declare const index_markDone: typeof markDone;
 declare const index_openOperation: typeof openOperation;
-declare const index_prepareUpdate: typeof prepareUpdate;
 declare const index_readCachedValue: typeof readCachedValue;
 declare const index_readonlySelectorFamily__INTERNAL: typeof readonlySelectorFamily__INTERNAL;
-declare const index_recallState: typeof recallState;
 declare const index_redoTransactionUpdate: typeof redoTransactionUpdate;
 declare const index_redo__INTERNAL: typeof redo__INTERNAL;
 declare const index_registerSelector: typeof registerSelector;
 declare const index_selectorFamily__INTERNAL: typeof selectorFamily__INTERNAL;
 declare const index_selector__INTERNAL: typeof selector__INTERNAL;
-declare const index_setAtomState: typeof setAtomState;
-declare const index_setSelectorState: typeof setSelectorState;
 declare const index_setState__INTERNAL: typeof setState__INTERNAL;
-declare const index_storeAtom: typeof storeAtom;
-declare const index_storeReadonlySelector: typeof storeReadonlySelector;
-declare const index_storeSelector: typeof storeSelector;
-declare const index_stowUpdate: typeof stowUpdate;
 declare const index_subscribeToRootAtoms: typeof subscribeToRootAtoms;
 declare const index_target: typeof target;
 declare const index_timeline__INTERNAL: typeof timeline__INTERNAL;
@@ -430,6 +365,7 @@ declare namespace index {
     index_TransactionStatus as TransactionStatus,
     index_TransactionUpdateInProgress as TransactionUpdateInProgress,
     index_abortTransaction as abortTransaction,
+    index_addAtomToTimeline as addAtomToTimeline,
     index_applyTransaction as applyTransaction,
     index_atomFamily__INTERNAL as atomFamily__INTERNAL,
     index_atom__INTERNAL as atom__INTERNAL,
@@ -437,14 +373,8 @@ declare namespace index {
     index_cacheValue as cacheValue,
     index_clearStore as clearStore,
     index_closeOperation as closeOperation,
-    index_computeSelectorState as computeSelectorState,
-    index_createStore as createStore,
     index_deposit as deposit,
-    index_emitUpdate as emitUpdate,
-    index_evictCachedValue as evictCachedValue,
-    index_evictDownStream as evictDownStream,
     index_getState__INTERNAL as getState__INTERNAL,
-    index_hasKeyBeenUsed as hasKeyBeenUsed,
     index_isAtomDefault as isAtomDefault,
     index_isDone as isDone,
     index_isSelectorDefault as isSelectorDefault,
@@ -455,22 +385,14 @@ declare namespace index {
     index_markAtomAsNotDefault as markAtomAsNotDefault,
     index_markDone as markDone,
     index_openOperation as openOperation,
-    index_prepareUpdate as prepareUpdate,
     index_readCachedValue as readCachedValue,
     index_readonlySelectorFamily__INTERNAL as readonlySelectorFamily__INTERNAL,
-    index_recallState as recallState,
     index_redoTransactionUpdate as redoTransactionUpdate,
     index_redo__INTERNAL as redo__INTERNAL,
     index_registerSelector as registerSelector,
     index_selectorFamily__INTERNAL as selectorFamily__INTERNAL,
     index_selector__INTERNAL as selector__INTERNAL,
-    index_setAtomState as setAtomState,
-    index_setSelectorState as setSelectorState,
     index_setState__INTERNAL as setState__INTERNAL,
-    index_storeAtom as storeAtom,
-    index_storeReadonlySelector as storeReadonlySelector,
-    index_storeSelector as storeSelector,
-    index_stowUpdate as stowUpdate,
     index_subscribeToRootAtoms as subscribeToRootAtoms,
     index_target as target,
     index_timeline__INTERNAL as timeline__INTERNAL,
@@ -484,11 +406,66 @@ declare namespace index {
   };
 }
 
+type ƒn = (...parameters: any[]) => any;
+
+type Effectors<T> = {
+    setSelf: <V extends T>(next: V | ((oldValue: T) => V)) => void;
+    onSet: (callback: (options: {
+        newValue: T;
+        oldValue: T;
+    }) => void) => void;
+};
+type AtomEffect<T> = (tools: Effectors<T>) => void;
+type AtomOptions<T> = {
+    key: string;
+    default: T | (() => T);
+    effects?: AtomEffect<T>[];
+    mutable?: boolean;
+};
+declare function atom<T>(options: AtomOptions<T>): AtomToken<T>;
+type AtomFamilyOptions<T, K extends Serializable> = {
+    key: string;
+    default: T | ((key: K) => T);
+    effects?: (key: K) => AtomEffect<T>[];
+};
+type AtomFamily<T, K extends Serializable = Serializable> = ((key: K) => AtomToken<T>) & {
+    key: string;
+    type: `atom_family`;
+    subject: Subject<AtomToken<T>>;
+};
+declare function atomFamily<T, K extends Serializable>(options: AtomFamilyOptions<T, K>): AtomFamily<T, K>;
+
 type Logger = Pick<Console, `error` | `info` | `warn`>;
 declare const LOG_LEVELS: ReadonlyArray<keyof Logger>;
 declare const setLogLevel: (preferredLevel: `error` | `info` | `warn` | null, store?: Store) => void;
 declare const useLogger: (logger: Logger, store?: Store) => void;
 
+type TransactionToken<_> = {
+    key: string;
+    type: `transaction`;
+    __brand?: _;
+};
+type TransactionUpdate<ƒ extends ƒn> = {
+    key: string;
+    atomUpdates: KeyedStateUpdate<unknown>[];
+    params: Parameters<ƒ>;
+    output: ReturnType<ƒ>;
+};
+type Transactors = {
+    get: <S>(state: ReadonlySelectorToken<S> | StateToken<S>) => S;
+    set: <S>(state: StateToken<S>, newValue: S | ((oldValue: S) => S)) => void;
+};
+type ReadonlyTransactors = Pick<Transactors, `get`>;
+type Read<ƒ extends ƒn> = (transactors: ReadonlyTransactors, ...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+type Write<ƒ extends ƒn> = (transactors: Transactors, ...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+type TransactionOptions<ƒ extends ƒn> = {
+    key: string;
+    do: Write<ƒ>;
+};
+type TransactionIO<Token extends TransactionToken<any>> = Token extends TransactionToken<infer ƒ> ? ƒ : never;
+declare function transaction<ƒ extends ƒn>(options: TransactionOptions<ƒ>): TransactionToken<ƒ>;
+declare const runTransaction: <ƒ extends ƒn>(token: TransactionToken<ƒ>, store?: Store) => (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+
 type SelectorOptions<T> = {
     key: string;
     get: Read<() => T>;
@@ -522,8 +499,7 @@ type ReadonlySelectorFamily<T, K extends Serializable = Serializable> = ((key: K
 declare function selectorFamily<T, K extends Serializable>(options: SelectorFamilyOptions<T, K>): SelectorFamily<T, K>;
 declare function selectorFamily<T, K extends Serializable>(options: ReadonlySelectorFamilyOptions<T, K>): ReadonlySelectorFamily<T, K>;
 
-type Silo = ReturnType<typeof silo>;
-declare const silo: (name: string, fromStore?: Store | null) => {
+declare class Silo {
     store: Store;
     atom: typeof atom;
     atomFamily: typeof atomFamily;
@@ -536,7 +512,8 @@ declare const silo: (name: string, fromStore?: Store | null) => {
     subscribe: typeof subscribe;
     undo: typeof undo;
     redo: typeof redo;
-};
+    constructor(name: string, fromStore?: Store | null);
+}
 
 type StateUpdate<T> = {
     newValue: T;
@@ -544,12 +521,13 @@ type StateUpdate<T> = {
 };
 type KeyedStateUpdate<T> = StateUpdate<T> & {
     key: string;
+    family?: FamilyMetadata;
 };
 type UpdateHandler<T> = (update: StateUpdate<T>) => void;
-declare const subscribe: <T>(token: ReadonlySelectorToken<T> | StateToken<T>, handleUpdate: UpdateHandler<T>, store?: Store) => (() => void);
+declare const subscribe: <T>(token: ReadonlySelectorToken<T> | StateToken<T>, handleUpdate: UpdateHandler<T>, key?: string, store?: Store) => (() => void);
 type TransactionUpdateHandler<ƒ extends ƒn> = (data: TransactionUpdate<ƒ>) => void;
-declare const subscribeToTransaction: <ƒ extends ƒn>(token: TransactionToken<ƒ>, handleUpdate: TransactionUpdateHandler<ƒ>, store?: Store) => (() => void);
-declare const subscribeToTimeline: (token: TimelineToken, handleUpdate: (update: TimelineUpdate) => void, store?: Store) => (() => void);
+declare const subscribeToTransaction: <ƒ extends ƒn>(token: TransactionToken<ƒ>, handleUpdate: TransactionUpdateHandler<ƒ>, key?: string, store?: Store) => (() => void);
+declare const subscribeToTimeline: (token: TimelineToken, handleUpdate: (update: TimelineUpdate | `redo` | `undo`) => void, key?: string, store?: Store) => (() => void);
 
 type TimelineToken = {
     key: string;
@@ -591,4 +569,4 @@ declare const getState: <T>(token: ReadonlySelectorToken<T> | StateToken<T>, sto
 declare const setState: <T, New extends T>(token: StateToken<T>, value: New | ((oldValue: T) => New), store?: Store) => void;
 declare const isDefault: (token: ReadonlySelectorToken<unknown> | StateToken<unknown>, store?: Store) => boolean;
 
-export { AtomEffect, AtomFamily, AtomFamilyOptions, AtomOptions, AtomToken, Effectors, FamilyMetadata, KeyedStateUpdate, LOG_LEVELS, Logger, Read, ReadonlySelectorFamily, ReadonlySelectorFamilyOptions, ReadonlySelectorOptions, ReadonlySelectorToken, ReadonlyTransactors, SelectorFamily, SelectorFamilyOptions, SelectorOptions, SelectorToken, Serializable, Silo, StateToken, StateUpdate, Store, TimelineOptions, TimelineToken, TimelineUpdate, TransactionIO, TransactionOptions, TransactionToken, TransactionUpdate, TransactionUpdateHandler, Transactors, UpdateHandler, Write, index as __INTERNAL__, atom, atomFamily, getState, isDefault, redo, runTransaction, selector, selectorFamily, setLogLevel, setState, silo, subscribe, subscribeToTimeline, subscribeToTransaction, timeline, transaction, undo, useLogger };
+export { AtomEffect, AtomFamily, AtomFamilyOptions, AtomOptions, AtomToken, Effectors, FamilyMetadata, json as Json, KeyedStateUpdate, LOG_LEVELS, Logger, Read, ReadonlySelectorFamily, ReadonlySelectorFamilyOptions, ReadonlySelectorOptions, ReadonlySelectorToken, ReadonlyTransactors, SelectorFamily, SelectorFamilyOptions, SelectorOptions, SelectorToken, Silo, StateToken, StateUpdate, Store, TimelineOptions, TimelineToken, TimelineUpdate, TransactionIO, TransactionOptions, TransactionToken, TransactionUpdate, TransactionUpdateHandler, Transactors, UpdateHandler, Write, index as __INTERNAL__, atom, atomFamily, getState, isDefault, redo, runTransaction, selector, selectorFamily, setLogLevel, setState, subscribe, subscribeToTimeline, subscribeToTransaction, timeline, transaction, undo, useLogger, ƒn };