atom.io 0.43.1 → 0.44.0

package/dist/main/index.d.ts

@@ -16,11 +16,11 @@ declare const redo: (timeline: TimelineToken<any>) => void;
 * @param timeline - A {@link TimelineToken}
 */
 declare const undo: (timeline: TimelineToken<any>) => void;
-type TimelineOptions<ManagedAtom extends TimelineManageable> = {
+type TimelineOptions<ManagedAtom$1 extends TimelineManageable> = {
   /** The unique identifier of the timeline */
   key: string;
   /** The managed atoms (and families of atoms) to record */
-  scope: ManagedAtom[];
+  scope: ManagedAtom$1[];
 };
 /**
 * Create a timeline, a mechanism for recording, undoing, and replaying changes to groups of atoms
@@ -42,16 +42,16 @@ declare const timeline: <ManagedAtom extends TimelineManageable>(options: Timeli
 * Tokens are fully serializable, so they can be passed between processes.
 */
 type AtomIOToken = ReadableFamilyToken<any, any, any> | ReadableToken<any, any, any> | TimelineToken<any> | TransactionToken<any>;
-type ReadableToken<T, K extends Canonical = any, E = never> = AtomToken<T, K, E> | SelectorToken<T, K, E>;
-type WritableToken<T, K extends Canonical = any, E = never> = AtomToken<T, K, E> | WritableSelectorToken<T, K, E>;
+type ReadableToken<T$1, K$1 extends Canonical = any, E = never> = AtomToken<T$1, K$1, E> | SelectorToken<T$1, K$1, E>;
+type WritableToken<T$1, K$1 extends Canonical = any, E = never> = AtomToken<T$1, K$1, E> | WritableSelectorToken<T$1, K$1, E>;
 /**
 * States belonging to this family can be read from the store.
 */
-type ReadableFamilyToken<T, K extends Canonical, E = never> = AtomFamilyToken<T, K, E> | SelectorFamilyToken<T, K, E>;
+type ReadableFamilyToken<T$1, K$1 extends Canonical, E = never> = AtomFamilyToken<T$1, K$1, E> | SelectorFamilyToken<T$1, K$1, E>;
 /**
 * States belonging to this family can be written directly.
 */
-type WritableFamilyToken<T, K extends Canonical, E = never> = AtomFamilyToken<T, K, E> | WritableSelectorFamilyToken<T, K, E>;
+type WritableFamilyToken<T$1, K$1 extends Canonical, E = never> = AtomFamilyToken<T$1, K$1, E> | WritableSelectorFamilyToken<T$1, K$1, E>;
 type TimelineToken<M> = {
   /** The unique identifier of the timeline */
   key: string;
@@ -60,166 +60,166 @@ type TimelineToken<M> = {
   /** Never present. This is a marker that preserves the type of the managed atoms */
   __M?: M;
 };
-type TransactionToken<F extends Fn$1> = {
+type TransactionToken<F$1 extends Fn$1> = {
   /** The unique identifier of the transaction */
   key: string;
   /** Discriminator */
   type: `transaction`;
   /** Never present. This is a marker that preserves the type of the transaction function */
-  __F?: F;
+  __F?: F$1;
 };
-type AtomToken<T, K extends Canonical = any, E = never> = MutableAtomToken<T extends Transceiver<any, any, any> ? T : never, K> | RegularAtomToken<T, K, E>;
-type RegularAtomToken<T, K extends Canonical = any, E = never> = {
+type AtomToken<T$1, K$1 extends Canonical = any, E = never> = MutableAtomToken<T$1 extends Transceiver<any, any, any> ? T$1 : never, K$1> | RegularAtomToken<T$1, K$1, E>;
+type RegularAtomToken<T$1, K$1 extends Canonical = any, E = never> = {
   /** The unique identifier of the atom. */
   key: string;
   /** Discriminator. */
   type: `atom`;
   /** Present if the atom belongs to a family. */
-  family?: FamilyMetadata<K>;
+  family?: FamilyMetadata<K$1>;
   /** Never present. This is a marker that preserves the type of the atom's value. */
-  __T?: T;
+  __T?: T$1;
   /** Never present. This is a marker that preserves the type of errors this atom is capable of catching and setting as its value. */
   __E?: E;
 };
-type MutableAtomToken<T extends Transceiver<any, any, any>, K extends Canonical = any> = {
+type MutableAtomToken<T$1 extends Transceiver<any, any, any>, K$1 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>;
+  family?: FamilyMetadata<K$1>;
   /** Never present. This is a marker that preserves the JSON form of the atom's transceiver value. */
-  __J?: AsJSON<T>;
+  __J?: AsJSON<T$1>;
 };
-type SelectorToken<T, K extends Canonical = any, E = never> = ReadonlySelectorToken<T, K, E> | WritableSelectorToken<T, K, E>;
-type ReadonlySelectorToken<T, K extends Canonical = any, E = never> = ReadonlyHeldSelectorToken<T, K> | ReadonlyPureSelectorToken<T, K, E>;
-type WritableSelectorToken<T, K extends Canonical = any, E = never> = WritableHeldSelectorToken<T, K> | WritablePureSelectorToken<T, K, E>;
-type PureSelectorToken<T, K extends Canonical = any, E = never> = ReadonlyPureSelectorToken<T, K, E> | WritablePureSelectorToken<T, K, E>;
-type HeldSelectorToken<T, K extends Canonical = any> = ReadonlyHeldSelectorToken<T, K> | WritableHeldSelectorToken<T, K>;
-type WritablePureSelectorToken<T, K extends Canonical = any, E = never> = {
+type SelectorToken<T$1, K$1 extends Canonical = any, E = never> = ReadonlySelectorToken<T$1, K$1, E> | WritableSelectorToken<T$1, K$1, E>;
+type ReadonlySelectorToken<T$1, K$1 extends Canonical = any, E = never> = ReadonlyHeldSelectorToken<T$1, K$1> | ReadonlyPureSelectorToken<T$1, K$1, E>;
+type WritableSelectorToken<T$1, K$1 extends Canonical = any, E = never> = WritableHeldSelectorToken<T$1, K$1> | WritablePureSelectorToken<T$1, K$1, E>;
+type PureSelectorToken<T$1, K$1 extends Canonical = any, E = never> = ReadonlyPureSelectorToken<T$1, K$1, E> | WritablePureSelectorToken<T$1, K$1, E>;
+type HeldSelectorToken<T$1, K$1 extends Canonical = any> = ReadonlyHeldSelectorToken<T$1, K$1> | WritableHeldSelectorToken<T$1, K$1>;
+type WritablePureSelectorToken<T$1, K$1 extends Canonical = any, E = never> = {
   /** The unique identifier of the selector. */
   key: string;
   /** Discriminator. */
   type: `writable_pure_selector`;
   /** Present if the selector belongs to a family. */
-  family?: FamilyMetadata<K>;
+  family?: FamilyMetadata<K$1>;
   /** Never present. This is a marker that preserves the type of the selector's value. */
-  __T?: T;
+  __T?: T$1;
   /** Never present. This is a marker that preserves the type of errors this selector is capable of catching and setting as its value. */
   __E?: E;
 };
-type WritableHeldSelectorToken<T, K extends Canonical = any> = {
+type WritableHeldSelectorToken<T$1, K$1 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>;
+  family?: FamilyMetadata<K$1>;
   /** Never present. This is a marker that preserves the type of the selector's value. */
-  __T?: T;
+  __T?: T$1;
 };
-type ReadonlyPureSelectorToken<T, K extends Canonical = any, E = never> = {
+type ReadonlyPureSelectorToken<T$1, K$1 extends Canonical = any, E = never> = {
   /** The unique identifier of the selector. */
   key: string;
   /** Discriminator. */
   type: `readonly_pure_selector`;
   /** Present if the selector belongs to a family. */
-  family?: FamilyMetadata<K>;
+  family?: FamilyMetadata<K$1>;
   /** Never present. This is a marker that preserves the type of the selector's value. */
-  __T?: T;
+  __T?: T$1;
   /** Never present. This is a marker that preserves the type of errors this selector is capable of catching and setting as its value. */
   __E?: E;
 };
-type ReadonlyHeldSelectorToken<T, K extends Canonical = any> = {
+type ReadonlyHeldSelectorToken<T$1, K$1 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>;
+  family?: FamilyMetadata<K$1>;
   /** Never present. This is a marker that preserves the type of the selector's value. */
-  __T?: T;
+  __T?: T$1;
 };
 /**
 * Identifies a state's connection to its family.
 */
-type FamilyMetadata<K extends Canonical = any> = {
+type FamilyMetadata<K$1 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>;
+  subKey: stringified<K$1>;
 };
-type AtomFamilyToken<T, K extends Canonical = Canonical, E = never> = MutableAtomFamilyToken<T extends Transceiver<any, any, any> ? T : never, K> | RegularAtomFamilyToken<T, K, E>;
-type RegularAtomFamilyToken<T, K extends Canonical, E = never> = {
+type AtomFamilyToken<T$1, K$1 extends Canonical = Canonical, E = never> = MutableAtomFamilyToken<T$1 extends Transceiver<any, any, any> ? T$1 : never, K$1> | RegularAtomFamilyToken<T$1, K$1, E>;
+type RegularAtomFamilyToken<T$1, K$1 extends Canonical, E = never> = {
   /** The unique identifier of the atom family */
   key: string;
   /** Discriminator */
   type: `atom_family`;
   /** Never present. This is a marker that preserves the type of atoms in this family */
-  __T?: T;
+  __T?: T$1;
   /** Never present. This is a marker that preserves the type of keys used for atoms in this family */
-  __K?: K;
+  __K?: K$1;
   /** Never present. This is a marker that preserves the type of errors this family is capable of catching and setting as its value. */
   __E?: E;
 };
-type MutableAtomFamilyToken<T extends Transceiver<any, any, any>, K extends Canonical> = {
+type MutableAtomFamilyToken<T$1 extends Transceiver<any, any, any>, K$1 extends Canonical> = {
   /** The unique identifier of the atom family */
   key: string;
   /** Discriminator */
   type: `mutable_atom_family`;
   /** Never present. This is a marker that preserves the type of atoms in this family */
-  __T?: T;
+  __T?: T$1;
   /** Never present. This is a marker that preserves the type of keys used for atoms in this family */
-  __K?: K;
+  __K?: K$1;
 };
-type SelectorFamilyToken<T, K extends Canonical, E = never> = ReadonlySelectorFamilyToken<T, K, E> | WritableSelectorFamilyToken<T, K, E>;
-type ReadonlySelectorFamilyToken<T, K extends Canonical, E = never> = ReadonlyHeldSelectorFamilyToken<T, K> | ReadonlyPureSelectorFamilyToken<T, K, E>;
-type WritableSelectorFamilyToken<T, K extends Canonical, E = never> = WritableHeldSelectorFamilyToken<T, K> | WritablePureSelectorFamilyToken<T, K, E>;
-type PureSelectorFamilyToken<T, K extends Canonical, E = never> = ReadonlyPureSelectorFamilyToken<T, K, E> | WritablePureSelectorFamilyToken<T, K, E>;
-type HeldSelectorFamilyToken<T, K extends Canonical> = ReadonlyHeldSelectorFamilyToken<T, K> | WritableHeldSelectorFamilyToken<T, K>;
-type WritablePureSelectorFamilyToken<T, K extends Canonical, E = never> = {
+type SelectorFamilyToken<T$1, K$1 extends Canonical, E = never> = ReadonlySelectorFamilyToken<T$1, K$1, E> | WritableSelectorFamilyToken<T$1, K$1, E>;
+type ReadonlySelectorFamilyToken<T$1, K$1 extends Canonical, E = never> = ReadonlyHeldSelectorFamilyToken<T$1, K$1> | ReadonlyPureSelectorFamilyToken<T$1, K$1, E>;
+type WritableSelectorFamilyToken<T$1, K$1 extends Canonical, E = never> = WritableHeldSelectorFamilyToken<T$1, K$1> | WritablePureSelectorFamilyToken<T$1, K$1, E>;
+type PureSelectorFamilyToken<T$1, K$1 extends Canonical, E = never> = ReadonlyPureSelectorFamilyToken<T$1, K$1, E> | WritablePureSelectorFamilyToken<T$1, K$1, E>;
+type HeldSelectorFamilyToken<T$1, K$1 extends Canonical> = ReadonlyHeldSelectorFamilyToken<T$1, K$1> | WritableHeldSelectorFamilyToken<T$1, K$1>;
+type WritablePureSelectorFamilyToken<T$1, K$1 extends Canonical, E = never> = {
   /** 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;
+  __T?: T$1;
   /** Never present. This is a marker that preserves the type of keys used for each family member */
-  __K?: K;
+  __K?: K$1;
   /** Never present. This is a marker that preserves the type of errors this family is capable of catching and setting as its value. */
   __E?: E;
 };
-type ReadonlyPureSelectorFamilyToken<T, K extends Canonical, E = never> = {
+type ReadonlyPureSelectorFamilyToken<T$1, K$1 extends Canonical, E = never> = {
   /** 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;
+  __T?: T$1;
   /** Never present. This is a marker that preserves the type of keys used for each family member */
-  __K?: K;
+  __K?: K$1;
   /** Never present. This is a marker that preserves the type of errors this family is capable of catching and setting as its value. */
   __E?: E;
 };
-type WritableHeldSelectorFamilyToken<T, K extends Canonical> = {
+type WritableHeldSelectorFamilyToken<T$1, K$1 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;
+  __T?: T$1;
   /** Never present. This is a marker that preserves the type of keys used for each family member */
-  __K?: K;
+  __K?: K$1;
 };
-type ReadonlyHeldSelectorFamilyToken<T, K extends Canonical> = {
+type ReadonlyHeldSelectorFamilyToken<T$1, K$1 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;
+  __T?: T$1;
   /** Never present. This is a marker that preserves the type of keys used for each family member */
-  __K?: K;
+  __K?: K$1;
 };
 //#endregion
 //#region src/main/validators.d.ts
@@ -238,21 +238,21 @@ declare function belongsTo<Family extends WritableFamilyToken<any, any>>(family:
 declare function belongsTo<Family extends ReadableFamilyToken<any, any>>(family: Family, unknownToken: ReadableToken<any>): unknownToken is ReadableToken<TokenType<Family>>;
 //#endregion
 //#region src/main/events.d.ts
-type StateUpdate<T> = {
-  readonly oldValue?: ViewOf$1<T>;
-  readonly newValue: ViewOf$1<T>;
+type StateUpdate<T$1> = {
+  readonly oldValue?: ViewOf$1<T$1>;
+  readonly newValue: ViewOf$1<T$1>;
 };
-type AtomUpdateEvent<A extends AtomToken<any, any, any>> = {
+type AtomUpdateEvent<A$1 extends AtomToken<any, any, any>> = {
   type: `atom_update`;
-  token: A;
-  update: StateUpdate<TokenType<A>>;
+  token: A$1;
+  update: StateUpdate<TokenType<A$1>>;
   timestamp: number;
 };
-type SelectorUpdateSubEvent<A extends AtomToken<any, any, any>> = AtomUpdateEvent<A> | StateCreationEvent<any>;
-type TimelineSelectorUpdateEvent<A extends TimelineManageable> = {
+type SelectorUpdateSubEvent<A$1 extends AtomToken<any, any, any>> = AtomUpdateEvent<A$1> | StateCreationEvent<any>;
+type TimelineSelectorUpdateEvent<A$1 extends TimelineManageable> = {
   type: `selector_update`;
   token: SelectorToken<any>;
-  subEvents: SelectorUpdateSubEvent<AtomOnly<A>>[];
+  subEvents: SelectorUpdateSubEvent<AtomOnly<A$1>>[];
   timestamp: number;
 };
 type StateLifecycleEvent<R extends ReadableToken<any, any, any>> = StateCreationEvent<R> | StateDisposalEvent<R>;
@@ -306,28 +306,28 @@ type MoleculeTransferEvent = {
   timestamp: number;
 };
 type TransactionSubEvent = AtomUpdateEvent<AtomToken<any, any, any>> | MoleculeCreationEvent | MoleculeDisposalEvent | MoleculeTransferEvent | StateCreationEvent<ReadableToken<unknown, any, any>> | StateDisposalEvent<ReadableToken<unknown, any, any>> | TransactionOutcomeEvent<TransactionToken<any>>;
-type TransactionOutcomeEvent<T extends TransactionToken<any>> = {
+type TransactionOutcomeEvent<T$1 extends TransactionToken<any>> = {
   type: `transaction_outcome`;
-  token: T;
+  token: T$1;
   id: string;
   epoch: number;
   timestamp: number;
   subEvents: TransactionSubEvent[];
-  params: Parameters<TokenType<T>>;
-  output: ReturnType<TokenType<T>>;
+  params: Parameters<TokenType<T$1>>;
+  output: ReturnType<TokenType<T$1>>;
 };
-type TimelineEvent<ManagedAtom extends TimelineManageable> = {
+type TimelineEvent<ManagedAtom$1 extends TimelineManageable> = {
   checkpoint?: true;
-} & (AtomUpdateEvent<AtomOnly<ManagedAtom>> | StateCreationEvent<AtomOnly<ManagedAtom>> | StateDisposalEvent<AtomOnly<ManagedAtom>> | TimelineSelectorUpdateEvent<ManagedAtom> | TransactionOutcomeEvent<TransactionToken<any>>);
+} & (AtomUpdateEvent<AtomOnly<ManagedAtom$1>> | StateCreationEvent<AtomOnly<ManagedAtom$1>> | StateDisposalEvent<AtomOnly<ManagedAtom$1>> | TimelineSelectorUpdateEvent<ManagedAtom$1> | TransactionOutcomeEvent<TransactionToken<any>>);
 //#endregion
 //#region src/main/atom.d.ts
-type RegularAtomOptions<T, E = never> = {
+type RegularAtomOptions<T$1, E = never> = {
   /** The unique identifier of the atom */
   key: string;
   /** The starting value of the atom */
-  default: T | (() => T);
+  default: T$1 | (() => T$1);
   /** Hooks used to run side effects when the atom is set */
-  effects?: readonly AtomEffect<T, E>[];
+  effects?: readonly AtomEffect<T$1, E>[];
   /** The classes of errors that might be thrown when deriving the atom's default value */
   catch?: readonly Ctor<E>[];
 };
@@ -337,14 +337,14 @@ type RegularAtomOptions<T, E = never> = {
 * @returns
 * A reference to the atom created: a {@link RegularAtomToken}
 */
-declare function atom<T, E = never>(options: RegularAtomOptions<T, E>): RegularAtomToken<T, any, E>;
-type MutableAtomOptions<T extends Transceiver<any, any, any>> = {
+declare function atom<T$1, E = never>(options: RegularAtomOptions<T$1, E>): RegularAtomToken<T$1, any, E>;
+type MutableAtomOptions<T$1 extends Transceiver<any, any, any>> = {
   /** The unique identifier of the atom */
   key: string;
   /** A constructor for the atom's value */
-  class: ConstructorOf<T>;
+  class: ConstructorOf<T$1>;
   /** Hooks used to run side effects when the atom is set */
-  effects?: readonly AtomEffect<T>[];
+  effects?: readonly AtomEffect<T$1>[];
 };
 /**
 * Create a mutable atom, a global reactive variable in the implicit store
@@ -355,15 +355,15 @@ type MutableAtomOptions<T extends Transceiver<any, any, any>> = {
 * @returns
 * A reference to the atom created: a {@link MutableAtomToken}
 */
-declare function mutableAtom<T extends Transceiver<any, any, any>>(options: MutableAtomOptions<T>): MutableAtomToken<T>;
+declare function mutableAtom<T$1 extends Transceiver<any, any, any>>(options: MutableAtomOptions<T$1>): MutableAtomToken<T$1>;
 /**
 * A function that runs side effects when the atom is set
 * @param tools - {@link Effectors} that can be used to run side effects
 * @returns
 * Optionally, a cleanup function that will be called when the atom is disposed
 */
-type AtomEffect<T, E = never> = (tools: Effectors<T, E>) => (() => void) | void;
-type Effectors<T, E = never> = {
+type AtomEffect<T$1, E = never> = (tools: Effectors<T$1, E>) => (() => void) | void;
+type Effectors<T$1, E = never> = {
   /**
   * Reset the value of the atom to its default
   */
@@ -372,21 +372,21 @@ type Effectors<T, E = never> = {
   * Set the value of the atom
   * @param next - The new value of the atom, or a setter function
   */
-  setSelf: <New extends T>(next: New | ((old: T) => New)) => void;
+  setSelf: <New extends T$1>(next: New | ((old: T$1) => New)) => void;
   /** Subscribe to changes to the atom */
-  onSet: (callback: (options: StateUpdate<E | T>) => void) => void;
+  onSet: (callback: (options: StateUpdate<E | T$1>) => void) => void;
   /** The token of the atom */
-  token: T extends Transceiver<any, any, any> ? MutableAtomToken<T> : AtomToken<T, any, E>;
+  token: T$1 extends Transceiver<any, any, any> ? MutableAtomToken<T$1> : AtomToken<T$1, any, E>;
   /** The store in which the atom exists */
   store: Store;
 };
-type RegularAtomFamilyOptions<T, K extends Canonical, E = never> = {
+type RegularAtomFamilyOptions<T$1, K$1 extends Canonical, E = never> = {
   /** The unique identifier of the atom family */
   key: string;
   /** The starting value of the atom family */
-  default: T | ((key: K) => T);
+  default: T$1 | ((key: K$1) => T$1);
   /** Hooks used to run side effects when an atom in the family is set  */
-  effects?: (key: K) => AtomEffect<T, E>[];
+  effects?: (key: K$1) => AtomEffect<T$1, E>[];
   /** The classes of errors that might be thrown when deriving the atom's default value */
   catch?: readonly Ctor<E>[];
 };
@@ -396,14 +396,14 @@ type RegularAtomFamilyOptions<T, K extends Canonical, E = never> = {
 * @returns
 * A reference to the atom family created: a {@link RegularAtomFamilyToken}
 */
-declare function atomFamily<T, K extends Canonical, E = never>(options: RegularAtomFamilyOptions<T, K, E>): RegularAtomFamilyToken<T, K, E>;
-type MutableAtomFamilyOptions<T extends Transceiver<any, any, any>, K extends Canonical> = {
+declare function atomFamily<T$1, K$1 extends Canonical, E = never>(options: RegularAtomFamilyOptions<T$1, K$1, E>): RegularAtomFamilyToken<T$1, K$1, E>;
+type MutableAtomFamilyOptions<T$1 extends Transceiver<any, any, any>, K$1 extends Canonical> = {
   /** The unique identifier of the atom family */
   key: string;
   /** The class of the transceiver to be created */
-  class: ConstructorOf<T>;
+  class: ConstructorOf<T$1>;
   /** Hooks used to run side effects when an atom in the family is set  */
-  effects?: (key: K) => AtomEffect<T>[];
+  effects?: (key: K$1) => AtomEffect<T$1>[];
 };
 /**
 * Create a family of mutable atoms, allowing for the dynamic creation and disposal of atoms.
@@ -414,7 +414,7 @@ type MutableAtomFamilyOptions<T extends Transceiver<any, any, any>, K extends Ca
 * @returns
 * A reference to the atom family created: a {@link MutableAtomFamilyToken}
 */
-declare function mutableAtomFamily<T extends Transceiver<any, any, any>, K extends Canonical>(options: MutableAtomFamilyOptions<T, K>): MutableAtomFamilyToken<T, K>;
+declare function mutableAtomFamily<T$1 extends Transceiver<any, any, any>, K$1 extends Canonical>(options: MutableAtomFamilyOptions<T$1, K$1>): MutableAtomFamilyToken<T$1, K$1>;
 //#endregion
 //#region src/main/dispose-state.d.ts
 /**
@@ -435,7 +435,7 @@ declare function disposeState(token: ReadableToken<any>): void;
 * @param key - The unique key of the state to dispose
 * @overload Streamlined
 */
-declare function disposeState<K extends Canonical>(token: ReadableFamilyToken<any, K>, key: K): void;
+declare function disposeState<K$1 extends Canonical>(token: ReadableFamilyToken<any, K$1>, key: K$1): void;
 //#endregion
 //#region src/main/find-state.d.ts
 /**
@@ -451,7 +451,7 @@ declare function disposeState<K extends Canonical>(token: ReadableFamilyToken<an
 * The current value of the state
 * @overload Mutable Atom
 */
-declare function findState<T extends Transceiver<any, any, any>, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, K>, key: Key): MutableAtomToken$1<T, K>;
+declare function findState<T$1 extends Transceiver<any, any, any>, K$1 extends Canonical, Key extends K$1>(token: MutableAtomFamilyToken<T$1, K$1>, key: Key): MutableAtomToken$1<T$1, K$1>;
 /**
 * Finds a {@link RegularAtomToken} in the store, without accessing its value.
 *
@@ -465,7 +465,7 @@ declare function findState<T extends Transceiver<any, any, any>, K extends Canon
 * The current value of the state
 * @overload Regular Atom
 */
-declare function findState<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken$1<T, Key>;
+declare function findState<T$1, K$1 extends Canonical, Key extends K$1>(token: RegularAtomFamilyToken<T$1, K$1>, key: Key): RegularAtomToken$1<T$1, Key>;
 /**
 * Finds a {@link WritableSelectorToken} in the store, without accessing its value.
 *
@@ -479,7 +479,7 @@ declare function findState<T, K extends Canonical, Key extends K>(token: Regular
 * 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, Key>;
+declare function findState<T$1, K$1 extends Canonical, Key extends K$1>(token: WritableSelectorFamilyToken$1<T$1, K$1>, key: Key): WritableSelectorToken$1<T$1, Key>;
 /**
 * Finds a {@link ReadonlySelectorToken} in the store, without accessing its value.
 *
@@ -493,7 +493,7 @@ declare function findState<T, K extends Canonical, Key extends K>(token: Writabl
 * 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, Key>;
+declare function findState<T$1, K$1 extends Canonical, Key extends K$1>(token: ReadonlySelectorFamilyToken$1<T$1, K$1>, key: Key): ReadonlySelectorToken$1<T$1, Key>;
 /**
 * Finds a {@link WritableToken} in the store, without accessing its value.
 *
@@ -507,7 +507,7 @@ declare function findState<T, K extends Canonical, Key extends K>(token: Readonl
 * 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, Key>;
+declare function findState<T$1, K$1 extends Canonical, Key extends K$1>(token: WritableFamilyToken$1<T$1, K$1>, key: Key): WritableToken$1<T$1, Key>;
 /**
 * Finds a {@link MutableAtomToken} in the store, without accessing its value.
 *
@@ -522,7 +522,7 @@ declare function findState<T, K extends Canonical, Key extends K>(token: Writabl
 * @overload Unknown
 * @default
 */
-declare function findState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken$1<T, K>, key: Key): ReadableToken$1<T, Key>;
+declare function findState<T$1, K$1 extends Canonical, Key extends K$1>(token: ReadableFamilyToken$1<T$1, K$1>, key: Key): ReadableToken$1<T$1, Key>;
 //#endregion
 //#region src/main/get-state.d.ts
 /**
@@ -532,7 +532,7 @@ declare function findState<T, K extends Canonical, Key extends K>(token: Readabl
 * @overload Default
 * @default
 */
-declare function getState<T, E = never>(token: ReadableToken<T, any, E>): ViewOf$1<E | T>;
+declare function getState<T$1, E = never>(token: ReadableToken<T$1, any, E>): ViewOf$1<E | T$1>;
 /**
 * Read or compute the current value of a state
 * @param token - The token of a state family
@@ -540,20 +540,20 @@ declare function getState<T, E = never>(token: ReadableToken<T, any, E>): ViewOf
 * @return The current value of the state
 * @overload Streamlined
 */
-declare function getState<T, K extends Canonical, E = never>(token: ReadableFamilyToken<T, K, E>, key: NoInfer<K>): ViewOf$1<E | T>;
+declare function getState<T$1, K$1 extends Canonical, E = never>(token: ReadableFamilyToken<T$1, K$1, E>, key: NoInfer<K$1>): ViewOf$1<E | T$1>;
 //#endregion
 //#region src/main/join.d.ts
-type JoinOptions<AName extends string, A extends string, BName extends string, B extends string, Cardinality extends `1:1` | `1:n` | `n:n`> = Flat<JunctionSchemaBase<AName, BName> & {
+type JoinOptions<AName extends string, A$1 extends string, BName extends string, B$1 extends string, Cardinality extends `1:1` | `1:n` | `n:n`> = Flat<JunctionSchemaBase<AName, BName> & {
   /** 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, A>;
+  readonly isAType: Refinement<string, A$1>;
   /** Type guard for the type of the right side */
-  readonly isBType: Refinement<string, B>;
-}> & Partial<JunctionEntriesBase<A, B, null>>;
-type JoinToken<AName extends string, A extends string, BName extends string, B extends string, Cardinality extends `1:1` | `1:n` | `n:n`> = {
+  readonly isBType: Refinement<string, B$1>;
+}> & Partial<JunctionEntriesBase<A$1, B$1, null>>;
+type JoinToken<AName extends string, A$1 extends string, BName extends string, B$1 extends string, Cardinality extends `1:1` | `1:n` | `n:n`> = {
   /** Unique identifier of the join */
   key: string;
   /** Discriminator */
@@ -565,9 +565,9 @@ type JoinToken<AName extends string, A extends string, BName extends string, B e
   /** Name of the join's right side */
   b: BName;
   /** Never present. This is a marker that preserves the type of the left side's keys */
-  __aType?: A;
+  __aType?: A$1;
   /** Never present. This is a marker that preserves the type of the right side's keys */
-  __bType?: B;
+  __bType?: B$1;
 };
 /**
 * Create a join, an interface for managing relations between two sets of keys.
@@ -580,8 +580,8 @@ type JoinToken<AName extends string, A extends string, BName extends string, B e
 * @returns
 * A reference to the join created: a {@link JoinToken}
 */
-declare function join<const AName extends string, const A extends string, const BName extends string, const B extends string, const Cardinality extends `1:1` | `1:n` | `n:n`>(options: JoinOptions<AName, A, BName, B, Cardinality>): JoinToken<AName, A, BName, B, Cardinality>;
-type JoinStates<AName extends string, A extends string, BName extends string, B extends string, Cardinality extends `1:1` | `1:n` | `n:n`> = Cardinality extends `1:1` ? { readonly [N in AName as `${N}KeyOf${Capitalize<BName>}`]: ReadonlyPureSelectorToken$1<A | null, B> } & { readonly [N in BName as `${N}KeyOf${Capitalize<AName>}`]: ReadonlyPureSelectorToken$1<B | null, A> } : Cardinality extends `1:n` ? { readonly [N in AName as `${N}KeyOf${Capitalize<BName>}`]: ReadonlyPureSelectorToken$1<A | null, B> } & { readonly [N in BName as `${N}KeysOf${Capitalize<AName>}`]: ReadonlyPureSelectorToken$1<B[], A> } : Cardinality extends `n:n` ? { readonly [N in AName as `${N}KeysOf${Capitalize<BName>}`]: ReadonlyPureSelectorToken$1<A[], B> } & { readonly [N in BName as `${N}KeysOf${Capitalize<AName>}`]: ReadonlyPureSelectorToken$1<B[], A> } : never;
+declare function join<const AName extends string, const A$1 extends string, const BName extends string, const B$1 extends string, const Cardinality extends `1:1` | `1:n` | `n:n`>(options: JoinOptions<AName, A$1, BName, B$1, Cardinality>): JoinToken<AName, A$1, BName, B$1, Cardinality>;
+type JoinStates<AName extends string, A$1 extends string, BName extends string, B$1 extends string, Cardinality extends `1:1` | `1:n` | `n:n`> = Cardinality extends `1:1` ? { readonly [N in AName as `${N}KeyOf${Capitalize<BName>}`]: ReadonlyPureSelectorToken$1<A$1 | null, B$1> } & { readonly [N in BName as `${N}KeyOf${Capitalize<AName>}`]: ReadonlyPureSelectorToken$1<B$1 | null, A$1> } : Cardinality extends `1:n` ? { readonly [N in AName as `${N}KeyOf${Capitalize<BName>}`]: ReadonlyPureSelectorToken$1<A$1 | null, B$1> } & { readonly [N in BName as `${N}KeysOf${Capitalize<AName>}`]: ReadonlyPureSelectorToken$1<B$1[], A$1> } : Cardinality extends `n:n` ? { readonly [N in AName as `${N}KeysOf${Capitalize<BName>}`]: ReadonlyPureSelectorToken$1<A$1[], B$1> } & { readonly [N in BName as `${N}KeysOf${Capitalize<AName>}`]: ReadonlyPureSelectorToken$1<B$1[], A$1> } : never;
 /**
 * Find the current value of a relation owned by a {@link join}
 * @param token - The token of the join
@@ -590,19 +590,19 @@ type JoinStates<AName extends string, A extends string, BName extends string, B
 * A {@link JoinStates} interface to access the relation
 * @overload Default
 */
-declare function findRelations<AName extends string, A extends string, BName extends string, B extends string, Cardinality extends `1:1` | `1:n` | `n:n`>(token: JoinToken<AName, A, BName, B, Cardinality>, key: A | B): JoinStates<AName, A, BName, B, Cardinality>;
+declare function findRelations<AName extends string, A$1 extends string, BName extends string, B$1 extends string, Cardinality extends `1:1` | `1:n` | `n:n`>(token: JoinToken<AName, A$1, BName, B$1, Cardinality>, key: A$1 | B$1): JoinStates<AName, A$1, BName, B$1, Cardinality>;
 /**
 * 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<AName extends string, A extends string, BName extends string, B extends string, Cardinality extends `1:1` | `1:n` | `n:n`>(token: JoinToken<AName, A, BName, B, Cardinality>, change: (relations: Junction<AName, A, BName, B>) => void): void;
+declare function editRelations<AName extends string, A$1 extends string, BName extends string, B$1 extends string, Cardinality extends `1:1` | `1:n` | `n:n`>(token: JoinToken<AName, A$1, BName, B$1, Cardinality>, change: (relations: Junction<AName, A$1, BName, B$1>) => void): void;
 /**
 * @param token - The token of the join
 * @returns
 * A {@link MutableAtomFamilyToken} to access the internal relations
 */
-declare function getInternalRelations<AName extends string, A extends string, BName extends string, B extends string, Cardinality extends `1:1` | `1:n` | `n:n`>(token: JoinToken<AName, A, BName, B, Cardinality>): MutableAtomFamilyToken$1<UList<A> | UList<B>, string>;
+declare function getInternalRelations<AName extends string, A$1 extends string, BName extends string, B$1 extends string, Cardinality extends `1:1` | `1:n` | `n:n`>(token: JoinToken<AName, A$1, BName, B$1, Cardinality>): MutableAtomFamilyToken$1<UList<A$1> | UList<B$1>, string>;
 //#endregion
 //#region src/main/logger.d.ts
 declare const LOGGER_ICON_DICTIONARY: {
@@ -681,7 +681,7 @@ declare class AtomIOLogger implements Logger {
 //#endregion
 //#region src/main/realm.d.ts
 declare const $validatedKey: unique symbol;
-type ValidKey<K extends Canonical> = K & {
+type ValidKey<K$1 extends Canonical> = K$1 & {
   [$validatedKey]?: true;
 };
 declare function simpleCompound(a: string, b: string): string;
@@ -765,10 +765,10 @@ declare class Anarchy {
 }
 declare function decomposeCompound(compound: Canonical): [type: string, a: string, b: string] | null;
 type T$ = `T$`;
-type TypeTag<T extends string> = `${T$}--${T}`;
-type SingularTypedKey<T extends string = string> = `${T}::${string}`;
-type CompoundTypedKey<T extends string = string, A extends string = string, B extends string = string> = `${TypeTag<T>}==${SingularTypedKey<A>}++${SingularTypedKey<B>}`;
-type TypedKey<T extends string = string, A extends string = string, B extends string = string> = CompoundTypedKey<T, A, B> | SingularTypedKey<T>;
+type TypeTag<T$1 extends string> = `${T$}--${T$1}`;
+type SingularTypedKey<T$1 extends string = string> = `${T$1}::${string}`;
+type CompoundTypedKey<T$1 extends string = string, A$1 extends string = string, B$1 extends string = string> = `${TypeTag<T$1>}==${SingularTypedKey<A$1>}++${SingularTypedKey<B$1>}`;
+type TypedKey<T$1 extends string = string, A$1 extends string = string, B$1 extends string = string> = CompoundTypedKey<T$1, A$1, B$1> | SingularTypedKey<T$1>;
 type Scope = SingularTypedKey[];
 type MutualFealty = {
   above: Scope;
@@ -779,7 +779,7 @@ type ExclusiveFealty = {
   below: Scope;
 };
 type Fealty = ExclusiveFealty | MutualFealty;
-type Hierarchy<F extends Fealty[] = Fealty[]> = Each<F>;
+type Hierarchy<F$1 extends Fealty[] = Fealty[]> = Each<F$1>;
 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];
@@ -806,7 +806,7 @@ declare function resetState(token: WritableToken<any, any, any>): void;
 * @param key - The unique key of the state to set.
 * @overload Streamlined
 */
-declare function resetState<K extends Canonical>(token: WritableFamilyToken<any, K, any>, key: K): void;
+declare function resetState<K$1 extends Canonical>(token: WritableFamilyToken<any, K$1, any>, key: K$1): void;
 //#endregion
 //#region src/main/set-state.d.ts
 /**
@@ -815,7 +815,7 @@ declare function resetState<K extends Canonical>(token: WritableFamilyToken<any,
 * @returns
 * The new value of the state.
 */
-type Setter<T> = (oldValue: T) => T;
+type Setter<T$1> = (oldValue: T$1) => T$1;
 /**
 * Set the value of a state into the implicit store.
 * @param token - An atom or writable selector token.
@@ -823,7 +823,7 @@ type Setter<T> = (oldValue: T) => T;
 * @overload Default
 * @default
 */
-declare function setState<T, TT extends T>(token: WritableToken<T, any, any>, value: Setter<TT> | TT): void;
+declare function setState<T$1, TT extends T$1>(token: WritableToken<T$1, any, any>, value: Setter<TT> | TT): void;
 /**
 * Set the value of a state into the implicit store.
 * @param token - An atom family or writable selector family token.
@@ -831,7 +831,7 @@ declare function setState<T, TT extends T>(token: WritableToken<T, any, any>, va
 * @param value - The new value of the state.
 * @overload Streamlined
 */
-declare function setState<T, TT extends T, K extends Canonical>(token: WritableFamilyToken<T, K, any>, key: NoInfer<K>, value: Setter<TT> | TT): void;
+declare function setState<T$1, TT extends T$1, K$1 extends Canonical>(token: WritableFamilyToken<T$1, K$1, any>, key: NoInfer<K$1>, value: Setter<TT> | TT): void;
 //#endregion
 //#region src/main/transaction.d.ts
 type ReaderToolkit = Pick<ActorToolkit, `find` | `get` | `json`>;
@@ -846,66 +846,66 @@ type ActorToolkit = Readonly<{
   run: typeof runTransaction;
   env: () => EnvironmentData;
 }>;
-type Read<F extends Fn$1> = (toolkit: ReaderToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
-type Write<F extends Fn$1> = (toolkit: WriterToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
-type Transact<F extends Fn$1> = (toolkit: ActorToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
+type Read<F$1 extends Fn$1> = (toolkit: ReaderToolkit, ...parameters: Parameters<F$1>) => ReturnType<F$1>;
+type Write<F$1 extends Fn$1> = (toolkit: WriterToolkit, ...parameters: Parameters<F$1>) => ReturnType<F$1>;
+type Transact<F$1 extends Fn$1> = (toolkit: ActorToolkit, ...parameters: Parameters<F$1>) => ReturnType<F$1>;
 type TransactionIO<Token extends TransactionToken<any>> = Token extends TransactionToken<infer F> ? F : never;
-type TransactionOptions<F extends Fn$1> = {
+type TransactionOptions<F$1 extends Fn$1> = {
   /** The unique identifier of the transaction */
   key: string;
   /** The operation to perform */
-  do: Transact<F>;
+  do: Transact<F$1>;
 };
 /**
 * 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 Fn$1>(options: TransactionOptions<F>): TransactionToken<F>;
+declare function transaction<F$1 extends Fn$1>(options: TransactionOptions<F$1>): TransactionToken<F$1>;
 /**
 * 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 Fn$1>(token: TransactionToken<F>, id?: string): (...parameters: Parameters<F>) => ReturnType<F>;
+declare function runTransaction<F$1 extends Fn$1>(token: TransactionToken<F$1>, id?: string): (...parameters: Parameters<F$1>) => ReturnType<F$1>;
 //#endregion
 //#region src/main/selector.d.ts
-type WritablePureSelectorOptions<T, E = never> = {
+type WritablePureSelectorOptions<T$1, E = never> = {
   /** The unique identifier of the selector */
   key: string;
   /** For each instantiated selector, a function that computes its value */
-  get: Read<() => T>;
+  get: Read<() => T$1>;
   /** For each instantiated selector, a function that sets its value */
-  set: Write<(newValue: T) => void>;
+  set: Write<(newValue: T$1) => void>;
   /** The classes of errors that might be thrown when deriving the atom's default value */
   catch?: readonly Ctor<E>[];
 };
-type ReadonlyPureSelectorOptions<T, E = never> = {
+type ReadonlyPureSelectorOptions<T$1, E = never> = {
   /** The unique identifier of the selector */
   key: string;
   /** For each instantiated selector, a function that computes its value */
-  get: Read<() => T>;
+  get: Read<() => T$1>;
   /** The classes of errors that might be thrown when deriving the atom's default value */
   catch?: readonly Ctor<E>[];
 };
-type ReadonlyHeldSelectorOptions<T extends object> = {
+type ReadonlyHeldSelectorOptions<T$1 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;
+  const: T$1;
   /** For each instantiated selector, a function that computes its value */
-  get: Read<(permanent: T) => void>;
+  get: Read<(permanent: T$1) => void>;
 };
-type WritableHeldSelectorOptions<T extends object> = {
+type WritableHeldSelectorOptions<T$1 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;
+  const: T$1;
   /** For each instantiated selector, a function that computes its value */
-  get: Read<(permanent: T) => void>;
+  get: Read<(permanent: T$1) => void>;
   /** For each instantiated selector, a function that sets its value */
-  set: Write<(newValue: T) => void>;
+  set: Write<(newValue: T$1) => void>;
 };
 /**
 * Declare a selector. The value of a selector should depend
@@ -924,7 +924,7 @@ type WritableHeldSelectorOptions<T extends object> = {
 * The token for your selector.
 * @overload WritableHeld
 */
-declare function selector<T extends object>(options: WritableHeldSelectorOptions<T>): WritableHeldSelectorToken<T>;
+declare function selector<T$1 extends object>(options: WritableHeldSelectorOptions<T$1>): WritableHeldSelectorToken<T$1>;
 /**
 * Declare a selector. The value of a selector should depend
 * on the value of atoms or other selectors in the store,
@@ -940,7 +940,7 @@ declare function selector<T extends object>(options: WritableHeldSelectorOptions
 * The token for your selector.
 * @overload ReadonlyHeld
 */
-declare function selector<T extends object>(options: ReadonlyHeldSelectorOptions<T>): ReadonlyHeldSelectorToken<T>;
+declare function selector<T$1 extends object>(options: ReadonlyHeldSelectorOptions<T$1>): ReadonlyHeldSelectorToken<T$1>;
 /**
 * Declare a selector. The value of a selector should depend
 * on the value of atoms or other selectors in the store.
@@ -957,7 +957,7 @@ declare function selector<T extends object>(options: ReadonlyHeldSelectorOptions
 * The token for your selector.
 * @overload WritablePure
 */
-declare function selector<T, E = never>(options: WritablePureSelectorOptions<T, E>): WritablePureSelectorToken<T, any, E>;
+declare function selector<T$1, E = never>(options: WritablePureSelectorOptions<T$1, E>): WritablePureSelectorToken<T$1, any, E>;
 /**
 * Declare a selector. The value of a selector should depend
 * on the value of atoms or other selectors in the store.
@@ -972,42 +972,42 @@ declare function selector<T, E = never>(options: WritablePureSelectorOptions<T,
 * The token for your selector.
 * @overload ReadonlyPure
 */
-declare function selector<T, E = never>(options: ReadonlyPureSelectorOptions<T, E>): ReadonlyPureSelectorToken<T, any, E>;
-type WritablePureSelectorFamilyOptions<T, K extends Canonical, E = never> = {
+declare function selector<T$1, E = never>(options: ReadonlyPureSelectorOptions<T$1, E>): ReadonlyPureSelectorToken<T$1, any, E>;
+type WritablePureSelectorFamilyOptions<T$1, K$1 extends Canonical, E = never> = {
   /** The unique identifier of the family */
   key: string;
   /** For each instantiated family member, a function that computes its value */
-  get: (key: K) => Read<() => T>;
+  get: (key: K$1) => Read<() => T$1>;
   /** For each instantiated family member, a function that sets its value */
-  set: (key: K) => Write<(newValue: T) => void>;
+  set: (key: K$1) => Write<(newValue: T$1) => void>;
   /** The classes of errors that might be thrown when deriving the atom's default value */
   catch?: readonly Ctor<E>[];
 };
-type ReadonlyPureSelectorFamilyOptions<T, K extends Canonical, E = never> = {
+type ReadonlyPureSelectorFamilyOptions<T$1, K$1 extends Canonical, E = never> = {
   /** The unique identifier of the family */
   key: string;
   /** For each instantiated family member, a function that computes its value */
-  get: (key: K) => Read<() => T>;
+  get: (key: K$1) => Read<() => T$1>;
   /** The classes of errors that might be thrown when deriving the atom's default value */
   catch?: readonly Ctor<E>[];
 };
-type WritableHeldSelectorFamilyOptions<T extends object, K extends Canonical> = {
+type WritableHeldSelectorFamilyOptions<T$1 extends object, K$1 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;
+  const: (key: K$1) => T$1;
   /** For each instantiated family member, a function that computes its value */
-  get: (key: K) => Read<(permanent: T) => void>;
+  get: (key: K$1) => Read<(permanent: T$1) => void>;
   /** For each instantiated family member, a function that sets its value */
-  set: (key: K) => Write<(newValue: T) => void>;
+  set: (key: K$1) => Write<(newValue: T$1) => void>;
 };
-type ReadonlyHeldSelectorFamilyOptions<T extends object, K extends Canonical> = {
+type ReadonlyHeldSelectorFamilyOptions<T$1 extends object, K$1 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;
+  const: (key: K$1) => T$1;
   /** For each instantiated family member, a function that computes its value */
-  get: (key: K) => Read<(permanent: T) => void>;
+  get: (key: K$1) => Read<(permanent: T$1) => void>;
 };
 /**
 * Create a family of selectors, allowing for the dynamic creation and disposal of selectors.
@@ -1027,7 +1027,7 @@ type ReadonlyHeldSelectorFamilyOptions<T extends object, K extends Canonical> =
 * A reference to the selector family created: a {@link WritableHeldSelectorFamilyToken}
 * @overload WritableHeld
 */
-declare function selectorFamily<T extends object, K extends Canonical>(options: WritableHeldSelectorFamilyOptions<T, K>): WritableHeldSelectorFamilyToken<T, K>;
+declare function selectorFamily<T$1 extends object, K$1 extends Canonical>(options: WritableHeldSelectorFamilyOptions<T$1, K$1>): WritableHeldSelectorFamilyToken<T$1, K$1>;
 /**
 * Create a family of selectors, allowing for the dynamic creation and disposal of selectors.
 *
@@ -1044,7 +1044,7 @@ declare function selectorFamily<T extends object, K extends Canonical>(options:
 * A reference to the selector family created: a {@link ReadonlyHeldSelectorFamilyToken}
 * @overload ReadonlyHeld
 */
-declare function selectorFamily<T extends object, K extends Canonical>(options: ReadonlyHeldSelectorFamilyOptions<T, K>): ReadonlyHeldSelectorFamilyToken<T, K>;
+declare function selectorFamily<T$1 extends object, K$1 extends Canonical>(options: ReadonlyHeldSelectorFamilyOptions<T$1, K$1>): ReadonlyHeldSelectorFamilyToken<T$1, K$1>;
 /**
 * Create a family of selectors, allowing for the dynamic creation and disposal of selectors.
 *
@@ -1062,7 +1062,7 @@ declare function selectorFamily<T extends object, K extends Canonical>(options:
 * A reference to the selector family created: a {@link TransientWritableSelectorFamilyToken}
 * @overload WritablePure
 */
-declare function selectorFamily<T, K extends Canonical, E = never>(options: WritablePureSelectorFamilyOptions<T, K, E>): WritablePureSelectorFamilyToken<T, K, E>;
+declare function selectorFamily<T$1, K$1 extends Canonical, E = never>(options: WritablePureSelectorFamilyOptions<T$1, K$1, E>): WritablePureSelectorFamilyToken<T$1, K$1, E>;
 /**
 * Create a family of selectors, allowing for the dynamic creation and disposal of selectors.
 *
@@ -1078,7 +1078,7 @@ declare function selectorFamily<T, K extends Canonical, E = never>(options: Writ
 * A reference to the selector family created: a {@link ReadonlyPureSelectorFamilyToken}
 * @overload ReadonlyPure
 */
-declare function selectorFamily<T, K extends Canonical, E = never>(options: ReadonlyPureSelectorFamilyOptions<T, K, E>): ReadonlyPureSelectorFamilyToken<T, K, E>;
+declare function selectorFamily<T$1, K$1 extends Canonical, E = never>(options: ReadonlyPureSelectorFamilyOptions<T$1, K$1, E>): ReadonlyPureSelectorFamilyToken<T$1, K$1, E>;
 //#endregion
 //#region src/main/silo.d.ts
 declare class Silo {
@@ -1105,8 +1105,8 @@ declare class Silo {
 }
 //#endregion
 //#region src/main/subscribe.d.ts
-type UpdateHandler<T> = (update: StateUpdate<T>) => void;
-type TransactionUpdateHandler<F extends Fn$1> = (data: TransactionOutcomeEvent<TransactionToken<F>>) => void;
+type UpdateHandler<T$1> = (update: StateUpdate<T$1>) => void;
+type TransactionUpdateHandler<F$1 extends Fn$1> = (data: TransactionOutcomeEvent<TransactionToken<F$1>>) => void;
 /**
 * Subscribe to a state in the implicit store
 * @param token - The token of the state to subscribe to
@@ -1115,7 +1115,7 @@ type TransactionUpdateHandler<F extends Fn$1> = (data: TransactionOutcomeEvent<T
 * @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;
+declare function subscribe<T$1>(token: ReadableToken<T$1>, handleUpdate: UpdateHandler<T$1>, key?: string): () => void;
 /**
 * Subscribe to a transaction in the implicit store
 * @param token - The token of the transaction to subscribe to
@@ -1124,7 +1124,7 @@ declare function subscribe<T>(token: ReadableToken<T>, handleUpdate: UpdateHandl
 * @returns A function that can be called to unsubscribe from the transaction
 * @overload Transaction
 */
-declare function subscribe<F extends Fn$1>(token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key?: string): () => void;
+declare function subscribe<F$1 extends Fn$1>(token: TransactionToken<F$1>, handleUpdate: TransactionUpdateHandler<F$1>, key?: string): () => void;
 /**
 * Subscribe to a timeline in the implicit store
 * @param token - The token of the timeline to subscribe to
@@ -1143,10 +1143,10 @@ declare function subscribe<M extends TimelineManageable>(token: TimelineToken<M>
 *
 * As a result, we consider any state that can be a set to a Promise to be a "loadable" state, whose value may or may not be a Promise at any given time.
 */
-type Loadable<T> = Promise<T> | T;
-type ViewOf<T> = T extends {
+type Loadable<T$1> = Promise<T$1> | T$1;
+type ViewOf<T$1> = T$1 extends {
   READONLY_VIEW: infer View;
-} ? View : T;
+} ? View : T$1;
 //#endregion
 export { $validatedKey, Above, ActorToolkit, Anarchy, AtomDisposalEvent, AtomEffect, AtomFamilyToken, AtomIOLogger, AtomIOToken, AtomOnly, AtomToken, AtomUpdateEvent, Below, CompoundFrom, CompoundTypedKey, Effectors, FamilyMetadata, HeldSelectorFamilyToken, HeldSelectorToken, Hierarchy, JoinOptions, JoinStates, JoinToken, LOG_LEVELS, Loadable, LogFilter, LogFn, LogLevel, Logger, LoggerIcon, MoleculeCreationEvent, MoleculeDisposalEvent, MoleculeTransferEvent, MutableAtomFamilyOptions, MutableAtomFamilyToken, MutableAtomOptions, MutableAtomToken, Mutuals, PRETTY_TOKEN_TYPES, PureSelectorFamilyToken, PureSelectorToken, Read, ReadableFamilyToken, ReadableStateCreationEvent, ReadableToken, ReaderToolkit, ReadonlyHeldSelectorFamilyOptions, ReadonlyHeldSelectorFamilyToken, ReadonlyHeldSelectorOptions, ReadonlyHeldSelectorToken, ReadonlyPureSelectorFamilyOptions, ReadonlyPureSelectorFamilyToken, ReadonlyPureSelectorOptions, ReadonlyPureSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, Realm, RegularAtomFamilyOptions, RegularAtomFamilyToken, RegularAtomOptions, RegularAtomToken, SelectorDisposalEvent, SelectorFamilyToken, SelectorToken, SelectorUpdateSubEvent, Setter, Silo, SingularTypedKey, StateCreationEvent, StateDisposalEvent, StateLifecycleEvent, StateUpdate, T$, TimelineEvent, TimelineManageable, TimelineOptions, TimelineSelectorUpdateEvent, TimelineToken, TokenDenomination, TokenType, Transact, TransactionIO, TransactionOptions, TransactionOutcomeEvent, TransactionSubEvent, TransactionToken, TransactionUpdateHandler, TypeTag, TypedKey, UpdateHandler, ValidKey, Vassal, ViewOf, WritableFamilyToken, WritableHeldSelectorFamilyOptions, WritableHeldSelectorFamilyToken, WritableHeldSelectorOptions, WritableHeldSelectorToken, WritablePureSelectorFamilyOptions, WritablePureSelectorFamilyToken, WritablePureSelectorOptions, WritablePureSelectorToken, WritableSelectorFamilyToken, WritableSelectorToken, WritableStateCreationEvent, WritableToken, Write, WriterToolkit, atom, atomFamily, belongsTo, decomposeCompound, disposeState, editRelations, findRelations, findState, getInternalRelations, getState, isToken, join, mutableAtom, mutableAtomFamily, redo, resetState, runTransaction, selector, selectorFamily, setState, simpleCompound, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };
 //# sourceMappingURL=index.d.ts.map