atom.io 0.6.9 → 0.8.0

package/README.md

@@ -25,8 +25,27 @@
 npm i atom.io
 ```
 ```shell
-pnpm add atom.io
+pnpm i atom.io
+```
+```shell
+bun i atom.io
 ```
 <hr>
 
-Reactive state graph for node and the browser inspired by [Recoil](https://recoiljs.org/).
+Fine-grained reactivity for JavaScript environments.
+
+💙 Inspired by [Recoil](https://recoiljs.org/).
+
+# Usage
+
+```typescript
+import { atom } from 'atom.io'
+
+const countState = atom({
+  key: 'count',
+  default: 0
+}) 
+   // { key: 'count', type: 'atom' }
+
+
+```

package/dist/index.d.mts

@@ -1,412 +1,5 @@
-type primitive = boolean | number | string | null;
-
-type Serializable = primitive | Readonly<{
-    [key: string]: Serializable;
-}> | ReadonlyArray<Serializable>;
-type Object$1<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
-type Array<Element extends Serializable = Serializable> = ReadonlyArray<Element>;
-
-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,
-  };
-}
-
-type Refinement<Unrefined, Refined extends Unrefined> = (value: Unrefined) => value is Refined;
-type Cardinality = `1:1` | `1:n` | `n:n`;
-
-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;
-} | {
-    open: true;
-    done: Set<string>;
-    prev: Map<string, any>;
-    time: number;
-    token: StateToken<any>;
-};
-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 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;
-    type: `selector`;
-    family?: FamilyMetadata;
-    install: (store: Store) => void;
-    subject: Subject<{
-        newValue: T;
-        oldValue: T;
-    }>;
-    get: () => T;
-    set: (newValue: T | ((oldValue: T) => T)) => void;
-};
-type ReadonlySelector<T> = {
-    key: string;
-    type: `readonly_selector`;
-    family?: FamilyMetadata;
-    install: (store: Store) => void;
-    subject: Subject<{
-        newValue: T;
-        oldValue: T;
-    }>;
-    get: () => 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 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;
-
-type TimelineAtomUpdate = StateUpdate<unknown> & {
-    key: string;
-    type: `atom_update`;
-    timestamp: number;
-    family?: FamilyMetadata;
-};
-type TimelineSelectorUpdate = {
-    key: string;
-    type: `selector_update`;
-    timestamp: number;
-    atomUpdates: Omit<TimelineAtomUpdate, `timestamp`>[];
-};
-type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
-    key: string;
-    type: `transaction_update`;
-    timestamp: number;
-};
-type Timeline = {
-    type: `timeline`;
-    key: string;
-    at: number;
-    timeTraveling: `into_future` | `into_past` | null;
-    history: TimelineUpdate[];
-    selectorTime: number | null;
-    transactionKey: string | null;
-    install: (store: Store) => void;
-    subject: Subject<TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate | `redo` | `undo`>;
-};
-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`;
-    install: (store: Store) => void;
-    subject: Subject<TransactionUpdate<ƒ>>;
-    run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
-};
-declare function transaction__INTERNAL<ƒ extends ƒn>(options: TransactionOptions<ƒ>, store?: Store): TransactionToken<ƒ>;
-declare const target: (store?: Store) => StoreCore;
-
-declare const abortTransaction: (store: Store) => void;
-
-declare const applyTransaction: <ƒ extends ƒn>(output: ReturnType<ƒ>, store: Store) => void;
-
-declare const buildTransaction: (key: string, params: any[], store: Store) => void;
-
-declare const redoTransactionUpdate: <ƒ extends ƒn>(update: TransactionUpdate<ƒ>, store: Store) => void;
-
-declare const undoTransactionUpdate: <ƒ extends ƒn>(update: TransactionUpdate<ƒ>, store: Store) => void;
-
-declare const TRANSACTION_PHASES: readonly ["idle", "building", "applying"];
-type TransactionPhase = typeof TRANSACTION_PHASES[number];
-type TransactionUpdateInProgress<ƒ extends ƒn> = TransactionUpdate<ƒ> & {
-    phase: `applying` | `building`;
-    time: number;
-    core: StoreCore;
-};
-type TransactionIdle = {
-    phase: `idle`;
-};
-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;
-declare const index_TRANSACTION_PHASES: typeof TRANSACTION_PHASES;
-type index_Timeline = Timeline;
-type index_TimelineAtomUpdate = TimelineAtomUpdate;
-type index_TimelineSelectorUpdate = TimelineSelectorUpdate;
-type index_TimelineTransactionUpdate = TimelineTransactionUpdate;
-type index_Transaction<ƒ extends ƒn> = Transaction<ƒ>;
-type index_TransactionIdle = TransactionIdle;
-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;
-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_deposit: typeof deposit;
-declare const index_getState__INTERNAL: typeof getState__INTERNAL;
-declare const index_isAtomDefault: typeof isAtomDefault;
-declare const index_isDone: typeof isDone;
-declare const index_isSelectorDefault: typeof isSelectorDefault;
-declare const index_isValueCached: typeof isValueCached;
-declare const index_lookup: typeof lookup;
-declare const index_lookupSelectorSources: typeof lookupSelectorSources;
-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_readCachedValue: typeof readCachedValue;
-declare const index_readonlySelectorFamily__INTERNAL: typeof readonlySelectorFamily__INTERNAL;
-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_setState__INTERNAL: typeof setState__INTERNAL;
-declare const index_subscribeToRootAtoms: typeof subscribeToRootAtoms;
-declare const index_target: typeof target;
-declare const index_timeline__INTERNAL: typeof timeline__INTERNAL;
-declare const index_traceAllSelectorAtoms: typeof traceAllSelectorAtoms;
-declare const index_traceSelectorAtoms: typeof traceSelectorAtoms;
-declare const index_transaction__INTERNAL: typeof transaction__INTERNAL;
-declare const index_undoTransactionUpdate: typeof undoTransactionUpdate;
-declare const index_undo__INTERNAL: typeof undo__INTERNAL;
-declare const index_updateSelectorAtoms: typeof updateSelectorAtoms;
-declare const index_withdraw: typeof withdraw;
-declare namespace index {
-  export {
-    index_Atom as Atom,
-    index_IMPLICIT as IMPLICIT,
-    index_OperationProgress as OperationProgress,
-    index_ReadonlySelector as ReadonlySelector,
-    index_Selector as Selector,
-    index_Store as Store,
-    index_StoreCore as StoreCore,
-    index_Subject as Subject,
-    index_TRANSACTION_PHASES as TRANSACTION_PHASES,
-    index_Timeline as Timeline,
-    index_TimelineAtomUpdate as TimelineAtomUpdate,
-    index_TimelineSelectorUpdate as TimelineSelectorUpdate,
-    index_TimelineTransactionUpdate as TimelineTransactionUpdate,
-    index_Transaction as Transaction,
-    index_TransactionIdle as TransactionIdle,
-    index_TransactionPhase as TransactionPhase,
-    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,
-    index_buildTransaction as buildTransaction,
-    index_cacheValue as cacheValue,
-    index_clearStore as clearStore,
-    index_closeOperation as closeOperation,
-    index_deposit as deposit,
-    index_getState__INTERNAL as getState__INTERNAL,
-    index_isAtomDefault as isAtomDefault,
-    index_isDone as isDone,
-    index_isSelectorDefault as isSelectorDefault,
-    index_isValueCached as isValueCached,
-    index_lookup as lookup,
-    index_lookupSelectorSources as lookupSelectorSources,
-    index_markAtomAsDefault as markAtomAsDefault,
-    index_markAtomAsNotDefault as markAtomAsNotDefault,
-    index_markDone as markDone,
-    index_openOperation as openOperation,
-    index_readCachedValue as readCachedValue,
-    index_readonlySelectorFamily__INTERNAL as readonlySelectorFamily__INTERNAL,
-    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_setState__INTERNAL as setState__INTERNAL,
-    index_subscribeToRootAtoms as subscribeToRootAtoms,
-    index_target as target,
-    index_timeline__INTERNAL as timeline__INTERNAL,
-    index_traceAllSelectorAtoms as traceAllSelectorAtoms,
-    index_traceSelectorAtoms as traceSelectorAtoms,
-    index_transaction__INTERNAL as transaction__INTERNAL,
-    index_undoTransactionUpdate as undoTransactionUpdate,
-    index_undo__INTERNAL as undo__INTERNAL,
-    index_updateSelectorAtoms as updateSelectorAtoms,
-    index_withdraw as withdraw,
-  };
-}
-
-type ƒn = (...parameters: any[]) => any;
+import { Transceiver, Subject, Store, TimelineAtomUpdate, TimelineSelectorUpdate, TimelineTransactionUpdate } from 'atom.io/internal';
+import { Json, JsonInterface } from 'atom.io/json';
 
 type Effectors<T> = {
     setSelf: <V extends T>(next: V | ((oldValue: T) => V)) => void;
@@ -420,21 +13,35 @@ type AtomOptions<T> = {
     key: string;
     default: T | (() => T);
     effects?: AtomEffect<T>[];
-    mutable?: boolean;
 };
+type MutableAtomOptions<T extends Transceiver<any>, J extends Json.Serializable> = JsonInterface<T, J> & Omit<AtomOptions<T>, `default`> & {
+    default: () => T;
+    mutable: true;
+};
+declare function atom<T extends Transceiver<any>, J extends Json.Serializable>(options: MutableAtomOptions<T, J>): MutableAtomToken<T, J>;
 declare function atom<T>(options: AtomOptions<T>): AtomToken<T>;
-type AtomFamilyOptions<T, K extends Serializable> = {
+type AtomFamilyOptions<T, K extends Json.Serializable> = {
     key: string;
     default: T | ((key: K) => T);
     effects?: (key: K) => AtomEffect<T>[];
 };
-type AtomFamily<T, K extends Serializable = Serializable> = ((key: K) => AtomToken<T>) & {
+type AtomFamily<T, K extends Json.Serializable = Json.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 MutableAtomFamilyOptions<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable> = AtomFamilyOptions<T, K> & JsonInterface<T, J> & {
+    mutable: true;
+};
+type MutableAtomFamily<Core extends Transceiver<any>, SerializableCore extends Json.Serializable, Key extends Json.Serializable> = JsonInterface<Core, SerializableCore> & ((key: Key) => MutableAtomToken<Core, SerializableCore>) & {
+    key: `${string}::mutable`;
+    type: `atom_family`;
+    subject: Subject<MutableAtomToken<Core, SerializableCore>>;
+};
+declare function atomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamily<T, J, K>;
+declare function atomFamily<T, K extends Json.Serializable>(options: AtomFamilyOptions<T, K>): AtomFamily<T, K>;
 
+declare const NO_OP: () => void;
 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;
@@ -477,27 +84,27 @@ type ReadonlySelectorOptions<T> = {
 };
 declare function selector<T>(options: SelectorOptions<T>): SelectorToken<T>;
 declare function selector<T>(options: ReadonlySelectorOptions<T>): ReadonlySelectorToken<T>;
-type SelectorFamilyOptions<T, K extends Serializable> = {
+type SelectorFamilyOptions<T, K extends Json.Serializable> = {
     key: string;
     get: (key: K) => Read<() => T>;
     set: (key: K) => Write<(newValue: T) => void>;
 };
-type ReadonlySelectorFamilyOptions<T, K extends Serializable> = {
+type ReadonlySelectorFamilyOptions<T, K extends Json.Serializable> = {
     key: string;
     get: (key: K) => Read<() => T>;
 };
-type SelectorFamily<T, K extends Serializable = Serializable> = ((key: K) => SelectorToken<T>) & {
+type SelectorFamily<T, K extends Json.Serializable = Json.Serializable> = ((key: K) => SelectorToken<T>) & {
     key: string;
     type: `selector_family`;
     subject: Subject<SelectorToken<T>>;
 };
-type ReadonlySelectorFamily<T, K extends Serializable = Serializable> = ((key: K) => ReadonlySelectorToken<T>) & {
+type ReadonlySelectorFamily<T, K extends Json.Serializable = Json.Serializable> = ((key: K) => ReadonlySelectorToken<T>) & {
     key: string;
     type: `readonly_selector_family`;
     subject: Subject<ReadonlySelectorToken<T>>;
 };
-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>;
+declare function selectorFamily<T, K extends Json.Serializable>(options: SelectorFamilyOptions<T, K>): SelectorFamily<T, K>;
+declare function selectorFamily<T, K extends Json.Serializable>(options: ReadonlySelectorFamilyOptions<T, K>): ReadonlySelectorFamily<T, K>;
 
 declare class Silo {
     store: Store;
@@ -524,7 +131,7 @@ type KeyedStateUpdate<T> = StateUpdate<T> & {
     family?: FamilyMetadata;
 };
 type UpdateHandler<T> = (update: StateUpdate<T>) => void;
-declare const subscribe: <T>(token: ReadonlySelectorToken<T> | StateToken<T>, handleUpdate: UpdateHandler<T>, key?: string, store?: Store) => (() => void);
+declare function 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<ƒ>, key?: string, store?: Store) => (() => void);
 declare const subscribeToTimeline: (token: TimelineToken, handleUpdate: (update: TimelineUpdate | `redo` | `undo`) => void, key?: string, store?: Store) => (() => void);
@@ -542,12 +149,17 @@ declare const timeline: (options: TimelineOptions) => TimelineToken;
 declare const redo: (token: TimelineToken) => void;
 declare const undo: (token: TimelineToken) => void;
 
+type ƒn = (...parameters: any[]) => any;
 type AtomToken<_> = {
     key: string;
     type: `atom`;
     family?: FamilyMetadata;
     __brand?: _;
 };
+interface MutableAtomToken<T extends Transceiver<any>, J extends Json.Serializable> extends AtomToken<T> {
+    __asJSON?: J;
+    __update?: T extends Transceiver<infer Update> ? Update : never;
+}
 type SelectorToken<_> = {
     key: string;
     type: `selector`;
@@ -565,8 +177,9 @@ type FamilyMetadata = {
     key: string;
     subKey: string;
 };
+declare const capitalize: (str: string) => string;
 declare const getState: <T>(token: ReadonlySelectorToken<T> | StateToken<T>, store?: Store) => T;
 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, 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 };
+export { AtomEffect, AtomFamily, AtomFamilyOptions, AtomOptions, AtomToken, Effectors, FamilyMetadata, KeyedStateUpdate, LOG_LEVELS, Logger, MutableAtomFamily, MutableAtomFamilyOptions, MutableAtomOptions, MutableAtomToken, NO_OP, Read, ReadonlySelectorFamily, ReadonlySelectorFamilyOptions, ReadonlySelectorOptions, ReadonlySelectorToken, ReadonlyTransactors, SelectorFamily, SelectorFamilyOptions, SelectorOptions, SelectorToken, Silo, StateToken, StateUpdate, TimelineOptions, TimelineToken, TimelineUpdate, TransactionIO, TransactionOptions, TransactionToken, TransactionUpdate, TransactionUpdateHandler, Transactors, UpdateHandler, Write, atom, atomFamily, capitalize, getState, isDefault, redo, runTransaction, selector, selectorFamily, setLogLevel, setState, subscribe, subscribeToTimeline, subscribeToTransaction, timeline, transaction, undo, useLogger, ƒn };