atom.io 0.26.0 → 0.27.0

package/internal/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as atom_io from 'atom.io';
 import { TransactionToken, TransactionUpdate, TransactionOptions, ActorToolkit, RegularAtomToken, MutableAtomToken, AtomToken, WritableSelectorToken, ReadonlySelectorToken, SelectorToken, WritableToken, MoleculeToken, MoleculeFamily, MoleculeFamilyToken, ReadableToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, StateCreation, StateDisposal, MoleculeConstructor, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, TimelineToken, WritableSelectorFamily, MutableAtomFamily, RegularAtomFamily, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomFamily, ReadableFamily, SelectorFamily, WritableFamily, RegularAtomFamilyToken, MutableAtomFamilyToken, AtomFamilyToken, ReadonlySelectorFamilyToken, WritableSelectorFamilyToken, SelectorFamilyToken, ReadableFamilyToken, WritableFamilyToken, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, MoleculeKey, KeyedStateUpdate, MoleculeFamilyOptions, MoleculeParams, ReadonlySelectorOptions, WritableSelectorOptions, SetterToolkit, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
-import { Json, JsonInterface } from 'atom.io/json';
+import { Canonical, Json, JsonInterface } from 'atom.io/json';
 import { Join } from 'atom.io/data';
 
 type primitive = boolean | number | string | null;
@@ -155,10 +155,10 @@ declare function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T
 declare function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>;
 declare function deposit<T>(state: Selector<T>): SelectorToken<T>;
 declare function deposit<T>(state: WritableState<T>): WritableToken<T>;
-declare function deposit<K extends Json.Serializable, S extends {
+declare function deposit<K extends Canonical, S extends {
     [key: string]: any;
 }, P extends any[]>(state: Molecule<any>): MoleculeToken<any>;
-declare function deposit<K extends Json.Serializable, S extends {
+declare function deposit<K extends Canonical, S extends {
     [key: string]: any;
 }, P extends any[]>(state: MoleculeFamily<any>): MoleculeFamilyToken<any>;
 declare function deposit<T extends Func>(state: Transaction<T>): TransactionToken<T>;
@@ -295,14 +295,14 @@ declare function withdraw<T>(token: ReadonlySelectorToken<T>, store: Store): Rea
 declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T>;
 declare function withdraw<T>(token: WritableToken<T>, store: Store): WritableState<T>;
 declare function withdraw<T>(token: ReadableToken<T>, store: Store): ReadableState<T>;
-declare function withdraw<T, K extends Json.Serializable>(token: RegularAtomFamilyToken<T, K>, store: Store): RegularAtomFamily<T, K>;
-declare function withdraw<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(token: MutableAtomFamilyToken<T, J, K>, store: Store): MutableAtomFamily<T, J, K>;
-declare function withdraw<T, K extends Json.Serializable>(token: AtomFamilyToken<T>, store: Store): AtomFamily<T, any>;
-declare function withdraw<T, K extends Json.Serializable>(token: ReadonlySelectorFamilyToken<T, K>, store: Store): ReadonlySelectorFamily<T, any>;
-declare function withdraw<T, K extends Json.Serializable>(token: WritableSelectorFamilyToken<T, K>, store: Store): WritableSelectorFamily<T, any>;
-declare function withdraw<T, K extends Json.Serializable>(token: SelectorFamilyToken<T, K>, store: Store): SelectorFamily<T, any>;
-declare function withdraw<T, K extends Json.Serializable>(token: ReadableFamilyToken<T, K>, store: Store): ReadableFamily<T, any>;
-declare function withdraw<T, K extends Json.Serializable>(token: WritableFamilyToken<T, K>, store: Store): WritableFamily<T, any>;
+declare function withdraw<T, K extends Canonical>(token: RegularAtomFamilyToken<T, K>, store: Store): RegularAtomFamily<T, K>;
+declare function withdraw<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(token: MutableAtomFamilyToken<T, J, K>, store: Store): MutableAtomFamily<T, J, K>;
+declare function withdraw<T, K extends Canonical>(token: AtomFamilyToken<T>, store: Store): AtomFamily<T, any>;
+declare function withdraw<T, K extends Canonical>(token: ReadonlySelectorFamilyToken<T, K>, store: Store): ReadonlySelectorFamily<T, any>;
+declare function withdraw<T, K extends Canonical>(token: WritableSelectorFamilyToken<T, K>, store: Store): WritableSelectorFamily<T, any>;
+declare function withdraw<T, K extends Canonical>(token: SelectorFamilyToken<T, K>, store: Store): SelectorFamily<T, any>;
+declare function withdraw<T, K extends Canonical>(token: ReadableFamilyToken<T, K>, store: Store): ReadableFamily<T, any>;
+declare function withdraw<T, K extends Canonical>(token: WritableFamilyToken<T, K>, store: Store): WritableFamily<T, any>;
 declare function withdraw<M extends MoleculeConstructor>(token: MoleculeToken<M>, store: Store): Molecule<M>;
 declare function withdraw<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, store: Store): MoleculeFamily<M>;
 declare function withdraw<T extends Func>(token: TransactionToken<T>, store: Store): Transaction<T extends Func ? T : never>;
@@ -329,9 +329,6 @@ declare const getJsonToken: <Core extends Transceiver<any>, SerializableCore ext
 
 declare const getUpdateToken: <Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => RegularAtomToken<Signal<Core>>;
 
-declare function isMutable(atom: Atom<any>): atom is MutableAtom<any, any>;
-declare function isMutable(family: AtomFamily<any, any>): family is MutableAtomFamily<any, any, any>;
-
 /**
  * @internal Give the tracker a transceiver state and a store, and it will
  * subscribe to the transceiver's inner value. When the inner value changes,
@@ -350,7 +347,7 @@ declare class Tracker<Mutable extends Transceiver<any>> {
     constructor(mutableState: MutableAtomToken<Mutable, Json.Serializable>, store: Store);
 }
 
-declare class FamilyTracker<Core extends Transceiver<any>, FamilyMemberKey extends Json.Serializable> {
+declare class FamilyTracker<Core extends Transceiver<any>, FamilyMemberKey extends Canonical> {
     private readonly Update;
     readonly latestUpdateAtoms: RegularAtomFamily<typeof this.Update | null, FamilyMemberKey>;
     readonly mutableAtoms: MutableAtomFamily<Core, any, FamilyMemberKey>;
@@ -394,46 +391,46 @@ declare function cacheValue<T extends Promise<any>>(key: string, value: T, subje
 declare const readCachedValue: <T>(token: ReadableState<any>, target: Store) => T;
 declare const evictCachedValue: (key: string, target: Store) => void;
 
-declare function createAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(options: MutableAtomFamilyOptions<T, J, K>, store: Store): MutableAtomFamily<T, J, K>;
-declare function createAtomFamily<T, K extends Json.Serializable>(options: RegularAtomFamilyOptions<T, K>, store: Store): RegularAtomFamily<T, K>;
+declare function createAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(options: MutableAtomFamilyOptions<T, J, K>, store: Store): MutableAtomFamily<T, J, K>;
+declare function createAtomFamily<T, K extends Canonical>(options: RegularAtomFamilyOptions<T, K>, store: Store): RegularAtomFamily<T, K>;
 
-declare function createReadonlySelectorFamily<T, K extends Json.Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamily<T, K>;
+declare function createReadonlySelectorFamily<T, K extends Canonical>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamily<T, K>;
 
-declare function createRegularAtomFamily<T, K extends Json.Serializable>(options: RegularAtomFamilyOptions<T, K>, store: Store): RegularAtomFamily<T, K>;
+declare function createRegularAtomFamily<T, K extends Canonical>(options: RegularAtomFamilyOptions<T, K>, store: Store): RegularAtomFamily<T, K>;
 
-declare function createSelectorFamily<T, K extends Json.Serializable>(options: WritableSelectorFamilyOptions<T, K>, store: Store): WritableSelectorFamily<T, K>;
-declare function createSelectorFamily<T, K extends Json.Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamily<T, K>;
+declare function createSelectorFamily<T, K extends Canonical>(options: WritableSelectorFamilyOptions<T, K>, store: Store): WritableSelectorFamily<T, K>;
+declare function createSelectorFamily<T, K extends Canonical>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamily<T, K>;
 
 declare function disposeFromStore(token: MoleculeToken<any> | ReadableToken<any>, store: Store): void;
-declare function disposeFromStore<K extends Json.Serializable>(token: ReadableFamilyToken<any, K>, key: K, store: Store): void;
+declare function disposeFromStore<K extends Canonical>(token: ReadableFamilyToken<any, K>, key: K, store: Store): void;
 declare function disposeFromStore<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>, store: Store): void;
 
-declare function findInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J>;
-declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T>;
-declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T>;
-declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key, store: Store): WritableSelectorToken<T>;
-declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key, store: Store): ReadonlySelectorToken<T>;
-declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T>;
-declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T>;
-declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T>;
-
-declare function initFamilyMemberInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J>;
-declare function initFamilyMemberInStore<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T>;
-declare function initFamilyMemberInStore<T, K extends Json.Serializable, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T>;
-declare function initFamilyMemberInStore<T, K extends Json.Serializable, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key, store: Store): WritableSelectorToken<T>;
-declare function initFamilyMemberInStore<T, K extends Json.Serializable, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key, store: Store): ReadonlySelectorToken<T>;
-declare function initFamilyMemberInStore<T, K extends Json.Serializable, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T>;
-declare function initFamilyMemberInStore<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T>;
-declare function initFamilyMemberInStore<T, K extends Json.Serializable, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T>;
-
-declare function seekInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J> | undefined;
-declare function seekInStore<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T> | undefined;
-declare function seekInStore<T, K extends Json.Serializable, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T> | undefined;
-declare function seekInStore<T, K extends Json.Serializable, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key, store: Store): WritableSelectorToken<T> | undefined;
-declare function seekInStore<T, K extends Json.Serializable, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key, store: Store): ReadonlySelectorToken<T> | undefined;
-declare function seekInStore<T, K extends Json.Serializable, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T> | undefined;
-declare function seekInStore<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T> | undefined;
-declare function seekInStore<T, K extends Json.Serializable, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T> | undefined;
+declare function findInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J>;
+declare function findInStore<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key, store: Store): WritableSelectorToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key, store: Store): ReadonlySelectorToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T>;
+
+declare function initFamilyMemberInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key, store: Store): WritableSelectorToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key, store: Store): ReadonlySelectorToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T>;
+
+declare function seekInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key, store: Store): WritableSelectorToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key, store: Store): ReadonlySelectorToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T> | undefined;
 declare function seekInStore<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>, store: Store): MoleculeKey<M> | undefined;
 
 type EnvironmentData = {
@@ -443,7 +440,7 @@ declare function getEnvironmentData(store: Store): EnvironmentData;
 
 declare function getFromStore<T>(token: ReadableToken<T>, store: Store): T;
 declare function getFromStore<M extends MoleculeConstructor>(token: MoleculeToken<M>, store: Store): InstanceType<M> | undefined;
-declare function getFromStore<T, K extends Json.Serializable>(token: ReadableFamilyToken<T, K>, key: K, store: Store): T;
+declare function getFromStore<T, K extends Canonical>(token: ReadableFamilyToken<T, K>, key: K, store: Store): T;
 declare function getFromStore<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>, store: Store): InstanceType<M>;
 
 declare const readOrComputeValue: <T>(state: ReadableState<T>, target: Store) => T;
@@ -506,14 +503,14 @@ declare class Molecule<M extends MoleculeConstructor> implements MoleculeToken<M
     constructor(ctx: Molecule<any> | Molecule<any>[] | undefined, key: MoleculeKey<M>, family?: MoleculeFamilyToken<M>);
 }
 
-declare function growMoleculeInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(molecule: Molecule<any>, family: MutableAtomFamily<T, J, K>, store: Store): MutableAtomToken<T, J>;
-declare function growMoleculeInStore<T, K extends Json.Serializable>(molecule: Molecule<any>, family: RegularAtomFamily<T, K>, store: Store): RegularAtomToken<T>;
-declare function growMoleculeInStore<T, K extends Json.Serializable>(molecule: Molecule<any>, family: AtomFamily<T, K>, store: Store): AtomToken<T>;
-declare function growMoleculeInStore<T, K extends Json.Serializable>(molecule: Molecule<any>, family: WritableSelectorFamily<T, K>, store: Store): WritableSelectorToken<T>;
-declare function growMoleculeInStore<T, K extends Json.Serializable>(molecule: Molecule<any>, family: ReadonlySelectorFamily<T, K>, store: Store): ReadonlySelectorToken<T>;
-declare function growMoleculeInStore<T, K extends Json.Serializable>(molecule: Molecule<any>, family: SelectorFamily<T, K>, store: Store): SelectorToken<T>;
-declare function growMoleculeInStore<T, K extends Json.Serializable>(molecule: Molecule<any>, family: WritableFamily<T, K>, store: Store): WritableToken<T>;
-declare function growMoleculeInStore<T, K extends Json.Serializable>(molecule: Molecule<any>, family: ReadableFamily<T, K>, store: Store): ReadableToken<T>;
+declare function growMoleculeInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(molecule: Molecule<any>, family: MutableAtomFamily<T, J, K>, store: Store): MutableAtomToken<T, J>;
+declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: RegularAtomFamily<T, K>, store: Store): RegularAtomToken<T>;
+declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: AtomFamily<T, K>, store: Store): AtomToken<T>;
+declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: WritableSelectorFamily<T, K>, store: Store): WritableSelectorToken<T>;
+declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: ReadonlySelectorFamily<T, K>, store: Store): ReadonlySelectorToken<T>;
+declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: SelectorFamily<T, K>, store: Store): SelectorToken<T>;
+declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: WritableFamily<T, K>, store: Store): WritableToken<T>;
+declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: ReadableFamily<T, K>, store: Store): ReadableToken<T>;
 
 declare function makeMoleculeInStore<M extends MoleculeConstructor>(store: Store, context: MoleculeToken<M> | MoleculeToken<M>[], familyToken: MoleculeFamilyToken<M>, key: MoleculeKey<M>, ...params: MoleculeParams<M>): MoleculeToken<M>;
 
@@ -547,7 +544,7 @@ declare const become: <T>(nextVersionOfThing: Modify<T> | T) => (originalThing:
 declare const setAtomOrSelector: <T>(state: WritableState<T>, value: T | ((oldValue: T) => T), store: Store) => void;
 
 declare function setIntoStore<T, New extends T>(token: WritableToken<T>, value: New | ((oldValue: T) => New), store: Store): void;
-declare function setIntoStore<T, K extends Json.Serializable, New extends T>(token: WritableFamilyToken<T, K>, key: K, value: New | ((oldValue: T) => New), store: Store): void;
+declare function setIntoStore<T, K extends Canonical, New extends T>(token: WritableFamilyToken<T, K>, key: K, value: New | ((oldValue: T) => New), store: Store): void;
 
 declare const subscribeToRootAtoms: <T>(selector: Selector<T>, store: Store) => (() => void)[];
 
@@ -590,4 +587,4 @@ type Selector<T> = ReadonlySelector<T> | WritableSelector<T>;
 type WritableState<T> = Atom<T> | WritableSelector<T>;
 type ReadableState<T> = Atom<T> | Selector<T>;
 
-export { type Atom, type AtomIOState, type AtomKey, type ChildStore, type EnvironmentData, FamilyTracker, type Flat, type Func, Future, IMPLICIT, LazyMap, type Lineage, type Modify, Molecule, type MutableAtom, NotFoundError, type OperationProgress, type ReadableState, type ReadonlySelector, type ReadonlySelectorKey, type RegularAtom, type RootStore, type Selector, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineMoleculeCreation, type TimelineMoleculeDisposal, type TimelineSelectorUpdate, type TimelineStateCreation, type TimelineStateDisposal, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableSelector, type WritableState, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+export { type Atom, type AtomIOState, type AtomKey, type ChildStore, type EnvironmentData, FamilyTracker, type Flat, type Func, Future, IMPLICIT, LazyMap, type Lineage, type Modify, Molecule, type MutableAtom, NotFoundError, type OperationProgress, type ReadableState, type ReadonlySelector, type ReadonlySelectorKey, type RegularAtom, type RootStore, type Selector, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineMoleculeCreation, type TimelineMoleculeDisposal, type TimelineSelectorUpdate, type TimelineStateCreation, type TimelineStateDisposal, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableSelector, type WritableState, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };

package/internal/dist/index.js

@@ -465,8 +465,8 @@ function createRegularAtomFamily(options, store) {
 
 // internal/src/families/create-atom-family.ts
 function createAtomFamily(options, store) {
-  const isMutable2 = `mutable` in options;
-  if (isMutable2) {
+  const isMutable = `mutable` in options;
+  if (isMutable) {
     return createMutableAtomFamily(options, store);
   }
   return createRegularAtomFamily(options, store);
@@ -2325,11 +2325,6 @@ var getUpdateToken = (mutableAtomToken) => {
   return updateToken;
 };
 
-// internal/src/mutable/is-mutable.ts
-function isMutable(atomOrTokenOrFamily) {
-  return atomOrTokenOrFamily.type === `mutable_atom` || atomOrTokenOrFamily.type === `mutable_atom_family`;
-}
-
 // internal/src/mutable/transceiver.ts
 function isTransceiver(value) {
   return typeof value === `object` && value !== null && `do` in value && `undo` in value && `subscribe` in value;
@@ -2486,8 +2481,8 @@ function createRegularAtom(options, family, store) {
 
 // internal/src/atom/create-standalone-atom.ts
 function createStandaloneAtom(options, store) {
-  const isMutable2 = `mutable` in options;
-  if (isMutable2) {
+  const isMutable = `mutable` in options;
+  if (isMutable) {
     const state2 = createMutableAtom(options, void 0, store);
     store.on.atomCreation.next(state2);
     return state2;
@@ -3047,4 +3042,4 @@ var timeTravel = (action, token, store) => {
   );
 };
 
-export { FamilyTracker, Future, IMPLICIT, LazyMap, Molecule, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+export { FamilyTracker, Future, IMPLICIT, LazyMap, Molecule, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };

package/internal/src/families/create-atom-family.ts

@@ -4,7 +4,7 @@ import type {
 	RegularAtomFamily,
 	RegularAtomFamilyOptions,
 } from "atom.io"
-import type { Json } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 
 import { createMutableAtomFamily, type Transceiver } from "../mutable"
 import type { Store } from "../store"
@@ -13,16 +13,16 @@ import { createRegularAtomFamily } from "./create-regular-atom-family"
 export function createAtomFamily<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-	K extends Json.Serializable,
+	K extends Canonical,
 >(
 	options: MutableAtomFamilyOptions<T, J, K>,
 	store: Store,
 ): MutableAtomFamily<T, J, K>
-export function createAtomFamily<T, K extends Json.Serializable>(
+export function createAtomFamily<T, K extends Canonical>(
 	options: RegularAtomFamilyOptions<T, K>,
 	store: Store,
 ): RegularAtomFamily<T, K>
-export function createAtomFamily<T, K extends Json.Serializable>(
+export function createAtomFamily<T, K extends Canonical>(
 	options:
 		| MutableAtomFamilyOptions<any, any, any>
 		| RegularAtomFamilyOptions<T, K>,

package/internal/src/families/create-readonly-selector-family.ts

@@ -6,7 +6,7 @@ import type {
 	StateCreation,
 	StateDisposal,
 } from "atom.io"
-import type { Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
 import { newest } from "../lineage"
@@ -14,7 +14,7 @@ import { createReadonlySelector } from "../selector"
 import type { Store } from "../store"
 import { Subject } from "../subject"
 
-export function createReadonlySelectorFamily<T, K extends Json.Serializable>(
+export function createReadonlySelectorFamily<T, K extends Canonical>(
 	options: ReadonlySelectorFamilyOptions<T, K>,
 	store: Store,
 ): ReadonlySelectorFamily<T, K> {

package/internal/src/families/create-regular-atom-family.ts

@@ -7,7 +7,7 @@ import type {
 	StateCreation,
 	StateDisposal,
 } from "atom.io"
-import type { Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
 import { createRegularAtom } from "../atom"
@@ -15,7 +15,7 @@ import { newest } from "../lineage"
 import type { Store } from "../store"
 import { Subject } from "../subject"
 
-export function createRegularAtomFamily<T, K extends Json.Serializable>(
+export function createRegularAtomFamily<T, K extends Canonical>(
 	options: RegularAtomFamilyOptions<T, K>,
 	store: Store,
 ): RegularAtomFamily<T, K> {

package/internal/src/families/create-selector-family.ts

@@ -4,21 +4,21 @@ import type {
 	WritableSelectorFamily,
 	WritableSelectorFamilyOptions,
 } from "atom.io"
-import type { Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
 import type { Store } from "../store"
 import { createReadonlySelectorFamily } from "./create-readonly-selector-family"
 import { createWritableSelectorFamily } from "./create-writable-selector-family"
 
-export function createSelectorFamily<T, K extends Json.Serializable>(
+export function createSelectorFamily<T, K extends Canonical>(
 	options: WritableSelectorFamilyOptions<T, K>,
 	store: Store,
 ): WritableSelectorFamily<T, K>
-export function createSelectorFamily<T, K extends Json.Serializable>(
+export function createSelectorFamily<T, K extends Canonical>(
 	options: ReadonlySelectorFamilyOptions<T, K>,
 	store: Store,
 ): ReadonlySelectorFamily<T, K>
-export function createSelectorFamily<T, K extends Json.Serializable>(
+export function createSelectorFamily<T, K extends Canonical>(
 	options:
 		| ReadonlySelectorFamilyOptions<T, K>
 		| WritableSelectorFamilyOptions<T, K>,

package/internal/src/families/create-writable-selector-family.ts

@@ -6,7 +6,7 @@ import type {
 	WritableSelectorFamilyOptions,
 	WritableSelectorToken,
 } from "atom.io"
-import type { Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
 import { newest } from "../lineage"
@@ -14,7 +14,7 @@ import { createWritableSelector } from "../selector"
 import type { Store } from "../store"
 import { Subject } from "../subject"
 
-export function createWritableSelectorFamily<T, K extends Json.Serializable>(
+export function createWritableSelectorFamily<T, K extends Canonical>(
 	options: WritableSelectorFamilyOptions<T, K>,
 	store: Store,
 ): WritableSelectorFamily<T, K> {

package/internal/src/families/dispose-from-store.ts

@@ -6,7 +6,7 @@ import type {
 	ReadableFamilyToken,
 	ReadableToken,
 } from "atom.io"
-import type { Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
 import { disposeAtom } from "../atom"
 import { disposeMolecule } from "../molecule/dispose-molecule"
@@ -21,7 +21,7 @@ export function disposeFromStore(
 	store: Store,
 ): void
 
-export function disposeFromStore<K extends Json.Serializable>(
+export function disposeFromStore<K extends Canonical>(
 	token: ReadableFamilyToken<any, K>,
 	key: K,
 	store: Store,
@@ -35,13 +35,9 @@ export function disposeFromStore<M extends MoleculeConstructor>(
 
 export function disposeFromStore(
 	...params:
-		| [
-				token: ReadableFamilyToken<any, any>,
-				key: Json.Serializable,
-				store: Store,
-		  ]
 		| [token: MoleculeFamilyToken<any>, key: MoleculeKey<any>, store: Store]
 		| [token: MoleculeToken<any> | ReadableToken<any>, store: Store]
+		| [token: ReadableFamilyToken<any, any>, key: Canonical, store: Store]
 ): void {
 	let token: MoleculeToken<any> | ReadableToken<any>
 	let store: Store

package/internal/src/families/find-in-store.ts

@@ -16,7 +16,7 @@ import type {
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Json } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 
 import type { Transceiver } from "../mutable"
 import type { Store } from "../store"
@@ -26,7 +26,7 @@ import { seekInStore } from "./seek-in-store"
 export function findInStore<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-	K extends Json.Serializable,
+	K extends Canonical,
 	Key extends K,
 >(
 	token: MutableAtomFamilyToken<T, J, K>,
@@ -34,43 +34,43 @@ export function findInStore<
 	store: Store,
 ): MutableAtomToken<T, J>
 
-export function findInStore<T, K extends Json.Serializable, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K>(
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): RegularAtomToken<T>
 
-export function findInStore<T, K extends Json.Serializable, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K>(
 	token: AtomFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): AtomToken<T>
 
-export function findInStore<T, K extends Json.Serializable, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K>(
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): WritableSelectorToken<T>
 
-export function findInStore<T, K extends Json.Serializable, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K>(
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): ReadonlySelectorToken<T>
 
-export function findInStore<T, K extends Json.Serializable, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K>(
 	token: SelectorFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): SelectorToken<T>
 
-export function findInStore<T, K extends Json.Serializable, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K>(
 	token: WritableFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): WritableToken<T>
 
-export function findInStore<T, K extends Json.Serializable, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K>(
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
 	store: Store,

package/internal/src/families/init-family-member.ts

@@ -16,7 +16,7 @@ import type {
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Json } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 
 import { newest } from "../lineage"
 import type { Transceiver } from "../mutable"
@@ -27,7 +27,7 @@ import { isChildStore, isRootStore } from "../transaction"
 export function initFamilyMemberInStore<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-	K extends Json.Serializable,
+	K extends Canonical,
 	Key extends K,
 >(
 	token: MutableAtomFamilyToken<T, J, K>,
@@ -35,59 +35,47 @@ export function initFamilyMemberInStore<
 	store: Store,
 ): MutableAtomToken<T, J>
 
-export function initFamilyMemberInStore<
-	T,
-	K extends Json.Serializable,
-	Key extends K,
->(
+export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): RegularAtomToken<T>
 
-export function initFamilyMemberInStore<
-	T,
-	K extends Json.Serializable,
-	Key extends K,
->(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T>
+export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
+	token: AtomFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): AtomToken<T>
 
-export function initFamilyMemberInStore<
-	T,
-	K extends Json.Serializable,
-	Key extends K,
->(
+export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): WritableSelectorToken<T>
 
-export function initFamilyMemberInStore<
-	T,
-	K extends Json.Serializable,
-	Key extends K,
->(
+export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): ReadonlySelectorToken<T>
 
-export function initFamilyMemberInStore<
-	T,
-	K extends Json.Serializable,
-	Key extends K,
->(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T>
+export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
+	token: SelectorFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): SelectorToken<T>
 
-export function initFamilyMemberInStore<
-	T,
-	K extends Json.Serializable,
-	Key extends K,
->(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T>
+export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
+	token: WritableFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): WritableToken<T>
 
-export function initFamilyMemberInStore<
-	T,
-	K extends Json.Serializable,
-	Key extends K,
->(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T>
+export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
+	token: ReadableFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): ReadableToken<T>
 
 export function initFamilyMemberInStore(
 	token: ReadableFamilyToken<any, any>,