atom.io 0.43.2 → 0.44.1

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$1 extends TimelineManageable> = {
+type TimelineOptions<ManagedAtom extends TimelineManageable> = {
   /** The unique identifier of the timeline */
   key: string;
   /** The managed atoms (and families of atoms) to record */
-  scope: ManagedAtom$1[];
+  scope: ManagedAtom[];
 };
 /**
 * 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$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>;
+type ReadableToken<T, K$1 extends Canonical = any, E = never> = AtomToken<T, K$1, E> | SelectorToken<T, K$1, E>;
+type WritableToken<T, K$1 extends Canonical = any, E = never> = AtomToken<T, K$1, E> | WritableSelectorToken<T, K$1, E>;
 /**
 * States belonging to this family can be read from the store.
 */
-type ReadableFamilyToken<T$1, K$1 extends Canonical, E = never> = AtomFamilyToken<T$1, K$1, E> | SelectorFamilyToken<T$1, K$1, E>;
+type ReadableFamilyToken<T, K$1 extends Canonical, E = never> = AtomFamilyToken<T, K$1, E> | SelectorFamilyToken<T, K$1, E>;
 /**
 * States belonging to this family can be written directly.
 */
-type WritableFamilyToken<T$1, K$1 extends Canonical, E = never> = AtomFamilyToken<T$1, K$1, E> | WritableSelectorFamilyToken<T$1, K$1, E>;
+type WritableFamilyToken<T, K$1 extends Canonical, E = never> = AtomFamilyToken<T, K$1, E> | WritableSelectorFamilyToken<T, K$1, E>;
 type TimelineToken<M> = {
   /** The unique identifier of the timeline */
   key: string;
@@ -68,8 +68,8 @@ type TransactionToken<F$1 extends Fn$1> = {
   /** Never present. This is a marker that preserves the type of the transaction function */
   __F?: F$1;
 };
-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> = {
+type AtomToken<T, K$1 extends Canonical = any, E = never> = MutableAtomToken<T extends Transceiver<any, any, any> ? T : never, K$1> | RegularAtomToken<T, K$1, E>;
+type RegularAtomToken<T, K$1 extends Canonical = any, E = never> = {
   /** The unique identifier of the atom. */
   key: string;
   /** Discriminator. */
@@ -77,11 +77,11 @@ type RegularAtomToken<T$1, K$1 extends Canonical = any, E = never> = {
   /** Present if the atom belongs to a family. */
   family?: FamilyMetadata<K$1>;
   /** Never present. This is a marker that preserves the type of the atom's value. */
-  __T?: T$1;
+  __T?: T;
   /** 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$1 extends Transceiver<any, any, any>, K$1 extends Canonical = any> = {
+type MutableAtomToken<T extends Transceiver<any, any, any>, K$1 extends Canonical = any> = {
   /** The unique identifier of the atom. */
   key: string;
   /** Discriminator. */
@@ -89,14 +89,14 @@ type MutableAtomToken<T$1 extends Transceiver<any, any, any>, K$1 extends Canoni
   /** Present if the atom belongs to a family. */
   family?: FamilyMetadata<K$1>;
   /** Never present. This is a marker that preserves the JSON form of the atom's transceiver value. */
-  __J?: AsJSON<T$1>;
+  __J?: AsJSON<T>;
 };
-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> = {
+type SelectorToken<T, K$1 extends Canonical = any, E = never> = ReadonlySelectorToken<T, K$1, E> | WritableSelectorToken<T, K$1, E>;
+type ReadonlySelectorToken<T, K$1 extends Canonical = any, E = never> = ReadonlyHeldSelectorToken<T, K$1> | ReadonlyPureSelectorToken<T, K$1, E>;
+type WritableSelectorToken<T, K$1 extends Canonical = any, E = never> = WritableHeldSelectorToken<T, K$1> | WritablePureSelectorToken<T, K$1, E>;
+type PureSelectorToken<T, K$1 extends Canonical = any, E = never> = ReadonlyPureSelectorToken<T, K$1, E> | WritablePureSelectorToken<T, K$1, E>;
+type HeldSelectorToken<T, K$1 extends Canonical = any> = ReadonlyHeldSelectorToken<T, K$1> | WritableHeldSelectorToken<T, K$1>;
+type WritablePureSelectorToken<T, K$1 extends Canonical = any, E = never> = {
   /** The unique identifier of the selector. */
   key: string;
   /** Discriminator. */
@@ -104,11 +104,11 @@ type WritablePureSelectorToken<T$1, K$1 extends Canonical = any, E = never> = {
   /** Present if the selector belongs to a family. */
   family?: FamilyMetadata<K$1>;
   /** Never present. This is a marker that preserves the type of the selector's value. */
-  __T?: T$1;
+  __T?: T;
   /** 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$1, K$1 extends Canonical = any> = {
+type WritableHeldSelectorToken<T, K$1 extends Canonical = any> = {
   /** The unique identifier of the selector. */
   key: string;
   /** Discriminator. */
@@ -116,9 +116,9 @@ type WritableHeldSelectorToken<T$1, K$1 extends Canonical = any> = {
   /** Present if the selector belongs to a family. */
   family?: FamilyMetadata<K$1>;
   /** Never present. This is a marker that preserves the type of the selector's value. */
-  __T?: T$1;
+  __T?: T;
 };
-type ReadonlyPureSelectorToken<T$1, K$1 extends Canonical = any, E = never> = {
+type ReadonlyPureSelectorToken<T, K$1 extends Canonical = any, E = never> = {
   /** The unique identifier of the selector. */
   key: string;
   /** Discriminator. */
@@ -126,11 +126,11 @@ type ReadonlyPureSelectorToken<T$1, K$1 extends Canonical = any, E = never> = {
   /** Present if the selector belongs to a family. */
   family?: FamilyMetadata<K$1>;
   /** Never present. This is a marker that preserves the type of the selector's value. */
-  __T?: T$1;
+  __T?: T;
   /** 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$1, K$1 extends Canonical = any> = {
+type ReadonlyHeldSelectorToken<T, K$1 extends Canonical = any> = {
   /** The unique identifier of the selector. */
   key: string;
   /** Discriminator. */
@@ -138,7 +138,7 @@ type ReadonlyHeldSelectorToken<T$1, K$1 extends Canonical = any> = {
   /** Present if the selector belongs to a family. */
   family?: FamilyMetadata<K$1>;
   /** Never present. This is a marker that preserves the type of the selector's value. */
-  __T?: T$1;
+  __T?: T;
 };
 /**
 * Identifies a state's connection to its family.
@@ -149,75 +149,75 @@ type FamilyMetadata<K$1 extends Canonical = any> = {
   /** The family member's unique identifier, in the form of a string. */
   subKey: stringified<K$1>;
 };
-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> = {
+type AtomFamilyToken<T, K$1 extends Canonical = Canonical, E = never> = MutableAtomFamilyToken<T extends Transceiver<any, any, any> ? T : never, K$1> | RegularAtomFamilyToken<T, K$1, E>;
+type RegularAtomFamilyToken<T, 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$1;
+  __T?: T;
   /** Never present. This is a marker that preserves the type of keys used for atoms in this family */
   __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$1 extends Transceiver<any, any, any>, K$1 extends Canonical> = {
+type MutableAtomFamilyToken<T 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$1;
+  __T?: T;
   /** Never present. This is a marker that preserves the type of keys used for atoms in this family */
   __K?: K$1;
 };
-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> = {
+type SelectorFamilyToken<T, K$1 extends Canonical, E = never> = ReadonlySelectorFamilyToken<T, K$1, E> | WritableSelectorFamilyToken<T, K$1, E>;
+type ReadonlySelectorFamilyToken<T, K$1 extends Canonical, E = never> = ReadonlyHeldSelectorFamilyToken<T, K$1> | ReadonlyPureSelectorFamilyToken<T, K$1, E>;
+type WritableSelectorFamilyToken<T, K$1 extends Canonical, E = never> = WritableHeldSelectorFamilyToken<T, K$1> | WritablePureSelectorFamilyToken<T, K$1, E>;
+type PureSelectorFamilyToken<T, K$1 extends Canonical, E = never> = ReadonlyPureSelectorFamilyToken<T, K$1, E> | WritablePureSelectorFamilyToken<T, K$1, E>;
+type HeldSelectorFamilyToken<T, K$1 extends Canonical> = ReadonlyHeldSelectorFamilyToken<T, K$1> | WritableHeldSelectorFamilyToken<T, K$1>;
+type WritablePureSelectorFamilyToken<T, 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$1;
+  __T?: T;
   /** Never present. This is a marker that preserves the type of keys used for each family member */
   __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$1, K$1 extends Canonical, E = never> = {
+type ReadonlyPureSelectorFamilyToken<T, 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$1;
+  __T?: T;
   /** Never present. This is a marker that preserves the type of keys used for each family member */
   __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$1, K$1 extends Canonical> = {
+type WritableHeldSelectorFamilyToken<T, 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$1;
+  __T?: T;
   /** Never present. This is a marker that preserves the type of keys used for each family member */
   __K?: K$1;
 };
-type ReadonlyHeldSelectorFamilyToken<T$1, K$1 extends Canonical> = {
+type ReadonlyHeldSelectorFamilyToken<T, 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$1;
+  __T?: T;
   /** Never present. This is a marker that preserves the type of keys used for each family member */
   __K?: K$1;
 };
@@ -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$1> = {
-  readonly oldValue?: ViewOf$1<T$1>;
-  readonly newValue: ViewOf$1<T$1>;
+type StateUpdate<T> = {
+  readonly oldValue?: ViewOf$1<T>;
+  readonly newValue: ViewOf$1<T>;
 };
-type AtomUpdateEvent<A$1 extends AtomToken<any, any, any>> = {
+type AtomUpdateEvent<A extends AtomToken<any, any, any>> = {
   type: `atom_update`;
-  token: A$1;
-  update: StateUpdate<TokenType<A$1>>;
+  token: A;
+  update: StateUpdate<TokenType<A>>;
   timestamp: number;
 };
-type SelectorUpdateSubEvent<A$1 extends AtomToken<any, any, any>> = AtomUpdateEvent<A$1> | StateCreationEvent<any>;
-type TimelineSelectorUpdateEvent<A$1 extends TimelineManageable> = {
+type SelectorUpdateSubEvent<A extends AtomToken<any, any, any>> = AtomUpdateEvent<A> | StateCreationEvent<any>;
+type TimelineSelectorUpdateEvent<A extends TimelineManageable> = {
   type: `selector_update`;
   token: SelectorToken<any>;
-  subEvents: SelectorUpdateSubEvent<AtomOnly<A$1>>[];
+  subEvents: SelectorUpdateSubEvent<AtomOnly<A>>[];
   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$1 extends TransactionToken<any>> = {
+type TransactionOutcomeEvent<T extends TransactionToken<any>> = {
   type: `transaction_outcome`;
-  token: T$1;
+  token: T;
   id: string;
   epoch: number;
   timestamp: number;
   subEvents: TransactionSubEvent[];
-  params: Parameters<TokenType<T$1>>;
-  output: ReturnType<TokenType<T$1>>;
+  params: Parameters<TokenType<T>>;
+  output: ReturnType<TokenType<T>>;
 };
-type TimelineEvent<ManagedAtom$1 extends TimelineManageable> = {
+type TimelineEvent<ManagedAtom extends TimelineManageable> = {
   checkpoint?: true;
-} & (AtomUpdateEvent<AtomOnly<ManagedAtom$1>> | StateCreationEvent<AtomOnly<ManagedAtom$1>> | StateDisposalEvent<AtomOnly<ManagedAtom$1>> | TimelineSelectorUpdateEvent<ManagedAtom$1> | TransactionOutcomeEvent<TransactionToken<any>>);
+} & (AtomUpdateEvent<AtomOnly<ManagedAtom>> | StateCreationEvent<AtomOnly<ManagedAtom>> | StateDisposalEvent<AtomOnly<ManagedAtom>> | TimelineSelectorUpdateEvent<ManagedAtom> | TransactionOutcomeEvent<TransactionToken<any>>);
 //#endregion
 //#region src/main/atom.d.ts
-type RegularAtomOptions<T$1, E = never> = {
+type RegularAtomOptions<T, E = never> = {
   /** The unique identifier of the atom */
   key: string;
   /** The starting value of the atom */
-  default: T$1 | (() => T$1);
+  default: T | (() => T);
   /** Hooks used to run side effects when the atom is set */
-  effects?: readonly AtomEffect<T$1, E>[];
+  effects?: readonly AtomEffect<T, 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$1, E = never> = {
 * @returns
 * A reference to the atom created: a {@link RegularAtomToken}
 */
-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>> = {
+declare function atom<T, E = never>(options: RegularAtomOptions<T, E>): RegularAtomToken<T, any, E>;
+type MutableAtomOptions<T extends Transceiver<any, any, any>> = {
   /** The unique identifier of the atom */
   key: string;
   /** A constructor for the atom's value */
-  class: ConstructorOf<T$1>;
+  class: ConstructorOf<T>;
   /** Hooks used to run side effects when the atom is set */
-  effects?: readonly AtomEffect<T$1>[];
+  effects?: readonly AtomEffect<T>[];
 };
 /**
 * Create a mutable atom, a global reactive variable in the implicit store
@@ -355,15 +355,15 @@ type MutableAtomOptions<T$1 extends Transceiver<any, any, any>> = {
 * @returns
 * A reference to the atom created: a {@link MutableAtomToken}
 */
-declare function mutableAtom<T$1 extends Transceiver<any, any, any>>(options: MutableAtomOptions<T$1>): MutableAtomToken<T$1>;
+declare function mutableAtom<T extends Transceiver<any, any, any>>(options: MutableAtomOptions<T>): MutableAtomToken<T>;
 /**
 * 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$1, E = never> = (tools: Effectors<T$1, E>) => (() => void) | void;
-type Effectors<T$1, E = never> = {
+type AtomEffect<T, E = never> = (tools: Effectors<T, E>) => (() => void) | void;
+type Effectors<T, E = never> = {
   /**
   * Reset the value of the atom to its default
   */
@@ -372,21 +372,21 @@ type Effectors<T$1, E = never> = {
   * Set the value of the atom
   * @param next - The new value of the atom, or a setter function
   */
-  setSelf: <New extends T$1>(next: New | ((old: T$1) => New)) => void;
+  setSelf: <New extends T>(next: New | ((old: T) => New)) => void;
   /** Subscribe to changes to the atom */
-  onSet: (callback: (options: StateUpdate<E | T$1>) => void) => void;
+  onSet: (callback: (options: StateUpdate<E | T>) => void) => void;
   /** The token of the atom */
-  token: T$1 extends Transceiver<any, any, any> ? MutableAtomToken<T$1> : AtomToken<T$1, any, E>;
+  token: T extends Transceiver<any, any, any> ? MutableAtomToken<T> : AtomToken<T, any, E>;
   /** The store in which the atom exists */
   store: Store;
 };
-type RegularAtomFamilyOptions<T$1, K$1 extends Canonical, E = never> = {
+type RegularAtomFamilyOptions<T, K$1 extends Canonical, E = never> = {
   /** The unique identifier of the atom family */
   key: string;
   /** The starting value of the atom family */
-  default: T$1 | ((key: K$1) => T$1);
+  default: T | ((key: K$1) => T);
   /** Hooks used to run side effects when an atom in the family is set  */
-  effects?: (key: K$1) => AtomEffect<T$1, E>[];
+  effects?: (key: K$1) => AtomEffect<T, 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$1, K$1 extends Canonical, E = never> = {
 * @returns
 * A reference to the atom family created: a {@link RegularAtomFamilyToken}
 */
-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> = {
+declare function atomFamily<T, K$1 extends Canonical, E = never>(options: RegularAtomFamilyOptions<T, K$1, E>): RegularAtomFamilyToken<T, K$1, E>;
+type MutableAtomFamilyOptions<T 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$1>;
+  class: ConstructorOf<T>;
   /** Hooks used to run side effects when an atom in the family is set  */
-  effects?: (key: K$1) => AtomEffect<T$1>[];
+  effects?: (key: K$1) => AtomEffect<T>[];
 };
 /**
 * Create a family of mutable atoms, allowing for the dynamic creation and disposal of atoms.
@@ -414,7 +414,7 @@ type MutableAtomFamilyOptions<T$1 extends Transceiver<any, any, any>, K$1 extend
 * @returns
 * A reference to the atom family created: a {@link MutableAtomFamilyToken}
 */
-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>;
+declare function mutableAtomFamily<T extends Transceiver<any, any, any>, K$1 extends Canonical>(options: MutableAtomFamilyOptions<T, K$1>): MutableAtomFamilyToken<T, K$1>;
 //#endregion
 //#region src/main/dispose-state.d.ts
 /**
@@ -451,7 +451,7 @@ declare function disposeState<K$1 extends Canonical>(token: ReadableFamilyToken<
 * The current value of the state
 * @overload Mutable Atom
 */
-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>;
+declare function findState<T extends Transceiver<any, any, any>, K$1 extends Canonical, Key extends K$1>(token: MutableAtomFamilyToken<T, K$1>, key: Key): MutableAtomToken$1<T, K$1>;
 /**
 * Finds a {@link RegularAtomToken} in the store, without accessing its value.
 *
@@ -465,7 +465,7 @@ declare function findState<T$1 extends Transceiver<any, any, any>, K$1 extends C
 * The current value of the state
 * @overload Regular Atom
 */
-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>;
+declare function findState<T, K$1 extends Canonical, Key extends K$1>(token: RegularAtomFamilyToken<T, K$1>, key: Key): RegularAtomToken$1<T, Key>;
 /**
 * Finds a {@link WritableSelectorToken} in the store, without accessing its value.
 *
@@ -479,7 +479,7 @@ declare function findState<T$1, K$1 extends Canonical, Key extends K$1>(token: R
 * The current value of the state
 * @overload Writable Selector
 */
-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>;
+declare function findState<T, K$1 extends Canonical, Key extends K$1>(token: WritableSelectorFamilyToken$1<T, K$1>, key: Key): WritableSelectorToken$1<T, Key>;
 /**
 * Finds a {@link ReadonlySelectorToken} in the store, without accessing its value.
 *
@@ -493,7 +493,7 @@ declare function findState<T$1, K$1 extends Canonical, Key extends K$1>(token: W
 * The current value of the state
 * @overload Readonly Selector
 */
-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>;
+declare function findState<T, K$1 extends Canonical, Key extends K$1>(token: ReadonlySelectorFamilyToken$1<T, K$1>, key: Key): ReadonlySelectorToken$1<T, Key>;
 /**
 * Finds a {@link WritableToken} in the store, without accessing its value.
 *
@@ -507,7 +507,7 @@ declare function findState<T$1, K$1 extends Canonical, Key extends K$1>(token: R
 * The current value of the state
 * @overload Writable State
 */
-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>;
+declare function findState<T, K$1 extends Canonical, Key extends K$1>(token: WritableFamilyToken$1<T, K$1>, key: Key): WritableToken$1<T, Key>;
 /**
 * Finds a {@link MutableAtomToken} in the store, without accessing its value.
 *
@@ -522,7 +522,7 @@ declare function findState<T$1, K$1 extends Canonical, Key extends K$1>(token: W
 * @overload Unknown
 * @default
 */
-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>;
+declare function findState<T, K$1 extends Canonical, Key extends K$1>(token: ReadableFamilyToken$1<T, K$1>, key: Key): ReadableToken$1<T, Key>;
 //#endregion
 //#region src/main/get-state.d.ts
 /**
@@ -532,7 +532,7 @@ declare function findState<T$1, K$1 extends Canonical, Key extends K$1>(token: R
 * @overload Default
 * @default
 */
-declare function getState<T$1, E = never>(token: ReadableToken<T$1, any, E>): ViewOf$1<E | T$1>;
+declare function getState<T, E = never>(token: ReadableToken<T, any, E>): ViewOf$1<E | T>;
 /**
 * 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$1, E = never>(token: ReadableToken<T$1, any, E>): Vi
 * @return The current value of the state
 * @overload Streamlined
 */
-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>;
+declare function getState<T, K$1 extends Canonical, E = never>(token: ReadableFamilyToken<T, K$1, E>, key: NoInfer<K$1>): ViewOf$1<E | T>;
 //#endregion
 //#region src/main/join.d.ts
-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> & {
+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> & {
   /** 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$1>;
+  readonly isAType: Refinement<string, A>;
   /** Type guard for the type of the right side */
-  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`> = {
+  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`> = {
   /** Unique identifier of the join */
   key: string;
   /** Discriminator */
@@ -565,9 +565,9 @@ type JoinToken<AName extends string, A$1 extends string, BName extends string, B
   /** 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$1;
+  __aType?: A;
   /** Never present. This is a marker that preserves the type of the right side's keys */
-  __bType?: B$1;
+  __bType?: B;
 };
 /**
 * Create a join, an interface for managing relations between two sets of keys.
@@ -580,8 +580,8 @@ type JoinToken<AName extends string, A$1 extends string, BName extends string, B
 * @returns
 * A reference to the join created: a {@link JoinToken}
 */
-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;
+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;
 /**
 * 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$1 extends string, BName extends string,
 * A {@link JoinStates} interface to access the relation
 * @overload Default
 */
-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>;
+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>;
 /**
 * 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$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;
+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;
 /**
 * @param token - The token of the join
 * @returns
 * A {@link MutableAtomFamilyToken} to access the internal relations
 */
-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>;
+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>;
 //#endregion
 //#region src/main/logger.d.ts
 declare const LOGGER_ICON_DICTIONARY: {
@@ -688,7 +688,7 @@ declare function simpleCompound(a: string, b: string): string;
 declare class Realm<H extends Hierarchy> {
   store: RootStore;
   deallocateTX: TransactionToken<(claim: ValidKey<Vassal<H>>) => void>;
-  claimTX: TransactionToken<<V extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V, H>>(newProvenance: A, claim: ValidKey<V>, exclusive?: `exclusive`) => void>;
+  claimTX: TransactionToken<<V$1 extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V$1, H>>(newProvenance: A, claim: ValidKey<V$1>, exclusive?: `exclusive`) => void>;
   /**
   * @param store - The store to which the realm will be attached
   */
@@ -701,7 +701,7 @@ declare class Realm<H extends Hierarchy> {
   * @returns
   * The subject's key, given status as a true {@link ValidKey}
   */
-  allocate<V extends Vassal<H>, A extends Above<V, H>>(provenance: A, key: V, attachmentStyle?: `all` | `any`): ValidKey<V>;
+  allocate<V$1 extends Vassal<H>, A extends Above<V$1, H>>(provenance: A, key: V$1, attachmentStyle?: `all` | `any`): ValidKey<V$1>;
   /**
   * Fuse two reagents into a compound
   * @param type - the name of the compound that is being fused
@@ -715,7 +715,7 @@ declare class Realm<H extends Hierarchy> {
   * Remove a subject from the realm
   * @param claim - The subject to be deallocated
   */
-  deallocate<V extends Vassal<H>>(claim: ValidKey<V>): void;
+  deallocate<V$1 extends Vassal<H>>(claim: ValidKey<V$1>): void;
   /**
   * Transfer a subject of the realm from one owner to another
   * @param newProvenance - A key for an owner {@link Above} the new subject in the realm's {@link Hierarchy}
@@ -724,7 +724,7 @@ declare class Realm<H extends Hierarchy> {
   * @returns
   * The subject's key, given status as a true {@link ValidKey}
   */
-  claim<V extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V, H>>(newProvenance: A, claim: ValidKey<V>, exclusive?: `exclusive`): void;
+  claim<V$1 extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V$1, H>>(newProvenance: A, claim: ValidKey<V$1>, exclusive?: `exclusive`): void;
 }
 declare class Anarchy {
   store: RootStore;
@@ -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$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 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 Scope = SingularTypedKey[];
 type MutualFealty = {
   above: Scope;
@@ -815,7 +815,7 @@ declare function resetState<K$1 extends Canonical>(token: WritableFamilyToken<an
 * @returns
 * The new value of the state.
 */
-type Setter<T$1> = (oldValue: T$1) => T$1;
+type Setter<T> = (oldValue: T) => T;
 /**
 * 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$1> = (oldValue: T$1) => T$1;
 * @overload Default
 * @default
 */
-declare function setState<T$1, TT extends T$1>(token: WritableToken<T$1, any, any>, value: Setter<TT> | TT): void;
+declare function setState<T, TT extends T>(token: WritableToken<T, 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$1, TT extends T$1>(token: WritableToken<T$1, any, an
 * @param value - The new value of the state.
 * @overload Streamlined
 */
-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;
+declare function setState<T, TT extends T, K$1 extends Canonical>(token: WritableFamilyToken<T, 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`>;
@@ -871,41 +871,41 @@ declare function transaction<F$1 extends Fn$1>(options: TransactionOptions<F$1>)
 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$1, E = never> = {
+type WritablePureSelectorOptions<T, E = never> = {
   /** The unique identifier of the selector */
   key: string;
   /** For each instantiated selector, a function that computes its value */
-  get: Read<() => T$1>;
+  get: Read<() => T>;
   /** For each instantiated selector, a function that sets its value */
-  set: Write<(newValue: T$1) => void>;
+  set: Write<(newValue: T) => void>;
   /** The classes of errors that might be thrown when deriving the atom's default value */
   catch?: readonly Ctor<E>[];
 };
-type ReadonlyPureSelectorOptions<T$1, E = never> = {
+type ReadonlyPureSelectorOptions<T, E = never> = {
   /** The unique identifier of the selector */
   key: string;
   /** For each instantiated selector, a function that computes its value */
-  get: Read<() => T$1>;
+  get: Read<() => T>;
   /** The classes of errors that might be thrown when deriving the atom's default value */
   catch?: readonly Ctor<E>[];
 };
-type ReadonlyHeldSelectorOptions<T$1 extends object> = {
+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$1;
+  const: T;
   /** For each instantiated selector, a function that computes its value */
-  get: Read<(permanent: T$1) => void>;
+  get: Read<(permanent: T) => void>;
 };
-type WritableHeldSelectorOptions<T$1 extends object> = {
+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$1;
+  const: T;
   /** For each instantiated selector, a function that computes its value */
-  get: Read<(permanent: T$1) => void>;
+  get: Read<(permanent: T) => void>;
   /** For each instantiated selector, a function that sets its value */
-  set: Write<(newValue: T$1) => void>;
+  set: Write<(newValue: T) => void>;
 };
 /**
 * Declare a selector. The value of a selector should depend
@@ -924,7 +924,7 @@ type WritableHeldSelectorOptions<T$1 extends object> = {
 * The token for your selector.
 * @overload WritableHeld
 */
-declare function selector<T$1 extends object>(options: WritableHeldSelectorOptions<T$1>): WritableHeldSelectorToken<T$1>;
+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,
@@ -940,7 +940,7 @@ declare function selector<T$1 extends object>(options: WritableHeldSelectorOptio
 * The token for your selector.
 * @overload ReadonlyHeld
 */
-declare function selector<T$1 extends object>(options: ReadonlyHeldSelectorOptions<T$1>): ReadonlyHeldSelectorToken<T$1>;
+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.
@@ -957,7 +957,7 @@ declare function selector<T$1 extends object>(options: ReadonlyHeldSelectorOptio
 * The token for your selector.
 * @overload WritablePure
 */
-declare function selector<T$1, E = never>(options: WritablePureSelectorOptions<T$1, E>): WritablePureSelectorToken<T$1, any, E>;
+declare function selector<T, E = never>(options: WritablePureSelectorOptions<T, E>): WritablePureSelectorToken<T, 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$1, E = never>(options: WritablePureSelectorOptions<T
 * The token for your selector.
 * @overload ReadonlyPure
 */
-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> = {
+declare function selector<T, E = never>(options: ReadonlyPureSelectorOptions<T, E>): ReadonlyPureSelectorToken<T, any, E>;
+type WritablePureSelectorFamilyOptions<T, 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$1) => Read<() => T$1>;
+  get: (key: K$1) => Read<() => T>;
   /** For each instantiated family member, a function that sets its value */
-  set: (key: K$1) => Write<(newValue: T$1) => void>;
+  set: (key: K$1) => Write<(newValue: T) => void>;
   /** The classes of errors that might be thrown when deriving the atom's default value */
   catch?: readonly Ctor<E>[];
 };
-type ReadonlyPureSelectorFamilyOptions<T$1, K$1 extends Canonical, E = never> = {
+type ReadonlyPureSelectorFamilyOptions<T, 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$1) => Read<() => T$1>;
+  get: (key: K$1) => Read<() => T>;
   /** The classes of errors that might be thrown when deriving the atom's default value */
   catch?: readonly Ctor<E>[];
 };
-type WritableHeldSelectorFamilyOptions<T$1 extends object, K$1 extends Canonical> = {
+type WritableHeldSelectorFamilyOptions<T 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$1) => T$1;
+  const: (key: K$1) => T;
   /** For each instantiated family member, a function that computes its value */
-  get: (key: K$1) => Read<(permanent: T$1) => void>;
+  get: (key: K$1) => Read<(permanent: T) => void>;
   /** For each instantiated family member, a function that sets its value */
-  set: (key: K$1) => Write<(newValue: T$1) => void>;
+  set: (key: K$1) => Write<(newValue: T) => void>;
 };
-type ReadonlyHeldSelectorFamilyOptions<T$1 extends object, K$1 extends Canonical> = {
+type ReadonlyHeldSelectorFamilyOptions<T 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$1) => T$1;
+  const: (key: K$1) => T;
   /** For each instantiated family member, a function that computes its value */
-  get: (key: K$1) => Read<(permanent: T$1) => void>;
+  get: (key: K$1) => Read<(permanent: T) => void>;
 };
 /**
 * Create a family of selectors, allowing for the dynamic creation and disposal of selectors.
@@ -1027,7 +1027,7 @@ type ReadonlyHeldSelectorFamilyOptions<T$1 extends object, K$1 extends Canonical
 * A reference to the selector family created: a {@link WritableHeldSelectorFamilyToken}
 * @overload WritableHeld
 */
-declare function selectorFamily<T$1 extends object, K$1 extends Canonical>(options: WritableHeldSelectorFamilyOptions<T$1, K$1>): WritableHeldSelectorFamilyToken<T$1, K$1>;
+declare function selectorFamily<T extends object, K$1 extends Canonical>(options: WritableHeldSelectorFamilyOptions<T, K$1>): WritableHeldSelectorFamilyToken<T, K$1>;
 /**
 * Create a family of selectors, allowing for the dynamic creation and disposal of selectors.
 *
@@ -1044,7 +1044,7 @@ declare function selectorFamily<T$1 extends object, K$1 extends Canonical>(optio
 * A reference to the selector family created: a {@link ReadonlyHeldSelectorFamilyToken}
 * @overload ReadonlyHeld
 */
-declare function selectorFamily<T$1 extends object, K$1 extends Canonical>(options: ReadonlyHeldSelectorFamilyOptions<T$1, K$1>): ReadonlyHeldSelectorFamilyToken<T$1, K$1>;
+declare function selectorFamily<T extends object, K$1 extends Canonical>(options: ReadonlyHeldSelectorFamilyOptions<T, K$1>): ReadonlyHeldSelectorFamilyToken<T, K$1>;
 /**
 * Create a family of selectors, allowing for the dynamic creation and disposal of selectors.
 *
@@ -1062,7 +1062,7 @@ declare function selectorFamily<T$1 extends object, K$1 extends Canonical>(optio
 * A reference to the selector family created: a {@link TransientWritableSelectorFamilyToken}
 * @overload WritablePure
 */
-declare function selectorFamily<T$1, K$1 extends Canonical, E = never>(options: WritablePureSelectorFamilyOptions<T$1, K$1, E>): WritablePureSelectorFamilyToken<T$1, K$1, E>;
+declare function selectorFamily<T, K$1 extends Canonical, E = never>(options: WritablePureSelectorFamilyOptions<T, K$1, E>): WritablePureSelectorFamilyToken<T, 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$1, K$1 extends Canonical, E = never>(options:
 * A reference to the selector family created: a {@link ReadonlyPureSelectorFamilyToken}
 * @overload ReadonlyPure
 */
-declare function selectorFamily<T$1, K$1 extends Canonical, E = never>(options: ReadonlyPureSelectorFamilyOptions<T$1, K$1, E>): ReadonlyPureSelectorFamilyToken<T$1, K$1, E>;
+declare function selectorFamily<T, K$1 extends Canonical, E = never>(options: ReadonlyPureSelectorFamilyOptions<T, K$1, E>): ReadonlyPureSelectorFamilyToken<T, K$1, E>;
 //#endregion
 //#region src/main/silo.d.ts
 declare class Silo {
@@ -1105,7 +1105,7 @@ declare class Silo {
 }
 //#endregion
 //#region src/main/subscribe.d.ts
-type UpdateHandler<T$1> = (update: StateUpdate<T$1>) => void;
+type UpdateHandler<T> = (update: StateUpdate<T>) => void;
 type TransactionUpdateHandler<F$1 extends Fn$1> = (data: TransactionOutcomeEvent<TransactionToken<F$1>>) => void;
 /**
 * Subscribe to a state in the implicit store
@@ -1115,7 +1115,7 @@ type TransactionUpdateHandler<F$1 extends Fn$1> = (data: TransactionOutcomeEvent
 * @returns A function that can be called to unsubscribe from the state
 * @overload State
 */
-declare function subscribe<T$1>(token: ReadableToken<T$1>, handleUpdate: UpdateHandler<T$1>, key?: string): () => void;
+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
@@ -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$1> = Promise<T$1> | T$1;
-type ViewOf<T$1> = T$1 extends {
+type Loadable<T> = Promise<T> | T;
+type ViewOf<T> = T extends {
   READONLY_VIEW: infer View;
-} ? View : T$1;
+} ? View : T;
 //#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