atom.io 0.40.1 → 0.40.2

package/dist/internal/index.d.ts

@@ -5,7 +5,7 @@ import { SetRTX } from "atom.io/transceivers/set-rtx";
 //#region src/internal/atom/has-role.d.ts
 declare const INTERNAL_ROLES: readonly ["tracker:signal"];
 type internalRole = (typeof INTERNAL_ROLES)[number];
-declare function hasRole(atom: Atom<any>, role: internalRole): boolean;
+declare function hasRole(atom: Atom<any, any>, role: internalRole): boolean;
 //#endregion
 //#region src/internal/store/circular-buffer.d.ts
 declare class CircularBuffer<T> {
@@ -238,22 +238,22 @@ type TransactionEpoch = {
 };
 //#endregion
 //#region src/internal/store/deposit.d.ts
-declare function deposit<T>(state: RegularAtom<T>): RegularAtomToken<T>;
+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>(state: Atom<T>): AtomToken<T>;
-declare function deposit<T>(state: WritablePureSelector<T>): WritablePureSelectorToken<T>;
-declare function deposit<T>(state: ReadonlyPureSelector<T>): ReadonlyPureSelectorToken<T>;
-declare function deposit<T>(state: Selector<T>): SelectorToken<T>;
-declare function deposit<T>(state: WritableState<T>): WritableToken<T>;
-declare function deposit<T>(state: ReadableState<T>): ReadableToken<T>;
-declare function deposit<T, K extends Canonical>(state: RegularAtomFamily<T, K>): RegularAtomFamilyToken<T, K>;
+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>(state: AtomFamily<T, any>): AtomFamilyToken<T, any>;
-declare function deposit<T>(state: WritablePureSelectorFamily<T, any>): WritablePureSelectorFamilyToken<T, any>;
-declare function deposit<T>(state: ReadonlyPureSelectorFamily<T, any>): ReadonlyPureSelectorFamilyToken<T, any>;
-declare function deposit<T>(state: SelectorFamily<T, any>): SelectorFamilyToken<T, any>;
-declare function deposit<T>(state: WritableFamily<T, any>): WritableFamilyToken<T, any>;
-declare function deposit<T>(state: ReadableFamily<T, any>): ReadableFamilyToken<T, any>;
+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<M extends TimelineManageable>(state: Timeline<M>): TimelineToken<M>;
 declare function deposit(resource: AtomIOInternalResource): AtomIOToken;
@@ -270,13 +270,13 @@ declare const FAMILY_MEMBER_TOKEN_TYPES: {
   readonly writable_pure_selector_family: "writable_pure_selector";
 };
 declare function mint<T extends Transceiver<any, any, any>, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, K>, key: Key): MutableAtomToken<T>;
-declare function mint<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, counterfeit?: typeof COUNTERFEIT): RegularAtomToken<T>;
-declare function mint<T, K extends Canonical, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, counterfeit?: typeof COUNTERFEIT): AtomToken<T>;
-declare function mint<T, K extends Canonical, Key extends K>(token: WritablePureSelectorFamilyToken<T, K>, key: Key, counterfeit?: typeof COUNTERFEIT): WritablePureSelectorToken<T>;
-declare function mint<T, K extends Canonical, Key extends K>(token: ReadonlyPureSelectorFamilyToken<T, K>, key: Key, counterfeit?: typeof COUNTERFEIT): ReadonlyPureSelectorToken<T>;
-declare function mint<T, K extends Canonical, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, counterfeit?: typeof COUNTERFEIT): SelectorToken<T>;
-declare function mint<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, counterfeit?: typeof COUNTERFEIT): WritableToken<T>;
-declare function mint<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, counterfeit?: typeof COUNTERFEIT): ReadableToken<T>;
+declare function mint<T, K extends Canonical, Key extends K, E>(token: RegularAtomFamilyToken<T, K, E>, key: Key, counterfeit?: typeof COUNTERFEIT): RegularAtomToken<T, Key, E>;
+declare function mint<T, K extends Canonical, Key extends K, E>(token: AtomFamilyToken<T, K, E>, key: Key, counterfeit?: typeof COUNTERFEIT): AtomToken<T, Key, E>;
+declare function mint<T, K extends Canonical, Key extends K, E>(token: WritablePureSelectorFamilyToken<T, K, E>, key: Key, counterfeit?: typeof COUNTERFEIT): WritablePureSelectorToken<T, Key, E>;
+declare function mint<T, K extends Canonical, Key extends K, E>(token: ReadonlyPureSelectorFamilyToken<T, K, E>, key: Key, counterfeit?: typeof COUNTERFEIT): ReadonlyPureSelectorToken<T, Key, E>;
+declare function mint<T, K extends Canonical, Key extends K, E>(token: SelectorFamilyToken<T, K, E>, key: Key, counterfeit?: typeof COUNTERFEIT): SelectorToken<T, Key, E>;
+declare function mint<T, K extends Canonical, Key extends K, E>(token: WritableFamilyToken<T, K, E>, key: Key, counterfeit?: typeof COUNTERFEIT): WritableToken<T, Key, E>;
+declare function mint<T, K extends Canonical, Key extends K, E>(token: ReadableFamilyToken<T, K, E>, key: Key, counterfeit?: typeof COUNTERFEIT): ReadableToken<T, Key, E>;
 //#endregion
 //#region src/internal/join/create-join.d.ts
 declare function createJoin<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object>(store: RootStore, options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>, defaultContent: Content | undefined): JoinToken<ASide, AType, BSide, BType, Cardinality, Content>;
