atom.io 0.34.2 → 0.35.0

package/dist/main/index.d.ts

@@ -1,85 +1,132 @@
 import { Each, EnvironmentData, Flat, Func, Junction, JunctionEntriesBase, JunctionSchemaBase, Refinement, Store, Timeline, TimelineAtomUpdate, TimelineMoleculeCreation, TimelineMoleculeDisposal, TimelineSelectorUpdate, TimelineStateCreation, TimelineStateDisposal, TimelineTransactionUpdate, Transceiver } from "atom.io/internal";
 import { Canonical, Json, JsonInterface, stringified } from "atom.io/json";
-import { MutableAtomFamilyToken as MutableAtomFamilyToken$1, MutableAtomToken as MutableAtomToken$1, ReadableFamilyToken as ReadableFamilyToken$1, ReadableToken as ReadableToken$1, ReadonlyPureSelectorFamilyToken as ReadonlyPureSelectorFamilyToken$1, ReadonlyPureSelectorToken as ReadonlyPureSelectorToken$1, ReadonlySelectorFamilyToken as ReadonlySelectorFamilyToken$1, ReadonlySelectorToken as ReadonlySelectorToken$1, RegularAtomFamilyToken as RegularAtomFamilyToken$1, RegularAtomToken as RegularAtomToken$1, WritableFamilyToken as WritableFamilyToken$1, WritablePureSelectorFamilyToken as WritablePureSelectorFamilyToken$1, WritablePureSelectorToken as WritablePureSelectorToken$1, WritableSelectorFamilyToken as WritableSelectorFamilyToken$1, WritableSelectorToken as WritableSelectorToken$1, WritableToken as WritableToken$1, findState as findState$1, getState as getState$1, setState as setState$1 } from "atom.io";
+import { MutableAtomFamilyToken as MutableAtomFamilyToken$1, MutableAtomToken as MutableAtomToken$1, ReadableFamilyToken as ReadableFamilyToken$1, ReadableToken as ReadableToken$1, ReadonlyPureSelectorToken as ReadonlyPureSelectorToken$1, ReadonlySelectorFamilyToken as ReadonlySelectorFamilyToken$1, ReadonlySelectorToken as ReadonlySelectorToken$1, RegularAtomToken as RegularAtomToken$1, WritableFamilyToken as WritableFamilyToken$1, WritableSelectorFamilyToken as WritableSelectorFamilyToken$1, WritableSelectorToken as WritableSelectorToken$1, WritableToken as WritableToken$1, findState as findState$1 } from "atom.io";
 import { SetRTX, SetRTXJson } from "atom.io/transceivers/set-rtx";
 
-//#region src/main/atom.d.ts
+//#region src/main/tokens.d.ts
 
 /**
-* @public
-* Create a mutable atom, a global reactive variable in the implicit store
+* A token is an object that uniquely identifies a particular state, family, timeline, or transaction.
 *
-* The value of a mutable atom must be some kind of {@link Transceiver}.
+* While they represent one of these resources, they are not the resource itself. Think of them like paper currency representing money in the bank.
 *
-* @param options - {@link MutableAtomOptions}.
-* @returns
-* A reference to the atom created: a {@link MutableAtomToken}
-* @overload Mutable
+* Tokens are returned from resource creation functions, such as {@link atom} and {@link transaction}.
+*
+* Tokens can be used as parameters to functions that take a token, such as {@link getState}, {@link setState}, or {@link runTransaction}.
+*
+* Tokens are fully serializable, so they can be passed between processes.
 */
-declare function atom<T extends Transceiver<any>, J extends Json.Serializable>(options: MutableAtomOptions<T, J>): MutableAtomToken<T, J>;
+type AtomIOToken = ReadableFamilyToken<any, any> | ReadableToken<any> | TimelineToken<any> | TransactionToken<any>;
 /**
-* @public
-* Create a regular atom, a global reactive variable in the implicit store
-* @param options - {@link RegularAtomOptions}.
-* @returns
-* A reference to the atom created: a {@link RegularAtomToken}
-* @overload Regular
+* These states cannot be set.
 */
-declare function atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T>;
-/** @public */
-type Effectors<T> = {
-  /**
-  * Reset the value of the atom to its default
-  */
-  resetSelf: () => void;
-  /**
-  * Set the value of the atom
-  * @param next - The new value of the atom, or a setter function
-  */
-  setSelf: <New extends T>(next: New | Setter<T, New>) => void;
-  /** Subscribe to changes to the atom */
-  onSet: (callback: (options: {
-    newValue: T;
-    oldValue: T;
-  }) => void) => void;
-};
+type ReadableToken<T, K extends Canonical = any> = AtomToken<T, K> | SelectorToken<T, K>;
 /**
-* @public
-* A function that runs side effects when the atom is set
-* @param tools - {@link Effectors} that can be used to run side effects
-* @returns
-* Optionally, a cleanup function that will be called when the atom is disposed
+* These states can be set.
 */
