atom.io 0.43.1 → 0.43.2

package/dist/internal/index.d.ts

@@ -7,82 +7,82 @@ import { UList } from "atom.io/transceivers/u-list";
 declare function arbitrary(random?: () => number): string;
 //#endregion
 //#region src/internal/store/circular-buffer.d.ts
-declare class CircularBuffer<T> {
-  protected _buffer: T[];
+declare class CircularBuffer<T$1> {
+  protected _buffer: T$1[];
   protected _index: number;
-  constructor(array: T[]);
+  constructor(array: T$1[]);
   constructor(length: number);
-  get buffer(): ReadonlyArray<T | undefined>;
+  get buffer(): ReadonlyArray<T$1 | undefined>;
   get index(): number;
-  add(item: T): void;
-  copy(): CircularBuffer<T>;
+  add(item: T$1): void;
+  copy(): CircularBuffer<T$1>;
 }
 //#endregion
 //#region src/internal/mutable/transceiver.d.ts
 interface Transceiver<V extends {
-  subscribe: (key: string, fn: (update: S) => void) => () => void;
-}, S extends Json.Serializable, J extends Json.Serializable> {
+  subscribe: (key: string, fn: (update: S$1) => void) => () => void;
+}, S$1 extends Json.Serializable, J$1 extends Json.Serializable> {
   READONLY_VIEW: V;
-  do: (update: S) => number | `OUT_OF_RANGE` | null;
-  undo: (update: S) => void;
-  subscribe: (key: string, fn: (update: S) => void) => () => void;
-  toJSON: () => J;
+  do: (update: S$1) => number | `OUT_OF_RANGE` | null;
+  undo: (update: S$1) => void;
+  subscribe: (key: string, fn: (update: S$1) => void) => () => void;
+  toJSON: () => J$1;
 }
-type TransceiverConstructor<J extends Json.Serializable, T extends Transceiver<any, any, J>> = (new () => T) & {
-  fromJSON: (json: J) => T;
+type TransceiverConstructor<J$1 extends Json.Serializable, T$1 extends Transceiver<any, any, J$1>> = (new () => T$1) & {
+  fromJSON: (json: J$1) => T$1;
 };
 declare function isTransceiver(value: unknown): value is Transceiver<any, Json.Serializable, Json.Serializable>;
 type TransceiverMode = `playback` | `record` | `transaction`;
-type SignalFrom<T extends Transceiver<any, any, any>> = T extends Transceiver<any, infer S, any> ? S : never;
-type AsJSON<T extends Transceiver<any, any, any>> = T extends Transceiver<any, any, infer J> ? J : never;
-type ConstructorOf<T extends Transceiver<any, any, any>> = TransceiverConstructor<AsJSON<T>, T>;
+type SignalFrom<T$1 extends Transceiver<any, any, any>> = T$1 extends Transceiver<any, infer S, any> ? S : never;
+type AsJSON<T$1 extends Transceiver<any, any, any>> = T$1 extends Transceiver<any, any, infer J> ? J : never;
+type ConstructorOf<T$1 extends Transceiver<any, any, any>> = TransceiverConstructor<AsJSON<T$1>, T$1>;
 //#endregion
 //#region src/internal/mutable/create-mutable-atom.d.ts
-declare function createMutableAtom<T extends Transceiver<any, any, any>>(store: Store, options: MutableAtomOptions<T>, family: FamilyMetadata | undefined): MutableAtomToken<T>;
+declare function createMutableAtom<T$1 extends Transceiver<any, any, any>>(store: Store, options: MutableAtomOptions<T$1>, family: FamilyMetadata | undefined): MutableAtomToken<T$1>;
 //#endregion
 //#region src/internal/overlays/map-overlay.d.ts
-declare class MapOverlay<K, V> extends Map<K, V> {
-  deleted: Set<K>;
-  changed: Set<K>;
-  protected readonly source: Map<K, V>;
-  constructor(source: Map<K, V>);
-  get(key: K): V | undefined;
-  set(key: K, value: V): this;
-  hasOwn(key: K): boolean;
-  has(key: K): boolean;
-  delete(key: K): boolean;
+declare class MapOverlay<K$1, V> extends Map<K$1, V> {
+  deleted: Set<K$1>;
+  changed: Set<K$1>;
+  protected readonly source: Map<K$1, V>;
+  constructor(source: Map<K$1, V>);
+  get(key: K$1): V | undefined;
+  set(key: K$1, value: V): this;
+  hasOwn(key: K$1): boolean;
+  has(key: K$1): boolean;
+  delete(key: K$1): boolean;
   clear(): void;
-  [Symbol.iterator](): MapIterator<[K, V]>;
-  entries(): MapIterator<[K, V]>;
-  keys(): MapIterator<K>;
+  [Symbol.iterator](): MapIterator<[K$1, V]>;
+  entries(): MapIterator<[K$1, V]>;
+  keys(): MapIterator<K$1>;
   values(): MapIterator<V>;
-  forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void): void;
+  forEach(callbackfn: (value: V, key: K$1, map: Map<K$1, V>) => void): void;
   get size(): number;
 }
 //#endregion
 //#region src/internal/overlays/relations-overlay.d.ts
-declare class RelationsOverlay<K, V extends Set<any>> extends Map<K, V> {
-  deleted: Set<K>;
-  protected readonly source: Map<K, V>;
-  constructor(source: Map<K, V>);
-  get(key: K): V | undefined;
-  set(key: K, value: V): this;
-  has(key: K): boolean;
-  delete(key: K): boolean;
+declare class RelationsOverlay<K$1, V extends Set<any>> extends Map<K$1, V> {
+  deleted: Set<K$1>;
+  protected readonly source: Map<K$1, V>;
+  constructor(source: Map<K$1, V>);
+  get(key: K$1): V | undefined;
+  set(key: K$1, value: V): this;
+  has(key: K$1): boolean;
+  delete(key: K$1): boolean;
 }
 //#endregion
 //#region src/internal/overlays/set-overlay.d.ts
-declare class SetOverlay<T> extends Set<T> {
-  deleted: Set<T>;
-  source: Set<T>;
-  constructor(source: Set<T>);
-  add(value: T): this;
-  hasOwn(member: T): boolean;
-  has(key: T): boolean;
-  delete(key: T): boolean;
+declare class SetOverlay<T$1> extends Set<T$1> {
+  deleted: Set<T$1>;
+  source: Set<T$1>;
+  constructor(source: Set<T$1>);
+  add(value: T$1): this;
+  hasOwn(member: T$1): boolean;
+  has(key: T$1): boolean;
+  delete(key: T$1): boolean;
   clear(): void;
-  [Symbol.iterator](): SetIterator<T>;
-  iterateOwn(): SetIterator<T>;
+  [Symbol.iterator](): SetIterator<T$1>;
+  iterateOwn(): SetIterator<T$1>;
   get size(): number;
 }
 //#endregion
@@ -178,9 +178,9 @@ type JunctionOverlay<AName extends string, A extends string, BName extends strin
 //#region src/internal/transaction/transaction-meta-progress.d.ts
 declare const TRANSACTION_PHASES: readonly ["idle", "building", "applying"];
 type TransactionPhase = (typeof TRANSACTION_PHASES)[number];
-type TransactionProgress<F extends Fn> = {
+type TransactionProgress<F$1 extends Fn> = {
   phase: `applying` | `building`;
-  update: TransactionOutcomeEvent<TransactionToken<F>>;
+  update: TransactionOutcomeEvent<TransactionToken<F$1>>;
   toolkit: ActorToolkit;
 };
 type TransactionEpoch = {
@@ -207,10 +207,10 @@ declare function isChildStore(store: Store): store is ChildStore;
 declare const abortTransaction: (target: ChildStore) => void;
 //#endregion
 //#region src/internal/transaction/act-upon-store.d.ts
-declare function actUponStore<F extends Fn>(store: Store, token: TransactionToken<F>, id: string): (...parameters: Parameters<F>) => ReturnType<F>;
+declare function actUponStore<F$1 extends Fn>(store: Store, token: TransactionToken<F$1>, id: string): (...parameters: Parameters<F$1>) => ReturnType<F$1>;
 //#endregion
 //#region src/internal/transaction/apply-transaction.d.ts
-declare function applyTransaction<F extends Fn>(store: ChildStore, output: ReturnType<F>): void;
+declare function applyTransaction<F$1 extends Fn>(store: ChildStore, output: ReturnType<F$1>): void;
 //#endregion
 //#region src/internal/transaction/assign-transaction-to-continuity.d.ts
 declare function assignTransactionToContinuity(store: RootStore, continuityKey: string, transactionKey: string): void;
@@ -219,28 +219,28 @@ declare function assignTransactionToContinuity(store: RootStore, continuityKey:
 declare const buildTransaction: (store: RootStore, token: TransactionToken<any>, params: any[], id: string) => ChildStore;
 //#endregion
 //#region src/internal/subject.d.ts
-declare class Subject<T> {
-  Subscriber: (value: T) => void;
+declare class Subject<T$1> {
+  Subscriber: (value: T$1) => void;
   subscribers: Map<string, this[`Subscriber`]>;
   subscribe(key: string, subscriber: this[`Subscriber`]): () => void;
   private unsubscribe;
-  next(value: T): void;
+  next(value: T$1): void;
 }
-declare class StatefulSubject<T> extends Subject<T> {
-  state: T;
-  constructor(initialState: T);
-  next(value: T): void;
+declare class StatefulSubject<T$1> extends Subject<T$1> {
+  state: T$1;
+  constructor(initialState: T$1);
+  next(value: T$1): void;
 }
 //#endregion
 //#region src/internal/transaction/create-transaction.d.ts
-type Transaction<F extends Fn> = {
+type Transaction<F$1 extends Fn> = {
   key: string;
   type: `transaction`;
   install: (store: RootStore) => void;
-  subject: Subject<TransactionOutcomeEvent<TransactionToken<F>>>;
-  run: (parameters: Parameters<F>, id?: string) => ReturnType<F>;
+  subject: Subject<TransactionOutcomeEvent<TransactionToken<F$1>>>;
+  run: (parameters: Parameters<F$1>, id?: string) => ReturnType<F$1>;
 };
-declare function createTransaction<F extends Fn>(store: RootStore, options: TransactionOptions<F>): TransactionToken<F>;
+declare function createTransaction<F$1 extends Fn>(store: RootStore, options: TransactionOptions<F$1>): TransactionToken<F$1>;
 //#endregion
 //#region src/internal/transaction/get-epoch-number.d.ts
 declare function getContinuityKey(store: RootStore, transactionKey: string): string | undefined;
@@ -252,22 +252,22 @@ declare function setEpochNumberOfContinuity(store: RootStore, continuityKey: str
 declare function setEpochNumberOfAction(store: RootStore, transactionKey: string, newEpoch: number): void;
 //#endregion
 //#region src/internal/mutable/create-mutable-atom-family.d.ts
-declare function createMutableAtomFamily<T extends Transceiver<any, any, any>, K extends Canonical>(store: RootStore, options: MutableAtomFamilyOptions<T, K>, internalRoles?: string[]): MutableAtomFamilyToken<T, K>;
+declare function createMutableAtomFamily<T$1 extends Transceiver<any, any, any>, K$1 extends Canonical>(store: RootStore, options: MutableAtomFamilyOptions<T$1, K$1>, internalRoles?: string[]): MutableAtomFamilyToken<T$1, K$1>;
 //#endregion
 //#region src/internal/timeline/create-timeline.d.ts
-type Timeline<ManagedAtom extends TimelineManageable> = {
+type Timeline<ManagedAtom$1 extends TimelineManageable> = {
   type: `timeline`;
   key: string;
   at: number;
   timeTraveling: `into_future` | `into_past` | null;
-  history: TimelineEvent<ManagedAtom>[];
+  history: TimelineEvent<ManagedAtom$1>[];
   selectorTime: number | null;
   transactionKey: string | null;
   install: (store: RootStore) => void;
-  subject: Subject<TimelineEvent<ManagedAtom> | `redo` | `undo`>;
+  subject: Subject<TimelineEvent<ManagedAtom$1> | `redo` | `undo`>;
   subscriptions: Map<string, () => void>;
 };
-declare function createTimeline<ManagedAtom extends TimelineManageable>(store: RootStore, options: TimelineOptions<ManagedAtom>, data?: Timeline<ManagedAtom>): TimelineToken<ManagedAtom>;
+declare function createTimeline<ManagedAtom$1 extends TimelineManageable>(store: RootStore, options: TimelineOptions<ManagedAtom$1>, data?: Timeline<ManagedAtom$1>): TimelineToken<ManagedAtom$1>;
 //#endregion
 //#region src/internal/timeline/time-travel.d.ts
 declare const timeTravel: (store: Store, action: `redo` | `undo`, token: TimelineToken<any>) => void;
@@ -279,107 +279,107 @@ type AtomIOState = {
   install: (store: RootStore) => void;
   subject: Subject<StateUpdate<any>>;
 };
-type RegularAtom<T, E> = Flat<AtomIOState & {
+type RegularAtom<T$1, E$1> = Flat<AtomIOState & {
   type: `atom`;
-  default: T | (() => T);
+  default: T$1 | (() => T$1);
   cleanup?: () => void;
   internalRoles?: InternalRole[];
-  catch?: readonly Ctor<E>[];
-  __T?: T;
-  __E?: E;
+  catch?: readonly Ctor<E$1>[];
+  __T?: T$1;
+  __E?: E$1;
 }>;
-type MutableAtom<T extends Transceiver<any, any, any>> = Flat<AtomIOState & {
+type MutableAtom<T$1 extends Transceiver<any, any, any>> = Flat<AtomIOState & {
   type: `mutable_atom`;
-  class: ConstructorOf<T>;
+  class: ConstructorOf<T$1>;
   cleanup?: () => void;
-  __T?: T;
+  __T?: T$1;
 }>;
-type Atom<T, E> = RegularAtom<T, E> | (T extends Transceiver<any, any, any> ? MutableAtom<T> : never);
-type WritableHeldSelector<T> = Flat<AtomIOState & {
+type Atom<T$1, E$1> = RegularAtom<T$1, E$1> | (T$1 extends Transceiver<any, any, any> ? MutableAtom<T$1> : never);
+type WritableHeldSelector<T$1> = Flat<AtomIOState & {
   type: `writable_held_selector`;
-  const: T;
-  getFrom: (target: Store) => T;
-  setSelf: (newValue: T) => void;
-  __T?: T;
+  const: T$1;
+  getFrom: (target: Store) => T$1;
+  setSelf: (newValue: T$1) => void;
+  __T?: T$1;
 }>;
-type ReadonlyHeldSelector<T> = Flat<AtomIOState & {
+type ReadonlyHeldSelector<T$1> = Flat<AtomIOState & {
   type: `readonly_held_selector`;
-  const: T;
-  getFrom: (target: Store) => T;
-  __T?: T;
+  const: T$1;
+  getFrom: (target: Store) => T$1;
+  __T?: T$1;
 }>;
-type WritablePureSelector<T, E> = Flat<AtomIOState & {
+type WritablePureSelector<T$1, E$1> = Flat<AtomIOState & {
   type: `writable_pure_selector`;
-  getFrom: (target: Store) => E | T;
-  setSelf: (newValue: T) => void;
-  catch?: readonly Ctor<E>[];
-  __T?: T;
-  __E?: E;
+  getFrom: (target: Store) => E$1 | T$1;
+  setSelf: (newValue: T$1) => void;
+  catch?: readonly Ctor<E$1>[];
+  __T?: T$1;
+  __E?: E$1;
 }>;
-type ReadonlyPureSelector<T, E> = Flat<AtomIOState & {
+type ReadonlyPureSelector<T$1, E$1> = Flat<AtomIOState & {
   type: `readonly_pure_selector`;
-  getFrom: (target: Store) => E | T;
-  catch?: readonly Ctor<E>[];
-  __T?: T;
-  __E?: E;
+  getFrom: (target: Store) => E$1 | T$1;
+  catch?: readonly Ctor<E$1>[];
+  __T?: T$1;
+  __E?: E$1;
 }>;
-type ReadonlySelector<T, E> = ReadonlyHeldSelector<T> | ReadonlyPureSelector<T, E>;
-type WritableSelector<T, E> = WritableHeldSelector<T> | WritablePureSelector<T, E>;
-type HeldSelector<T> = ReadonlyHeldSelector<T> | WritableHeldSelector<T>;
-type PureSelector<T, E> = ReadonlyPureSelector<T, E> | WritablePureSelector<T, E>;
-type Selector<T, E> = ReadonlyHeldSelector<T> | ReadonlyPureSelector<T, E> | WritableHeldSelector<T> | WritablePureSelector<T, E>;
-type WritableState<T, E> = Atom<T, E> | WritableSelector<T, E>;
-type ReadableState<T, E> = Atom<T, E> | Selector<T, E>;
-type RegularAtomFamily<T, K extends Canonical, E = never> = Flat<RegularAtomFamilyToken<T, K, E> & {
-  create: <Key extends K>(key: Key) => RegularAtomToken<T, Key, E>;
-  default: T | ((key: K) => T);
+type ReadonlySelector<T$1, E$1> = ReadonlyHeldSelector<T$1> | ReadonlyPureSelector<T$1, E$1>;
+type WritableSelector<T$1, E$1> = WritableHeldSelector<T$1> | WritablePureSelector<T$1, E$1>;
+type HeldSelector<T$1> = ReadonlyHeldSelector<T$1> | WritableHeldSelector<T$1>;
+type PureSelector<T$1, E$1> = ReadonlyPureSelector<T$1, E$1> | WritablePureSelector<T$1, E$1>;
+type Selector<T$1, E$1> = ReadonlyHeldSelector<T$1> | ReadonlyPureSelector<T$1, E$1> | WritableHeldSelector<T$1> | WritablePureSelector<T$1, E$1>;
+type WritableState<T$1, E$1> = Atom<T$1, E$1> | WritableSelector<T$1, E$1>;
+type ReadableState<T$1, E$1> = Atom<T$1, E$1> | Selector<T$1, E$1>;
+type RegularAtomFamily<T$1, K$1 extends Canonical, E$1 = never> = Flat<RegularAtomFamilyToken<T$1, K$1, E$1> & {
+  create: <Key extends K$1>(key: Key) => RegularAtomToken<T$1, Key, E$1>;
+  default: T$1 | ((key: K$1) => T$1);
   install: (store: RootStore) => void;
   internalRoles: string[] | undefined;
-  subject: Subject<StateLifecycleEvent<RegularAtomToken<T, K, E>>>;
+  subject: Subject<StateLifecycleEvent<RegularAtomToken<T$1, K$1, E$1>>>;
 }>;
-type MutableAtomFamily<T extends Transceiver<any, any, any>, K extends Canonical> = Flat<MutableAtomFamilyToken<T, K> & {
-  create: <Key extends K>(key: Key) => MutableAtomToken<T, Key>;
-  class: ConstructorOf<T>;
+type MutableAtomFamily<T$1 extends Transceiver<any, any, any>, K$1 extends Canonical> = Flat<MutableAtomFamilyToken<T$1, K$1> & {
+  create: <Key extends K$1>(key: Key) => MutableAtomToken<T$1, Key>;
+  class: ConstructorOf<T$1>;
   install: (store: RootStore) => void;
   internalRoles: string[] | undefined;
-  subject: Subject<StateLifecycleEvent<MutableAtomToken<T>>>;
+  subject: Subject<StateLifecycleEvent<MutableAtomToken<T$1>>>;
 }>;
-type AtomFamily<T, K extends Canonical, E> = MutableAtomFamily<T extends Transceiver<any, any, any> ? T : never, K> | RegularAtomFamily<T, K, E>;
-type WritablePureSelectorFamily<T, K extends Canonical, E> = Flat<WritablePureSelectorFamilyToken<T, K, E> & {
-  create: <Key extends K>(key: Key) => WritablePureSelectorToken<T, Key, E>;
-  default: (key: K) => T;
+type AtomFamily<T$1, K$1 extends Canonical, E$1> = MutableAtomFamily<T$1 extends Transceiver<any, any, any> ? T$1 : never, K$1> | RegularAtomFamily<T$1, K$1, E$1>;
+type WritablePureSelectorFamily<T$1, K$1 extends Canonical, E$1> = Flat<WritablePureSelectorFamilyToken<T$1, K$1, E$1> & {
+  create: <Key extends K$1>(key: Key) => WritablePureSelectorToken<T$1, Key, E$1>;
+  default: (key: K$1) => T$1;
   install: (store: RootStore) => void;
   internalRoles: string[] | undefined;
-  subject: Subject<StateLifecycleEvent<WritablePureSelectorToken<T, K, E>>>;
+  subject: Subject<StateLifecycleEvent<WritablePureSelectorToken<T$1, K$1, E$1>>>;
 }>;
-type WritableHeldSelectorFamily<T, K extends Canonical> = Flat<WritableHeldSelectorFamilyToken<T, K> & {
-  create: <Key extends K>(key: Key) => WritableHeldSelectorToken<T, Key>;
-  default: (key: K) => T;
+type WritableHeldSelectorFamily<T$1, K$1 extends Canonical> = Flat<WritableHeldSelectorFamilyToken<T$1, K$1> & {
+  create: <Key extends K$1>(key: Key) => WritableHeldSelectorToken<T$1, Key>;
+  default: (key: K$1) => T$1;
   install: (store: RootStore) => void;
   internalRoles: string[] | undefined;
-  subject: Subject<StateLifecycleEvent<WritableHeldSelectorToken<T, K>>>;
+  subject: Subject<StateLifecycleEvent<WritableHeldSelectorToken<T$1, K$1>>>;
 }>;
-type ReadonlyPureSelectorFamily<T, K extends Canonical, E> = Flat<ReadonlyPureSelectorFamilyToken<T, K, E> & {
-  create: <Key extends K>(key: Key) => ReadonlyPureSelectorToken<T, Key, E>;
-  default: (key: K) => T;
+type ReadonlyPureSelectorFamily<T$1, K$1 extends Canonical, E$1> = Flat<ReadonlyPureSelectorFamilyToken<T$1, K$1, E$1> & {
+  create: <Key extends K$1>(key: Key) => ReadonlyPureSelectorToken<T$1, Key, E$1>;
+  default: (key: K$1) => T$1;
   install: (store: RootStore) => void;
   internalRoles: string[] | undefined;
-  subject: Subject<StateLifecycleEvent<ReadonlyPureSelectorToken<T, K, E>>>;
+  subject: Subject<StateLifecycleEvent<ReadonlyPureSelectorToken<T$1, K$1, E$1>>>;
 }>;
-type ReadonlyHeldSelectorFamily<T, K extends Canonical> = Flat<ReadonlyHeldSelectorFamilyToken<T, K> & {
-  create: <Key extends K>(key: Key) => ReadonlyHeldSelectorToken<T, Key>;
-  default: (key: K) => T;
+type ReadonlyHeldSelectorFamily<T$1, K$1 extends Canonical> = Flat<ReadonlyHeldSelectorFamilyToken<T$1, K$1> & {
+  create: <Key extends K$1>(key: Key) => ReadonlyHeldSelectorToken<T$1, Key>;
+  default: (key: K$1) => T$1;
   install: (store: RootStore) => void;
   internalRoles: string[] | undefined;
-  subject: Subject<StateLifecycleEvent<ReadonlyHeldSelectorToken<T>>>;
+  subject: Subject<StateLifecycleEvent<ReadonlyHeldSelectorToken<T$1>>>;
 }>;
-type PureSelectorFamily<T, K extends Canonical, E> = ReadonlyPureSelectorFamily<T, K, E> | WritablePureSelectorFamily<T, K, E>;
-type HeldSelectorFamily<T, K extends Canonical> = ReadonlyHeldSelectorFamily<T, K> | WritableHeldSelectorFamily<T, K>;
-type ReadonlySelectorFamily<T, K extends Canonical, E> = ReadonlyHeldSelectorFamily<T, K> | ReadonlyPureSelectorFamily<T, K, E>;
-type WritableSelectorFamily<T, K extends Canonical, E> = WritableHeldSelectorFamily<T, K> | WritablePureSelectorFamily<T, K, E>;
-type SelectorFamily<T, K extends Canonical, E> = HeldSelectorFamily<T, K> | PureSelectorFamily<T, K, E>;
-type WritableFamily<T, K extends Canonical, E> = AtomFamily<T, K, E> | WritableSelectorFamily<T, K, E>;
-type ReadableFamily<T, K extends Canonical, E> = AtomFamily<T, K, E> | SelectorFamily<T, K, E>;
+type PureSelectorFamily<T$1, K$1 extends Canonical, E$1> = ReadonlyPureSelectorFamily<T$1, K$1, E$1> | WritablePureSelectorFamily<T$1, K$1, E$1>;
+type HeldSelectorFamily<T$1, K$1 extends Canonical> = ReadonlyHeldSelectorFamily<T$1, K$1> | WritableHeldSelectorFamily<T$1, K$1>;
+type ReadonlySelectorFamily<T$1, K$1 extends Canonical, E$1> = ReadonlyHeldSelectorFamily<T$1, K$1> | ReadonlyPureSelectorFamily<T$1, K$1, E$1>;
+type WritableSelectorFamily<T$1, K$1 extends Canonical, E$1> = WritableHeldSelectorFamily<T$1, K$1> | WritablePureSelectorFamily<T$1, K$1, E$1>;
+type SelectorFamily<T$1, K$1 extends Canonical, E$1> = HeldSelectorFamily<T$1, K$1> | PureSelectorFamily<T$1, K$1, E$1>;
+type WritableFamily<T$1, K$1 extends Canonical, E$1> = AtomFamily<T$1, K$1, E$1> | WritableSelectorFamily<T$1, K$1, E$1>;
+type ReadableFamily<T$1, K$1 extends Canonical, E$1> = AtomFamily<T$1, K$1, E$1> | SelectorFamily<T$1, K$1, E$1>;
 type AtomIOInternalResource = ReadableFamily<any, any, any> | ReadableState<any, any> | Timeline<any> | Transaction<any>;
 //#endregion
 //#region src/internal/mutable/get-json-family.d.ts
@@ -400,44 +400,44 @@ declare const getUpdateToken: <T extends Transceiver<any, any, any>>(mutableAtom
 * subscribe to the transceiver's inner value. When the inner value changes,
 * the tracker will update its own state to reflect the change.
 */
-declare class Tracker<T extends Transceiver<any, any, any>> {
+declare class Tracker<T$1 extends Transceiver<any, any, any>> {
   private initializeSignalAtom;
   private unsubscribeFromInnerValue;
   private unsubscribeFromState;
   private captureSignalsFromCore;
   private supplySignalsToCore;
-  mutableAtomToken: MutableAtomToken<T>;
-  latestSignalToken: RegularAtomToken<SignalFrom<T> | null>;
+  mutableAtomToken: MutableAtomToken<T$1>;
+  latestSignalToken: RegularAtomToken<SignalFrom<T$1> | null>;
   [Symbol.dispose]: () => void;
-  constructor(mutableAtomToken: MutableAtomToken<T>, store: Store);
+  constructor(mutableAtomToken: MutableAtomToken<T$1>, store: Store);
 }
 //#endregion
 //#region src/internal/mutable/tracker-family.d.ts
-declare class FamilyTracker<T extends Transceiver<any, any, any>, K extends Canonical> {
+declare class FamilyTracker<T$1 extends Transceiver<any, any, any>, K$1 extends Canonical> {
   private trackers;
-  readonly latestSignalAtoms: RegularAtomFamily<SignalFrom<T> | null, K>;
-  readonly mutableAtoms: MutableAtomFamily<T, K>;
-  constructor(mutableAtoms: MutableAtomFamily<T, K>, store: RootStore);
+  readonly latestSignalAtoms: RegularAtomFamily<SignalFrom<T$1> | null, K$1>;
+  readonly mutableAtoms: MutableAtomFamily<T$1, K$1>;
+  constructor(mutableAtoms: MutableAtomFamily<T$1, K$1>, store: RootStore);
 }
 //#endregion
 //#region src/internal/store/deposit.d.ts
-declare function deposit<T, E>(state: RegularAtom<T, E>): RegularAtomToken<T, Canonical, E>;
-declare function deposit<T extends Transceiver<any, any, any>>(state: MutableAtom<T>): MutableAtomToken<T>;
-declare function deposit<T, E>(state: Atom<T, E>): AtomToken<T, Canonical, E>;
-declare function deposit<T, E>(state: WritablePureSelector<T, E>): WritablePureSelectorToken<T, any, E>;
-declare function deposit<T, E>(state: ReadonlyPureSelector<T, E>): ReadonlyPureSelectorToken<T, any, E>;
-declare function deposit<T, E>(state: Selector<T, E>): SelectorToken<T, any, E>;
-declare function deposit<T, E>(state: WritableState<T, E>): WritableToken<T, any, E>;
-declare function deposit<T, E>(state: ReadableState<T, E>): ReadableToken<T, any, E>;
-declare function deposit<T, K extends Canonical, E>(state: RegularAtomFamily<T, K, E>): RegularAtomFamilyToken<T, K, E>;
-declare function deposit<T extends Transceiver<any, any, any>, K extends Canonical>(state: MutableAtomFamily<T, K>): MutableAtomFamilyToken<T, K>;
-declare function deposit<T, E>(state: AtomFamily<T, any, E>): AtomFamilyToken<T, any, E>;
-declare function deposit<T, E>(state: WritablePureSelectorFamily<T, any, E>): WritablePureSelectorFamilyToken<T, any, E>;
-declare function deposit<T, E>(state: ReadonlyPureSelectorFamily<T, any, E>): ReadonlyPureSelectorFamilyToken<T, any, E>;
-declare function deposit<T, E>(state: SelectorFamily<T, any, E>): SelectorFamilyToken<T, any, E>;
-declare function deposit<T, E>(state: WritableFamily<T, any, E>): WritableFamilyToken<T, any, E>;
-declare function deposit<T, E>(state: ReadableFamily<T, any, E>): ReadableFamilyToken<T, any, E>;
-declare function deposit<T extends Fn>(state: Transaction<T>): TransactionToken<T>;
+declare function deposit<T$1, E$1>(state: RegularAtom<T$1, E$1>): RegularAtomToken<T$1, Canonical, E$1>;
+declare function deposit<T$1 extends Transceiver<any, any, any>>(state: MutableAtom<T$1>): MutableAtomToken<T$1>;
+declare function deposit<T$1, E$1>(state: Atom<T$1, E$1>): AtomToken<T$1, Canonical, E$1>;
+declare function deposit<T$1, E$1>(state: WritablePureSelector<T$1, E$1>): WritablePureSelectorToken<T$1, any, E$1>;
+declare function deposit<T$1, E$1>(state: ReadonlyPureSelector<T$1, E$1>): ReadonlyPureSelectorToken<T$1, any, E$1>;
+declare function deposit<T$1, E$1>(state: Selector<T$1, E$1>): SelectorToken<T$1, any, E$1>;
+declare function deposit<T$1, E$1>(state: WritableState<T$1, E$1>): WritableToken<T$1, any, E$1>;
+declare function deposit<T$1, E$1>(state: ReadableState<T$1, E$1>): ReadableToken<T$1, any, E$1>;
+declare function deposit<T$1, K$1 extends Canonical, E$1>(state: RegularAtomFamily<T$1, K$1, E$1>): RegularAtomFamilyToken<T$1, K$1, E$1>;
+declare function deposit<T$1 extends Transceiver<any, any, any>, K$1 extends Canonical>(state: MutableAtomFamily<T$1, K$1>): MutableAtomFamilyToken<T$1, K$1>;
+declare function deposit<T$1, E$1>(state: AtomFamily<T$1, any, E$1>): AtomFamilyToken<T$1, any, E$1>;
+declare function deposit<T$1, E$1>(state: WritablePureSelectorFamily<T$1, any, E$1>): WritablePureSelectorFamilyToken<T$1, any, E$1>;
+declare function deposit<T$1, E$1>(state: ReadonlyPureSelectorFamily<T$1, any, E$1>): ReadonlyPureSelectorFamilyToken<T$1, any, E$1>;
+declare function deposit<T$1, E$1>(state: SelectorFamily<T$1, any, E$1>): SelectorFamilyToken<T$1, any, E$1>;
+declare function deposit<T$1, E$1>(state: WritableFamily<T$1, any, E$1>): WritableFamilyToken<T$1, any, E$1>;
+declare function deposit<T$1, E$1>(state: ReadableFamily<T$1, any, E$1>): ReadableFamilyToken<T$1, any, E$1>;
+declare function deposit<T$1 extends Fn>(state: Transaction<T$1>): TransactionToken<T$1>;
 declare function deposit<M extends TimelineManageable>(state: Timeline<M>): TimelineToken<M>;
 declare function deposit(resource: AtomIOInternalResource): AtomIOToken;
 //#endregion
@@ -475,19 +475,19 @@ interface Lineage {
   parent: typeof this | null;
   child: typeof this | null;
 }
-declare function newest<T extends Lineage>(scion: T): Exclude<T[`child`], null> | T;
-declare function eldest<T extends Lineage>(scion: T): Exclude<T[`parent`], T[`child`] | null>;
+declare function newest<T$1 extends Lineage>(scion: T$1): Exclude<T$1[`child`], null> | T$1;
+declare function eldest<T$1 extends Lineage>(scion: T$1): Exclude<T$1[`parent`], T$1[`child`] | null>;
 //#endregion
 //#region src/internal/molecule.d.ts
-type Molecule<K extends Canonical> = {
-  readonly key: K;
-  readonly stringKey: stringified<K>;
+type Molecule<K$1 extends Canonical> = {
+  readonly key: K$1;
+  readonly stringKey: stringified<K$1>;
   readonly dependsOn: `all` | `any`;
   readonly subject: Subject<void>;
 };
-declare function makeRootMoleculeInStore<S extends string>(store: Store, key: S): S;
+declare function makeRootMoleculeInStore<S$1 extends string>(store: Store, key: S$1): S$1;
 declare function allocateIntoStore<H extends Hierarchy, V extends Vassal<H>, A extends Above<V, H>>(store: Store, provenance: A, key: V, dependsOn?: `all` | `any`): ValidKey<V>;
-declare function fuseWithinStore<H extends Hierarchy, C extends CompoundFrom<H>, T extends (C extends CompoundTypedKey<infer t, any, any> ? t : never), A extends (C extends CompoundTypedKey<any, infer a, any> ? a : never), B extends (C extends CompoundTypedKey<any, any, infer b> ? b : never)>(store: Store, type: T, sideA: SingularTypedKey<A>, sideB: SingularTypedKey<B>): ValidKey<CompoundTypedKey<T, A, B>>;
+declare function fuseWithinStore<H extends Hierarchy, C extends CompoundFrom<H>, T$1 extends (C extends CompoundTypedKey<infer t, any, any> ? t : never), A extends (C extends CompoundTypedKey<any, infer a, any> ? a : never), B extends (C extends CompoundTypedKey<any, any, infer b> ? b : never)>(store: Store, type: T$1, sideA: SingularTypedKey<A>, sideB: SingularTypedKey<B>): ValidKey<CompoundTypedKey<T$1, A, B>>;
 declare function createDeallocateTX<H extends Hierarchy, V extends Exclude<Vassal<H>, CompoundTypedKey>>(store: RootStore): TransactionToken<(claim: ValidKey<V>) => void>;
 declare function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(target: Store, claim: ValidKey<V>): void;
 declare function createClaimTX<H extends Hierarchy, V extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V, H>>(store: RootStore): TransactionToken<(newProvenance: A, claim: ValidKey<V>, exclusive?: `exclusive`) => void>;
@@ -578,38 +578,38 @@ declare const IMPLICIT: {
 declare const clearStore: (store: Store) => void;
 //#endregion
 //#region src/internal/store/withdraw.d.ts
-declare function withdraw<T, E>(store: Store, token: RegularAtomToken<T, any, E>): RegularAtom<T, E>;
-declare function withdraw<T extends Transceiver<any, any, any>>(store: Store, token: MutableAtomToken<T, any>): MutableAtom<T>;
-declare function withdraw<T, E>(store: Store, token: AtomToken<T, any, E>): Atom<T, E>;
-declare function withdraw<T>(store: Store, token: WritableHeldSelectorToken<T>): WritableHeldSelector<T>;
-declare function withdraw<T>(store: Store, token: ReadonlyHeldSelectorToken<T>): ReadonlyHeldSelector<T>;
-declare function withdraw<T, E>(store: Store, token: WritablePureSelectorToken<T, any, E>): WritablePureSelector<T, E>;
-declare function withdraw<T, E>(store: Store, token: ReadonlyPureSelectorToken<T, any, E>): ReadonlyPureSelector<T, E>;
-declare function withdraw<T, E>(store: Store, token: ReadonlySelectorToken<T, any, E>): ReadonlySelector<T, E>;
-declare function withdraw<T, E>(store: Store, token: WritableSelectorToken<T, any, E>): WritableSelector<T, E>;
-declare function withdraw<T>(store: Store, token: HeldSelectorToken<T>): HeldSelector<T>;
-declare function withdraw<T, E>(store: Store, token: PureSelectorToken<T, any, E>): PureSelector<T, E>;
-declare function withdraw<T, E>(store: Store, token: SelectorToken<T, any, E>): Selector<T, E>;
-declare function withdraw<T, E>(store: Store, token: WritableToken<T, any, E>): WritableState<T, E>;
-declare function withdraw<T, E>(store: Store, token: ReadableToken<T, any, E>): ReadableState<T, E>;
-declare function withdraw<T, K extends Canonical, E>(store: Store, token: RegularAtomFamilyToken<T, K, E>): RegularAtomFamily<T, K, E>;
-declare function withdraw<T extends Transceiver<any, any, any>, K extends Canonical>(store: Store, token: MutableAtomFamilyToken<T, K>): MutableAtomFamily<T, K>;
-declare function withdraw<T, K extends Canonical, E>(store: Store, token: AtomFamilyToken<T, K, E>): AtomFamily<T, K, E>;
-declare function withdraw<T, K extends Canonical>(store: Store, token: ReadonlyHeldSelectorFamilyToken<T, K>): ReadonlyHeldSelectorFamily<T, K>;
-declare function withdraw<T, K extends Canonical>(store: Store, token: WritableHeldSelectorFamilyToken<T, K>): WritableHeldSelectorFamily<T, K>;
-declare function withdraw<T, K extends Canonical, E>(store: Store, token: ReadonlyPureSelectorFamilyToken<T, K, E>): ReadonlyPureSelectorFamily<T, K, E>;
-declare function withdraw<T, K extends Canonical, E>(store: Store, token: WritablePureSelectorFamilyToken<T, K, E>): WritablePureSelectorFamily<T, K, E>;
-declare function withdraw<T, K extends Canonical, E>(store: Store, token: ReadonlySelectorFamilyToken<T, K, E>): ReadonlySelectorFamily<T, K, E>;
-declare function withdraw<T, K extends Canonical, E>(store: Store, token: WritableSelectorFamilyToken<T, K, E>): WritableSelectorFamily<T, K, E>;
-declare function withdraw<T, K extends Canonical>(store: Store, token: HeldSelectorFamilyToken<T, K>): HeldSelectorFamily<T, K>;
-declare function withdraw<T, K extends Canonical, E>(store: Store, token: PureSelectorFamilyToken<T, K, E>): PureSelectorFamily<T, K, E>;
-declare function withdraw<T, K extends Canonical, E>(store: Store, token: SelectorFamilyToken<T, K, E>): SelectorFamily<T, K, E>;
-declare function withdraw<T, K extends Canonical, E>(store: Store, token: WritableFamilyToken<T, K, E>): WritableFamily<T, K, E>;
-declare function withdraw<T, K extends Canonical, E>(store: Store, token: ReadableFamilyToken<T, K, E>): ReadableFamily<T, K, E>;
-declare function withdraw<T extends Fn>(store: Store, token: TransactionToken<T>): Transaction<T extends Fn ? T : never>;
-declare function withdraw<T>(store: Store, token: TimelineToken<T>): Timeline<T extends TimelineManageable ? T : never>;
-declare function withdraw<T, E>(store: Store, token: WritableToken<T, any, E>): WritableState<T, E>;
-declare function withdraw<T, E>(store: Store, token: ReadableToken<T, any, E>): ReadableState<T, E>;
+declare function withdraw<T$1, E$1>(store: Store, token: RegularAtomToken<T$1, any, E$1>): RegularAtom<T$1, E$1>;
+declare function withdraw<T$1 extends Transceiver<any, any, any>>(store: Store, token: MutableAtomToken<T$1, any>): MutableAtom<T$1>;
+declare function withdraw<T$1, E$1>(store: Store, token: AtomToken<T$1, any, E$1>): Atom<T$1, E$1>;
+declare function withdraw<T$1>(store: Store, token: WritableHeldSelectorToken<T$1>): WritableHeldSelector<T$1>;
+declare function withdraw<T$1>(store: Store, token: ReadonlyHeldSelectorToken<T$1>): ReadonlyHeldSelector<T$1>;
+declare function withdraw<T$1, E$1>(store: Store, token: WritablePureSelectorToken<T$1, any, E$1>): WritablePureSelector<T$1, E$1>;
+declare function withdraw<T$1, E$1>(store: Store, token: ReadonlyPureSelectorToken<T$1, any, E$1>): ReadonlyPureSelector<T$1, E$1>;
+declare function withdraw<T$1, E$1>(store: Store, token: ReadonlySelectorToken<T$1, any, E$1>): ReadonlySelector<T$1, E$1>;
+declare function withdraw<T$1, E$1>(store: Store, token: WritableSelectorToken<T$1, any, E$1>): WritableSelector<T$1, E$1>;
+declare function withdraw<T$1>(store: Store, token: HeldSelectorToken<T$1>): HeldSelector<T$1>;
+declare function withdraw<T$1, E$1>(store: Store, token: PureSelectorToken<T$1, any, E$1>): PureSelector<T$1, E$1>;
+declare function withdraw<T$1, E$1>(store: Store, token: SelectorToken<T$1, any, E$1>): Selector<T$1, E$1>;
+declare function withdraw<T$1, E$1>(store: Store, token: WritableToken<T$1, any, E$1>): WritableState<T$1, E$1>;
+declare function withdraw<T$1, E$1>(store: Store, token: ReadableToken<T$1, any, E$1>): ReadableState<T$1, E$1>;
+declare function withdraw<T$1, K$1 extends Canonical, E$1>(store: Store, token: RegularAtomFamilyToken<T$1, K$1, E$1>): RegularAtomFamily<T$1, K$1, E$1>;
+declare function withdraw<T$1 extends Transceiver<any, any, any>, K$1 extends Canonical>(store: Store, token: MutableAtomFamilyToken<T$1, K$1>): MutableAtomFamily<T$1, K$1>;
+declare function withdraw<T$1, K$1 extends Canonical, E$1>(store: Store, token: AtomFamilyToken<T$1, K$1, E$1>): AtomFamily<T$1, K$1, E$1>;
+declare function withdraw<T$1, K$1 extends Canonical>(store: Store, token: ReadonlyHeldSelectorFamilyToken<T$1, K$1>): ReadonlyHeldSelectorFamily<T$1, K$1>;
+declare function withdraw<T$1, K$1 extends Canonical>(store: Store, token: WritableHeldSelectorFamilyToken<T$1, K$1>): WritableHeldSelectorFamily<T$1, K$1>;
+declare function withdraw<T$1, K$1 extends Canonical, E$1>(store: Store, token: ReadonlyPureSelectorFamilyToken<T$1, K$1, E$1>): ReadonlyPureSelectorFamily<T$1, K$1, E$1>;
+declare function withdraw<T$1, K$1 extends Canonical, E$1>(store: Store, token: WritablePureSelectorFamilyToken<T$1, K$1, E$1>): WritablePureSelectorFamily<T$1, K$1, E$1>;
+declare function withdraw<T$1, K$1 extends Canonical, E$1>(store: Store, token: ReadonlySelectorFamilyToken<T$1, K$1, E$1>): ReadonlySelectorFamily<T$1, K$1, E$1>;
+declare function withdraw<T$1, K$1 extends Canonical, E$1>(store: Store, token: WritableSelectorFamilyToken<T$1, K$1, E$1>): WritableSelectorFamily<T$1, K$1, E$1>;
+declare function withdraw<T$1, K$1 extends Canonical>(store: Store, token: HeldSelectorFamilyToken<T$1, K$1>): HeldSelectorFamily<T$1, K$1>;
+declare function withdraw<T$1, K$1 extends Canonical, E$1>(store: Store, token: PureSelectorFamilyToken<T$1, K$1, E$1>): PureSelectorFamily<T$1, K$1, E$1>;
+declare function withdraw<T$1, K$1 extends Canonical, E$1>(store: Store, token: SelectorFamilyToken<T$1, K$1, E$1>): SelectorFamily<T$1, K$1, E$1>;
+declare function withdraw<T$1, K$1 extends Canonical, E$1>(store: Store, token: WritableFamilyToken<T$1, K$1, E$1>): WritableFamily<T$1, K$1, E$1>;
+declare function withdraw<T$1, K$1 extends Canonical, E$1>(store: Store, token: ReadableFamilyToken<T$1, K$1, E$1>): ReadableFamily<T$1, K$1, E$1>;
+declare function withdraw<T$1 extends Fn>(store: Store, token: TransactionToken<T$1>): Transaction<T$1 extends Fn ? T$1 : never>;
+declare function withdraw<T$1>(store: Store, token: TimelineToken<T$1>): Timeline<T$1 extends TimelineManageable ? T$1 : never>;
+declare function withdraw<T$1, E$1>(store: Store, token: WritableToken<T$1, any, E$1>): WritableState<T$1, E$1>;
+declare function withdraw<T$1, E$1>(store: Store, token: ReadableToken<T$1, any, E$1>): ReadableState<T$1, E$1>;
 declare function withdraw(store: Store, token: AtomIOToken): AtomIOInternalResource;
 //#endregion
 //#region src/internal/atom/has-role.d.ts
@@ -618,7 +618,7 @@ type InternalRole = (typeof INTERNAL_ROLES)[number];
 declare function hasRole(atom: Atom<any, any>, role: InternalRole): boolean;
 //#endregion
 //#region src/internal/atom/create-regular-atom.d.ts
-declare function createRegularAtom<T, K extends Canonical, E>(store: Store, options: RegularAtomOptions<T, E>, family: FamilyMetadata<K> | undefined, internalRoles?: InternalRole[]): RegularAtomToken<T, K, E>;
+declare function createRegularAtom<T$1, K$1 extends Canonical, E$1>(store: Store, options: RegularAtomOptions<T$1, E$1>, family: FamilyMetadata<K$1> | undefined, internalRoles?: InternalRole[]): RegularAtomToken<T$1, K$1, E$1>;
 //#endregion
 //#region src/internal/atom/dispose-atom.d.ts
 declare function disposeAtom(store: Store, atomToken: AtomToken<any, any, any>): void;
@@ -633,31 +633,31 @@ declare function disposeAtom(store: Store, atomToken: AtomToken<any, any, any>):
 * @remarks
 * Can be constructed like a Promise, or from an existing Promise.
 */
-declare class Future<T> extends Promise<T> {
+declare class Future<T$1> extends Promise<T$1> {
   private fate;
   private resolve;
   private reject;
   done: boolean;
-  constructor(executor: Promise<T> | ((resolve: (value: T) => void, reject: (reason?: any) => void) => void));
+  constructor(executor: Promise<T$1> | ((resolve: (value: T$1) => void, reject: (reason?: any) => void) => void));
   private pass;
   private fail;
-  use(value: Promise<T> | T): void;
+  use(value: Promise<T$1> | T$1): void;
 }
 //#endregion
 //#region src/internal/caching.d.ts
-declare function writeToCache<T, E>(target: Store, state: ReadableState<T, E>, value: E | T): E | T;
-declare function writeToCache<T extends Promise<any>, E>(target: Store, state: ReadableState<T, E>, value: T): Future<Awaited<E | T>>;
+declare function writeToCache<T$1, E$1>(target: Store, state: ReadableState<T$1, E$1>, value: E$1 | T$1): E$1 | T$1;
+declare function writeToCache<T$1 extends Promise<any>, E$1>(target: Store, state: ReadableState<T$1, E$1>, value: T$1): Future<Awaited<E$1 | T$1>>;
 /**
 * @param target - the newest layer of the store
 * @param state - the state to read from cache
 * @param mut - whether the value is intended to be mutable
 * @returns the state's current value
 */
-declare function readFromCache<T, E>(target: Store, state: ReadableState<T, E>, mut: `mut` | undefined): E | T;
+declare function readFromCache<T$1, E$1>(target: Store, state: ReadableState<T$1, E$1>, mut: `mut` | undefined): E$1 | T$1;
 declare function evictCachedValue(target: Store, key: string): void;
 //#endregion
 //#region src/internal/capitalize.d.ts
-declare function capitalize<S extends string>(string: S): Capitalize<S>;
+declare function capitalize<S$1 extends string>(string: S$1): Capitalize<S$1>;
 //#endregion
 //#region src/internal/events/ingest-atom-update.d.ts
 declare function ingestAtomUpdateEvent(store: Store, event: AtomUpdateEvent<any>, applying: `newValue` | `oldValue`): void;
@@ -676,52 +676,52 @@ declare function ingestSelectorUpdateEvent(store: Store, selectorUpdate: Timelin
 declare function ingestTransactionOutcomeEvent(store: Store, event: TransactionOutcomeEvent<any>, applying: `newValue` | `oldValue`): void;
 //#endregion
 //#region src/internal/families/create-readonly-pure-selector-family.d.ts
-declare function createReadonlyPureSelectorFamily<T, K extends Canonical, E>(store: RootStore, options: ReadonlyPureSelectorFamilyOptions<T, K, E>, internalRoles?: string[]): ReadonlyPureSelectorFamilyToken<T, K, E>;
+declare function createReadonlyPureSelectorFamily<T$1, K$1 extends Canonical, E$1>(store: RootStore, options: ReadonlyPureSelectorFamilyOptions<T$1, K$1, E$1>, internalRoles?: string[]): ReadonlyPureSelectorFamilyToken<T$1, K$1, E$1>;
 //#endregion
 //#region src/internal/families/create-regular-atom-family.d.ts
-declare function createRegularAtomFamily<T, K extends Canonical, E>(store: RootStore, options: RegularAtomFamilyOptions<T, K, E>, internalRoles?: string[]): RegularAtomFamilyToken<T, K, E>;
+declare function createRegularAtomFamily<T$1, K$1 extends Canonical, E$1>(store: RootStore, options: RegularAtomFamilyOptions<T$1, K$1, E$1>, internalRoles?: string[]): RegularAtomFamilyToken<T$1, K$1, E$1>;
 //#endregion
 //#region src/internal/families/create-selector-family.d.ts
-declare function createSelectorFamily<T extends object, K extends Canonical>(store: RootStore, options: WritableHeldSelectorFamilyOptions<T, K>): WritableHeldSelectorFamilyToken<T, K>;
-declare function createSelectorFamily<T extends object, K extends Canonical>(store: RootStore, options: ReadonlyHeldSelectorFamilyOptions<T, K>): ReadonlyHeldSelectorFamilyToken<T, K>;
-declare function createSelectorFamily<T, K extends Canonical, E>(store: RootStore, options: WritablePureSelectorFamilyOptions<T, K, E>): WritablePureSelectorFamilyToken<T, K, E>;
-declare function createSelectorFamily<T, K extends Canonical, E>(store: RootStore, options: ReadonlyPureSelectorFamilyOptions<T, K, E>): ReadonlyPureSelectorFamilyToken<T, K, E>;
+declare function createSelectorFamily<T$1 extends object, K$1 extends Canonical>(store: RootStore, options: WritableHeldSelectorFamilyOptions<T$1, K$1>): WritableHeldSelectorFamilyToken<T$1, K$1>;
+declare function createSelectorFamily<T$1 extends object, K$1 extends Canonical>(store: RootStore, options: ReadonlyHeldSelectorFamilyOptions<T$1, K$1>): ReadonlyHeldSelectorFamilyToken<T$1, K$1>;
+declare function createSelectorFamily<T$1, K$1 extends Canonical, E$1>(store: RootStore, options: WritablePureSelectorFamilyOptions<T$1, K$1, E$1>): WritablePureSelectorFamilyToken<T$1, K$1, E$1>;
+declare function createSelectorFamily<T$1, K$1 extends Canonical, E$1>(store: RootStore, options: ReadonlyPureSelectorFamilyOptions<T$1, K$1, E$1>): ReadonlyPureSelectorFamilyToken<T$1, K$1, E$1>;
 //#endregion
 //#region src/internal/families/create-writable-pure-selector-family.d.ts
-declare function createWritablePureSelectorFamily<T, K extends Canonical, E>(store: Store, options: WritablePureSelectorFamilyOptions<T, K, E>, internalRoles?: string[]): WritablePureSelectorFamilyToken<T, K, E>;
+declare function createWritablePureSelectorFamily<T$1, K$1 extends Canonical, E$1>(store: Store, options: WritablePureSelectorFamilyOptions<T$1, K$1, E$1>, internalRoles?: string[]): WritablePureSelectorFamilyToken<T$1, K$1, E$1>;
 //#endregion
 //#region src/internal/families/dispose-from-store.d.ts
 declare function disposeFromStore(store: Store, token: ReadableToken<any, any, any>): void;
-declare function disposeFromStore<K extends Canonical>(store: Store, token: ReadableFamilyToken<any, K, any>, key: NoInfer<K>): void;
-declare function disposeFromStore<K extends Canonical>(store: Store, ...params: [token: ReadableFamilyToken<any, K, any>, key: NoInfer<K>] | [token: ReadableToken<any, any, any>]): void;
+declare function disposeFromStore<K$1 extends Canonical>(store: Store, token: ReadableFamilyToken<any, K$1, any>, key: NoInfer<K$1>): void;
+declare function disposeFromStore<K$1 extends Canonical>(store: Store, ...params: [token: ReadableFamilyToken<any, K$1, any>, key: NoInfer<K$1>] | [token: ReadableToken<any, any, any>]): void;
 //#endregion
 //#region src/internal/families/find-in-store.d.ts
-declare function findInStore<T extends Transceiver<any, any, any>, K extends Canonical, Key extends K>(store: Store, familyToken: MutableAtomFamilyToken<T, K>, key: Key): MutableAtomToken<T, Key>;
-declare function findInStore<T, K extends Canonical, Key extends K, E>(store: Store, familyToken: RegularAtomFamilyToken<T, K, E>, key: Key): RegularAtomToken<T, Key, E>;
-declare function findInStore<T, K extends Canonical, Key extends K, E>(store: Store, familyToken: AtomFamilyToken<T, K, E>, key: Key): AtomToken<T, Key, E>;
-declare function findInStore<T, K extends Canonical, Key extends K, E>(store: Store, familyToken: WritablePureSelectorFamilyToken<T, K, E>, key: Key): WritablePureSelectorToken<T, Key, E>;
-declare function findInStore<T, K extends Canonical, Key extends K, E>(store: Store, familyToken: ReadonlyPureSelectorFamilyToken<T, K, E>, key: Key): ReadonlyPureSelectorToken<T, Key, E>;
-declare function findInStore<T, K extends Canonical, Key extends K, E>(store: Store, familyToken: SelectorFamilyToken<T, K, E>, key: Key): SelectorToken<T, Key, E>;
-declare function findInStore<T, K extends Canonical, Key extends K, E>(store: Store, familyToken: WritableFamilyToken<T, K, E>, key: Key): WritableToken<T, Key, E>;
-declare function findInStore<T, K extends Canonical, Key extends K, E>(store: Store, familyToken: ReadableFamilyToken<T, K, E>, key: Key): ReadableToken<T, Key, E>;
+declare function findInStore<T$1 extends Transceiver<any, any, any>, K$1 extends Canonical, Key$1 extends K$1>(store: Store, familyToken: MutableAtomFamilyToken<T$1, K$1>, key: Key$1): MutableAtomToken<T$1, Key$1>;
+declare function findInStore<T$1, K$1 extends Canonical, Key$1 extends K$1, E$1>(store: Store, familyToken: RegularAtomFamilyToken<T$1, K$1, E$1>, key: Key$1): RegularAtomToken<T$1, Key$1, E$1>;
+declare function findInStore<T$1, K$1 extends Canonical, Key$1 extends K$1, E$1>(store: Store, familyToken: AtomFamilyToken<T$1, K$1, E$1>, key: Key$1): AtomToken<T$1, Key$1, E$1>;
+declare function findInStore<T$1, K$1 extends Canonical, Key$1 extends K$1, E$1>(store: Store, familyToken: WritablePureSelectorFamilyToken<T$1, K$1, E$1>, key: Key$1): WritablePureSelectorToken<T$1, Key$1, E$1>;
+declare function findInStore<T$1, K$1 extends Canonical, Key$1 extends K$1, E$1>(store: Store, familyToken: ReadonlyPureSelectorFamilyToken<T$1, K$1, E$1>, key: Key$1): ReadonlyPureSelectorToken<T$1, Key$1, E$1>;
+declare function findInStore<T$1, K$1 extends Canonical, Key$1 extends K$1, E$1>(store: Store, familyToken: SelectorFamilyToken<T$1, K$1, E$1>, key: Key$1): SelectorToken<T$1, Key$1, E$1>;
+declare function findInStore<T$1, K$1 extends Canonical, Key$1 extends K$1, E$1>(store: Store, familyToken: WritableFamilyToken<T$1, K$1, E$1>, key: Key$1): WritableToken<T$1, Key$1, E$1>;
+declare function findInStore<T$1, K$1 extends Canonical, Key$1 extends K$1, E$1>(store: Store, familyToken: ReadableFamilyToken<T$1, K$1, E$1>, key: Key$1): ReadableToken<T$1, Key$1, E$1>;
 //#endregion
 //#region src/internal/families/get-family-of-token.d.ts
-declare function getFamilyOfToken<T extends Transceiver<any, any, any>, K extends Canonical>(store: Store, token: MutableAtomToken<T, K>): MutableAtomFamily<T, K>;
-declare function getFamilyOfToken<T, K extends Canonical, E>(store: Store, token: RegularAtomToken<T, K, E>): RegularAtomFamily<T, K, E>;
-declare function getFamilyOfToken<T, K extends Canonical, E>(store: Store, token: WritablePureSelectorToken<T, K, E>): WritablePureSelectorFamily<T, K, E>;
-declare function getFamilyOfToken<T, K extends Canonical, E>(store: Store, token: ReadonlyPureSelectorToken<T, K, E>): ReadonlyPureSelectorFamily<T, K, E>;
-declare function getFamilyOfToken<T, K extends Canonical, E>(store: Store, token: WritableToken<T, K, E>): WritableFamily<T, K, E>;
-declare function getFamilyOfToken<T, K extends Canonical, E>(store: Store, token: ReadableToken<T, K, E>): ReadableFamily<T, K, E>;
+declare function getFamilyOfToken<T$1 extends Transceiver<any, any, any>, K$1 extends Canonical>(store: Store, token: MutableAtomToken<T$1, K$1>): MutableAtomFamily<T$1, K$1>;
+declare function getFamilyOfToken<T$1, K$1 extends Canonical, E$1>(store: Store, token: RegularAtomToken<T$1, K$1, E$1>): RegularAtomFamily<T$1, K$1, E$1>;
+declare function getFamilyOfToken<T$1, K$1 extends Canonical, E$1>(store: Store, token: WritablePureSelectorToken<T$1, K$1, E$1>): WritablePureSelectorFamily<T$1, K$1, E$1>;
+declare function getFamilyOfToken<T$1, K$1 extends Canonical, E$1>(store: Store, token: ReadonlyPureSelectorToken<T$1, K$1, E$1>): ReadonlyPureSelectorFamily<T$1, K$1, E$1>;
+declare function getFamilyOfToken<T$1, K$1 extends Canonical, E$1>(store: Store, token: WritableToken<T$1, K$1, E$1>): WritableFamily<T$1, K$1, E$1>;
+declare function getFamilyOfToken<T$1, K$1 extends Canonical, E$1>(store: Store, token: ReadableToken<T$1, K$1, E$1>): ReadableFamily<T$1, K$1, E$1>;
 //#endregion
 //#region src/internal/families/seek-in-store.d.ts
-declare function seekInStore<T extends Transceiver<any, any, any>, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, K>, key: Key): MutableAtomToken<T, Key> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K, E>(store: Store, token: RegularAtomFamilyToken<T, K, E>, key: Key): RegularAtomToken<T, Key, E> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K, E>(store: Store, token: AtomFamilyToken<T, K, E>, key: Key): AtomToken<T, Key, E> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K, E>(store: Store, token: WritablePureSelectorFamilyToken<T, K, E>, key: Key): WritablePureSelectorToken<T, Key, E> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K, E>(store: Store, token: ReadonlyPureSelectorFamilyToken<T, K, E>, key: Key): ReadonlyPureSelectorToken<T, Key, E> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K, E>(store: Store, token: SelectorFamilyToken<T, K, E>, key: Key): SelectorToken<T, Key, E> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K, E>(store: Store, token: WritableFamilyToken<T, K, E>, key: Key): WritableToken<T, Key, E> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K, E>(store: Store, token: ReadableFamilyToken<T, K, E>, key: Key): ReadableToken<T, Key, E> | undefined;
+declare function seekInStore<T$1 extends Transceiver<any, any, any>, K$1 extends Canonical, Key$1 extends K$1>(store: Store, token: MutableAtomFamilyToken<T$1, K$1>, key: Key$1): MutableAtomToken<T$1, Key$1> | undefined;
+declare function seekInStore<T$1, K$1 extends Canonical, Key$1 extends K$1, E$1>(store: Store, token: RegularAtomFamilyToken<T$1, K$1, E$1>, key: Key$1): RegularAtomToken<T$1, Key$1, E$1> | undefined;
+declare function seekInStore<T$1, K$1 extends Canonical, Key$1 extends K$1, E$1>(store: Store, token: AtomFamilyToken<T$1, K$1, E$1>, key: Key$1): AtomToken<T$1, Key$1, E$1> | undefined;
+declare function seekInStore<T$1, K$1 extends Canonical, Key$1 extends K$1, E$1>(store: Store, token: WritablePureSelectorFamilyToken<T$1, K$1, E$1>, key: Key$1): WritablePureSelectorToken<T$1, Key$1, E$1> | undefined;
+declare function seekInStore<T$1, K$1 extends Canonical, Key$1 extends K$1, E$1>(store: Store, token: ReadonlyPureSelectorFamilyToken<T$1, K$1, E$1>, key: Key$1): ReadonlyPureSelectorToken<T$1, Key$1, E$1> | undefined;
+declare function seekInStore<T$1, K$1 extends Canonical, Key$1 extends K$1, E$1>(store: Store, token: SelectorFamilyToken<T$1, K$1, E$1>, key: Key$1): SelectorToken<T$1, Key$1, E$1> | undefined;
+declare function seekInStore<T$1, K$1 extends Canonical, Key$1 extends K$1, E$1>(store: Store, token: WritableFamilyToken<T$1, K$1, E$1>, key: Key$1): WritableToken<T$1, Key$1, E$1> | undefined;
+declare function seekInStore<T$1, K$1 extends Canonical, Key$1 extends K$1, E$1>(store: Store, token: ReadableFamilyToken<T$1, K$1, E$1>, key: Key$1): ReadableToken<T$1, Key$1, E$1> | undefined;
 //#endregion
 //#region src/internal/get-environment-data.d.ts
 type EnvironmentData = {
@@ -730,14 +730,14 @@ type EnvironmentData = {
 declare function getEnvironmentData(store: Store): EnvironmentData;
 //#endregion
 //#region src/internal/get-state/get-from-store.d.ts
-declare function getFromStore<T>(store: Store, token: ReadableToken<T>): T;
-declare function getFromStore<T, E>(store: Store, token: ReadableToken<T, any, E>): E | T;
-declare function getFromStore<T, K extends Canonical, E>(store: Store, token: ReadableFamilyToken<T, K, E>, key: NoInfer<K>): ViewOf<E | T>;
-declare function getFromStore<T, K extends Canonical, E>(store: Store, ...params: [token: ReadableFamilyToken<T, K, E>, key: NoInfer<K>] | [token: ReadableToken<T, any, E>]): ViewOf<E | T>;
+declare function getFromStore<T$1>(store: Store, token: ReadableToken<T$1>): T$1;
+declare function getFromStore<T$1, E$1>(store: Store, token: ReadableToken<T$1, any, E$1>): E$1 | T$1;
+declare function getFromStore<T$1, K$1 extends Canonical, E$1>(store: Store, token: ReadableFamilyToken<T$1, K$1, E$1>, key: NoInfer<K$1>): ViewOf<E$1 | T$1>;
+declare function getFromStore<T$1, K$1 extends Canonical, E$1>(store: Store, ...params: [token: ReadableFamilyToken<T$1, K$1, E$1>, key: NoInfer<K$1>] | [token: ReadableToken<T$1, any, E$1>]): ViewOf<E$1 | T$1>;
 //#endregion
 //#region src/internal/get-state/read-or-compute-value.d.ts
-declare function readOrComputeValue<T, E>(target: Store, state: ReadableState<T, E>, mut?: undefined): ViewOf<E | T>;
-declare function readOrComputeValue<T, E>(target: Store, state: ReadableState<T, E>, mut: `mut`): E | T;
+declare function readOrComputeValue<T$1, E$1>(target: Store, state: ReadableState<T$1, E$1>, mut?: undefined): ViewOf<E$1 | T$1>;
+declare function readOrComputeValue<T$1, E$1>(target: Store, state: ReadableState<T$1, E$1>, mut: `mut`): E$1 | T$1;
 //#endregion
 //#region src/internal/get-trace.d.ts
 declare function getTrace(error: Error): string;
@@ -757,22 +757,22 @@ declare function installIntoStore(tokens: AtomIOToken[], target: RootStore, sour
 declare function isFn(input: unknown): input is Fn;
 //#endregion
 //#region src/internal/keys.d.ts
-type AtomKey<T> = string & {
+type AtomKey<T$1> = string & {
   __atomKey?: never;
-  __brand?: T;
+  __brand?: T$1;
 };
-type SelectorKey<T> = string & {
+type SelectorKey<T$1> = string & {
   __selectorKey?: never;
-  __brand?: T;
+  __brand?: T$1;
 };
-type ReadonlySelectorKey<T> = string & {
+type ReadonlySelectorKey<T$1> = string & {
   __readonlySelectorKey?: never;
-  __brand?: T;
+  __brand?: T$1;
 };
 declare const isAtomKey: (store: Store, key: string) => key is AtomKey<unknown>;
 declare const isSelectorKey: (store: Store, key: string) => key is SelectorKey<unknown>;
 declare const isReadonlySelectorKey: (store: Store, key: string) => key is ReadonlySelectorKey<unknown>;
-type StateKey<T> = AtomKey<T> | ReadonlySelectorKey<T> | SelectorKey<T>;
+type StateKey<T$1> = AtomKey<T$1> | ReadonlySelectorKey<T$1> | SelectorKey<T$1>;
 declare const isStateKey: (store: Store, key: string) => key is StateKey<unknown>;
 //#endregion
 //#region src/internal/not-found-error.d.ts
@@ -785,22 +785,22 @@ type ReservedIntrospectionKey = `🔍 ${string}`;
 declare function isReservedIntrospectionKey(value: string): value is ReservedIntrospectionKey;
 //#endregion
 //#region src/internal/selector/create-readonly-held-selector.d.ts
-declare function createReadonlyHeldSelector<T extends object>(store: Store, options: ReadonlyHeldSelectorOptions<T>, family: FamilyMetadata | undefined): ReadonlyHeldSelectorToken<T>;
+declare function createReadonlyHeldSelector<T$1 extends object>(store: Store, options: ReadonlyHeldSelectorOptions<T$1>, family: FamilyMetadata | undefined): ReadonlyHeldSelectorToken<T$1>;
 //#endregion
 //#region src/internal/selector/create-readonly-pure-selector.d.ts
-declare function createReadonlyPureSelector<T, K extends Canonical, E>(store: Store, options: ReadonlyPureSelectorOptions<T, E>, family: FamilyMetadata<K> | undefined): ReadonlyPureSelectorToken<T, K, E>;
+declare function createReadonlyPureSelector<T$1, K$1 extends Canonical, E$1>(store: Store, options: ReadonlyPureSelectorOptions<T$1, E$1>, family: FamilyMetadata<K$1> | undefined): ReadonlyPureSelectorToken<T$1, K$1, E$1>;
 //#endregion
 //#region src/internal/selector/create-standalone-selector.d.ts
-declare function createStandaloneSelector<T extends object>(store: Store, options: WritableHeldSelectorOptions<T>): WritableHeldSelectorToken<T>;
-declare function createStandaloneSelector<T extends object>(store: Store, options: ReadonlyHeldSelectorOptions<T>): ReadonlyHeldSelectorToken<T>;
-declare function createStandaloneSelector<T, E>(store: Store, options: WritablePureSelectorOptions<T, E>): WritablePureSelectorToken<T, any, E>;
-declare function createStandaloneSelector<T, E>(store: Store, options: ReadonlyPureSelectorOptions<T, E>): ReadonlyPureSelectorToken<T, any, E>;
+declare function createStandaloneSelector<T$1 extends object>(store: Store, options: WritableHeldSelectorOptions<T$1>): WritableHeldSelectorToken<T$1>;
+declare function createStandaloneSelector<T$1 extends object>(store: Store, options: ReadonlyHeldSelectorOptions<T$1>): ReadonlyHeldSelectorToken<T$1>;
+declare function createStandaloneSelector<T$1, E$1>(store: Store, options: WritablePureSelectorOptions<T$1, E$1>): WritablePureSelectorToken<T$1, any, E$1>;
+declare function createStandaloneSelector<T$1, E$1>(store: Store, options: ReadonlyPureSelectorOptions<T$1, E$1>): ReadonlyPureSelectorToken<T$1, any, E$1>;
 //#endregion
 //#region src/internal/selector/create-writable-held-selector.d.ts
-declare function createWritableHeldSelector<T extends object>(store: Store, options: WritableHeldSelectorOptions<T>, family: FamilyMetadata | undefined): WritableHeldSelectorToken<T>;
+declare function createWritableHeldSelector<T$1 extends object>(store: Store, options: WritableHeldSelectorOptions<T$1>, family: FamilyMetadata | undefined): WritableHeldSelectorToken<T$1>;
 //#endregion
 //#region src/internal/selector/create-writable-pure-selector.d.ts
-declare function createWritablePureSelector<T, K extends Canonical, E>(store: Store, options: WritablePureSelectorOptions<T, E>, family: FamilyMetadata<K> | undefined): WritablePureSelectorToken<T, K, E>;
+declare function createWritablePureSelector<T$1, K$1 extends Canonical, E$1>(store: Store, options: WritablePureSelectorOptions<T$1, E$1>, family: FamilyMetadata<K$1> | undefined): WritablePureSelectorToken<T$1, K$1, E$1>;
 //#endregion
 //#region src/internal/selector/dispose-selector.d.ts
 declare function disposeSelector(store: Store, selectorToken: SelectorToken<unknown, any, any>): void;
@@ -818,7 +818,7 @@ declare function traceRootSelectorAtoms(store: Store, selectorKey: string, cover
 declare function updateSelectorAtoms(store: Store, selectorType: `readonly_held_selector` | `readonly_pure_selector` | `writable_held_selector` | `writable_pure_selector`, selectorKey: string, dependency: ReadableToken<unknown, any, unknown>, covered: Set<string>): void;
 //#endregion
 //#region src/internal/set-state/become.d.ts
-declare function become<T>(nextVersionOfThing: T | ((prev: T) => T), originalThing: T): T;
+declare function become<T$1>(nextVersionOfThing: T$1 | ((prev: T$1) => T$1), originalThing: T$1): T$1;
 //#endregion
 //#region src/internal/set-state/evict-downstream.d.ts
 declare function evictDownstreamFromAtom(store: Store, atom: Atom<any, any>): void;
@@ -827,22 +827,22 @@ declare function evictDownstreamFromSelector(store: Store, selectorKey: string):
 //#region src/internal/set-state/reset-in-store.d.ts
 declare const RESET_STATE: unique symbol;
 declare function resetInStore(store: Store, token: WritableToken<any, any, any>): void;
-declare function resetInStore<K extends Canonical>(store: Store, token: WritableFamilyToken<any, K, any>, key: NoInfer<K>): void;
-declare function resetInStore<T, K extends Canonical>(store: Store, ...params: [token: WritableFamilyToken<T, K, any>, key: NoInfer<K>] | [token: WritableToken<T, any, any>]): void;
+declare function resetInStore<K$1 extends Canonical>(store: Store, token: WritableFamilyToken<any, K$1, any>, key: NoInfer<K$1>): void;
+declare function resetInStore<T$1, K$1 extends Canonical>(store: Store, ...params: [token: WritableFamilyToken<T$1, K$1, any>, key: NoInfer<K$1>] | [token: WritableToken<T$1, any, any>]): void;
 //#endregion
 //#region src/internal/set-state/operate-on-store.d.ts
-type ProtoUpdate<T> = {
-  oldValue: T;
-  newValue: T;
+type ProtoUpdate<T$1> = {
+  oldValue: T$1;
+  newValue: T$1;
 };
 declare const OWN_OP: unique symbol;
 declare const JOIN_OP: unique symbol;
-declare function operateOnStore<T, TT extends T, K extends Canonical, E>(opMode: typeof JOIN_OP | typeof OWN_OP, store: Store, ...params: [token: WritableFamilyToken<T, K, E>, key: NoInfer<K>, value: Setter<TT> | TT | typeof RESET_STATE] | [token: WritableToken<T, any, E>, value: Setter<TT> | TT | typeof RESET_STATE]): void;
+declare function operateOnStore<T$1, TT extends T$1, K$1 extends Canonical, E$1>(opMode: typeof JOIN_OP | typeof OWN_OP, store: Store, ...params: [token: WritableFamilyToken<T$1, K$1, E$1>, key: NoInfer<K$1>, value: Setter<TT> | TT | typeof RESET_STATE] | [token: WritableToken<T$1, any, E$1>, value: Setter<TT> | TT | typeof RESET_STATE]): void;
 //#endregion
 //#region src/internal/set-state/reset-atom-or-selector.d.ts
-declare function resetAtomOrSelector<T, E>(target: Store & {
+declare function resetAtomOrSelector<T$1, E$1>(target: Store & {
   operation: OpenOperation;
-}, state: WritableState<T, E>): ProtoUpdate<E | T>;
+}, state: WritableState<T$1, E$1>): ProtoUpdate<E$1 | T$1>;
 //#endregion
 //#region src/internal/set-state/set-atom-or-selector.d.ts
 declare const setAtomOrSelector: <T>(target: Store & {
@@ -850,16 +850,16 @@ declare const setAtomOrSelector: <T>(target: Store & {
 }, state: WritableState<T, any>, value: NoInfer<T> | ((oldValue: T) => NoInfer<T>)) => ProtoUpdate<T>;
 //#endregion
 //#region src/internal/set-state/set-into-store.d.ts
-declare function setIntoStore<T, TT extends T>(store: Store, token: WritableToken<T, any, any>, value: Setter<TT> | TT | typeof RESET_STATE): void;
-declare function setIntoStore<T, TT extends T, K extends Canonical>(store: Store, token: WritableFamilyToken<T, K, any>, key: NoInfer<K>, value: Setter<TT> | TT | typeof RESET_STATE): void;
-declare function setIntoStore<T, TT extends T, K extends Canonical>(store: Store, ...params: [token: WritableFamilyToken<T, K, any>, key: NoInfer<K>, value: Setter<TT> | TT | typeof RESET_STATE] | [token: WritableToken<T, any, any>, value: Setter<TT> | TT | typeof RESET_STATE]): void;
+declare function setIntoStore<T$1, TT extends T$1>(store: Store, token: WritableToken<T$1, any, any>, value: Setter<TT> | TT | typeof RESET_STATE): void;
+declare function setIntoStore<T$1, TT extends T$1, K$1 extends Canonical>(store: Store, token: WritableFamilyToken<T$1, K$1, any>, key: NoInfer<K$1>, value: Setter<TT> | TT | typeof RESET_STATE): void;
+declare function setIntoStore<T$1, TT extends T$1, K$1 extends Canonical>(store: Store, ...params: [token: WritableFamilyToken<T$1, K$1, any>, key: NoInfer<K$1>, value: Setter<TT> | TT | typeof RESET_STATE] | [token: WritableToken<T$1, any, any>, value: Setter<TT> | TT | typeof RESET_STATE]): void;
 //#endregion
 //#region src/internal/subscribe/recall-state.d.ts
 declare const recallState: <T, E>(store: Store, state: ReadableState<T, E>) => T;
 //#endregion
 //#region src/internal/subscribe/subscribe-in-store.d.ts
-declare function subscribeInStore<T>(store: Store, token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key?: string): () => void;
-declare function subscribeInStore<F extends Fn>(store: Store, token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key?: string): () => void;
+declare function subscribeInStore<T$1>(store: Store, token: ReadableToken<T$1>, handleUpdate: UpdateHandler<T$1>, key?: string): () => void;
+declare function subscribeInStore<F$1 extends Fn>(store: Store, token: TransactionToken<F$1>, handleUpdate: TransactionUpdateHandler<F$1>, key?: string): () => void;
 declare function subscribeInStore<M extends TimelineManageable>(store: Store, token: TimelineToken<M>, handleUpdate: (update: TimelineEvent<M> | `redo` | `undo`) => void, key?: string): () => void;
 declare function subscribeInStore<M extends TimelineManageable>(store: Store, token: ReadableToken<any> | TimelineToken<M> | TransactionToken<any>, handleUpdate: TransactionUpdateHandler<any> | UpdateHandler<any> | ((update: TimelineEvent<M> | `redo` | `undo`) => void), key?: string): () => void;
 //#endregion
@@ -867,7 +867,7 @@ declare function subscribeInStore<M extends TimelineManageable>(store: Store, to
 declare const subscribeToRootDependency: (target: Store, selector: Selector<any, any>, atom: Atom<any, any>) => (() => void);
 //#endregion
 //#region src/internal/subscribe/subscribe-to-state.d.ts
-declare function subscribeToState<T, E>(store: Store, token: ReadableToken<T, any, E>, key: string, handleUpdate: UpdateHandler<E | T>): () => void;
+declare function subscribeToState<T$1, E$1>(store: Store, token: ReadableToken<T$1, any, E$1>, key: string, handleUpdate: UpdateHandler<E$1 | T$1>): () => void;
 //#endregion
 //#region src/internal/subscribe/subscribe-to-timeline.d.ts
 declare const subscribeToTimeline: <ManagedAtom extends TimelineManageable>(store: Store, token: TimelineToken<ManagedAtom>, key: string, handleUpdate: (update: TimelineEvent<any> | `redo` | `undo`) => void) => (() => void);