@@ -337,7 +337,7 @@ declare function claimWithinStore<H extends Hierarchy, V extends Exclude<Vassal<
 type OperationProgress = OpenOperation<any> | {
   open: false;
 };
-type OpenOperation<R extends ReadableToken<any> = ReadableToken<any>> = {
+type OpenOperation<R extends ReadableToken<any, any> = ReadableToken<any, any>> = {
   open: true;
   token: R;
   done: Set<string>;
@@ -345,7 +345,7 @@ type OpenOperation<R extends ReadableToken<any> = ReadableToken<any>> = {
   timestamp: number;
   subEvents: (AtomUpdateEvent<any> | StateCreationEvent<any>)[];
 };
-declare function openOperation(store: Store, token: ReadableToken<any>): number | (Store & {
+declare function openOperation(store: Store, token: ReadableToken<any, any, any>): number | (Store & {
   operation: OpenOperation;
 });
 declare function closeOperation(store: Store): void;
@@ -376,16 +376,16 @@ declare class Store implements Lineage {
   child: ChildStore | null;
   valueMap: Map<string, any>;
   defaults: Map<string, any>;
-  atoms: Map<string, Atom<any>>;
-  writableSelectors: Map<string, WritableSelector<any>>;
-  readonlySelectors: Map<string, ReadonlySelector<any>>;
+  atoms: Map<string, Atom<any, any>>;
+  writableSelectors: Map<string, WritableSelector<any, any>>;
+  readonlySelectors: Map<string, ReadonlySelector<any, any>>;
   atomsThatAreDefault: Set<string>;
   selectorAtoms: Junction<`selectorKey`, string, `atomKey`, string>;
   selectorGraph: Junction<`upstreamSelectorKey`, string, `downstreamSelectorKey`, string, {
     source: string;
   }>;
   trackers: Map<string, Tracker<Transceiver<any, any, any>>>;
-  families: Map<string, HeldSelectorFamily<any, any> | MutableAtomFamily<any, any> | PureSelectorFamily<any, any> | RegularAtomFamily<any, any>>;
+  families: Map<string, HeldSelectorFamily<any, any> | MutableAtomFamily<any, any> | PureSelectorFamily<any, any, any> | RegularAtomFamily<any, any, any>>;
   joins: Map<string, Join<any, any, any, any, any, any>>;
   transactions: Map<string, Transaction<Fn>>;
   transactionMeta: TransactionEpoch | TransactionProgress<Fn>;
@@ -415,10 +415,10 @@ declare class Store implements Lineage {
   constructor(config: Store[`config`], store?: Store | null);
 }
 type StoreEventCarrier = {
-  atomCreation: Subject<AtomToken<unknown>>;
-  atomDisposal: Subject<AtomToken<unknown>>;
-  selectorCreation: Subject<SelectorToken<unknown>>;
-  selectorDisposal: Subject<SelectorToken<unknown>>;
+  atomCreation: Subject<AtomToken<unknown, any, any>>;
+  atomDisposal: Subject<AtomToken<unknown, any, any>>;
+  selectorCreation: Subject<SelectorToken<unknown, any, any>>;
+  selectorDisposal: Subject<SelectorToken<unknown, any, any>>;
   timelineCreation: Subject<TimelineToken<unknown>>;
   transactionCreation: Subject<TransactionToken<Fn>>;
   transactionApplying: StatefulSubject<TransactionProgress<Fn> | null>;
@@ -435,38 +435,38 @@ declare const IMPLICIT: {
 declare const clearStore: (store: Store) => void;
 //#endregion
 //#region src/internal/store/withdraw.d.ts
-declare function withdraw<T>(store: Store, token: RegularAtomToken<T>): RegularAtom<T>;
+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>(store: Store, token: AtomToken<T>): Atom<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>(store: Store, token: WritablePureSelectorToken<T>): WritablePureSelector<T>;
-declare function withdraw<T>(store: Store, token: ReadonlyPureSelectorToken<T>): ReadonlyPureSelector<T>;
-declare function withdraw<T>(store: Store, token: ReadonlySelectorToken<T>): ReadonlySelector<T>;
-declare function withdraw<T>(store: Store, token: WritableSelectorToken<T>): WritableSelector<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>(store: Store, token: PureSelectorToken<T>): PureSelector<T>;
-declare function withdraw<T>(store: Store, token: SelectorToken<T>): Selector<T>;
-declare function withdraw<T>(store: Store, token: WritableToken<T>): WritableState<T>;
-declare function withdraw<T>(store: Store, token: ReadableToken<T>): ReadableState<T>;
-declare function withdraw<T, K extends Canonical>(store: Store, token: RegularAtomFamilyToken<T, K>): RegularAtomFamily<T, K>;
+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>(store: Store, token: AtomFamilyToken<T, K>): AtomFamily<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>(store: Store, token: ReadonlyPureSelectorFamilyToken<T, K>): ReadonlyPureSelectorFamily<T, K>;
-declare function withdraw<T, K extends Canonical>(store: Store, token: WritablePureSelectorFamilyToken<T, K>): WritablePureSelectorFamily<T, K>;
-declare function withdraw<T, K extends Canonical>(store: Store, token: ReadonlySelectorFamilyToken<T, K>): ReadonlySelectorFamily<T, K>;
-declare function withdraw<T, K extends Canonical>(store: Store, token: WritableSelectorFamilyToken<T, K>): WritableSelectorFamily<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>(store: Store, token: PureSelectorFamilyToken<T, K>): PureSelectorFamily<T, K>;
-declare function withdraw<T, K extends Canonical>(store: Store, token: SelectorFamilyToken<T, K>): SelectorFamily<T, K>;
-declare function withdraw<T, K extends Canonical>(store: Store, token: WritableFamilyToken<T, K>): WritableFamily<T, K>;
-declare function withdraw<T, K extends Canonical>(store: Store, token: ReadableFamilyToken<T, K>): ReadableFamily<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>(store: Store, token: WritableToken<T>): WritableState<T>;
-declare function withdraw<T>(store: Store, token: ReadableToken<T>): ReadableState<T>;
+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(store: Store, token: AtomIOToken): AtomIOInternalResource;
 //#endregion
 //#region src/internal/mutable/transceiver.d.ts
@@ -495,13 +495,13 @@ declare function createMutableAtom<T extends Transceiver<any, any, any>>(store:
 declare function createMutableAtomFamily<T extends Transceiver<any, any, any>, K extends Canonical>(store: RootStore, options: MutableAtomFamilyOptions<T, K>, internalRoles?: string[]): MutableAtomFamilyToken<T, K>;
 //#endregion
 //#region src/internal/mutable/get-json-family.d.ts
-declare const getJsonFamily: <Core extends Transceiver<any, Json.Serializable, Json.Serializable>, Key extends Canonical>(mutableAtomFamily: MutableAtomFamilyToken<Core, Key>, store: Store) => WritablePureSelectorFamily<ReturnType<Core[`toJSON`]>, Key>;
+declare const getJsonFamily: <Core extends Transceiver<any, Json.Serializable, Json.Serializable>, Key extends Canonical>(mutableAtomFamily: MutableAtomFamilyToken<Core, Key>, store: Store) => WritablePureSelectorFamily<ReturnType<Core[`toJSON`]>, Key, never>;
 //#endregion
 //#region src/internal/mutable/get-json-token.d.ts
 declare const getJsonToken: <T extends Transceiver<any, any, any>>(store: Store, mutableAtomToken: MutableAtomToken<T>) => WritablePureSelectorToken<AsJSON<T>>;
 //#endregion
 //#region src/internal/mutable/get-update-family.d.ts
-declare const getUpdateFamily: <T extends Transceiver<any, Json.Serializable, Json.Serializable>, K extends string>(mutableAtomFamily: MutableAtomFamilyToken<T, K>, store: Store) => AtomFamily<SignalFrom<T>, K>;
+declare const getUpdateFamily: <T extends Transceiver<any, Json.Serializable, Json.Serializable>, K extends string>(mutableAtomFamily: MutableAtomFamilyToken<T, K>, store: Store) => RegularAtomFamily<SignalFrom<T>, K, never>;
 //#endregion
 //#region src/internal/mutable/get-update-token.d.ts
 declare const getUpdateToken: <T extends Transceiver<any, any, any>>(mutableAtomToken: MutableAtomToken<T>) => RegularAtomToken<SignalFrom<T>>;
@@ -536,10 +536,10 @@ declare class FamilyTracker<T extends Transceiver<any, any, any>, K extends Cano
 declare function arbitrary(random?: () => number): string;
 //#endregion
 //#region src/internal/atom/create-regular-atom.d.ts
-declare function createRegularAtom<T>(store: Store, options: RegularAtomOptions<T>, family: FamilyMetadata | undefined, internalRoles?: internalRole[]): RegularAtomToken<T>;
+declare function createRegularAtom<T, K extends Canonical, E>(store: Store, options: RegularAtomOptions<T, E>, family: FamilyMetadata<K> | undefined, internalRoles?: internalRole[]): RegularAtomToken<T, K, E>;
 //#endregion
 //#region src/internal/atom/dispose-atom.d.ts
-declare function disposeAtom(store: Store, atomToken: AtomToken<any>): void;
+declare function disposeAtom(store: Store, atomToken: AtomToken<any, any, any>): void;
 //#endregion
 //#region src/internal/future.d.ts
 /**
@@ -563,15 +563,15 @@ declare class Future<T> extends Promise<T> {
 }
 //#endregion
 //#region src/internal/caching.d.ts
-declare function writeToCache<T>(target: Store, state: ReadableState<T>, value: T): T;
-declare function writeToCache<T extends Promise<any>>(target: Store, state: ReadableState<T>, value: T): Future<Awaited<T>>;
+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>>;
 /**
 * @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>(target: Store, state: ReadableState<T>, mut: `mut` | undefined): T;
+declare function readFromCache<T, E>(target: Store, state: ReadableState<T, E>, mut: `mut` | undefined): E | T;
 declare function evictCachedValue(target: Store, key: string): void;
 //#endregion
 //#region src/internal/capitalize.d.ts
@@ -582,7 +582,7 @@ declare function ingestAtomUpdateEvent(store: Store, event: AtomUpdateEvent<any>
 //#endregion
 //#region src/internal/events/ingest-creation-disposal.d.ts
 declare function ingestCreationEvent(store: Store, event: StateCreationEvent<any>, applying: `newValue` | `oldValue`): void;
-declare function ingestDisposalEvent(store: Store, event: StateDisposalEvent<ReadableToken<any>>, applying: `newValue` | `oldValue`): void;
+declare function ingestDisposalEvent(store: Store, event: StateDisposalEvent<ReadableToken<any, any, any>>, applying: `newValue` | `oldValue`): void;
 declare function ingestMoleculeCreationEvent(store: Store, event: MoleculeCreationEvent, applying: `newValue` | `oldValue`): void;
 declare function ingestMoleculeDisposalEvent(store: Store, event: MoleculeDisposalEvent, applying: `newValue` | `oldValue`): void;
 declare function ingestMoleculeTransferEvent(store: Store, event: MoleculeTransferEvent, applying: `newValue` | `oldValue`): void;
@@ -594,44 +594,44 @@ 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>(store: RootStore, options: ReadonlyPureSelectorFamilyOptions<T, K>, internalRoles?: string[]): ReadonlyPureSelectorFamilyToken<T, K>;
+declare function createReadonlyPureSelectorFamily<T, K extends Canonical, E>(store: RootStore, options: ReadonlyPureSelectorFamilyOptions<T, K, E>, internalRoles?: string[]): ReadonlyPureSelectorFamilyToken<T, K, E>;
 //#endregion
 //#region src/internal/families/create-regular-atom-family.d.ts
-declare function createRegularAtomFamily<T, K extends Canonical>(store: RootStore, options: RegularAtomFamilyOptions<T, K>, internalRoles?: string[]): RegularAtomFamilyToken<T, K>;
+declare function createRegularAtomFamily<T, K extends Canonical, E>(store: RootStore, options: RegularAtomFamilyOptions<T, K, E>, internalRoles?: string[]): RegularAtomFamilyToken<T, K, E>;
 //#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>(store: RootStore, options: WritablePureSelectorFamilyOptions<T, K>): WritablePureSelectorFamilyToken<T, K>;
-declare function createSelectorFamily<T, K extends Canonical>(store: RootStore, options: ReadonlyPureSelectorFamilyOptions<T, K>): ReadonlyPureSelectorFamilyToken<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>;
 //#endregion
 //#region src/internal/families/create-writable-pure-selector-family.d.ts
-declare function createWritablePureSelectorFamily<T, K extends Canonical>(store: Store, options: WritablePureSelectorFamilyOptions<T, K>, internalRoles?: string[]): WritablePureSelectorFamilyToken<T, K>;
+declare function createWritablePureSelectorFamily<T, K extends Canonical, E>(store: Store, options: WritablePureSelectorFamilyOptions<T, K, E>, internalRoles?: string[]): WritablePureSelectorFamilyToken<T, K, E>;
 //#endregion
 //#region src/internal/families/dispose-from-store.d.ts
-declare function disposeFromStore(store: Store, token: ReadableToken<any>): void;
-declare function disposeFromStore<K extends Canonical, Key extends K>(store: Store, token: ReadableFamilyToken<any, K>, key: Key): void;
-declare function disposeFromStore<K extends Canonical, Key extends K>(store: Store, ...params: [token: ReadableFamilyToken<any, K>, key: Key] | [token: ReadableToken<any>]): void;
+declare function disposeFromStore(store: Store, token: ReadableToken<any, any, any>): void;
+declare function disposeFromStore<K extends Canonical, Key extends K>(store: Store, token: ReadableFamilyToken<any, K, any>, key: Key): void;
+declare function disposeFromStore<K extends Canonical, Key extends K>(store: Store, ...params: [token: ReadableFamilyToken<any, K, any>, key: Key] | [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, K>;
-declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, familyToken: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T, K>;
-declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, familyToken: AtomFamilyToken<T, K>, key: Key): AtomToken<T, K>;
-declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, familyToken: WritablePureSelectorFamilyToken<T, K>, key: Key): WritablePureSelectorToken<T, K>;
-declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, familyToken: ReadonlyPureSelectorFamilyToken<T, K>, key: Key): ReadonlyPureSelectorToken<T, K>;
-declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, familyToken: SelectorFamilyToken<T, K>, key: Key): SelectorToken<T, K>;
-declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, familyToken: WritableFamilyToken<T, K>, key: Key): WritableToken<T, K>;
-declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, familyToken: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T, K>;
+declare function findInStore<T, K extends Canonical, Key extends K, E>(store: Store, familyToken: RegularAtomFamilyToken<T, K, E>, key: Key): RegularAtomToken<T, K, E>;
+declare function findInStore<T, K extends Canonical, Key extends K, E>(store: Store, familyToken: AtomFamilyToken<T, K, E>, key: Key): AtomToken<T, K, E>;
+declare function findInStore<T, K extends Canonical, Key extends K, E>(store: Store, familyToken: WritablePureSelectorFamilyToken<T, K, E>, key: Key): WritablePureSelectorToken<T, K, E>;
+declare function findInStore<T, K extends Canonical, Key extends K, E>(store: Store, familyToken: ReadonlyPureSelectorFamilyToken<T, K, E>, key: Key): ReadonlyPureSelectorToken<T, K, E>;
+declare function findInStore<T, K extends Canonical, Key extends K, E>(store: Store, familyToken: SelectorFamilyToken<T, K, E>, key: Key): SelectorToken<T, K, E>;
+declare function findInStore<T, K extends Canonical, Key extends K, E>(store: Store, familyToken: WritableFamilyToken<T, K, E>, key: Key): WritableToken<T, K, E>;
+declare function findInStore<T, K extends Canonical, Key extends K, E>(store: Store, familyToken: ReadableFamilyToken<T, K, E>, key: Key): ReadableToken<T, K, E>;
 //#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, K> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T, K> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: AtomFamilyToken<T, K>, key: Key): AtomToken<T, K> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritablePureSelectorFamilyToken<T, K>, key: Key): WritablePureSelectorToken<T, K> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadonlyPureSelectorFamilyToken<T, K>, key: Key): ReadonlyPureSelectorToken<T, K> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: SelectorFamilyToken<T, K>, key: Key): SelectorToken<T, K> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableFamilyToken<T, K>, key: Key): WritableToken<T, K> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T, K> | undefined;
+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;
 //#endregion
 //#region src/internal/get-environment-data.d.ts
 type EnvironmentData = {
@@ -641,12 +641,13 @@ 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, K extends Canonical>(store: Store, token: ReadableFamilyToken<T, K>, key: K): T;
-declare function getFromStore<T, K extends Canonical, Key extends K>(store: Store, ...params: [token: ReadableFamilyToken<T, K>, key: Key] | [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: K): ViewOf<E | T>;
+declare function getFromStore<T, K extends Canonical, Key extends K, E>(store: Store, ...params: [token: ReadableFamilyToken<T, K, E>, key: Key] | [token: ReadableToken<T, any, E>]): ViewOf<E | T>;
 //#endregion
 //#region src/internal/get-state/read-or-compute-value.d.ts
-declare function readOrComputeValue<T>(target: Store, state: ReadableState<T>, mut?: undefined): ViewOf<T>;
-declare function readOrComputeValue<T>(target: Store, state: ReadableState<T>, mut: `mut`): T;
+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;
 //#endregion
 //#region src/internal/get-trace.d.ts
 declare function getTrace(error: Error): string;
@@ -694,22 +695,22 @@ declare function isReservedIntrospectionKey(value: string): value is ReservedInt
 declare function createReadonlyHeldSelector<T extends object>(store: Store, options: ReadonlyHeldSelectorOptions<T>, family: FamilyMetadata | undefined): ReadonlyHeldSelectorToken<T>;
 //#endregion
 //#region src/internal/selector/create-readonly-pure-selector.d.ts
-declare function createReadonlyPureSelector<T>(store: Store, options: ReadonlyPureSelectorOptions<T>, family: FamilyMetadata | undefined): ReadonlyPureSelectorToken<T>;
+declare function createReadonlyPureSelector<T, K extends Canonical, E>(store: Store, options: ReadonlyPureSelectorOptions<T, E>, family: FamilyMetadata<K> | undefined): ReadonlyPureSelectorToken<T, K, E>;
 //#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>(store: Store, options: WritablePureSelectorOptions<T>): WritablePureSelectorToken<T>;
-declare function createStandaloneSelector<T>(store: Store, options: ReadonlyPureSelectorOptions<T>): ReadonlyPureSelectorToken<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>;
 //#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>;
 //#endregion
 //#region src/internal/selector/create-writable-pure-selector.d.ts
-declare function createWritablePureSelector<T>(store: Store, options: WritablePureSelectorOptions<T>, family: FamilyMetadata | undefined): WritablePureSelectorToken<T>;
+declare function createWritablePureSelector<T, K extends Canonical, E>(store: Store, options: WritablePureSelectorOptions<T, E>, family: FamilyMetadata<K> | undefined): WritablePureSelectorToken<T, K, E>;
 //#endregion
 //#region src/internal/selector/dispose-selector.d.ts
-declare function disposeSelector(store: Store, selectorToken: SelectorToken<unknown>): void;
+declare function disposeSelector(store: Store, selectorToken: SelectorToken<unknown, any, any>): void;
 //#endregion
 //#region src/internal/selector/get-selector-dependency-keys.d.ts
 declare function getSelectorDependencyKeys(store: Store, key: string): (AtomKey<unknown> | ReadonlySelectorKey<unknown> | SelectorKey<unknown>)[];
@@ -718,23 +719,23 @@ declare function getSelectorDependencyKeys(store: Store, key: string): (AtomKey<
 declare function registerSelector(store: Store, selectorType: `readonly_held_selector` | `readonly_pure_selector` | `writable_held_selector` | `writable_pure_selector`, selectorKey: string, covered: Set<string>): WriterToolkit;
 //#endregion
 //#region src/internal/selector/trace-selector-atoms.d.ts
-declare function traceRootSelectorAtoms(store: Store, selectorKey: string, covered?: Set<string>): Map<string, Atom<unknown>>;
+declare function traceRootSelectorAtoms(store: Store, selectorKey: string, covered?: Set<string>): Map<string, Atom<any, any>>;
 //#endregion
 //#region src/internal/selector/update-selector-atoms.d.ts
-declare function updateSelectorAtoms(store: Store, selectorType: `readonly_held_selector` | `readonly_pure_selector` | `writable_held_selector` | `writable_pure_selector`, selectorKey: string, dependency: ReadableToken<unknown>, covered: Set<string>): void;
+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;
 //#endregion
 //#region src/internal/set-state/evict-downstream.d.ts
-declare function evictDownstreamFromAtom(store: Store, atom: Atom<any>): void;
+declare function evictDownstreamFromAtom(store: Store, atom: Atom<any, any>): void;
 declare function evictDownstreamFromSelector(store: Store, selectorKey: string): void;
 //#endregion
 //#region src/internal/set-state/reset-in-store.d.ts
 declare const RESET_STATE: unique symbol;
-declare function resetInStore(store: Store, token: WritableToken<any>): void;
-declare function resetInStore<K extends Canonical>(store: Store, token: WritableFamilyToken<any, K>, key: K): void;
-declare function resetInStore<T, K extends Canonical, Key extends K>(store: Store, ...params: [token: WritableFamilyToken<T, K>, key: Key] | [token: WritableToken<T>]): void;
+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: K): void;
+declare function resetInStore<T, K extends Canonical, Key extends K>(store: Store, ...params: [token: WritableFamilyToken<T, K, any>, key: Key] | [token: WritableToken<T, any, any>]): void;
 //#endregion
 //#region src/internal/set-state/operate-on-store.d.ts
 type ProtoUpdate<T> = {
@@ -743,22 +744,22 @@ type ProtoUpdate<T> = {
 };
 //#endregion
 //#region src/internal/set-state/reset-atom-or-selector.d.ts
-declare function resetAtomOrSelector<T>(target: Store & {
+declare function resetAtomOrSelector<T, E>(target: Store & {
   operation: OpenOperation;
-}, state: WritableState<T>): ProtoUpdate<T>;
+}, state: WritableState<T, E>): ProtoUpdate<E | T>;
 //#endregion
 //#region src/internal/set-state/set-atom-or-selector.d.ts
 declare const setAtomOrSelector: <T>(target: Store & {
   operation: OpenOperation;
-}, state: WritableState<T>, value: T | ((oldValue: T) => T)) => ProtoUpdate<T>;
+}, state: WritableState<T, any>, value: T | ((oldValue: T) => T)) => ProtoUpdate<T>;
 //#endregion
 //#region src/internal/set-state/set-into-store.d.ts
-declare function setIntoStore<T, New extends T>(store: Store, token: WritableToken<T>, value: New | typeof RESET_STATE | ((oldValue: T) => New)): void;
-declare function setIntoStore<T, K extends Canonical, New extends T, Key extends K>(store: Store, token: WritableFamilyToken<T, K>, key: Key, value: New | typeof RESET_STATE | ((oldValue: T) => New)): void;
-declare function setIntoStore<T, K extends Canonical, New extends T, Key extends K>(store: Store, ...params: [token: WritableFamilyToken<T, K>, key: Key, value: New | typeof RESET_STATE | ((oldValue: T) => New)] | [token: WritableToken<T>, value: New | typeof RESET_STATE | ((oldValue: T) => New)]): void;
+declare function setIntoStore<T, New extends T, E>(store: Store, token: WritableToken<T, any, E>, value: New | typeof RESET_STATE | ((oldValue: T) => New)): void;
+declare function setIntoStore<T, K extends Canonical, New extends T, Key extends K, E>(store: Store, token: WritableFamilyToken<T, K, E>, key: Key, value: New | typeof RESET_STATE | ((oldValue: T) => New)): void;
+declare function setIntoStore<T, K extends Canonical, New extends T, Key extends K, E>(store: Store, ...params: [token: WritableFamilyToken<T, K, E>, key: Key, value: New | typeof RESET_STATE | ((oldValue: T) => New)] | [token: WritableToken<T, any, E>, value: New | typeof RESET_STATE | ((oldValue: T) => New)]): void;
 //#endregion
 //#region src/internal/subscribe/recall-state.d.ts
-declare const recallState: <T>(store: Store, state: ReadableState<T>) => T;
+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;
@@ -767,10 +768,10 @@ declare function subscribeInStore<M extends TimelineManageable>(store: Store, to
 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
 //#region src/internal/subscribe/subscribe-to-root-atoms.d.ts
-declare const subscribeToRootDependency: (target: Store, selector: Selector<any>, atom: Atom<any>) => (() => void);
+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>(store: Store, token: ReadableToken<T>, key: string, handleUpdate: UpdateHandler<T>): () => void;
+declare function subscribeToState<T, E>(store: Store, token: ReadableToken<T, any, E>, key: string, handleUpdate: UpdateHandler<E | T>): () => 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);
@@ -785,18 +786,19 @@ type AtomIOState = {
   install: (store: RootStore) => void;
   subject: Subject<StateUpdate<any>>;
 };
-type RegularAtom<T> = Flat<AtomIOState & {
+type RegularAtom<T, E> = Flat<AtomIOState & {
   type: `atom`;
   default: T | (() => T);
   cleanup?: () => void;
   internalRoles?: internalRole[];
+  catch?: readonly (new () => E)[];
 }>;
 type MutableAtom<T extends Transceiver<any, any, any>> = Flat<AtomIOState & {
   type: `mutable_atom`;
   class: ConstructorOf<T>;
   cleanup?: () => void;
 }>;
-type Atom<T> = RegularAtom<T> | (T extends Transceiver<any, any, any> ? MutableAtom<T> : never);
+type Atom<T, E> = RegularAtom<T, E> | (T extends Transceiver<any, any, any> ? MutableAtom<T> : never);
 type WritableHeldSelector<T> = Flat<AtomIOState & {
   type: `writable_held_selector`;
   const: T;
@@ -808,67 +810,69 @@ type ReadonlyHeldSelector<T> = Flat<AtomIOState & {
   const: T;
   getFrom: (target: Store) => T;
 }>;
-type WritablePureSelector<T> = Flat<AtomIOState & {
+type WritablePureSelector<T, E> = Flat<AtomIOState & {
   type: `writable_pure_selector`;
-  getFrom: (target: Store) => T;
+  getFrom: (target: Store) => E | T;
   setSelf: (newValue: T) => void;
+  catch?: readonly (new () => E)[];
 }>;
-type ReadonlyPureSelector<T> = Flat<AtomIOState & {
+type ReadonlyPureSelector<T, E> = Flat<AtomIOState & {
   type: `readonly_pure_selector`;
-  getFrom: (target: Store) => T;
+  getFrom: (target: Store) => E | T;
+  catch?: readonly (new () => E)[];
 }>;
-type ReadonlySelector<T> = ReadonlyHeldSelector<T> | ReadonlyPureSelector<T>;
-type WritableSelector<T> = WritableHeldSelector<T> | WritablePureSelector<T>;
+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> = ReadonlyPureSelector<T> | WritablePureSelector<T>;
-type Selector<T> = ReadonlyHeldSelector<T> | ReadonlyPureSelector<T> | WritableHeldSelector<T> | WritablePureSelector<T>;
-type WritableState<T> = Atom<T> | WritableSelector<T>;
-type ReadableState<T> = Atom<T> | Selector<T>;
-type RegularAtomFamily<T, K extends Canonical> = Flat<RegularAtomFamilyToken<T, K> & {
+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> & {
   default: T | ((key: K) => T);
   install: (store: RootStore) => void;
   internalRoles: string[] | undefined;
-  subject: Subject<StateLifecycleEvent<RegularAtomToken<T>>>;
-}> & ((key: K) => RegularAtomToken<T>);
+  subject: Subject<StateLifecycleEvent<RegularAtomToken<T, K, E>>>;
+}> & (<Key extends K>(key: Key) => RegularAtomToken<T, Key, E>);
 type MutableAtomFamily<T extends Transceiver<any, any, any>, K extends Canonical> = Flat<MutableAtomFamilyToken<T, K> & {
   class: ConstructorOf<T>;
   install: (store: RootStore) => void;
   internalRoles: string[] | undefined;
   subject: Subject<StateLifecycleEvent<MutableAtomToken<T>>>;
-}> & ((key: K) => MutableAtomToken<T>);
-type AtomFamily<T, K extends Canonical = Canonical> = MutableAtomFamily<T extends Transceiver<any, any, any> ? T : never, K> | RegularAtomFamily<T, K>;
-type WritablePureSelectorFamily<T, K extends Canonical> = Flat<WritablePureSelectorFamilyToken<T, K> & {
+}> & (<Key extends K>(key: Key) => MutableAtomToken<T, Key>);
+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> & {
   default: (key: K) => T;
   install: (store: RootStore) => void;
   internalRoles: string[] | undefined;
-  subject: Subject<StateLifecycleEvent<WritablePureSelectorToken<T>>>;
-}> & ((key: K) => WritablePureSelectorToken<T>);
+  subject: Subject<StateLifecycleEvent<WritablePureSelectorToken<T, K, E>>>;
+}> & (<Key extends K>(key: Key) => WritablePureSelectorToken<T, Key, E>);
 type WritableHeldSelectorFamily<T, K extends Canonical> = Flat<WritableHeldSelectorFamilyToken<T, K> & {
   default: (key: K) => T;
   install: (store: RootStore) => void;
   internalRoles: string[] | undefined;
-  subject: Subject<StateLifecycleEvent<WritableHeldSelectorToken<T>>>;
-}> & ((key: K) => WritableHeldSelectorToken<T>);
-type ReadonlyPureSelectorFamily<T, K extends Canonical> = Flat<ReadonlyPureSelectorFamilyToken<T, K> & {
+  subject: Subject<StateLifecycleEvent<WritableHeldSelectorToken<T, K>>>;
+}> & (<Key extends K>(key: Key) => WritableHeldSelectorToken<T, Key>);
+type ReadonlyPureSelectorFamily<T, K extends Canonical, E> = Flat<ReadonlyPureSelectorFamilyToken<T, K, E> & {
   default: (key: K) => T;
   install: (store: RootStore) => void;
   internalRoles: string[] | undefined;
-  subject: Subject<StateLifecycleEvent<ReadonlyPureSelectorToken<T>>>;
-}> & ((key: K) => ReadonlyPureSelectorToken<T>);
+  subject: Subject<StateLifecycleEvent<ReadonlyPureSelectorToken<T, K, E>>>;
+}> & (<Key extends K>(key: Key) => ReadonlyPureSelectorToken<T, Key, E>);
 type ReadonlyHeldSelectorFamily<T, K extends Canonical> = Flat<ReadonlyHeldSelectorFamilyToken<T, K> & {
   default: (key: K) => T;
   install: (store: RootStore) => void;
   internalRoles: string[] | undefined;
   subject: Subject<StateLifecycleEvent<ReadonlyHeldSelectorToken<T>>>;
-}> & ((key: K) => ReadonlyHeldSelectorToken<T>);
-type PureSelectorFamily<T, K extends Canonical> = ReadonlyPureSelectorFamily<T, K> | WritablePureSelectorFamily<T, K>;
+}> & (<Key extends K>(key: Key) => ReadonlyHeldSelectorToken<T, Key>);
+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> = ReadonlyHeldSelectorFamily<T, K> | ReadonlyPureSelectorFamily<T, K>;
-type WritableSelectorFamily<T, K extends Canonical> = WritableHeldSelectorFamily<T, K> | WritablePureSelectorFamily<T, K>;
-type SelectorFamily<T, K extends Canonical> = HeldSelectorFamily<T, K> | PureSelectorFamily<T, K>;
-type WritableFamily<T, K extends Canonical> = AtomFamily<T, K> | WritablePureSelectorFamily<T, K>;
-type ReadableFamily<T, K extends Canonical> = AtomFamily<T, K> | SelectorFamily<T, K>;
-type AtomIOInternalResource = ReadableFamily<any, any> | ReadableState<any> | Timeline<any> | Transaction<any>;
+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 AtomIOInternalResource = ReadableFamily<any, any, any> | ReadableState<any, any> | Timeline<any> | Transaction<any>;
 //#endregion
 export { AsJSON, Atom, AtomFamily, AtomIOInternalResource, AtomIOState, AtomKey, BaseExternalStoreConfiguration, COUNTERFEIT, ChildStore, CircularBuffer, ConstructorOf, Count, Each, Empty, EnvironmentData, ExternalStoreConfiguration, ExternalStoreWithContentConfiguration, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Flat, Fn, Future, HeldSelector, HeldSelectorFamily, IMPLICIT, INTERNAL_ROLES, Join, JoinStateFamilies, Junction, JunctionAdvancedConfiguration, JunctionEntries, JunctionEntriesBase, JunctionJSON, JunctionOverlay, JunctionSchema, JunctionSchemaBase, Lineage, MapOverlay, Molecule, MutableAtom, MutableAtomFamily, NotFoundError, OpenOperation, OperationProgress, PureSelector, PureSelectorFamily, RESET_STATE, ReadableFamily, ReadableState, ReadonlyHeldSelector, ReadonlyHeldSelectorFamily, ReadonlyPureSelector, ReadonlyPureSelectorFamily, ReadonlySelector, ReadonlySelectorFamily, ReadonlySelectorKey, Refinement, RegularAtom, RegularAtomFamily, RelationsOverlay, ReservedIntrospectionKey, RootStore, Selector, SelectorFamily, SelectorKey, SetOverlay, SignalFrom, StateKey, StatefulSubject, Store, StoreEventCarrier, Subject, TRANSACTION_PHASES, Timeline, Tracker, Transaction, TransactionEpoch, TransactionPhase, TransactionProgress, Transceiver, TransceiverConstructor, TransceiverMode, WritableFamily, WritableHeldSelector, WritableHeldSelectorFamily, WritablePureSelector, WritablePureSelectorFamily, WritableSelector, WritableSelectorFamily, WritableState, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, capitalize, claimWithinStore, clearStore, closeOperation, createClaimTX, createDeallocateTX, createJoin, createMutableAtom, createMutableAtomFamily, createReadonlyHeldSelector, createReadonlyPureSelector, createReadonlyPureSelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneSelector, createTimeline, createTransaction, createWritableHeldSelector, createWritablePureSelector, createWritablePureSelectorFamily, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, eldest, evictCachedValue, evictDownstreamFromAtom, evictDownstreamFromSelector, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, hasRole, ingestAtomUpdateEvent, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdateEvent, ingestTransactionOutcomeEvent, installIntoStore, internalRole, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markDone, mint, newest, openOperation, readFromCache, readOrComputeValue, recallState, registerSelector, resetAtomOrSelector, resetInStore, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootDependency, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceRootSelectorAtoms, updateSelectorAtoms, withdraw, writeToCache };
 //# sourceMappingURL=index.d.ts.map