-type AtomEffect<T> = (tools: Effectors<T>) => (() => void) | void;
-/** @public */
-type RegularAtomOptions<T> = {
-  /** The unique identifier of the atom */
+type WritableToken<T, K extends Canonical = any> = AtomToken<T, K> | WritableSelectorToken<T, K>;
+/**
+* States belonging to this family can be gotten from the store.
+*/
+type ReadableFamilyToken<T, K extends Canonical> = AtomFamilyToken<T, K> | SelectorFamilyToken<T, K>;
+/**
+* States belonging to this family can be set.
+*/
+type WritableFamilyToken<T, K extends Canonical> = AtomFamilyToken<T, K> | WritableSelectorFamilyToken<T, K>;
+type TimelineToken<M> = {
+  /** The unique identifier of the timeline */
   key: string;
-  /** The starting value of the atom */
-  default: T | (() => T);
-  /** Hooks used to run side effects when the atom is set */
-  effects?: AtomEffect<T>[];
+  /** Discriminator */
+  type: `timeline`;
+  /** Never present. This is a marker that preserves the type of the managed atoms */
+  __M?: M;
 };
-/** @public */
-type MutableAtomOptions<T extends Transceiver<any>, J extends Json.Serializable> = JsonInterface<T, J> & {
-  /** Used to signal that the atom is mutable */
-  mutable: true;
-  /** The unique identifier of the atom */
+type TransactionToken<F extends Func> = {
+  /** The unique identifier of the transaction */
   key: string;
-  /** A function to create an initial value for the atom */
-  default: () => T;
-  /** Hooks used to run side effects when the atom is set */
-  effects?: AtomEffect<T>[];
+  /** Discriminator */
+  type: `transaction`;
+  /** Never present. This is a marker that preserves the type of the transaction function */
+  __F?: F;
 };
-/** @public */
-type RegularAtomFamilyOptions<T, K extends Canonical> = {
-  /** The unique identifier of the atom family */
+type AtomToken<T, K extends Canonical = any> = MutableAtomToken<T extends Transceiver<any> ? T : never, any, K> | RegularAtomToken<T, K>;
+type RegularAtomToken<T, K extends Canonical = any> = {
+  /** The unique identifier of the atom. */
   key: string;
-  /** The starting value of the atom family */
-  default: T | ((key: K) => T);
-  /** Hooks used to run side effects when an atom in the family is set  */
-  effects?: (key: K) => AtomEffect<T>[];
+  /** Discriminator. */
+  type: `atom`;
+  /** Present if the atom belongs to a family. */
+  family?: FamilyMetadata<K>;
+  /** Never present. This is a marker that preserves the type of the atom's value. */
+  __T?: T;
+};
+type MutableAtomToken<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical = any> = {
+  /** The unique identifier of the atom. */
+  key: string;
+  /** Discriminator. */
+  type: `mutable_atom`;
+  /** Present if the atom belongs to a family. */
+  family?: FamilyMetadata<K>;
+  /** Never present. This is a marker that preserves the JSON form of the atom's transceiver value. */
+  __J?: J;
+  /** Never present. This is a marker that preserves the type of the atom's transceiver value. */
+  __U?: T extends Transceiver<infer Update> ? Update : never;
+};
+type SelectorToken<T, K extends Canonical = any> = ReadonlySelectorToken<T, K> | WritableSelectorToken<T, K>;
+type ReadonlySelectorToken<T, K extends Canonical = any> = ReadonlyHeldSelectorToken<T, K> | ReadonlyPureSelectorToken<T, K>;
+type WritableSelectorToken<T, K extends Canonical = any> = WritableHeldSelectorToken<T, K> | WritablePureSelectorToken<T, K>;
+type PureSelectorToken<T, K extends Canonical = any> = ReadonlyPureSelectorToken<T, K> | WritablePureSelectorToken<T, K>;
+type HeldSelectorToken<T, K extends Canonical = any> = ReadonlyHeldSelectorToken<T, K> | WritableHeldSelectorToken<T, K>;
+type WritablePureSelectorToken<T, K extends Canonical = any> = {
+  /** The unique identifier of the selector. */
+  key: string;
+  /** Discriminator. */
+  type: `writable_pure_selector`;
+  /** Present if the selector belongs to a family. */
+  family?: FamilyMetadata<K>;
+  /** Never present. This is a marker that preserves the type of the selector's value. */
+  __T?: T;
+};
+type WritableHeldSelectorToken<T, K extends Canonical = any> = {
+  /** The unique identifier of the selector. */
+  key: string;
+  /** Discriminator. */
+  type: `writable_held_selector`;
+  /** Present if the selector belongs to a family. */
+  family?: FamilyMetadata<K>;
+  /** Never present. This is a marker that preserves the type of the selector's value. */
+  __T?: T;
+};
+type ReadonlyPureSelectorToken<T, K extends Canonical = any> = {
+  /** The unique identifier of the selector. */
+  key: string;
+  /** Discriminator. */
+  type: `readonly_pure_selector`;
+  /** Present if the selector belongs to a family. */
+  family?: FamilyMetadata<K>;
+  /** Never present. This is a marker that preserves the type of the selector's value. */
+  __T?: T;
+};
+type ReadonlyHeldSelectorToken<T, K extends Canonical = any> = {
+  /** The unique identifier of the selector. */
+  key: string;
+  /** Discriminator. */
+  type: `readonly_held_selector`;
+  /** Present if the selector belongs to a family. */
+  family?: FamilyMetadata<K>;
+  /** Never present. This is a marker that preserves the type of the selector's value. */
+  __T?: T;
+};
+/**
+* Identifies a state's connection to its family.
+*/
+type FamilyMetadata<K extends Canonical = any> = {
+  /** The family's unique key. */
+  key: string;
+  /** The family member's unique identifier, in the form of a string. */
+  subKey: stringified<K>;
 };
+type AtomFamilyToken<T, K extends Canonical = Canonical> = MutableAtomFamilyToken<T extends Transceiver<any> ? T : never, any, K> | RegularAtomFamilyToken<T, K>;
 type RegularAtomFamilyToken<T, K extends Canonical> = {
   /** The unique identifier of the atom family */
   key: string;
@@ -90,17 +137,6 @@ type RegularAtomFamilyToken<T, K extends Canonical> = {
   /** Never present. This is a marker that preserves the type of keys used for atoms in this family */
   __K?: K;
 };
-/** @public */
-type MutableAtomFamilyOptions<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical> = JsonInterface<T, J> & {
-  /** Used to signal that the atoms created from this family are mutable */
-  mutable: true;
-  /** The unique identifier of the atom family */
-  key: string;
-  /** A function to create an initial value for each atom in the family */
-  default: (key: K) => T;
-  /** Hooks used to run side effects when an atom in the family is set  */
-  effects?: (key: K) => AtomEffect<T>[];
-};
 type MutableAtomFamilyToken<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical> = {
   /** The unique identifier of the atom family */
   key: string;
@@ -113,685 +149,372 @@ type MutableAtomFamilyToken<T extends Transceiver<any>, J extends Json.Serializa
   /** Never present. This is a marker that preserves the type of keys used for atoms in this family */
   __K?: K;
 };
-type AtomFamilyToken<T, K extends Canonical = Canonical> = MutableAtomFamilyToken<T extends Transceiver<any> ? T : never, any, K> | RegularAtomFamilyToken<T, K>;
-/**
-* @public
-* Create a family of mutable atoms, allowing for the dynamic creation and disposal of atoms.
-*
-* The value of a mutable atom must be some kind of {@link Transceiver}.
-*
-* @param options - {@link MutableAtomFamilyOptions}
-* @returns
-* A reference to the atom family created: a {@link MutableAtomFamilyToken}
-* @overload Mutable
-*/
-declare function atomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamilyToken<T, J, K>;
+type SelectorFamilyToken<T, K extends Canonical> = ReadonlySelectorFamilyToken<T, K> | WritableSelectorFamilyToken<T, K>;
+type ReadonlySelectorFamilyToken<T, K extends Canonical> = ReadonlyHeldSelectorFamilyToken<T, K> | ReadonlyPureSelectorFamilyToken<T, K>;
+type WritableSelectorFamilyToken<T, K extends Canonical> = WritableHeldSelectorFamilyToken<T, K> | WritablePureSelectorFamilyToken<T, K>;
+type PureSelectorFamilyToken<T, K extends Canonical> = ReadonlyPureSelectorFamilyToken<T, K> | WritablePureSelectorFamilyToken<T, K>;
+type HeldSelectorFamilyToken<T, K extends Canonical> = ReadonlyHeldSelectorFamilyToken<T, K> | WritableHeldSelectorFamilyToken<T, K>;
+type WritablePureSelectorFamilyToken<T, K extends Canonical> = {
+  /** The unique identifier of the family */
+  key: string;
+  /** Discriminator */
+  type: `writable_pure_selector_family`;
+  /** Never present. This is a marker that preserves the type of the value of each family member */
+  __T?: T;
+  /** Never present. This is a marker that preserves the type of keys used for each family member */
+  __K?: K;
+};
+type ReadonlyPureSelectorFamilyToken<T, K extends Canonical> = {
+  /** The unique identifier of the family */
+  key: string;
+  /** Discriminator */
+  type: `readonly_pure_selector_family`;
+  /** Never present. This is a marker that preserves the type of the value of each family member */
+  __T?: T;
+  /** Never present. This is a marker that preserves the type of keys used for each family member */
+  __K?: K;
+};
+type WritableHeldSelectorFamilyToken<T, K extends Canonical> = {
+  /** The unique identifier of the family */
+  key: string;
+  /** Discriminator */
+  type: `writable_held_selector_family`;
+  /** Never present. This is a marker that preserves the type of the value of each family member */
+  __T?: T;
+  /** Never present. This is a marker that preserves the type of keys used for each family member */
+  __K?: K;
+};
+type ReadonlyHeldSelectorFamilyToken<T, K extends Canonical> = {
+  /** The unique identifier of the family */
+  key: string;
+  /** Discriminator */
+  type: `readonly_held_selector_family`;
+  /** Never present. This is a marker that preserves the type of the value of each family member */
+  __T?: T;
+  /** Never present. This is a marker that preserves the type of keys used for each family member */
+  __K?: K;
+};
+//#endregion
+//#region src/main/set-state.d.ts
 /**
-* @public
-* Create a family of regular atoms, allowing for the dynamic creation and disposal of atoms.
-* @param options - {@link RegularAtomFamilyOptions}
+* A function that sets the value of a state.
+* @param oldValue - The current value of the state.
 * @returns
-* A reference to the atom family created: a {@link RegularAtomFamilyToken}
-* @overload Regular
+* The new value of the state.
 */
-declare function atomFamily<T, K extends Canonical>(options: RegularAtomFamilyOptions<T, K>): RegularAtomFamilyToken<T, K>;
-//#endregion
-//#region src/main/reset-state.d.ts
+type Setter<T, New extends T> = (oldValue: T) => New;
 /**
-* @public
-* Set the value of a state into the implicit store back to its default value.
+* Set the value of a state into the implicit store.
 * @param token - An atom or writable selector token.
+* @param value - The new value of the state.
 * @overload Default
 * @default
 */
-declare function resetState(token: WritableToken<any>): void;
+declare function setState<T, New extends T>(token: WritableToken<T>, value: New | Setter<T, New>): void;
 /**
-* @public
-* Set the value of a state into the implicit store back to its default value.
+* Set the value of a state into the implicit store.
 * @param token - An atom family or writable selector family token.
 * @param key - The unique key of the state to set.
+* @param value - The new value of the state.
 * @overload Streamlined
 */
-declare function resetState<K extends Canonical>(token: WritableFamilyToken<any, K>, key: K): void;
+declare function setState<T, K extends Canonical, New extends T, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, value: New | Setter<T, New>): void;
 //#endregion
-//#region src/main/transaction.d.ts
-/** @public */
-type TransactionToken<F extends Func> = {
-  /** The unique identifier of the transaction */
+//#region src/main/atom.d.ts
+type RegularAtomOptions<T> = {
+  /** The unique identifier of the atom */
   key: string;
-  /** Discriminator */
-  type: `transaction`;
-  /** Never present. This is a marker that preserves the type of the transaction function */
-  __F?: F;
+  /** The starting value of the atom */
+  default: T | (() => T);
+  /** Hooks used to run side effects when the atom is set */
+  effects?: AtomEffect<T>[];
 };
-/** @public */
-type StateCreation<Token extends ReadableToken<any>> = {
-  type: `state_creation`;
-  token: Token;
-};
-/** @public */
-type AtomDisposal<Token extends ReadableToken<any>> = {
-  type: `state_disposal`;
-  subType: `atom`;
-  token: Token;
-  value: TokenType<Token>;
-};
-/** @public */
-type SelectorDisposal<Token extends ReadableToken<any>> = {
-  type: `state_disposal`;
-  subType: `selector`;
-  token: Token;
-};
-/** @public */
-type StateDisposal<Token extends ReadableToken<any>> = AtomDisposal<Token> | SelectorDisposal<Token>;
-/** @public */
-type MoleculeCreation = {
-  type: `molecule_creation`;
-  key: Canonical;
-  provenance: Canonical;
-};
-/** @public */
-type MoleculeDisposal = {
-  type: `molecule_disposal`;
-  key: Canonical;
-  provenance: stringified<Canonical>[];
-  values: [key: string, value: any][];
-};
-/** @public */
-type MoleculeTransfer = {
-  type: `molecule_transfer`;
-  key: Canonical;
-  from: Canonical[];
-  to: Canonical[];
-};
-/** @public */
-type TransactionUpdateContent = KeyedStateUpdate<unknown> | MoleculeCreation | MoleculeDisposal | MoleculeTransfer | StateCreation<ReadableToken<unknown>> | StateDisposal<ReadableToken<unknown>> | TransactionUpdate<Func>;
-/** @public */
-type TransactionUpdate<F extends Func> = {
-  type: `transaction_update`;
-  key: string;
-  id: string;
-  epoch: number;
-  updates: TransactionUpdateContent[];
-  params: Parameters<F>;
-  output: ReturnType<F>;
-};
-/** @public */
-type GetterToolkit = Pick<SetterToolkit, `find` | `get` | `json`>;
-/** @public */
-type SetterToolkit = Readonly<{
-  get: typeof getState$1;
-  set: typeof setState$1;
-  find: typeof findState$1;
-  json: <T extends Transceiver<any>, J extends Json.Serializable>(state: MutableAtomToken<T, J>) => WritablePureSelectorToken<J>;
-}>;
-/** @public */
-type ActorToolkit = Readonly<{
-  get: typeof getState$1;
-  set: typeof setState$1;
-  reset: typeof resetState;
-  find: typeof findState$1;
-  json: <T extends Transceiver<any>, J extends Json.Serializable>(state: MutableAtomToken<T, J>) => WritablePureSelectorToken<J>;
-  dispose: typeof disposeState;
-  run: typeof runTransaction;
-  env: () => EnvironmentData;
-}>;
-/** @public */
-type Read<F extends Func> = (toolkit: GetterToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
-/** @public */
-type Write<F extends Func> = (toolkit: SetterToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
-/** @public */
-type Transact<F extends Func> = (toolkit: ActorToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
-/** @public */
-type TransactionIO<Token extends TransactionToken<any>> = Token extends TransactionToken<infer F> ? F : never;
-/** @public */
-type TransactionOptions<F extends Func> = {
-  /** The unique identifier of the transaction */
+/**
+* Create a regular atom, a global reactive variable in the implicit store
+* @param options - {@link RegularAtomOptions}.
+* @returns
+* A reference to the atom created: a {@link RegularAtomToken}
+*/
+declare function atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T>;
+type MutableAtomOptions<T extends Transceiver<any>, J extends Json.Serializable> = JsonInterface<T, J> & {
+  /** The unique identifier of the atom */
   key: string;
-  /** The operation to perform */
-  do: Transact<F>;
+  /** A function to create an initial value for the atom */
+  default: () => T;
+  /** Hooks used to run side effects when the atom is set */
+  effects?: AtomEffect<T>[];
 };
 /**
-* @public
-* Create a transaction, a mechanism for batching updates multiple states in a single, all-or-nothing operation
-* @param options - {@link TransactionOptions}
-* @returns A reference to the transaction created: a {@link TransactionToken}
+* Create a mutable atom, a global reactive variable in the implicit store
+*
+* The value of a mutable atom must be some kind of {@link Transceiver}.
+*
+* @param options - {@link MutableAtomOptions}.
+* @returns
+* A reference to the atom created: a {@link MutableAtomToken}
 */
-declare function transaction<F extends Func>(options: TransactionOptions<F>): TransactionToken<F>;
+declare function mutableAtom<T extends Transceiver<any>, J extends Json.Serializable>(options: MutableAtomOptions<T, J>): MutableAtomToken<T, J>;
 /**
-* @public
-* Execute a {@link transaction}
-* @param token - A {@link TransactionToken}
-* @param id - A unique identifier for the transaction. If not provided, a random identifier will be generated
-* @returns A function that can be called to run the transaction with its {@link TransactionIO} parameters
+* A function that runs side effects when the atom is set
+* @param tools - {@link Effectors} that can be used to run side effects
+* @returns
+* Optionally, a cleanup function that will be called when the atom is disposed
 */
-declare function runTransaction<F extends Func>(token: TransactionToken<F>, id?: string): (...parameters: Parameters<F>) => ReturnType<F>;
-//#endregion
-//#region src/main/selector.d.ts
-type WritablePureSelectorOptions<T> = {
-  /** The unique identifier of the selector */
-  key: string;
-  /** For each instantiated selector, a function that computes its value */
-  get: Read<() => T>;
-  /** For each instantiated selector, a function that sets its value */
-  set: Write<(newValue: T) => void>;
-};
-type ReadonlyPureSelectorOptions<T> = {
-  /** The unique identifier of the selector */
-  key: string;
-  /** For each instantiated selector, a function that computes its value */
-  get: Read<() => T>;
+type AtomEffect<T> = (tools: Effectors<T>) => (() => void) | void;
+type Effectors<T> = {
+  /**
+  * Reset the value of the atom to its default
+  */
+  resetSelf: () => void;
+  /**
+  * Set the value of the atom
+  * @param next - The new value of the atom, or a setter function
+  */
+  setSelf: <New extends T>(next: New | Setter<T, New>) => void;
+  /** Subscribe to changes to the atom */
+  onSet: (callback: (options: {
+    newValue: T;
+    oldValue: T;
+  }) => void) => void;
 };
-type ReadonlyHeldSelectorOptions<T extends object> = {
-  /** The unique identifier of the selector */
+type RegularAtomFamilyOptions<T, K extends Canonical> = {
+  /** The unique identifier of the atom family */
   key: string;
-  /** For each instantiated selector, a constant reference to a value that will not be replaced */
-  const: T;
-  /** For each instantiated selector, a function that computes its value */
-  get: Read<(permanent: T) => void>;
+  /** The starting value of the atom family */
+  default: T | ((key: K) => T);
+  /** Hooks used to run side effects when an atom in the family is set  */
+  effects?: (key: K) => AtomEffect<T>[];
 };
-type WritableHeldSelectorOptions<T extends object> = {
-  /** The unique identifier of the selector */
+/**
+* Create a family of regular atoms, allowing for the dynamic creation and disposal of atoms.
+* @param options - {@link RegularAtomFamilyOptions}
+* @returns
+* A reference to the atom family created: a {@link RegularAtomFamilyToken}
+*/
+declare function atomFamily<T, K extends Canonical>(options: RegularAtomFamilyOptions<T, K>): RegularAtomFamilyToken<T, K>;
+type MutableAtomFamilyOptions<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical> = JsonInterface<T, J> & {
+  /** The unique identifier of the atom family */
   key: string;
-  /** For each instantiated selector, a constant reference to a value that will not be replaced */
-  const: T;
-  /** For each instantiated selector, a function that computes its value */
-  get: Read<(permanent: T) => void>;
-  /** For each instantiated selector, a function that sets its value */
-  set: Write<(newValue: T) => void>;
+  /** A function to create an initial value for each atom in the family */
+  default: (key: K) => T;
+  /** Hooks used to run side effects when an atom in the family is set  */
+  effects?: (key: K) => AtomEffect<T>[];
 };
 /**
-* @public
-* Declare a selector. The value of a selector should depend
-* on the value of atoms or other selectors in the store, and
-* should be recycled when a root atom of the selector is set.
+* Create a family of mutable atoms, allowing for the dynamic creation and disposal of atoms.
 *
-* A held selector's value must be some object.
-* The reference to that object is permanent and will not be replaced.
+* The value of a mutable atom must be some kind of {@link Transceiver}.
 *
-* A writable selector can be "set" to a new value.
-* It is strongly advised to set its dependencies to values
-* that would produce the new value of the selector.
+* @param options - {@link MutableAtomFamilyOptions}
+* @returns
+* A reference to the atom family created: a {@link MutableAtomFamilyToken}
+*/
+declare function mutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamilyToken<T, J, K>;
+//#endregion
+//#region src/main/dispose-state.d.ts
+/**
+* Disposes of a state in the implicit store.
 *
-* @param options - {@link WritableHeldSelectorOptions}.
+* Only family members can be disposed of.
+*
+* @param token - The token of the state to dispose
+* @overload Default
+*/
+declare function disposeState(token: ReadableToken<any>): void;
+/**
+* Disposes of a state in the implicit store.
+*
+* Only family members can be disposed of.
+*
+* @param token - The token of the state family to dispose
+* @param key - The unique key of the state to dispose
+*/
+declare function disposeState<K extends Canonical>(token: ReadableFamilyToken<any, K>, key: K): void;
+//#endregion
+//#region src/main/find-state.d.ts
+/**
+* Finds a {@link MutableAtomToken} in the store, without accessing its value.
+*
+* In an ephemeral store, this will create a new atom if one does not exist with the given key.
+*
+* In an immortal store, a "counterfeit" atom token will be returned in this case and a warning will be logged.
+*
+* @param token - A {@link MutableAtomFamilyToken}
+* @param key - The key of the state
 * @returns
-* The token for your selector.
-* @overload WritableHeld
+* The current value of the state
+* @overload Mutable Atom
 */
-declare function selector<T extends object>(options: WritableHeldSelectorOptions<T>): WritableHeldSelectorToken<T>;
+declare function findState<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken$1<T, J, K>;
 /**
-* @public
-* Declare a selector. The value of a selector should depend
-* on the value of atoms or other selectors in the store,
-* and should be recycled when a root atom of the selector is set.
+* Finds a {@link RegularAtomToken} in the store, without accessing its value.
 *
-* A held selector's value must be some object.
-* The reference to that object is permanent and will not be replaced.
+* In an ephemeral store, this will create a new atom if one does not exist with the given key.
 *
-* A readonly selector can be "gotten" but not "set".
+* In an immortal store, a "counterfeit" atom token will be returned in this case and a warning will be logged.
 *
-* @param options - {@link ReadonlyHeldSelectorOptions}.
+* @param token - The token of the state family
+* @param key - The key of the state
 * @returns
-* The token for your selector.
-* @overload ReadonlyHeld
+* The current value of the state
+* @overload Regular Atom
 */
-declare function selector<T extends object>(options: ReadonlyHeldSelectorOptions<T>): ReadonlyHeldSelectorToken<T>;
+declare function findState<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken$1<T, K>;
 /**
-* @public
-* Declare a selector. The value of a selector should depend
-* on the value of atoms or other selectors in the store.
+* Finds a {@link WritableSelectorToken} in the store, without accessing its value.
 *
-* A pure selector's current value is evicted from the store
-* in order to be garbage collected when a root atom of the selector is set.
+* In an ephemeral store, this will create a new selector if one does not exist with the given key.
 *
-* A writable selector can be "set" to a new value.
-* It is strongly advised to set its dependencies to values
-* that would produce the new value of the selector.
+* In an immortal store, a "counterfeit" selector token will be returned in this case and a warning will be logged.
 *
-* @param options - {@link TransientWritableSelectorOptions}.
+* @param token - The token of the state family
+* @param key - The key of the state
 * @returns
-* The token for your selector.
-* @overload WritablePure
+* The current value of the state
+* @overload Writable Selector
 */
-declare function selector<T>(options: WritablePureSelectorOptions<T>): WritablePureSelectorToken<T>;
+declare function findState<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken$1<T, K>, key: Key): WritableSelectorToken$1<T, K>;
 /**
-* @public
-* Declare a selector. The value of a selector should depend
-* on the value of atoms or other selectors in the store.
+* Finds a {@link ReadonlySelectorToken} in the store, without accessing its value.
 *
-* A pure selector's current value is evicted from the store
-* in order to be garbage collected when a root atom of the selector is set.
+* In an ephemeral store, this will create a new selector if one does not exist with the given key.
 *
-* A readonly selector can be "gotten" but not "set".
+* In an immortal store, a "counterfeit" selector token will be returned in this case and a warning will be logged.
 *
-* @param options - {@link ReadonlyPureSelectorOptions}.
+* @param token - The token of the state family
+* @param key - The key of the state
 * @returns
-* The token for your selector.
-* @overload ReadonlyPure
+* The current value of the state
+* @overload Readonly Selector
 */
-declare function selector<T>(options: ReadonlyPureSelectorOptions<T>): ReadonlyPureSelectorToken<T>;
-/** @public */
-type WritablePureSelectorFamilyOptions<T, K extends Canonical> = {
-  /** The unique identifier of the family */
-  key: string;
-  /** For each instantiated family member, a function that computes its value */
-  get: (key: K) => Read<() => T>;
-  /** For each instantiated family member, a function that sets its value */
-  set: (key: K) => Write<(newValue: T) => void>;
-};
-/** @public */
-type ReadonlyPureSelectorFamilyOptions<T, K extends Canonical> = {
-  /** The unique identifier of the family */
-  key: string;
-  /** For each instantiated family member, a function that computes its value */
-  get: (key: K) => Read<() => T>;
-};
-/** @public */
-type WritableHeldSelectorFamilyOptions<T extends object, K extends Canonical> = {
-  /** The unique identifier of the family */
-  key: string;
-  /** For each instantiated family member, a constant reference to a value that will not be replaced */
-  const: (key: K) => T;
-  /** For each instantiated family member, a function that computes its value */
-  get: (key: K) => Read<(permanent: T) => void>;
-  /** For each instantiated family member, a function that sets its value */
-  set: (key: K) => Write<(newValue: T) => void>;
-};
-/** @public */
-type ReadonlyHeldSelectorFamilyOptions<T extends object, K extends Canonical> = {
-  /** The unique identifier of the family */
-  key: string;
-  /** For each instantiated family member, a constant reference to a value that will not be replaced */
-  const: (key: K) => T;
-  /** For each instantiated family member, a function that computes its value */
-  get: (key: K) => Read<(permanent: T) => void>;
-};
-type WritablePureSelectorFamilyToken<T, K extends Canonical> = {
-  /** The unique identifier of the family */
-  key: string;
-  /** Discriminator */
-  type: `writable_pure_selector_family`;
-  /** Never present. This is a marker that preserves the type of the value of each family member */
-  __T?: T;
-  /** Never present. This is a marker that preserves the type of keys used for each family member */
-  __K?: K;
-};
-type ReadonlyPureSelectorFamilyToken<T, K extends Canonical> = {
-  /** The unique identifier of the family */
-  key: string;
-  /** Discriminator */
-  type: `readonly_pure_selector_family`;
-  /** Never present. This is a marker that preserves the type of the value of each family member */
-  __T?: T;
-  /** Never present. This is a marker that preserves the type of keys used for each family member */
-  __K?: K;
-};
-type WritableHeldSelectorFamilyToken<T, K extends Canonical> = {
-  /** The unique identifier of the family */
-  key: string;
-  /** Discriminator */
-  type: `writable_held_selector_family`;
-  /** Never present. This is a marker that preserves the type of the value of each family member */
-  __T?: T;
-  /** Never present. This is a marker that preserves the type of keys used for each family member */
-  __K?: K;
-};
-type ReadonlyHeldSelectorFamilyToken<T, K extends Canonical> = {
-  /** The unique identifier of the family */
-  key: string;
-  /** Discriminator */
-  type: `readonly_held_selector_family`;
-  /** Never present. This is a marker that preserves the type of the value of each family member */
-  __T?: T;
-  /** Never present. This is a marker that preserves the type of keys used for each family member */
-  __K?: K;
-};
-type PureSelectorFamilyToken<T, K extends Canonical> = ReadonlyPureSelectorFamilyToken<T, K> | WritablePureSelectorFamilyToken<T, K>;
-type HeldSelectorFamilyToken<T, K extends Canonical> = ReadonlyHeldSelectorFamilyToken<T, K> | WritableHeldSelectorFamilyToken<T, K>;
-type ReadonlySelectorFamilyToken<T, K extends Canonical> = ReadonlyHeldSelectorFamilyToken<T, K> | ReadonlyPureSelectorFamilyToken<T, K>;
-type WritableSelectorFamilyToken<T, K extends Canonical> = WritableHeldSelectorFamilyToken<T, K> | WritablePureSelectorFamilyToken<T, K>;
-type SelectorFamilyToken<T, K extends Canonical> = HeldSelectorFamilyToken<T, K> | PureSelectorFamilyToken<T, K>;
+declare function findState<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken$1<T, K>, key: Key): ReadonlySelectorToken$1<T, K>;
 /**
-* @public
-* Create a family of selectors, allowing for the dynamic creation and disposal of selectors.
-*
-* The value of a held selector should depend on the value of atoms or other selectors in the store,
-* and should be recycled when a root atom of the selector is set.
+* Finds a {@link WritableToken} in the store, without accessing its value.
 *
-* A held selector's value must be some object.
-* The reference to that object is permanent and will not be replaced.
+* In an ephemeral store, this will create a new atom or selector if one does not exist with the given key.
 *
-* A writable selector can be "set" to a new value.
-* It is advised to set its dependencies to values
-* that would produce the new value of the selector.
+* In an immortal store, a "counterfeit" token will be returned in this case and a warning will be logged.
 *
-* @param options - {@link WritableHeldSelectorFamilyOptions}.
+* @param token - The token of the state family
+* @param key - The key of the state
 * @returns
-* A reference to the selector family created: a {@link WritableHeldSelectorFamilyToken}
-* @overload WritableHeld
+* The current value of the state
+* @overload Writable State
 */
-declare function selectorFamily<T extends object, K extends Canonical>(options: WritableHeldSelectorFamilyOptions<T, K>): WritableHeldSelectorFamilyToken<T, K>;
+declare function findState<T, K extends Canonical, Key extends K>(token: WritableFamilyToken$1<T, K>, key: Key): WritableToken$1<T, K>;
 /**
-* @public
-* Create a family of selectors, allowing for the dynamic creation and disposal of selectors.
-*
-* The value of a held selector should depend on the value of atoms or other selectors in the store,
-* and should be recycled when a root atom of the selector is set.
+* Finds a {@link MutableAtomToken} in the store, without accessing its value.
 *
-* A held selector's value must be some object.
-* The reference to that object is permanent and will not be replaced.
+* In an ephemeral store, this will create a new atom or selector if one does not exist with the given key.
 *
-* A readonly selector can be "gotten" but not "set".
+* In an immortal store, a "counterfeit" token will be returned in this case and a warning will be logged.
 *
-* @param options - {@link ReadonlyHeldSelectorFamilyOptions}.
+* @param token - A {@link ReadableFamilyToken}
+* @param key - The key of the state
 * @returns
-* A reference to the selector family created: a {@link ReadonlyHeldSelectorFamilyToken}
-* @overload ReadonlyHeld
+* The current value of the state
+* @overload Unknown
+* @default
 */
-declare function selectorFamily<T extends object, K extends Canonical>(options: ReadonlyHeldSelectorFamilyOptions<T, K>): ReadonlyHeldSelectorFamilyToken<T, K>;
+declare function findState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken$1<T, K>, key: Key): ReadableToken$1<T, K>;
+//#endregion
+//#region src/main/get-state.d.ts
 /**
-* @public
-* Create a family of selectors, allowing for the dynamic creation and disposal of selectors.
-*
-* The value of a selector should depend on the value of atoms or other selectors in the store.
+* Read or compute the current value of a state
+* @param token - The token of the state to get
+* @return The current value of the state
+* @overload Default
+* @default
+*/
+declare function getState<T>(token: ReadableToken<T>): T;
+/**
+* Read or compute the current value of a state
+* @param token - The token of a state family
+* @param key - The unique key of the state to get
+* @return The current value of the state
+* @overload Streamlined
+*/
+declare function getState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): T;
+//#endregion
+//#region src/main/join.d.ts
+type JoinOptions<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null> = Flat<JunctionSchemaBase<ASide, BSide> & {
+  /** Unique identifier of the join */
+  readonly key: string;
+  /** How many relations are allowed in each direction? */
+  readonly cardinality: Cardinality;
+  /** Type guard for the type of the left side */
+  readonly isAType: Refinement<string, AType>;
+  /** Type guard for the type of the right side */
+  readonly isBType: Refinement<string, BType>;
+}> & Partial<JunctionEntriesBase<AType, BType, Content>>;
+type JoinToken<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null = null> = {
+  /** Unique identifier of the join */
+  key: string;
+  /** Discriminator */
+  type: `join`;
+  /** How many relations are allowed in each direction? */
+  cardinality: Cardinality;
+  /** Name of the join's left side */
+  a: ASide;
+  /** Name of the join's right side */
+  b: BSide;
+  /** Never present. This is a marker that preserves the type of the left side's keys */
+  __aType?: AType;
+  /** Never present. This is a marker that preserves the type of the right side's keys */
+  __bType?: BType;
+  /** Never present. This is a marker that preserves the type of the data present for each relation */
+  __content?: Content;
+};
+/**
+* Create a join, an interface for managing relations between two sets of keys.
 *
-* A pure selector's current value is evicted from the store
-* in order to be garbage collected when a root atom of the selector is set.
+* Use joins when it is important to view relationships from either side.
 *
-* A writable selector can be "set" to a new value.
-* It is advised to set its dependencies to values
-* that would produce the new value of the selector.
+* Under the hood, joins coordinate changes of multiple atoms to support that the desired relationships stay consistent.
 *
-* @param options - {@link TransientWritableSelectorFamilyOptions}.
+* @param options - {@link JoinOptions}
+* @param defaultContent - (undefined)
 * @returns
-* A reference to the selector family created: a {@link TransientWritableSelectorFamilyToken}
-* @overload WritablePure
+* A reference to the join created: a {@link JoinToken}
+* @overload No Content
 */
-declare function selectorFamily<T, K extends Canonical>(options: WritablePureSelectorFamilyOptions<T, K>): WritablePureSelectorFamilyToken<T, K>;
+declare function join<const ASide extends string, const AType extends string, const BSide extends string, const BType extends string, const Cardinality extends `1:1` | `1:n` | `n:n`>(options: JoinOptions<ASide, AType, BSide, BType, Cardinality, null>, defaultContent?: undefined): JoinToken<ASide, AType, BSide, BType, Cardinality, null>;
 /**
-* @public
-* Create a family of selectors, allowing for the dynamic creation and disposal of selectors.
-*
-* The value of a selector should depend on the value of atoms or other selectors in the store.
+* Create a join, an interface for managing relations between two sets of keys.
 *
-* A pure selector's current value is evicted from the store
-* in order to be garbage collected when a root atom of the selector is set.
+* Use joins when it is important to view relationships from either side.
 *
-* A readonly selector can be "gotten" but not "set".
+* Under the hood, joins coordinate changes of multiple atoms to support that the desired relationships stay consistent.
 *
-* @param options - {@link ReadonlyPureSelectorFamilyOptions}.
+* @param options - {@link JoinOptions}
+* @param defaultContent - The default value for the content of each relation
 * @returns
-* A reference to the selector family created: a {@link ReadonlyPureSelectorFamilyToken}
-* @overload ReadonlyPure
+* A reference to the join created: a {@link JoinToken}
+* @overload With Content
 */
-declare function selectorFamily<T, K extends Canonical>(options: ReadonlyPureSelectorFamilyOptions<T, K>): ReadonlyPureSelectorFamilyToken<T, K>;
-//#endregion
-//#region src/main/timeline.d.ts
-/** @public */
-type TimelineManageable = AtomFamilyToken<any, any> | AtomToken<any>;
-/** @public */
-type AtomOnly<M extends TimelineManageable> = M extends AtomFamilyToken<any, any> ? AtomToken<any> : M extends AtomToken<any> ? M : never;
-/** @public */
-type TimelineToken<M> = {
-  /** The unique identifier of the timeline */
-  key: string;
-  /** Discriminator */
-  type: `timeline`;
-  /** Never present. This is a marker that preserves the type of the managed atoms */
-  __M?: M;
-};
+declare function join<const ASide extends string, const AType extends string, const BSide extends string, const BType extends string, const Cardinality extends `1:1` | `1:n` | `n:n`, const Content extends Json.Object>(options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>, defaultContent: Content): JoinToken<ASide, AType, BSide, BType, Cardinality, Content>;
+type JoinStates<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null> = Cardinality extends `1:1` ? (Content extends Json.Object ? { readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken$1<[AType, Content] | null, BType> } & { readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken$1<[BType, Content] | null, AType> } : {}) & { readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken$1<AType | null, BType> } & { readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken$1<BType | null, AType> } : Cardinality extends `1:n` ? (Content extends Json.Object ? { readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken$1<[AType, Content] | null, BType> } & { readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken$1<[BType, Content][], AType> } : {}) & { readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken$1<AType | null, BType> } & { readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken$1<BType[], AType> } : Cardinality extends `n:n` ? (Content extends Json.Object ? { readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken$1<[AType, Content][], BType> } & { readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken$1<[BType, Content][], AType> } : {}) & { readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken$1<AType[], BType> } & { readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken$1<BType[], AType> } : never;
 /**
-* @public
-* If there is an update ahead of the cursor (in the future of this {@link timeline}), apply it and move the cursor to the next update
-* @param timeline - A {@link TimelineToken}
+* Find the current value of a relation owned by a {@link join}
+* @param token - The token of the join
+* @param key - The key of the relation to find
+* @returns
+* A {@link JoinStates} interface to access the relation
+* @overload Default
 */
-declare const redo: (timeline: TimelineToken<any>) => void;
+declare function findRelations<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>, key: AType | BType): JoinStates<ASide, AType, BSide, BType, Cardinality, Content>;
 /**
-* @public
-* Reverse the last update on the {@link timeline} and move the cursor to the previous update
-* @param timeline - A {@link TimelineToken}
+* Change one or multiple relations owned by a {@link join}
+* @param token - The token of the join
+* @param change - A function that takes a {@link Junction} interface to edit the relations
 */
-declare const undo: (timeline: TimelineToken<any>) => void;
-/** @public */
-type TimelineUpdate<ManagedAtom extends TimelineManageable> = TimelineAtomUpdate<ManagedAtom> | TimelineMoleculeCreation | TimelineMoleculeDisposal | TimelineSelectorUpdate<ManagedAtom> | TimelineStateCreation<AtomOnly<ManagedAtom>> | TimelineStateDisposal<AtomOnly<ManagedAtom>> | TimelineTransactionUpdate;
-/** @public */
-type TimelineOptions<ManagedAtom extends TimelineManageable> = {
-  /** The unique identifier of the timeline */
-  key: string;
-  /** The managed atoms (and families of atoms) to record */
-  scope: ManagedAtom[];
-  /** A function that determines whether a given update should be recorded */
-  shouldCapture?: (update: TimelineUpdate<ManagedAtom>, timeline: Timeline<TimelineManageable>) => boolean;
-};
+declare function editRelations<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>, change: (relations: Junction<ASide, AType, BSide, BType, Content>) => void): void;
 /**
-* @public
-* Create a timeline, a mechanism for recording, undoing, and replaying changes to groups of atoms
-* @param options - {@link TimelineOptions}
-* @returns A reference to the timeline created: a {@link TimelineToken}
+* @param token - The token of the join
+* @returns
+* A {@link MutableAtomFamilyToken} to access the internal relations
 */
-declare const timeline: <ManagedAtom extends TimelineManageable>(options: TimelineOptions<ManagedAtom>) => TimelineToken<ManagedAtom>;
-//#endregion
-//#region src/main/dispose-state.d.ts
-/**
-* @public
-* Disposes of a state in the implicit store.
-*
-* Only family members can be disposed of.
-*
-* @param token - The token of the state to dispose
-* @overload Default
-*/
-declare function disposeState(token: ReadableToken<any>): void;
-/**
-* @public
-* Disposes of a state in the implicit store.
-*
-* Only family members can be disposed of.
-*
-* @param token - The token of the state family to dispose
-* @param key - The unique key of the state to dispose
-*/
-declare function disposeState<K extends Canonical>(token: ReadableFamilyToken<any, K>, key: K): void;
-//#endregion
-//#region src/main/find-state.d.ts
-/**
-* @public
-* Finds a {@link MutableAtomToken} in the store, without accessing its value.
-*
-* In an ephemeral store, this will create a new atom if one does not exist with the given key.
-*
-* In an immortal store, a "counterfeit" atom token will be returned in this case and a warning will be logged.
-*
-* @param token - A {@link MutableAtomFamilyToken}
-* @param key - The key of the state
-* @returns
-* The current value of the state
-* @overload Mutable Atom
-*/
-declare function findState<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken$1<T, J, K>, key: Key): MutableAtomToken$1<T, J, K>;
-/**
-* @public
-* Finds a {@link RegularAtomToken} in the store, without accessing its value.
-*
-* In an ephemeral store, this will create a new atom if one does not exist with the given key.
-*
-* In an immortal store, a "counterfeit" atom token will be returned in this case and a warning will be logged.
-*
-* @param token - The token of the state family
-* @param key - The key of the state
-* @returns
-* The current value of the state
-* @overload Regular Atom
-*/
-declare function findState<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken$1<T, K>, key: Key): RegularAtomToken$1<T, K>;
-/**
-* @public
-* Finds a {@link WritableSelectorToken} in the store, without accessing its value.
-*
-* In an ephemeral store, this will create a new selector if one does not exist with the given key.
-*
-* In an immortal store, a "counterfeit" selector token will be returned in this case and a warning will be logged.
-*
-* @param token - The token of the state family
-* @param key - The key of the state
-* @returns
-* The current value of the state
-* @overload Writable Selector
-*/
-declare function findState<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken$1<T, K>, key: Key): WritableSelectorToken$1<T, K>;
-/**
-* @public
-* Finds a {@link ReadonlySelectorToken} in the store, without accessing its value.
-*
-* In an ephemeral store, this will create a new selector if one does not exist with the given key.
-*
-* In an immortal store, a "counterfeit" selector token will be returned in this case and a warning will be logged.
-*
-* @param token - The token of the state family
-* @param key - The key of the state
-* @returns
-* The current value of the state
-* @overload Readonly Selector
-*/
-declare function findState<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken$1<T, K>, key: Key): ReadonlySelectorToken$1<T, K>;
-/**
-* @public
-* Finds a {@link WritableToken} in the store, without accessing its value.
-*
-* In an ephemeral store, this will create a new atom or selector if one does not exist with the given key.
-*
-* In an immortal store, a "counterfeit" token will be returned in this case and a warning will be logged.
-*
-* @param token - The token of the state family
-* @param key - The key of the state
-* @returns
-* The current value of the state
-* @overload Writable State
-*/
-declare function findState<T, K extends Canonical, Key extends K>(token: WritableFamilyToken$1<T, K>, key: Key): WritableToken$1<T, K>;
-/**
-* @public
-* Finds a {@link MutableAtomToken} in the store, without accessing its value.
-*
-* In an ephemeral store, this will create a new atom or selector if one does not exist with the given key.
-*
-* In an immortal store, a "counterfeit" token will be returned in this case and a warning will be logged.
-*
-* @param token - A {@link ReadableFamilyToken}
-* @param key - The key of the state
-* @returns
-* The current value of the state
-* @overload Unknown
-* @default
-*/
-declare function findState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken$1<T, K>, key: Key): ReadableToken$1<T, K>;
-//#endregion
-//#region src/main/get-state.d.ts
-/**
-* @public
-* Read or compute the current value of a state
-* @param token - The token of the state to get
-* @return The current value of the state
-* @overload Default
-* @default
-*/
-declare function getState<T>(token: ReadableToken<T>): T;
-/**
-* @public
-* Read or compute the current value of a state
-* @param token - The token of a state family
-* @param key - The unique key of the state to get
-* @return The current value of the state
-* @overload Streamlined
-*/
-declare function getState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): T;
-//#endregion
-//#region src/main/join.d.ts
-/** @public */
-type JoinOptions<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null> = Flat<JunctionSchemaBase<ASide, BSide> & {
-  /** Unique identifier of the join */
-  readonly key: string;
-  /** How many relations are allowed in each direction? */
-  readonly cardinality: Cardinality;
-  /** Type guard for the type of the left side */
-  readonly isAType: Refinement<string, AType>;
-  /** Type guard for the type of the right side */
-  readonly isBType: Refinement<string, BType>;
-}> & Partial<JunctionEntriesBase<AType, BType, Content>>;
-/** @public */
-type JoinToken<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null = null> = {
-  /** Unique identifier of the join */
-  key: string;
-  /** Discriminator */
-  type: `join`;
-  /** How many relations are allowed in each direction? */
-  cardinality: Cardinality;
-  /** Name of the join's left side */
-  a: ASide;
-  /** Name of the join's right side */
-  b: BSide;
-  /** Never present. This is a marker that preserves the type of the left side's keys */
-  __aType?: AType;
-  /** Never present. This is a marker that preserves the type of the right side's keys */
-  __bType?: BType;
-  /** Never present. This is a marker that preserves the type of the data present for each relation */
-  __content?: Content;
-};
-/**
-* @public
-* Create a join, an interface for managing relations between two sets of keys.
-*
-* Use joins when it is important to view relationships from either side.
-*
-* Under the hood, joins coordinate changes of multiple atoms to support that the desired relationships stay consistent.
-*
-* @param options - {@link JoinOptions}
-* @param defaultContent - (undefined)
-* @returns
-* A reference to the join created: a {@link JoinToken}
-* @overload No Content
-*/
-declare function join<const ASide extends string, const AType extends string, const BSide extends string, const BType extends string, const Cardinality extends `1:1` | `1:n` | `n:n`>(options: JoinOptions<ASide, AType, BSide, BType, Cardinality, null>, defaultContent?: undefined): JoinToken<ASide, AType, BSide, BType, Cardinality, null>;
-/**
-* @public
-* Create a join, an interface for managing relations between two sets of keys.
-*
-* Use joins when it is important to view relationships from either side.
-*
-* Under the hood, joins coordinate changes of multiple atoms to support that the desired relationships stay consistent.
-*
-* @param options - {@link JoinOptions}
-* @param defaultContent - The default value for the content of each relation
-* @returns
-* A reference to the join created: a {@link JoinToken}
-* @overload With Content
-*/
-declare function join<const ASide extends string, const AType extends string, const BSide extends string, const BType extends string, const Cardinality extends `1:1` | `1:n` | `n:n`, const Content extends Json.Object>(options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>, defaultContent: Content): JoinToken<ASide, AType, BSide, BType, Cardinality, Content>;
-type JoinStates<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null> = Cardinality extends `1:1` ? (Content extends Json.Object ? { readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken$1<[AType, Content] | null, BType> } & { readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken$1<[BType, Content] | null, AType> } : {}) & { readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken$1<AType | null, BType> } & { readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken$1<BType | null, AType> } : Cardinality extends `1:n` ? (Content extends Json.Object ? { readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken$1<[AType, Content] | null, BType> } & { readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken$1<[BType, Content][], AType> } : {}) & { readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken$1<AType | null, BType> } & { readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken$1<BType[], AType> } : Cardinality extends `n:n` ? (Content extends Json.Object ? { readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken$1<[AType, Content][], BType> } & { readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken$1<[BType, Content][], AType> } : {}) & { readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken$1<AType[], BType> } & { readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken$1<BType[], AType> } : never;
-/**
-* @public
-* Find the current value of a relation owned by a {@link join}
-* @param token - The token of the join
-* @param key - The key of the relation to find
-* @returns
-* A {@link JoinStates} interface to access the relation
-* @overload Default
-*/
-declare function findRelations<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>, key: AType | BType): JoinStates<ASide, AType, BSide, BType, Cardinality, Content>;
-/**
-* @public
-* Change one or multiple relations owned by a {@link join}
-* @param token - The token of the join
-* @param change - A function that takes a {@link Junction} interface to edit the relations
-*/
-declare function editRelations<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>, change: (relations: Junction<ASide, AType, BSide, BType, Content>) => void): void;
-/**
-* @public
-* @param token - The token of the join
-* @returns
-* A {@link MutableAtomFamilyToken} to access the internal relations
-*/
-declare function getInternalRelations<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>): MutableAtomFamilyToken$1<SetRTX<string>, SetRTXJson<string>, string>;
+declare function getInternalRelations<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>): MutableAtomFamilyToken$1<SetRTX<string>, SetRTXJson<string>, string>;
 //#endregion
 //#region src/main/logger.d.ts
 declare const LOGGER_ICON_DICTIONARY: {
@@ -950,53 +673,380 @@ type ExclusiveFealty = {
   above: TypedKey | `root`;
   below: Scope;
 };
-type Fealty = ExclusiveFealty | MutualFealty;
-type Hierarchy<F extends Fealty[] = Fealty[]> = Each<F>;
-type Vassal<H extends Hierarchy> = { [K in keyof H]: H[K] extends MutualFealty ? H[K][`below`] : H[K] extends {
-  below: Array<infer V>;
-} ? V extends TypedKey ? V : never : never }[keyof H];
-type Above<TK extends TypedKey, H extends Hierarchy> = { [K in keyof H]: H[K] extends MutualFealty ? TK extends H[K][`below`] ? H[K][`above`] : never : H[K] extends {
-  below: Array<infer V>;
-} ? TK extends V ? H[K] extends ExclusiveFealty ? H[K][`above`] : never : never : never }[keyof H];
-type Below<TK extends TypedKey | TypedKey[], H extends Hierarchy> = { [K in keyof H]: H[K] extends MutualFealty ? TK extends H[K][`above`] ? H[K][`below`] : TK extends H[K][`above`][number] ? H[K][`below`] : never : H[K] extends {
-  above: infer V;
-} ? TK extends V ? H[K] extends ExclusiveFealty ? H[K][`below`][number] : never : never : never }[keyof H];
-type Mutuals<TK extends TypedKey | TypedKey[], H extends Hierarchy> = { [K in keyof H]: H[K] extends MutualFealty ? TK extends H[K][`above`][number] ? [mutual: Exclude<H[K][`above`][number], TK>, below: H[K][`below`]] : never : never }[keyof H];
-type CompoundFrom<H extends Hierarchy> = { [K in keyof H]: H[K] extends MutualFealty ? H[K][`below`] : never }[keyof H];
-//#endregion
-//#region src/main/set-state.d.ts
+type Fealty = ExclusiveFealty | MutualFealty;
+type Hierarchy<F extends Fealty[] = Fealty[]> = Each<F>;
+type Vassal<H extends Hierarchy> = { [K in keyof H]: H[K] extends MutualFealty ? H[K][`below`] : H[K] extends {
+  below: Array<infer V>;
+} ? V extends TypedKey ? V : never : never }[keyof H];
+type Above<TK extends TypedKey, H extends Hierarchy> = { [K in keyof H]: H[K] extends MutualFealty ? TK extends H[K][`below`] ? H[K][`above`] : never : H[K] extends {
+  below: Array<infer V>;
+} ? TK extends V ? H[K] extends ExclusiveFealty ? H[K][`above`] : never : never : never }[keyof H];
+type Below<TK extends TypedKey | TypedKey[], H extends Hierarchy> = { [K in keyof H]: H[K] extends MutualFealty ? TK extends H[K][`above`] ? H[K][`below`] : TK extends H[K][`above`][number] ? H[K][`below`] : never : H[K] extends {
+  above: infer V;
+} ? TK extends V ? H[K] extends ExclusiveFealty ? H[K][`below`][number] : never : never : never }[keyof H];
+type Mutuals<TK extends TypedKey | TypedKey[], H extends Hierarchy> = { [K in keyof H]: H[K] extends MutualFealty ? TK extends H[K][`above`][number] ? [mutual: Exclude<H[K][`above`][number], TK>, below: H[K][`below`]] : never : never }[keyof H];
+type CompoundFrom<H extends Hierarchy> = { [K in keyof H]: H[K] extends MutualFealty ? H[K][`below`] : never }[keyof H];
+//#endregion
+//#region src/main/reset-state.d.ts
+/**
+* Set the value of a state into the implicit store back to its default value.
+* @param token - An atom or writable selector token.
+* @overload Default
+* @default
+*/
+declare function resetState(token: WritableToken<any>): void;
+/**
+* Set the value of a state into the implicit store back to its default value.
+* @param token - An atom family or writable selector family token.
+* @param key - The unique key of the state to set.
+* @overload Streamlined
+*/
+declare function resetState<K extends Canonical>(token: WritableFamilyToken<any, K>, key: K): void;
+//#endregion
+//#region src/main/subscribe.d.ts
+type StateUpdate<T> = {
+  newValue: T;
+  oldValue: T;
+};
+type KeyedStateUpdate<T> = Flat<StateUpdate<T> & {
+  key: string;
+  type: `atom_update` | `selector_update`;
+  family?: FamilyMetadata;
+}>;
+type UpdateHandler<T> = (update: StateUpdate<T>) => void;
+type TransactionUpdateHandler<F extends Func> = (data: TransactionUpdate<F>) => void;
+/**
+* Subscribe to a state in the implicit store
+* @param token - The token of the state to subscribe to
+* @param handleUpdate - A function that will be called when the state is updated
+* @param key - A unique key for the subscription. If not provided, a random key will be generated.
+* @returns A function that can be called to unsubscribe from the state
+* @overload State
+*/
+declare function subscribe<T>(token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key?: string): () => void;
+/**
+* Subscribe to a transaction in the implicit store
+* @param token - The token of the transaction to subscribe to
+* @param handleUpdate - A function that will be called when the transaction succeeds
+* @param key - A unique key for the subscription. If not provided, a random key will be generated.
+* @returns A function that can be called to unsubscribe from the transaction
+* @overload Transaction
+*/
+declare function subscribe<F extends Func>(token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key?: string): () => void;
+/**
+* Subscribe to a timeline in the implicit store
+* @param token - The token of the timeline to subscribe to
+* @param handleUpdate - A function that will be called when a new update is available
+* @param key - A unique key for the subscription. If not provided, a random key will be generated.
+* @returns A function that can be called to unsubscribe from the timeline
+* @overload Timeline
+*/
+declare function subscribe<M extends TimelineManageable>(token: TimelineToken<M>, handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void, key?: string): () => void;
+//#endregion
+//#region src/main/validators.d.ts
+type TokenType<Comparison extends ReadableFamilyToken<any, any> | ReadableToken<any>> = Comparison extends ReadableToken<infer RepresentedValue> ? RepresentedValue : Comparison extends ReadableFamilyToken<infer RepresentedValue, any> ? RepresentedValue : never;
+declare function isToken<KnownToken extends RegularAtomToken<any>>(knownToken: KnownToken, unknownToken: ReadableToken<any>): unknownToken is RegularAtomToken<TokenType<KnownToken>>;
+declare function isToken<KnownToken extends MutableAtomToken<any, any>>(knownToken: KnownToken, unknownToken: ReadableToken<any>): unknownToken is MutableAtomToken<TokenType<KnownToken>, any>;
+declare function isToken<KnownToken extends WritablePureSelectorToken<any>>(knownToken: KnownToken, unknownToken: ReadableToken<any>): unknownToken is WritablePureSelectorToken<TokenType<KnownToken>>;
+declare function isToken<KnownToken extends ReadonlyPureSelectorToken<any>>(knownToken: KnownToken, unknownToken: ReadableToken<any>): unknownToken is ReadonlyPureSelectorToken<TokenType<KnownToken>>;
+declare function isToken<KnownToken extends WritableToken<any>>(knownToken: KnownToken, unknownToken: ReadableToken<any>): unknownToken is WritableToken<TokenType<KnownToken>>;
+declare function isToken<KnownToken extends ReadableToken<any>>(knownToken: KnownToken, unknownToken: ReadableToken<any>): unknownToken is ReadableToken<TokenType<KnownToken>>;
+declare function belongsTo<Family extends RegularAtomFamilyToken<any, any>>(family: Family, unknownToken: ReadableToken<any>): unknownToken is RegularAtomToken<TokenType<Family>>;
+declare function belongsTo<Family extends MutableAtomFamilyToken<any, any, any>>(family: Family, unknownToken: ReadableToken<any>): unknownToken is MutableAtomToken<TokenType<Family>, any>;
+declare function belongsTo<Family extends WritablePureSelectorFamilyToken<any, any>>(family: Family, unknownToken: ReadableToken<any>): unknownToken is WritablePureSelectorToken<TokenType<Family>>;
+declare function belongsTo<Family extends ReadonlyPureSelectorFamilyToken<any, any>>(family: Family, unknownToken: ReadableToken<any>): unknownToken is ReadonlyPureSelectorToken<TokenType<Family>>;
+declare function belongsTo<Family extends WritableFamilyToken<any, any>>(family: Family, unknownToken: ReadableToken<any>): unknownToken is WritableToken<TokenType<Family>>;
+declare function belongsTo<Family extends ReadableFamilyToken<any, any>>(family: Family, unknownToken: ReadableToken<any>): unknownToken is ReadableToken<TokenType<Family>>;
+//#endregion
+//#region src/main/transaction.d.ts
+type StateCreation<Token extends ReadableToken<any>> = {
+  type: `state_creation`;
+  token: Token;
+};
+type StateDisposal<Token extends ReadableToken<any>> = AtomDisposal<Token> | SelectorDisposal<Token>;
+type AtomDisposal<Token extends ReadableToken<any>> = {
+  type: `state_disposal`;
+  subType: `atom`;
+  token: Token;
+  value: TokenType<Token>;
+};
+type SelectorDisposal<Token extends ReadableToken<any>> = {
+  type: `state_disposal`;
+  subType: `selector`;
+  token: Token;
+};
+type MoleculeCreation = {
+  type: `molecule_creation`;
+  key: Canonical;
+  provenance: Canonical;
+};
+type MoleculeDisposal = {
+  type: `molecule_disposal`;
+  key: Canonical;
+  provenance: stringified<Canonical>[];
+  values: [key: string, value: any][];
+};
+type MoleculeTransfer = {
+  type: `molecule_transfer`;
+  key: Canonical;
+  from: Canonical[];
+  to: Canonical[];
+};
+type TransactionUpdateContent = KeyedStateUpdate<unknown> | MoleculeCreation | MoleculeDisposal | MoleculeTransfer | StateCreation<ReadableToken<unknown>> | StateDisposal<ReadableToken<unknown>> | TransactionUpdate<Func>;
+type TransactionUpdate<F extends Func> = {
+  type: `transaction_update`;
+  key: string;
+  id: string;
+  epoch: number;
+  updates: TransactionUpdateContent[];
+  params: Parameters<F>;
+  output: ReturnType<F>;
+};
+type ReaderToolkit = Pick<ActorToolkit, `find` | `get` | `json`>;
+type WriterToolkit = Pick<ActorToolkit, `find` | `get` | `json` | `set`>;
+type ActorToolkit = Readonly<{
+  get: typeof getState;
+  set: typeof setState;
+  reset: typeof resetState;
+  find: typeof findState;
+  json: <T extends Transceiver<any>, J extends Json.Serializable>(state: MutableAtomToken<T, J>) => WritablePureSelectorToken<J>;
+  dispose: typeof disposeState;
+  run: typeof runTransaction;
+  env: () => EnvironmentData;
+}>;
+type Read<F extends Func> = (toolkit: ReaderToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
+type Write<F extends Func> = (toolkit: WriterToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
+type Transact<F extends Func> = (toolkit: ActorToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
+type TransactionIO<Token extends TransactionToken<any>> = Token extends TransactionToken<infer F> ? F : never;
+type TransactionOptions<F extends Func> = {
+  /** The unique identifier of the transaction */
+  key: string;
+  /** The operation to perform */
+  do: Transact<F>;
+};
+/**
+* Create a transaction, a mechanism for batching updates multiple states in a single, all-or-nothing operation
+* @param options - {@link TransactionOptions}
+* @returns A reference to the transaction created: a {@link TransactionToken}
+*/
+declare function transaction<F extends Func>(options: TransactionOptions<F>): TransactionToken<F>;
+/**
+* Execute a {@link transaction}
+* @param token - A {@link TransactionToken}
+* @param id - A unique identifier for the transaction. If not provided, a random identifier will be generated
+* @returns A function that can be called to run the transaction with its {@link TransactionIO} parameters
+*/
+declare function runTransaction<F extends Func>(token: TransactionToken<F>, id?: string): (...parameters: Parameters<F>) => ReturnType<F>;
+//#endregion
+//#region src/main/selector.d.ts
+type WritablePureSelectorOptions<T> = {
+  /** The unique identifier of the selector */
+  key: string;
+  /** For each instantiated selector, a function that computes its value */
+  get: Read<() => T>;
+  /** For each instantiated selector, a function that sets its value */
+  set: Write<(newValue: T) => void>;
+};
+type ReadonlyPureSelectorOptions<T> = {
+  /** The unique identifier of the selector */
+  key: string;
+  /** For each instantiated selector, a function that computes its value */
+  get: Read<() => T>;
+};
+type ReadonlyHeldSelectorOptions<T extends object> = {
+  /** The unique identifier of the selector */
+  key: string;
+  /** For each instantiated selector, a constant reference to a value that will not be replaced */
+  const: T;
+  /** For each instantiated selector, a function that computes its value */
+  get: Read<(permanent: T) => void>;
+};
+type WritableHeldSelectorOptions<T extends object> = {
+  /** The unique identifier of the selector */
+  key: string;
+  /** For each instantiated selector, a constant reference to a value that will not be replaced */
+  const: T;
+  /** For each instantiated selector, a function that computes its value */
+  get: Read<(permanent: T) => void>;
+  /** For each instantiated selector, a function that sets its value */
+  set: Write<(newValue: T) => void>;
+};
+/**
+* Declare a selector. The value of a selector should depend
+* on the value of atoms or other selectors in the store, and
+* should be recycled when a root atom of the selector is set.
+*
+* A held selector's value must be some object.
+* The reference to that object is permanent and will not be replaced.
+*
+* A writable selector can be "set" to a new value.
+* It is strongly advised to set its dependencies to values
+* that would produce the new value of the selector.
+*
+* @param options - {@link WritableHeldSelectorOptions}.
+* @returns
+* The token for your selector.
+* @overload WritableHeld
+*/
+declare function selector<T extends object>(options: WritableHeldSelectorOptions<T>): WritableHeldSelectorToken<T>;
+/**
+* Declare a selector. The value of a selector should depend
+* on the value of atoms or other selectors in the store,
+* and should be recycled when a root atom of the selector is set.
+*
+* A held selector's value must be some object.
+* The reference to that object is permanent and will not be replaced.
+*
+* A readonly selector can be "gotten" but not "set".
+*
+* @param options - {@link ReadonlyHeldSelectorOptions}.
+* @returns
+* The token for your selector.
+* @overload ReadonlyHeld
+*/
+declare function selector<T extends object>(options: ReadonlyHeldSelectorOptions<T>): ReadonlyHeldSelectorToken<T>;
+/**
+* Declare a selector. The value of a selector should depend
+* on the value of atoms or other selectors in the store.
+*
+* A pure selector's current value is evicted from the store
+* in order to be garbage collected when a root atom of the selector is set.
+*
+* A writable selector can be "set" to a new value.
+* It is strongly advised to set its dependencies to values
+* that would produce the new value of the selector.
+*
+* @param options - {@link TransientWritableSelectorOptions}.
+* @returns
+* The token for your selector.
+* @overload WritablePure
+*/
+declare function selector<T>(options: WritablePureSelectorOptions<T>): WritablePureSelectorToken<T>;
+/**
+* Declare a selector. The value of a selector should depend
+* on the value of atoms or other selectors in the store.
+*
+* A pure selector's current value is evicted from the store
+* in order to be garbage collected when a root atom of the selector is set.
+*
+* A readonly selector can be "gotten" but not "set".
+*
+* @param options - {@link ReadonlyPureSelectorOptions}.
+* @returns
+* The token for your selector.
+* @overload ReadonlyPure
+*/
+declare function selector<T>(options: ReadonlyPureSelectorOptions<T>): ReadonlyPureSelectorToken<T>;
+type WritablePureSelectorFamilyOptions<T, K extends Canonical> = {
+  /** The unique identifier of the family */
+  key: string;
+  /** For each instantiated family member, a function that computes its value */
+  get: (key: K) => Read<() => T>;
+  /** For each instantiated family member, a function that sets its value */
+  set: (key: K) => Write<(newValue: T) => void>;
+};
+type ReadonlyPureSelectorFamilyOptions<T, K extends Canonical> = {
+  /** The unique identifier of the family */
+  key: string;
+  /** For each instantiated family member, a function that computes its value */
+  get: (key: K) => Read<() => T>;
+};
+type WritableHeldSelectorFamilyOptions<T extends object, K extends Canonical> = {
+  /** The unique identifier of the family */
+  key: string;
+  /** For each instantiated family member, a constant reference to a value that will not be replaced */
+  const: (key: K) => T;
+  /** For each instantiated family member, a function that computes its value */
+  get: (key: K) => Read<(permanent: T) => void>;
+  /** For each instantiated family member, a function that sets its value */
+  set: (key: K) => Write<(newValue: T) => void>;
+};
+type ReadonlyHeldSelectorFamilyOptions<T extends object, K extends Canonical> = {
+  /** The unique identifier of the family */
+  key: string;
+  /** For each instantiated family member, a constant reference to a value that will not be replaced */
+  const: (key: K) => T;
+  /** For each instantiated family member, a function that computes its value */
+  get: (key: K) => Read<(permanent: T) => void>;
+};
 /**
-* @public
-* A function that sets the value of a state.
-* @param oldValue - The current value of the state.
+* Create a family of selectors, allowing for the dynamic creation and disposal of selectors.
+*
+* The value of a held selector should depend on the value of atoms or other selectors in the store,
+* and should be recycled when a root atom of the selector is set.
+*
+* A held selector's value must be some object.
+* The reference to that object is permanent and will not be replaced.
+*
+* A writable selector can be "set" to a new value.
+* It is advised to set its dependencies to values
+* that would produce the new value of the selector.
+*
+* @param options - {@link WritableHeldSelectorFamilyOptions}.
 * @returns
-* The new value of the state.
+* A reference to the selector family created: a {@link WritableHeldSelectorFamilyToken}
+* @overload WritableHeld
 */
-type Setter<T, New extends T> = (oldValue: T) => New;
+declare function selectorFamily<T extends object, K extends Canonical>(options: WritableHeldSelectorFamilyOptions<T, K>): WritableHeldSelectorFamilyToken<T, K>;
 /**
-* @public
-* Set the value of a state into the implicit store.
-* @param token - An atom or writable selector token.
-* @param value - The new value of the state.
-* @overload Default
-* @default
+* Create a family of selectors, allowing for the dynamic creation and disposal of selectors.
+*
+* The value of a held selector should depend on the value of atoms or other selectors in the store,
+* and should be recycled when a root atom of the selector is set.
+*
+* A held selector's value must be some object.
+* The reference to that object is permanent and will not be replaced.
+*
+* A readonly selector can be "gotten" but not "set".
+*
+* @param options - {@link ReadonlyHeldSelectorFamilyOptions}.
+* @returns
+* A reference to the selector family created: a {@link ReadonlyHeldSelectorFamilyToken}
+* @overload ReadonlyHeld
 */
-declare function setState<T, New extends T>(token: WritableToken<T>, value: New | Setter<T, New>): void;
+declare function selectorFamily<T extends object, K extends Canonical>(options: ReadonlyHeldSelectorFamilyOptions<T, K>): ReadonlyHeldSelectorFamilyToken<T, K>;
 /**
-* @public
-* Set the value of a state into the implicit store.
-* @param token - An atom family or writable selector family token.
-* @param key - The unique key of the state to set.
-* @param value - The new value of the state.
-* @overload Streamlined
+* Create a family of selectors, allowing for the dynamic creation and disposal of selectors.
+*
+* The value of a selector should depend on the value of atoms or other selectors in the store.
+*
+* A pure selector's current value is evicted from the store
+* in order to be garbage collected when a root atom of the selector is set.
+*
+* A writable selector can be "set" to a new value.
+* It is advised to set its dependencies to values
+* that would produce the new value of the selector.
+*
+* @param options - {@link TransientWritableSelectorFamilyOptions}.
+* @returns
+* A reference to the selector family created: a {@link TransientWritableSelectorFamilyToken}
+* @overload WritablePure
 */
-declare function setState<T, K extends Canonical, New extends T, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, value: New | Setter<T, New>): void;
+declare function selectorFamily<T, K extends Canonical>(options: WritablePureSelectorFamilyOptions<T, K>): WritablePureSelectorFamilyToken<T, K>;
+/**
+* Create a family of selectors, allowing for the dynamic creation and disposal of selectors.
+*
+* The value of a selector should depend on the value of atoms or other selectors in the store.
+*
+* A pure selector's current value is evicted from the store
+* in order to be garbage collected when a root atom of the selector is set.
+*
+* A readonly selector can be "gotten" but not "set".
+*
+* @param options - {@link ReadonlyPureSelectorFamilyOptions}.
+* @returns
+* A reference to the selector family created: a {@link ReadonlyPureSelectorFamilyToken}
+* @overload ReadonlyPure
+*/
+declare function selectorFamily<T, K extends Canonical>(options: ReadonlyPureSelectorFamilyOptions<T, K>): ReadonlyPureSelectorFamilyToken<T, K>;
 //#endregion
 //#region src/main/silo.d.ts
 declare class Silo {
   store: Store;
   atom: typeof atom;
+  mutableAtom: typeof mutableAtom;
   atomFamily: typeof atomFamily;
+  mutableAtomFamily: typeof mutableAtomFamily;
   selector: typeof selector;
   selectorFamily: typeof selectorFamily;
   transaction: typeof transaction;
@@ -1014,194 +1064,37 @@ declare class Silo {
   constructor(config: Store[`config`], fromStore?: Store | null);
 }
 //#endregion
-//#region src/main/subscribe.d.ts
-/** @public */
-type StateUpdate<T> = {
-  newValue: T;
-  oldValue: T;
-};
-/** @public */
-type KeyedStateUpdate<T> = Flat<StateUpdate<T> & {
-  key: string;
-  type: `atom_update` | `selector_update`;
-  family?: FamilyMetadata;
-}>;
-/** @public */
-type UpdateHandler<T> = (update: StateUpdate<T>) => void;
-/** @public */
-type TransactionUpdateHandler<F extends Func> = (data: TransactionUpdate<F>) => void;
-/**
-* @public
-* Subscribe to a state in the implicit store
-* @param token - The token of the state to subscribe to
-* @param handleUpdate - A function that will be called when the state is updated
-* @param key - A unique key for the subscription. If not provided, a random key will be generated.
-* @returns A function that can be called to unsubscribe from the state
-* @overload State
-*/
-declare function subscribe<T>(token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key?: string): () => void;
-/**
-* @public
-* Subscribe to a transaction in the implicit store
-* @param token - The token of the transaction to subscribe to
-* @param handleUpdate - A function that will be called when the transaction succeeds
-* @param key - A unique key for the subscription. If not provided, a random key will be generated.
-* @returns A function that can be called to unsubscribe from the transaction
-* @overload Transaction
-*/
-declare function subscribe<F extends Func>(token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key?: string): () => void;
+//#region src/main/timeline.d.ts
+type TimelineManageable = AtomFamilyToken<any, any> | AtomToken<any>;
+type AtomOnly<M extends TimelineManageable> = M extends AtomFamilyToken<any, any> ? AtomToken<any> : M extends AtomToken<any> ? M : never;
 /**
-* @public
-* Subscribe to a timeline in the implicit store
-* @param token - The token of the timeline to subscribe to
-* @param handleUpdate - A function that will be called when a new update is available
-* @param key - A unique key for the subscription. If not provided, a random key will be generated.
-* @returns A function that can be called to unsubscribe from the timeline
-* @overload Timeline
+* If there is an update ahead of the cursor (in the future of this {@link timeline}), apply it and move the cursor to the next update
+* @param timeline - A {@link TimelineToken}
 */
-declare function subscribe<M extends TimelineManageable>(token: TimelineToken<M>, handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void, key?: string): () => void;
-//#endregion
-//#region src/main/validators.d.ts
-type TokenType<Comparison extends ReadableFamilyToken$1<any, any> | ReadableToken$1<any>> = Comparison extends ReadableToken$1<infer RepresentedValue> ? RepresentedValue : Comparison extends ReadableFamilyToken$1<infer RepresentedValue, any> ? RepresentedValue : never;
-declare function isToken<KnownToken extends RegularAtomToken$1<any>>(knownToken: KnownToken, unknownToken: ReadableToken$1<any>): unknownToken is RegularAtomToken$1<TokenType<KnownToken>>;
-declare function isToken<KnownToken extends MutableAtomToken$1<any, any>>(knownToken: KnownToken, unknownToken: ReadableToken$1<any>): unknownToken is MutableAtomToken$1<TokenType<KnownToken>, any>;
-declare function isToken<KnownToken extends WritablePureSelectorToken$1<any>>(knownToken: KnownToken, unknownToken: ReadableToken$1<any>): unknownToken is WritablePureSelectorToken$1<TokenType<KnownToken>>;
-declare function isToken<KnownToken extends ReadonlyPureSelectorToken$1<any>>(knownToken: KnownToken, unknownToken: ReadableToken$1<any>): unknownToken is ReadonlyPureSelectorToken$1<TokenType<KnownToken>>;
-declare function isToken<KnownToken extends WritableToken$1<any>>(knownToken: KnownToken, unknownToken: ReadableToken$1<any>): unknownToken is WritableToken$1<TokenType<KnownToken>>;
-declare function isToken<KnownToken extends ReadableToken$1<any>>(knownToken: KnownToken, unknownToken: ReadableToken$1<any>): unknownToken is ReadableToken$1<TokenType<KnownToken>>;
-declare function belongsTo<Family extends RegularAtomFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is RegularAtomToken$1<TokenType<Family>>;
-declare function belongsTo<Family extends MutableAtomFamilyToken$1<any, any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is MutableAtomToken$1<TokenType<Family>, any>;
-declare function belongsTo<Family extends WritablePureSelectorFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is WritablePureSelectorToken$1<TokenType<Family>>;
-declare function belongsTo<Family extends ReadonlyPureSelectorFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is ReadonlyPureSelectorToken$1<TokenType<Family>>;
-declare function belongsTo<Family extends WritableFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is WritableToken$1<TokenType<Family>>;
-declare function belongsTo<Family extends ReadableFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is ReadableToken$1<TokenType<Family>>;
-//#endregion
-//#region src/main/index.d.ts
+declare const redo: (timeline: TimelineToken<any>) => void;
 /**
-* @public
-* A token is an object that uniquely identifies a particular state, family, timeline, or transaction.
-*
-* While they represent one of these resources, they are not the resource itself. Think of them like paper currency representing money in the bank.
-*
-* Tokens are returned from resource creation functions, such as {@link atom} and {@link transaction}.
-*
-* Tokens can be used as parameters to functions that take a token, such as {@link getState}, {@link setState}, or {@link runTransaction}.
-*
-* Tokens are fully serializable, so they can be passed between processes.
+* Reverse the last update on the {@link timeline} and move the cursor to the previous update
+* @param timeline - A {@link TimelineToken}
 */
-type AtomIOToken = ReadableFamilyToken<any, any> | ReadableToken<any> | TimelineToken<any> | TransactionToken<any>;
-/** @public */
-type RegularAtomToken<T, K extends Canonical = any> = {
-  /** The unique identifier of the atom. */
-  key: string;
-  /** Discriminator. */
-  type: `atom`;
-  /** Present if the atom belongs to a family. */
-  family?: FamilyMetadata<K>;
-  /** Never present. This is a marker that preserves the type of the atom's value. */
-  __T?: T;
-};
-/** @public */
-type MutableAtomToken<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical = any> = {
-  /** The unique identifier of the atom. */
-  key: string;
-  /** Discriminator. */
-  type: `mutable_atom`;
-  /** Present if the atom belongs to a family. */
-  family?: FamilyMetadata<K>;
-  /** Never present. This is a marker that preserves the JSON form of the atom's transceiver value. */
-  __J?: J;
-  /** Never present. This is a marker that preserves the type of the atom's transceiver value. */
-  __U?: T extends Transceiver<infer Update> ? Update : never;
-};
-/** @public */
-type AtomToken<T, K extends Canonical = any> = MutableAtomToken<T extends Transceiver<any> ? T : never, any, K> | RegularAtomToken<T, K>;
-/** @public */
-type WritablePureSelectorToken<T, K extends Canonical = any> = {
-  /** The unique identifier of the selector. */
-  key: string;
-  /** Discriminator. */
-  type: `writable_pure_selector`;
-  /** Present if the selector belongs to a family. */
-  family?: FamilyMetadata<K>;
-  /** Never present. This is a marker that preserves the type of the selector's value. */
-  __T?: T;
-};
-/** @public */
-type WritableHeldSelectorToken<T, K extends Canonical = any> = {
-  /** The unique identifier of the selector. */
-  key: string;
-  /** Discriminator. */
-  type: `writable_held_selector`;
-  /** Present if the selector belongs to a family. */
-  family?: FamilyMetadata<K>;
-  /** Never present. This is a marker that preserves the type of the selector's value. */
-  __T?: T;
-};
-/** @public */
-type ReadonlyPureSelectorToken<T, K extends Canonical = any> = {
-  /** The unique identifier of the selector. */
-  key: string;
-  /** Discriminator. */
-  type: `readonly_pure_selector`;
-  /** Present if the selector belongs to a family. */
-  family?: FamilyMetadata<K>;
-  /** Never present. This is a marker that preserves the type of the selector's value. */
-  __T?: T;
-};
-/** @public */
-type ReadonlyHeldSelectorToken<T, K extends Canonical = any> = {
-  /** The unique identifier of the selector. */
+declare const undo: (timeline: TimelineToken<any>) => void;
+type TimelineUpdate<ManagedAtom extends TimelineManageable> = TimelineAtomUpdate<ManagedAtom> | TimelineMoleculeCreation | TimelineMoleculeDisposal | TimelineSelectorUpdate<ManagedAtom> | TimelineStateCreation<AtomOnly<ManagedAtom>> | TimelineStateDisposal<AtomOnly<ManagedAtom>> | TimelineTransactionUpdate;
+type TimelineOptions<ManagedAtom extends TimelineManageable> = {
+  /** The unique identifier of the timeline */
   key: string;
-  /** Discriminator. */
-  type: `readonly_held_selector`;
-  /** Present if the selector belongs to a family. */
-  family?: FamilyMetadata<K>;
-  /** Never present. This is a marker that preserves the type of the selector's value. */
-  __T?: T;
+  /** The managed atoms (and families of atoms) to record */
+  scope: ManagedAtom[];
+  /** A function that determines whether a given update should be recorded */
+  shouldCapture?: (update: TimelineUpdate<ManagedAtom>, timeline: Timeline<TimelineManageable>) => boolean;
 };
-/** @public */
-type PureSelectorToken<T, K extends Canonical = any> = ReadonlyPureSelectorToken<T, K> | WritablePureSelectorToken<T, K>;
-/** @public */
-type HeldSelectorToken<T, K extends Canonical = any> = ReadonlyHeldSelectorToken<T, K> | WritableHeldSelectorToken<T, K>;
-/** @public */
-type ReadonlySelectorToken<T, K extends Canonical = any> = ReadonlyHeldSelectorToken<T, K> | ReadonlyPureSelectorToken<T, K>;
-/** @public */
-type WritableSelectorToken<T, K extends Canonical = any> = WritableHeldSelectorToken<T, K> | WritablePureSelectorToken<T, K>;
-/** @public */
-type SelectorToken<T, K extends Canonical = any> = ReadonlyHeldSelectorToken<T, K> | ReadonlyPureSelectorToken<T, K> | WritableHeldSelectorToken<T, K> | WritablePureSelectorToken<T, K>;
-/**
-* @public
-* These states can be set.
-*/
-type WritableToken<T, K extends Canonical = any> = AtomToken<T, K> | WritableSelectorToken<T, K>;
-/**
-* @public
-* These states cannot be set.
-*/
-type ReadableToken<T, K extends Canonical = any> = AtomToken<T, K> | SelectorToken<T, K>;
-/**
-* @public
-* States belonging to this family can be set.
-*/
-type WritableFamilyToken<T, K extends Canonical> = AtomFamilyToken<T, K> | WritableSelectorFamilyToken<T, K>;
 /**
-* @public
-* States belonging to this family cannot be set.
-*/
-type ReadableFamilyToken<T, K extends Canonical> = AtomFamilyToken<T, K> | SelectorFamilyToken<T, K>;
-/**
-* @public
-* Identifies a state's connection to its family.
+* Create a timeline, a mechanism for recording, undoing, and replaying changes to groups of atoms
+* @param options - {@link TimelineOptions}
+* @returns A reference to the timeline created: a {@link TimelineToken}
 */
-type FamilyMetadata<K extends Canonical = any> = {
-  /** The family's unique key. */
-  key: string;
-  /** The family member's unique identifier, in the form of a string. */
-  subKey: stringified<K>;
-};
+declare const timeline: <ManagedAtom extends TimelineManageable>(options: TimelineOptions<ManagedAtom>) => TimelineToken<ManagedAtom>;
+//#endregion
+//#region src/main/index.d.ts
 /**
-* @public
 * Loadable is used to type atoms or selectors that may at some point be initialized to or set to a {@link Promise}.
 *
 * When a Promise is cached as the value of a state in atom.io, that state will be automatically set to the resolved value of the Promise when it is resolved.
@@ -1210,5 +1103,5 @@ type FamilyMetadata<K extends Canonical = any> = {
 */
 type Loadable<T> = Promise<T> | T;
 //#endregion
-export { $claim, Above, ActorToolkit, Anarchy, AtomDisposal, AtomEffect, AtomFamilyToken, AtomIOLogger, AtomIOToken, AtomOnly, AtomToken, Below, Claim, CompoundFrom, CompoundTypedKey, Effectors, FamilyMetadata, GetterToolkit, HeldSelectorFamilyToken, HeldSelectorToken, Hierarchy, JoinOptions, JoinStates, JoinToken, KeyedStateUpdate, LOG_LEVELS, Loadable, LogFilter, LogFn, LogLevel, Logger, LoggerIcon, MoleculeCreation, MoleculeDisposal, MoleculeTransfer, MutableAtomFamilyOptions, MutableAtomFamilyToken, MutableAtomOptions, MutableAtomToken, Mutuals, PureSelectorFamilyToken, PureSelectorToken, Read, ReadableFamilyToken, ReadableToken, ReadonlyHeldSelectorFamilyOptions, ReadonlyHeldSelectorFamilyToken, ReadonlyHeldSelectorOptions, ReadonlyHeldSelectorToken, ReadonlyPureSelectorFamilyOptions, ReadonlyPureSelectorFamilyToken, ReadonlyPureSelectorOptions, ReadonlyPureSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, Realm, RegularAtomFamilyOptions, RegularAtomFamilyToken, RegularAtomOptions, RegularAtomToken, SelectorDisposal, SelectorFamilyToken, SelectorToken, Setter, SetterToolkit, Silo, SingularTypedKey, StateCreation, StateDisposal, StateUpdate, T$, TimelineManageable, TimelineOptions, TimelineToken, TimelineUpdate, TokenDenomination, TokenType, Transact, TransactionIO, TransactionOptions, TransactionToken, TransactionUpdate, TransactionUpdateContent, TransactionUpdateHandler, TypeTag, TypedKey, UpdateHandler, Vassal, WritableFamilyToken, WritableHeldSelectorFamilyOptions, WritableHeldSelectorFamilyToken, WritableHeldSelectorOptions, WritableHeldSelectorToken, WritablePureSelectorFamilyOptions, WritablePureSelectorFamilyToken, WritablePureSelectorOptions, WritablePureSelectorToken, WritableSelectorFamilyToken, WritableSelectorToken, WritableToken, Write, atom, atomFamily, belongsTo, disposeState, editRelations, findRelations, findState, getInternalRelations, getState, isToken, join, redo, resetState, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };
+export { $claim, Above, ActorToolkit, Anarchy, AtomDisposal, AtomEffect, AtomFamilyToken, AtomIOLogger, AtomIOToken, AtomOnly, AtomToken, Below, Claim, CompoundFrom, CompoundTypedKey, Effectors, FamilyMetadata, HeldSelectorFamilyToken, HeldSelectorToken, Hierarchy, JoinOptions, JoinStates, JoinToken, KeyedStateUpdate, LOG_LEVELS, Loadable, LogFilter, LogFn, LogLevel, Logger, LoggerIcon, MoleculeCreation, MoleculeDisposal, MoleculeTransfer, MutableAtomFamilyOptions, MutableAtomFamilyToken, MutableAtomOptions, MutableAtomToken, Mutuals, PureSelectorFamilyToken, PureSelectorToken, Read, ReadableFamilyToken, ReadableToken, ReaderToolkit, ReadonlyHeldSelectorFamilyOptions, ReadonlyHeldSelectorFamilyToken, ReadonlyHeldSelectorOptions, ReadonlyHeldSelectorToken, ReadonlyPureSelectorFamilyOptions, ReadonlyPureSelectorFamilyToken, ReadonlyPureSelectorOptions, ReadonlyPureSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, Realm, RegularAtomFamilyOptions, RegularAtomFamilyToken, RegularAtomOptions, RegularAtomToken, SelectorDisposal, SelectorFamilyToken, SelectorToken, Setter, Silo, SingularTypedKey, StateCreation, StateDisposal, StateUpdate, T$, TimelineManageable, TimelineOptions, TimelineToken, TimelineUpdate, TokenDenomination, TokenType, Transact, TransactionIO, TransactionOptions, TransactionToken, TransactionUpdate, TransactionUpdateContent, TransactionUpdateHandler, TypeTag, TypedKey, UpdateHandler, Vassal, WritableFamilyToken, WritableHeldSelectorFamilyOptions, WritableHeldSelectorFamilyToken, WritableHeldSelectorOptions, WritableHeldSelectorToken, WritablePureSelectorFamilyOptions, WritablePureSelectorFamilyToken, WritablePureSelectorOptions, WritablePureSelectorToken, WritableSelectorFamilyToken, WritableSelectorToken, WritableToken, Write, WriterToolkit, atom, atomFamily, belongsTo, disposeState, editRelations, findRelations, findState, getInternalRelations, getState, isToken, join, mutableAtom, mutableAtomFamily, redo, resetState, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };
 //# sourceMappingURL=index.d.ts.map