atom.io 0.35.0 → 0.36.1

package/dist/internal/index.d.ts

@@ -1,8 +1,13 @@
-import { Func as Func$1, Store as Store$1 } from "atom.io/internal";
-import { Canonical, Json, JsonInterface, stringified } from "atom.io/json";
-import { Above, ActorToolkit, Anarchy, AtomFamilyToken, AtomIOLogger, AtomIOToken, AtomToken, Claim, CompoundFrom, CompoundTypedKey, FamilyMetadata, HeldSelectorFamilyToken, HeldSelectorToken, Hierarchy, JoinOptions, JoinStates, JoinToken, KeyedStateUpdate, Logger, MoleculeCreation, MoleculeDisposal, MoleculeTransfer, MutableAtomFamilyOptions, MutableAtomFamilyToken, MutableAtomOptions, MutableAtomToken, PureSelectorFamilyToken, PureSelectorToken, ReadableFamilyToken, ReadableToken, ReadonlyHeldSelectorFamilyOptions, ReadonlyHeldSelectorFamilyToken, ReadonlyHeldSelectorOptions, ReadonlyHeldSelectorToken, ReadonlyPureSelectorFamilyOptions, ReadonlyPureSelectorFamilyToken, ReadonlyPureSelectorOptions, ReadonlyPureSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, RegularAtomFamilyOptions, RegularAtomFamilyToken, RegularAtomOptions, RegularAtomToken, SelectorFamilyToken, SelectorToken, SingularTypedKey, StateCreation, StateDisposal, StateUpdate, TimelineManageable, TimelineOptions, TimelineToken, TimelineUpdate, TokenType, TransactionOptions, TransactionToken, TransactionUpdate, TransactionUpdateHandler, UpdateHandler, Vassal, WritableFamilyToken, WritableHeldSelectorFamilyOptions, WritableHeldSelectorFamilyToken, WritableHeldSelectorOptions, WritableHeldSelectorToken, WritablePureSelectorFamilyOptions, WritablePureSelectorFamilyToken, WritablePureSelectorOptions, WritablePureSelectorToken, WritableSelectorFamilyToken, WritableSelectorToken, WritableToken, WriterToolkit } from "atom.io";
-import { SetRTX, SetRTXJson } from "atom.io/transceivers/set-rtx";
+import { Fn as Fn$1, Store as Store$1 } from "atom.io/internal";
+import { Canonical, Json, stringified } from "atom.io/json";
+import { Above, ActorToolkit, Anarchy, AtomFamilyToken, AtomIOLogger, AtomIOToken, AtomToken, Claim, CompoundFrom, CompoundTypedKey, FamilyMetadata, HeldSelectorFamilyToken, HeldSelectorToken, Hierarchy, JoinOptions, JoinStates, JoinToken, KeyedStateUpdate, Logger, MoleculeCreation, MoleculeDisposal, MoleculeTransfer, MutableAtomFamilyOptions, MutableAtomFamilyToken, MutableAtomOptions, MutableAtomToken, PureSelectorFamilyToken, PureSelectorToken, ReadableFamilyToken, ReadableToken, ReadonlyHeldSelectorFamilyOptions, ReadonlyHeldSelectorFamilyToken, ReadonlyHeldSelectorOptions, ReadonlyHeldSelectorToken, ReadonlyPureSelectorFamilyOptions, ReadonlyPureSelectorFamilyToken, ReadonlyPureSelectorOptions, ReadonlyPureSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, RegularAtomFamilyOptions, RegularAtomFamilyToken, RegularAtomOptions, RegularAtomToken, SelectorFamilyToken, SelectorToken, SingularTypedKey, StateCreation, StateDisposal, StateLifecycleEvent, StateUpdate, TimelineManageable, TimelineOptions, TimelineToken, TimelineUpdate, TokenType, TransactionOptions, TransactionToken, TransactionUpdate, TransactionUpdateHandler, UpdateHandler, Vassal, WritableFamilyToken, WritableHeldSelectorFamilyOptions, WritableHeldSelectorFamilyToken, WritableHeldSelectorOptions, WritableHeldSelectorToken, WritablePureSelectorFamilyOptions, WritablePureSelectorFamilyToken, WritablePureSelectorOptions, WritablePureSelectorToken, WritableSelectorFamilyToken, WritableSelectorToken, WritableToken, WriterToolkit } from "atom.io";
+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;
+//#endregion
 //#region src/internal/store/circular-buffer.d.ts
 declare class CircularBuffer<T> {
   protected _buffer: T[];
@@ -25,7 +30,7 @@ declare const FAMILY_MEMBER_TOKEN_TYPES: {
   readonly writable_held_selector_family: "writable_held_selector";
   readonly writable_pure_selector_family: "writable_pure_selector";
 };
-declare function counterfeit<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>;
+declare function counterfeit<T extends Transceiver<any, any, any>, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, K>, key: Key): MutableAtomToken<T>;
 declare function counterfeit<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T>;
 declare function counterfeit<T, K extends Canonical, Key extends K>(token: AtomFamilyToken<T, K>, key: Key): AtomToken<T>;
 declare function counterfeit<T, K extends Canonical, Key extends K>(token: WritablePureSelectorFamilyToken<T, K>, key: Key): WritablePureSelectorToken<T>;
@@ -35,7 +40,7 @@ declare function counterfeit<T, K extends Canonical, Key extends K>(token: Writa
 declare function counterfeit<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T>;
 //#endregion
 //#region src/internal/utility-types.d.ts
-type Func = (...parameters: any[]) => any;
+type Fn = (...parameters: any[]) => any;
 type Flat<R extends { [K in PropertyKey]: any }> = { [K in keyof R]: R[K] };
 type Count<N extends number, A extends any[] = []> = [...A, any][`length`] extends N ? A[`length`] : A[`length`] | Count<N, [...A, any]>;
 type Each<E extends any[]> = { [P in Count<E[`length`]>]: E[P] };
@@ -127,14 +132,26 @@ declare class Junction<const ASide extends string, const AType extends string, c
 declare const abortTransaction: (store: Store) => void;
 //#endregion
 //#region src/internal/transaction/act-upon-store.d.ts
-declare function actUponStore<F extends Func>(store: Store, token: TransactionToken<F>, id: string): (...parameters: Parameters<F>) => ReturnType<F>;
+declare function actUponStore<F extends Fn>(store: Store, token: TransactionToken<F>, id: string): (...parameters: Parameters<F>) => ReturnType<F>;
 //#endregion
 //#region src/internal/transaction/apply-transaction.d.ts
-declare const applyTransaction: <F extends Func>(output: ReturnType<F>, store: Store) => void;
+declare const applyTransaction: <F extends Fn>(output: ReturnType<F>, store: Store) => void;
 //#endregion
 //#region src/internal/transaction/assign-transaction-to-continuity.d.ts
 declare function assignTransactionToContinuity(store: Store, continuityKey: string, transactionKey: string): void;
 //#endregion
+//#region src/internal/lazy-map.d.ts
+declare class LazyMap<K, V> 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;
+  hasOwn(key: K): boolean;
+  has(key: K): boolean;
+  delete(key: K): boolean;
+}
+//#endregion
 //#region src/internal/transaction/is-root-store.d.ts
 interface RootStore extends Store {
   transactionMeta: TransactionEpoch;
@@ -142,9 +159,10 @@ interface RootStore extends Store {
   child: ChildStore | null;
 }
 interface ChildStore extends Store {
-  transactionMeta: TransactionProgress<Func>;
+  transactionMeta: TransactionProgress<Fn>;
   parent: ChildStore | RootStore;
   child: ChildStore | null;
+  valueMap: LazyMap<string, any>;
 }
 declare function isRootStore(store: Store): store is RootStore;
 declare function isChildStore(store: Store): store is ChildStore;
@@ -167,14 +185,14 @@ declare class StatefulSubject<T> extends Subject<T> {
 }
 //#endregion
 //#region src/internal/transaction/create-transaction.d.ts
-type Transaction<F extends Func> = {
+type Transaction<F extends Fn> = {
   key: string;
   type: `transaction`;
   install: (store: Store) => void;
   subject: Subject<TransactionUpdate<F>>;
   run: (parameters: Parameters<F>, id?: string) => ReturnType<F>;
 };
-declare function createTransaction<F extends Func>(store: Store, options: TransactionOptions<F>): TransactionToken<F>;
+declare function createTransaction<F extends Fn>(store: Store, options: TransactionOptions<F>): TransactionToken<F>;
 //#endregion
 //#region src/internal/transaction/get-epoch-number.d.ts
 declare function getContinuityKey(store: RootStore, transactionKey: string): string | undefined;
@@ -188,7 +206,7 @@ declare function setEpochNumberOfAction(store: Store, transactionKey: string, ne
 //#region src/internal/transaction/index.d.ts
 declare const TRANSACTION_PHASES: readonly ["idle", "building", "applying"];
 type TransactionPhase = (typeof TRANSACTION_PHASES)[number];
-type TransactionProgress<F extends Func> = {
+type TransactionProgress<F extends Fn> = {
   phase: `applying` | `building`;
   update: TransactionUpdate<F>;
   toolkit: ActorToolkit;
@@ -200,7 +218,7 @@ type TransactionEpoch = {
 //#endregion
 //#region src/internal/store/deposit.d.ts
 declare function deposit<T>(state: RegularAtom<T>): RegularAtomToken<T>;
-declare function deposit<T extends Transceiver<any>>(state: MutableAtom<T, any>): MutableAtomToken<T, any>;
+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>;
@@ -208,14 +226,14 @@ 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 extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(state: MutableAtomFamily<T, J, K>): MutableAtomFamilyToken<T, J, K>;
+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 extends Func>(state: Transaction<T>): TransactionToken<T>;
+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;
 //#endregion
@@ -229,7 +247,7 @@ declare function editRelationsInStore<ASide extends string, AType extends string
 declare function findRelationsInStore<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>, key: AType | BType, store: Store): JoinStates<ASide, AType, BSide, BType, Cardinality, Content>;
 //#endregion
 //#region src/internal/join/get-internal-relations-from-store.d.ts
-declare function getInternalRelationsFromStore(token: JoinToken<any, any, any, any, any, any>, store: Store): MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string>;
+declare function getInternalRelationsFromStore(token: JoinToken<any, any, any, any, any, any>, store: Store): MutableAtomFamilyToken<SetRTX<string>, string>;
 //#endregion
 //#region src/internal/molecule.d.ts
 type Molecule<K extends Canonical> = {
@@ -253,7 +271,7 @@ declare class Join<const ASide extends string, const AType extends string, const
   relations: Junction<ASide, AType, BSide, BType, Content>;
   states: JoinStateFamilies<ASide, AType, BSide, BType, Cardinality, Content>;
   core: {
-    relatedKeysAtoms: MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string>;
+    relatedKeysAtoms: MutableAtomFamilyToken<SetRTX<string>, string>;
   };
   transact(toolkit: WriterToolkit, run: (join: Join<ASide, AType, BSide, BType, Cardinality, Content>) => void): void;
   store: Store;
@@ -300,7 +318,7 @@ type TimelineSelectorUpdate<ManagedAtom extends TimelineManageable> = {
   timestamp: number;
   atomUpdates: Omit<TimelineAtomUpdate<ManagedAtom>, `timestamp`>[];
 };
-type TimelineTransactionUpdate = Flat<TransactionUpdate<Func> & {
+type TimelineTransactionUpdate = Flat<TransactionUpdate<Fn> & {
   key: string;
   type: `transaction_update`;
   timestamp: number;
@@ -349,11 +367,11 @@ declare class Store implements Lineage {
   selectorGraph: Junction<`upstreamSelectorKey`, string, `downstreamSelectorKey`, string, {
     source: string;
   }>;
-  trackers: Map<string, Tracker<Transceiver<any>>>;
-  families: Map<string, HeldSelectorFamily<any, any> | MutableAtomFamily<any, any, any> | PureSelectorFamily<any, any> | RegularAtomFamily<any, any>>;
+  trackers: Map<string, Tracker<Transceiver<any, any, any>>>;
+  families: Map<string, HeldSelectorFamily<any, any> | MutableAtomFamily<any, any> | PureSelectorFamily<any, any> | RegularAtomFamily<any, any>>;
   joins: Map<string, Join<any, any, any, any, any, any>>;
-  transactions: Map<string, Transaction<Func>>;
-  transactionMeta: TransactionEpoch | TransactionProgress<Func>;
+  transactions: Map<string, Transaction<Fn>>;
+  transactionMeta: TransactionEpoch | TransactionProgress<Fn>;
   timelines: Map<string, Timeline<any>>;
   timelineTopics: Junction<`timelineKey`, string, `topicKey`, string, {
     topicType: `atom_family` | `atom` | `molecule_family` | `molecule`;
@@ -385,8 +403,8 @@ type StoreEventCarrier = {
   selectorCreation: Subject<SelectorToken<unknown>>;
   selectorDisposal: Subject<SelectorToken<unknown>>;
   timelineCreation: Subject<TimelineToken<unknown>>;
-  transactionCreation: Subject<TransactionToken<Func>>;
-  transactionApplying: StatefulSubject<TransactionProgress<Func> | null>;
+  transactionCreation: Subject<TransactionToken<Fn>>;
+  transactionApplying: StatefulSubject<TransactionProgress<Fn> | null>;
   operationClose: Subject<OperationProgress>;
   moleculeCreation: Subject<MoleculeCreation>;
   moleculeDisposal: Subject<MoleculeDisposal>;
@@ -401,7 +419,7 @@ 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 extends Transceiver<any>>(store: Store, token: MutableAtomToken<T, any>): MutableAtom<T, any>;
+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>(store: Store, token: WritableHeldSelectorToken<T>): WritableHeldSelector<T>;
 declare function withdraw<T>(store: Store, token: ReadonlyHeldSelectorToken<T>): ReadonlyHeldSelector<T>;
@@ -415,7 +433,7 @@ 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 extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(store: Store, token: MutableAtomFamilyToken<T, J, K>): MutableAtomFamily<T, J, K>;
+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>(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>;
@@ -428,41 +446,49 @@ declare function withdraw<T, K extends Canonical>(store: Store, token: PureSelec
 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: ReadableFamilyToken<T, K>): ReadableFamily<T, K>;
 declare function withdraw<T, K extends Canonical>(store: Store, token: WritableFamilyToken<T, K>): WritableFamily<T, K>;
-declare function withdraw<T extends Func>(store: Store, token: TransactionToken<T>): Transaction<T extends Func ? T : never>;
+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(store: Store, token: AtomIOToken): AtomIOInternalResource;
 //#endregion
 //#region src/internal/mutable/transceiver.d.ts
-interface Transceiver<S extends Json.Serializable> {
+interface Transceiver<V, S extends Json.Serializable, J extends Json.Serializable> {
   do: (update: S) => number | `OUT_OF_RANGE` | null;
   undo: (update: S) => void;
   subscribe: (key: string, fn: (update: S) => void) => () => void;
   cacheUpdateNumber: number;
   getUpdateNumber: (update: S) => number;
+  view: () => V;
+  toJSON: () => J;
 }
-declare function isTransceiver(value: unknown): value is Transceiver<Json.Serializable>;
+type TransceiverConstructor<J extends Json.Serializable, T extends Transceiver<any, any, J>> = (new () => T) & {
+  fromJSON: (json: J) => T;
+};
+declare function isTransceiver(value: unknown): value is Transceiver<any, Json.Serializable, Json.Serializable>;
 type TransceiverMode = `playback` | `record` | `transaction`;
-type Signal$1<TVR extends Transceiver<any>> = TVR extends Transceiver<infer S> ? S : never;
+type ViewOf<T> = T extends Transceiver<infer V, any, any> ? V : T;
+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>;
 //#endregion
 //#region src/internal/mutable/create-mutable-atom.d.ts
-declare function createMutableAtom<T extends Transceiver<any>, J extends Json.Serializable>(store: Store, options: MutableAtomOptions<T, J>, family: FamilyMetadata | undefined): MutableAtomToken<T, J>;
+declare function createMutableAtom<T extends Transceiver<any, any, any>>(store: Store, options: MutableAtomOptions<T>, family: FamilyMetadata | undefined): MutableAtomToken<T>;
 //#endregion
 //#region src/internal/mutable/create-mutable-atom-family.d.ts
-declare function createMutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(store: Store, options: MutableAtomFamilyOptions<T, J, K>, internalRoles?: string[]): MutableAtomFamilyToken<T, J, K>;
+declare function createMutableAtomFamily<T extends Transceiver<any, any, any>, K extends Canonical>(store: Store, 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<Json.Serializable>, SerializableCore extends Json.Serializable, Key extends Canonical>(mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>, store: Store) => WritablePureSelectorFamily<SerializableCore, 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>;
 //#endregion
 //#region src/internal/mutable/get-json-token.d.ts
-declare const getJsonToken: <Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(store: Store, mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => WritablePureSelectorToken<SerializableCore>;
+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: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable, Key extends string>(mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>, store: Store) => AtomFamily<Signal$1<Core>, Key>;
+declare const getUpdateFamily: <T extends Transceiver<any, Json.Serializable, Json.Serializable>, K extends string>(mutableAtomFamily: MutableAtomFamilyToken<T, K>, store: Store) => AtomFamily<SignalFrom<T>, K>;
 //#endregion
 //#region src/internal/mutable/get-update-token.d.ts
-declare const getUpdateToken: <Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => RegularAtomToken<Signal$1<Core>>;
+declare const getUpdateToken: <T extends Transceiver<any, any, any>>(mutableAtomToken: MutableAtomToken<T>) => RegularAtomToken<SignalFrom<T>>;
 //#endregion
 //#region src/internal/mutable/tracker.d.ts
 /**
@@ -470,31 +496,31 @@ declare const getUpdateToken: <Core extends Transceiver<any>, SerializableCore e
 * 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<Mutable extends Transceiver<any>> {
-  private initializeState;
+declare class Tracker<T extends Transceiver<any, any, any>> {
+  private initializeSignalAtom;
   private unsubscribeFromInnerValue;
   private unsubscribeFromState;
-  private observeCore;
-  private updateCore;
-  mutableState: MutableAtomToken<Mutable, Json.Serializable>;
-  latestUpdateState: RegularAtomToken<(Mutable extends Transceiver<infer Signal> ? Signal : never) | null>;
+  private captureSignalsFromCore;
+  private supplySignalsToCore;
+  mutableAtomToken: MutableAtomToken<T>;
+  latestSignalToken: RegularAtomToken<SignalFrom<T> | null>;
   [Symbol.dispose]: () => void;
-  constructor(mutableState: MutableAtomToken<Mutable, Json.Serializable>, store: Store);
+  constructor(mutableAtomToken: MutableAtomToken<T>, store: Store);
 }
 //#endregion
 //#region src/internal/mutable/tracker-family.d.ts
-declare class FamilyTracker<Core extends Transceiver<any>, FamilyMemberKey extends Canonical> {
+declare class FamilyTracker<T extends Transceiver<any, any, any>, K extends Canonical> {
   private trackers;
-  readonly latestUpdateAtoms: RegularAtomFamily<(Core extends Transceiver<infer Signal> ? Signal : never) | null, FamilyMemberKey>;
-  readonly mutableAtoms: MutableAtomFamily<Core, any, FamilyMemberKey>;
-  constructor(mutableAtoms: MutableAtomFamily<Core, any, FamilyMemberKey>, store: Store);
+  readonly latestSignalAtoms: RegularAtomFamily<SignalFrom<T> | null, K>;
+  readonly mutableAtoms: MutableAtomFamily<T, K>;
+  constructor(mutableAtoms: MutableAtomFamily<T, K>, store: Store);
 }
 //#endregion
 //#region src/internal/arbitrary.d.ts
 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): RegularAtomToken<T>;
+declare function createRegularAtom<T>(store: Store, options: RegularAtomOptions<T>, family: FamilyMetadata | undefined, internalRoles?: internalRole[]): RegularAtomToken<T>;
 //#endregion
 //#region src/internal/atom/dispose-atom.d.ts
 declare function disposeAtom(store: Store, atomToken: AtomToken<unknown>): void;
@@ -521,10 +547,16 @@ declare class Future<T> extends Promise<T> {
 }
 //#endregion
 //#region src/internal/caching.d.ts
-declare function cacheValue<T>(store: Store, key: string, value: T, subject: Subject<StateUpdate<unknown>>): T;
-declare function cacheValue<T extends Promise<any>>(store: Store, key: string, value: T, subject: Subject<StateUpdate<unknown>>): Future<T>;
-declare const readCachedValue: <T>(state: ReadableState<any>, target: Store) => T;
-declare const evictCachedValue: (target: Store, key: string) => void;
+declare function writeToCache<T>(target: Store, key: string, value: T, subject: Subject<StateUpdate<unknown>>): T;
+declare function writeToCache<T extends Promise<any>>(target: Store, key: string, value: T, subject: Subject<StateUpdate<unknown>>): Future<Awaited<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 evictCachedValue(target: Store, key: string): void;
 //#endregion
 //#region src/internal/capitalize.d.ts
 declare function capitalize<S extends string>(string: S): Capitalize<S>;
@@ -549,7 +581,7 @@ declare function disposeFromStore(store: Store, token: ReadableToken<any>): void
 declare function disposeFromStore<K extends Canonical>(store: Store, token: ReadableFamilyToken<any, K>, key: K): void;
 //#endregion
 //#region src/internal/families/find-in-store.d.ts
-declare function findInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, K>;
+declare function findInStore<T extends Transceiver<any, any, any>, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, K>, key: Key): MutableAtomToken<T, K>;
 declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T, K>;
 declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: AtomFamilyToken<T, K>, key: Key): AtomToken<T, K>;
 declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritablePureSelectorFamilyToken<T, K>, key: Key): WritablePureSelectorToken<T, K>;
@@ -559,7 +591,7 @@ declare function findInStore<T, K extends Canonical, Key extends K>(store: Store
 declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T, K>;
 //#endregion
 //#region src/internal/families/init-family-member.d.ts
-declare function initFamilyMemberInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, K>;
+declare function initFamilyMemberInStore<T extends Transceiver<any, any, any>, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, K>, key: Key): MutableAtomToken<T, K>;
 declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T, K>;
 declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: AtomFamilyToken<T, K>, key: Key): AtomToken<T, K>;
 declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritablePureSelectorFamilyToken<T, K>, key: Key): WritablePureSelectorToken<T, K>;
@@ -569,7 +601,7 @@ declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T, K>;
 //#endregion
 //#region src/internal/families/seek-in-store.d.ts
-declare function seekInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, 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, 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;
@@ -589,7 +621,8 @@ 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;
 //#endregion
 //#region src/internal/get-state/read-or-compute-value.d.ts
-declare const readOrComputeValue: <T>(target: Store, state: ReadableState<T>) => T;
+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;
 //#endregion
 //#region src/internal/get-trace.d.ts
 declare function getTrace(error: Error): string;
@@ -640,18 +673,6 @@ declare const isReadonlySelectorKey: (store: Store, key: string) => key is Reado
 type StateKey<T> = AtomKey<T> | ReadonlySelectorKey<T> | SelectorKey<T>;
 declare const isStateKey: (store: Store, key: string) => key is StateKey<unknown>;
 //#endregion
-//#region src/internal/lazy-map.d.ts
-declare class LazyMap<K, V> 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;
-  hasOwn(key: K): boolean;
-  has(key: K): boolean;
-  delete(key: K): boolean;
-}
-//#endregion
 //#region src/internal/not-found-error.d.ts
 declare class NotFoundError extends Error {
   constructor(token: AtomIOToken, store: Store);
@@ -720,7 +741,7 @@ declare const recallState: <T>(store: Store, state: ReadableState<T>) => T;
 //#endregion
 //#region src/internal/subscribe/subscribe-in-store.d.ts
 declare function subscribeInStore<T>(store: Store$1, token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key?: string): () => void;
-declare function subscribeInStore<F extends Func$1>(store: Store$1, token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key?: string): () => void;
+declare function subscribeInStore<F extends Fn$1>(store: Store$1, token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key?: string): () => void;
 declare function subscribeInStore<M extends TimelineManageable>(store: Store$1, token: TimelineToken<M>, handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void, key?: string): () => void;
 declare function subscribeInStore<M extends TimelineManageable>(store: Store$1, token: ReadableToken<any> | TimelineToken<M> | TransactionToken<any>, handleUpdate: TransactionUpdateHandler<any> | UpdateHandler<any> | ((update: TimelineUpdate<M> | `redo` | `undo`) => void), key?: string): () => void;
 //#endregion
@@ -734,7 +755,7 @@ declare function subscribeToState<T>(store: Store, token: ReadableToken<T>, key:
 declare const subscribeToTimeline: <ManagedAtom extends TimelineManageable>(store: Store, token: TimelineToken<ManagedAtom>, key: string, handleUpdate: (update: TimelineUpdate<any> | `redo` | `undo`) => void) => (() => void);
 //#endregion
 //#region src/internal/subscribe/subscribe-to-transaction.d.ts
-declare const subscribeToTransaction: <F extends Func>(store: Store, token: TransactionToken<F>, key: string, handleUpdate: TransactionUpdateHandler<F>) => (() => void);
+declare const subscribeToTransaction: <F extends Fn>(store: Store, token: TransactionToken<F>, key: string, handleUpdate: TransactionUpdateHandler<F>) => (() => void);
 //#endregion
 //#region src/internal/index.d.ts
 type AtomIOState = {
@@ -750,13 +771,14 @@ type RegularAtom<T> = Flat<AtomIOState & {
   type: `atom`;
   default: T | (() => T);
   cleanup?: () => void;
+  internalRoles?: internalRole[];
 }>;
-type MutableAtom<T extends Transceiver<any>, J extends Json.Serializable> = Flat<AtomIOState & JsonInterface<T, J> & {
+type MutableAtom<T extends Transceiver<any, any, any>> = Flat<AtomIOState & {
   type: `mutable_atom`;
-  default: () => T;
+  class: ConstructorOf<T>;
   cleanup?: () => void;
 }>;
-type Atom<T> = RegularAtom<T> | (T extends Transceiver<any> ? MutableAtom<T, any> : never);
+type Atom<T> = RegularAtom<T> | (T extends Transceiver<any, any, any> ? MutableAtom<T> : never);
 type WritableHeldSelector<T> = Flat<AtomIOState & {
   type: `writable_held_selector`;
   const: T;
@@ -790,12 +812,12 @@ type RegularAtomFamily<T, K extends Canonical> = RegularAtomFamilyToken<T, K> &
   internalRoles: string[] | undefined;
   subject: Subject<StateCreation<AtomToken<T>> | StateDisposal<AtomToken<T>>>;
 };
-type MutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical> = Flat<JsonInterface<T, J> & MutableAtomFamilyToken<T, J, K> & {
+type MutableAtomFamily<T extends Transceiver<any, any, any>, K extends Canonical> = Flat<MutableAtomFamilyToken<T, K> & {
   install: (store: Store) => void;
   internalRoles: string[] | undefined;
-  subject: Subject<StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>>;
-}> & ((key: K) => MutableAtomToken<T, J>);
-type AtomFamily<T, K extends Canonical = Canonical> = MutableAtomFamily<T extends Transceiver<any> ? T : never, any, K> | RegularAtomFamily<T, K>;
+  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> & {
   default: (key: K) => T;
   install: (store: Store) => void;
@@ -829,5 +851,5 @@ type WritableFamily<T, K extends Canonical> = AtomFamily<T, K> | WritablePureSel
 type ReadableFamily<T, K extends Canonical> = AtomFamily<T, K> | SelectorFamily<T, K>;
 type AtomIOInternalResource = ReadableFamily<any, any> | ReadableState<any> | Timeline<any> | Transaction<any>;
 //#endregion
-export { Atom, AtomFamily, AtomIOInternalResource, AtomIOState, AtomKey, BaseExternalStoreConfiguration, ChildStore, CircularBuffer, Count, Each, Empty, EnvironmentData, ExternalStoreConfiguration, ExternalStoreWithContentConfiguration, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Flat, Func, Future, HeldSelector, HeldSelectorFamily, IMPLICIT, Join, JoinStateFamilies, Junction, JunctionAdvancedConfiguration, JunctionEntries, JunctionEntriesBase, JunctionJSON, JunctionSchema, JunctionSchemaBase, LazyMap, Lineage, Modify, Molecule, MutableAtom, MutableAtomFamily, NotFoundError, OperationProgress, PureSelector, PureSelectorFamily, ReadableFamily, ReadableState, ReadonlyHeldSelector, ReadonlyHeldSelectorFamily, ReadonlyPureSelector, ReadonlyPureSelectorFamily, ReadonlySelector, ReadonlySelectorFamily, ReadonlySelectorKey, Refinement, RegularAtom, RegularAtomFamily, ReservedIntrospectionKey, RootStore, Selector, SelectorFamily, SelectorKey, Signal$1 as Signal, StateKey, StatefulSubject, Store, StoreEventCarrier, Subject, TRANSACTION_PHASES, Timeline, TimelineAtomUpdate, TimelineMoleculeCreation, TimelineMoleculeDisposal, TimelineSelectorUpdate, TimelineStateCreation, TimelineStateDisposal, TimelineTransactionUpdate, Tracker, Transaction, TransactionEpoch, TransactionPhase, TransactionProgress, Transceiver, TransceiverMode, WritableFamily, WritableHeldSelector, WritableHeldSelectorFamily, WritablePureSelector, WritablePureSelectorFamily, WritableSelector, WritableSelectorFamily, WritableState, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, capitalize, claimWithinStore, clearStore, closeOperation, counterfeit, createJoin, createMutableAtom, createMutableAtomFamily, createReadonlyHeldSelector, createReadonlyPureSelector, createReadonlyPureSelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneSelector, createTimeline, createTransaction, createWritableHeldSelector, createWritablePureSelector, createWritablePureSelectorFamily, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, evictCachedValue, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, installIntoStore, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, resetAtomOrSelector, resetInStore, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootDependency, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceRootSelectorAtoms, updateSelectorAtoms, withdraw };
+export { AsJSON, Atom, AtomFamily, AtomIOInternalResource, AtomIOState, AtomKey, BaseExternalStoreConfiguration, 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, JunctionSchema, JunctionSchemaBase, LazyMap, Lineage, Modify, Molecule, MutableAtom, MutableAtomFamily, NotFoundError, OperationProgress, PureSelector, PureSelectorFamily, ReadableFamily, ReadableState, ReadonlyHeldSelector, ReadonlyHeldSelectorFamily, ReadonlyPureSelector, ReadonlyPureSelectorFamily, ReadonlySelector, ReadonlySelectorFamily, ReadonlySelectorKey, Refinement, RegularAtom, RegularAtomFamily, ReservedIntrospectionKey, RootStore, Selector, SelectorFamily, SelectorKey, SignalFrom, StateKey, StatefulSubject, Store, StoreEventCarrier, Subject, TRANSACTION_PHASES, Timeline, TimelineAtomUpdate, TimelineMoleculeCreation, TimelineMoleculeDisposal, TimelineSelectorUpdate, TimelineStateCreation, TimelineStateDisposal, TimelineTransactionUpdate, Tracker, Transaction, TransactionEpoch, TransactionPhase, TransactionProgress, Transceiver, TransceiverConstructor, TransceiverMode, ViewOf, WritableFamily, WritableHeldSelector, WritableHeldSelectorFamily, WritablePureSelector, WritablePureSelectorFamily, WritableSelector, WritableSelectorFamily, WritableState, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, capitalize, claimWithinStore, clearStore, closeOperation, counterfeit, createJoin, createMutableAtom, createMutableAtomFamily, createReadonlyHeldSelector, createReadonlyPureSelector, createReadonlyPureSelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneSelector, createTimeline, createTransaction, createWritableHeldSelector, createWritablePureSelector, createWritablePureSelectorFamily, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, evictCachedValue, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, hasRole, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, installIntoStore, internalRole, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markDone, newest, openOperation, prettyPrintTokenType, 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