atom.io 0.32.4 → 0.33.0

package/{internal/dist → dist/internal}/index.d.ts

@@ -1,25 +1,28 @@
-import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, AtomFamilyToken, AtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, SelectorFamilyToken, SelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, ReadableToken, TransactionToken, TransactionUpdate, TransactionOptions, ActorToolkit, TimelineManageable, TimelineToken, AtomIOToken, JoinToken, JoinStates, Hierarchy, Vassal, Above, Claim, CompoundFrom, CompoundTypedKey, SingularTypedKey, JoinOptions, SetterToolkit, Anarchy, TimelineUpdate, StateUpdate, TokenType, FamilyMetadata, StateCreation, StateDisposal, MoleculeCreation, MoleculeDisposal, TimelineOptions, AtomIOLogger, Logger, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, KeyedStateUpdate, MoleculeTransfer, ReadonlySelectorOptions, WritableSelectorOptions, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
-import { Json, Canonical, stringified, JsonInterface } from 'atom.io/json';
-import { SetRTX, SetRTXJson } from 'atom.io/transceivers/set-rtx';
-import { Store as Store$1, Func as Func$1 } from 'atom.io/internal';
+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, Hierarchy, JoinOptions, JoinStates, JoinToken, KeyedStateUpdate, Logger, MoleculeCreation, MoleculeDisposal, MoleculeTransfer, MutableAtomFamilyOptions, MutableAtomFamilyToken, MutableAtomOptions, MutableAtomToken, ReadableFamilyToken, ReadableToken, ReadonlySelectorFamilyOptions, ReadonlySelectorFamilyToken, ReadonlySelectorOptions, ReadonlySelectorToken, RegularAtomFamilyOptions, RegularAtomFamilyToken, RegularAtomOptions, RegularAtomToken, SelectorFamilyToken, SelectorToken, SetterToolkit, SingularTypedKey, StateCreation, StateDisposal, StateUpdate, TimelineManageable, TimelineOptions, TimelineToken, TimelineUpdate, TokenType, TransactionOptions, TransactionToken, TransactionUpdate, TransactionUpdateHandler, UpdateHandler, Vassal, WritableFamilyToken, WritableSelectorFamilyOptions, WritableSelectorFamilyToken, WritableSelectorOptions, WritableSelectorToken, WritableToken } from "atom.io";
+import { SetRTX, SetRTXJson } from "atom.io/transceivers/set-rtx";
 
+//#region src/internal/store/circular-buffer.d.ts
 declare class CircularBuffer<T> {
-    protected _buffer: T[];
-    protected _index: number;
-    constructor(array: T[]);
-    constructor(length: number);
-    get buffer(): ReadonlyArray<T | undefined>;
-    get index(): number;
-    add(item: T): void;
-    copy(): CircularBuffer<T>;
+  protected _buffer: T[];
+  protected _index: number;
+  constructor(array: T[]);
+  constructor(length: number);
+  get buffer(): ReadonlyArray<T | undefined>;
+  get index(): number;
+  add(item: T): void;
+  copy(): CircularBuffer<T>;
 }
 
+//#endregion
+//#region src/internal/store/counterfeit.d.ts
 declare const FAMILY_MEMBER_TOKEN_TYPES: {
-    readonly atom_family: "atom";
-    readonly mutable_atom_family: "mutable_atom";
-    readonly selector_family: "selector";
-    readonly readonly_selector_family: "readonly_selector";
-    readonly molecule_family: "molecule";
+  readonly atom_family: "atom";
+  readonly mutable_atom_family: "mutable_atom";
+  readonly selector_family: "selector";
+  readonly readonly_selector_family: "readonly_selector";
+  readonly molecule_family: "molecule";
 };
 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, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T>;
@@ -30,180 +33,183 @@ declare function counterfeit<T, K extends Canonical, Key extends K>(token: Selec
 declare function counterfeit<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T>;
 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 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];
-};
+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] };
 type Refinement<A, B extends A> = (a: A) => a is B;
 
+//#endregion
+//#region src/internal/junction.d.ts
 type JunctionEntriesBase<AType extends string, BType extends string, Content extends Json.Object | null> = {
-    readonly relations: ([AType, BType[]] | [BType, AType[]])[];
-    readonly contents: [string, Content][];
+  readonly relations: ([AType, BType[]] | [BType, AType[]])[];
+  readonly contents: [string, Content][];
 };
-interface JunctionEntries<AType extends string, BType extends string, Content extends Json.Object | null> extends Json.Object, JunctionEntriesBase<AType, BType, Content> {
-}
+interface JunctionEntries<AType extends string, BType extends string, Content extends Json.Object | null> extends Json.Object, JunctionEntriesBase<AType, BType, Content> {}
 type JunctionSchemaBase<ASide extends string, BSide extends string> = {
-    readonly between: [a: ASide, b: BSide];
-    readonly cardinality: `1:1` | `1:n` | `n:n`;
+  readonly between: [a: ASide, b: BSide];
+  readonly cardinality: `1:1` | `1:n` | `n:n`;
 };
-interface JunctionSchema<ASide extends string, BSide extends string> extends Json.Object, JunctionSchemaBase<ASide, BSide> {
-}
+interface JunctionSchema<ASide extends string, BSide extends string> extends Json.Object, JunctionSchemaBase<ASide, BSide> {}
 type BaseExternalStoreConfiguration = {
-    addRelation: (a: string, b: string) => void;
-    deleteRelation: (a: string, b: string) => void;
-    replaceRelationsSafely: (a: string, bs: string[]) => void;
-    replaceRelationsUnsafely: (a: string, bs: string[]) => void;
-    getRelatedKeys(key: string): Set<string> | undefined;
-    has: (a: string, b?: string) => boolean;
+  addRelation: (a: string, b: string) => void;
+  deleteRelation: (a: string, b: string) => void;
+  replaceRelationsSafely: (a: string, bs: string[]) => void;
+  replaceRelationsUnsafely: (a: string, bs: string[]) => void;
+  getRelatedKeys(key: string): Set<string> | undefined;
+  has: (a: string, b?: string) => boolean;
 };
 type ExternalStoreWithContentConfiguration<Content extends Json.Object> = {
-    getContent: (contentKey: string) => Content | undefined;
-    setContent: (contentKey: string, content: Content) => void;
-    deleteContent: (contentKey: string) => void;
-};
-type Empty<Obj extends object> = {
-    [Key in keyof Obj]?: undefined;
+  getContent: (contentKey: string) => Content | undefined;
+  setContent: (contentKey: string, content: Content) => void;
+  deleteContent: (contentKey: string) => void;
 };
+type Empty<Obj extends object> = { [Key in keyof Obj]?: undefined };
 type ExternalStoreConfiguration<Content extends Json.Object | null> = Content extends Json.Object ? BaseExternalStoreConfiguration & ExternalStoreWithContentConfiguration<Content> : BaseExternalStoreConfiguration & Empty<ExternalStoreWithContentConfiguration<Json.Object>>;
 type JunctionAdvancedConfiguration<AType extends string, BType extends string, Content extends Json.Object | null> = {
-    warn?: (...args: any[]) => void;
-    externalStore?: ExternalStoreConfiguration<Content>;
-    isAType?: Refinement<string, AType>;
-    isBType?: Refinement<string, BType>;
-    isContent?: Refinement<unknown, Content>;
-    makeContentKey?: (a: AType, b: BType) => string;
+  warn?: (...args: any[]) => void;
+  externalStore?: ExternalStoreConfiguration<Content>;
+  isAType?: Refinement<string, AType>;
+  isBType?: Refinement<string, BType>;
+  isContent?: Refinement<unknown, Content>;
+  makeContentKey?: (a: AType, b: BType) => string;
 };
 type JunctionJSON<ASide extends string, AType extends string, BSide extends string, BType extends string, Content extends Json.Object | null> = JunctionEntries<AType, BType, Content> & JunctionSchema<ASide, BSide>;
-declare class Junction<const ASide extends string, const AType extends string, const BSide extends string, const BType extends string, const Content extends Json.Object | null = null> {
-    readonly a: ASide;
-    readonly b: BSide;
-    readonly cardinality: `1:1` | `1:n` | `n:n`;
-    readonly relations: Map<AType | BType, Set<AType> | Set<BType>>;
-    readonly contents: Map<string, Content>;
-    isAType?: Refinement<string, AType> | null;
-    isBType?: Refinement<string, BType> | null;
-    isContent: Refinement<unknown, Content> | null;
-    makeContentKey: (a: AType, b: BType) => string;
-    warn?: (...args: any[]) => void;
-    getRelatedKeys(key: AType): Set<BType> | undefined;
-    getRelatedKeys(key: BType): Set<AType> | undefined;
-    getRelatedKeys(key: AType | BType): Set<AType> | Set<BType> | undefined;
-    protected addRelation(a: AType, b: BType): void;
-    protected deleteRelation(a: AType, b: BType): void;
-    protected replaceRelationsUnsafely(a: AType, bs: BType[]): void;
-    protected replaceRelationsUnsafely(b: BType, as: AType[]): void;
-    protected replaceRelationsSafely(a: AType, bs: BType[]): void;
-    protected replaceRelationsSafely(b: BType, as: AType[]): void;
-    protected getContentInternal(contentKey: string): Content | undefined;
-    protected setContent(contentKey: string, content: Content): void;
-    protected deleteContent(contentKey: string): void;
-    constructor(data: JunctionSchema<ASide, BSide> & Partial<JunctionEntries<NoInfer<AType>, NoInfer<BType>, Content>>, config?: JunctionAdvancedConfiguration<AType, BType, Content>);
-    toJSON(): JunctionJSON<ASide, AType, BSide, BType, Content>;
-    set(a: AType, ...rest: Content extends null ? [b: BType] : [b: BType, content: Content]): this;
-    set(relation: {
-        [Key in ASide]: AType;
-    } & {
-        [Key in BSide]: BType;
-    }, ...rest: Content extends null ? [] | [void?: undefined] : [content: Content]): this;
-    delete(a: AType, b?: BType): this;
-    delete(b: BType, a?: AType): this;
-    delete(relation: {
-        [Key in ASide]: AType;
-    } | {
-        [Key in BSide]: BType;
-    } | ({
-        [Key in ASide]: AType;
-    } & {
-        [Key in BSide]: BType;
-    }), b?: undefined): this;
-    getRelatedKey(key: AType): BType | undefined;
-    getRelatedKey(key: BType): AType | undefined;
-    replaceRelations(a: AType, relations: Content extends null ? BType[] : Record<BType, Content>, config?: {
-        reckless: boolean;
-    }): this;
-    replaceRelations(b: BType, relations: Content extends null ? AType[] : Record<AType, Content>, config?: {
-        reckless: boolean;
-    }): this;
-    getContent(a: AType, b: BType): Content | undefined;
-    getRelationEntries(input: Record<ASide, AType>): [BType, Content][];
-    getRelationEntries(input: Record<BSide, BType>): [AType, Content][];
-    has(a: AType, b?: BType): boolean;
-    has(b: BType, a?: AType): boolean;
+declare class Junction<ASide extends string, AType extends string, BSide extends string, BType extends string, Content extends Json.Object | null = null> {
+  readonly a: ASide;
+  readonly b: BSide;
+  readonly cardinality: `1:1` | `1:n` | `n:n`;
+  readonly relations: Map<AType | BType, Set<AType> | Set<BType>>;
+  readonly contents: Map<string, Content>;
+  isAType?: Refinement<string, AType> | null;
+  isBType?: Refinement<string, BType> | null;
+  isContent: Refinement<unknown, Content> | null;
+  makeContentKey: (a: AType, b: BType) => string;
+  warn?: (...args: any[]) => void;
+  getRelatedKeys(key: AType): Set<BType> | undefined;
+  getRelatedKeys(key: BType): Set<AType> | undefined;
+  getRelatedKeys(key: AType | BType): Set<AType> | Set<BType> | undefined;
+  protected addRelation(a: AType, b: BType): void;
+  protected deleteRelation(a: AType, b: BType): void;
+  protected replaceRelationsUnsafely(a: AType, bs: BType[]): void;
+  protected replaceRelationsUnsafely(b: BType, as: AType[]): void;
+  protected replaceRelationsSafely(a: AType, bs: BType[]): void;
+  protected replaceRelationsSafely(b: BType, as: AType[]): void;
+  protected getContentInternal(contentKey: string): Content | undefined;
+  protected setContent(contentKey: string, content: Content): void;
+  protected deleteContent(contentKey: string): void;
+  constructor(data: JunctionSchema<ASide, BSide> & Partial<JunctionEntries<NoInfer<AType>, NoInfer<BType>, Content>>, config?: JunctionAdvancedConfiguration<AType, BType, Content>);
+  toJSON(): JunctionJSON<ASide, AType, BSide, BType, Content>;
+  set(a: AType, ...rest: Content extends null ? [b: BType] : [b: BType, content: Content]): this;
+  set(relation: { [Key in ASide]: AType } & { [Key in BSide]: BType }, ...rest: Content extends null ? [] | [void?: undefined] : [content: Content]): this;
+  delete(a: AType, b?: BType): this;
+  delete(b: BType, a?: AType): this;
+  delete(relation: { [Key in ASide]: AType } | { [Key in BSide]: BType } | ({ [Key in ASide]: AType } & { [Key in BSide]: BType }), b?: undefined): this;
+  getRelatedKey(key: AType): BType | undefined;
+  getRelatedKey(key: BType): AType | undefined;
+  replaceRelations(a: AType, relations: Content extends null ? BType[] : Record<BType, Content>, config?: {
+    reckless: boolean;
+  }): this;
+  replaceRelations(b: BType, relations: Content extends null ? AType[] : Record<AType, Content>, config?: {
+    reckless: boolean;
+  }): this;
+  getContent(a: AType, b: BType): Content | undefined;
+  getRelationEntries(input: Record<ASide, AType>): [BType, Content][];
+  getRelationEntries(input: Record<BSide, BType>): [AType, Content][];
+  has(a: AType, b?: BType): boolean;
+  has(b: BType, a?: AType): boolean;
 }
 
+//#endregion
+//#region src/internal/transaction/abort-transaction.d.ts
 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>;
 
+//#endregion
+//#region src/internal/transaction/apply-transaction.d.ts
 declare const applyTransaction: <F extends Func>(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/transaction/is-root-store.d.ts
 interface RootStore extends Store {
-    transactionMeta: TransactionEpoch;
-    parent: null;
-    child: ChildStore | null;
+  transactionMeta: TransactionEpoch;
+  parent: null;
+  child: ChildStore | null;
 }
 interface ChildStore extends Store {
-    transactionMeta: TransactionProgress<Func>;
-    parent: ChildStore | RootStore;
-    child: ChildStore | null;
+  transactionMeta: TransactionProgress<Func>;
+  parent: ChildStore | RootStore;
+  child: ChildStore | null;
 }
 declare function isRootStore(store: Store): store is RootStore;
 declare function isChildStore(store: Store): store is ChildStore;
 
+//#endregion
+//#region src/internal/transaction/build-transaction.d.ts
 declare const buildTransaction: (store: Store, key: string, params: any[], id: string) => ChildStore;
 
+//#endregion
+//#region src/internal/subject.d.ts
 declare class Subject<T> {
-    Subscriber: (value: T) => void;
-    subscribers: Map<string, this[`Subscriber`]>;
-    subscribe(key: string, subscriber: this[`Subscriber`]): () => void;
-    private unsubscribe;
-    next(value: T): void;
+  Subscriber: (value: T) => void;
+  subscribers: Map<string, this[`Subscriber`]>;
+  subscribe(key: string, subscriber: this[`Subscriber`]): () => void;
+  private unsubscribe;
+  next(value: T): void;
 }
 declare class StatefulSubject<T> extends Subject<T> {
-    state: T;
-    constructor(initialState: T);
-    next(value: T): void;
+  state: T;
+  constructor(initialState: T);
+  next(value: T): void;
 }
 
+//#endregion
+//#region src/internal/transaction/create-transaction.d.ts
 type Transaction<F extends Func> = {
-    key: string;
-    type: `transaction`;
-    install: (store: Store) => void;
-    subject: Subject<TransactionUpdate<F>>;
-    run: (parameters: Parameters<F>, id?: string) => ReturnType<F>;
+  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>;
 
+//#endregion
+//#region src/internal/transaction/get-epoch-number.d.ts
 declare function getContinuityKey(store: RootStore, transactionKey: string): string | undefined;
 declare function getEpochNumberOfContinuity(store: RootStore, continuityKey: string): number | undefined;
 declare function getEpochNumberOfAction(store: Store, transactionKey: string): number | undefined;
 
+//#endregion
+//#region src/internal/transaction/set-epoch-number.d.ts
 declare function setEpochNumberOfContinuity(store: Store, continuityKey: string, newEpoch: number): void;
 declare function setEpochNumberOfAction(store: Store, transactionKey: string, newEpoch: number): void;
 
+//#endregion
+//#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> = {
-    phase: `applying` | `building`;
-    update: TransactionUpdate<F>;
-    toolkit: ActorToolkit;
+  phase: `applying` | `building`;
+  update: TransactionUpdate<F>;
+  toolkit: ActorToolkit;
 };
 type TransactionEpoch = {
-    epoch: Map<string, number>;
-    actionContinuities: Junction<`continuity`, string, `action`, string>;
+  epoch: Map<string, number>;
+  actionContinuities: Junction<`continuity`, string, `action`, string>;
 };
 
+//#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>(state: Atom<T>): AtomToken<T>;
@@ -224,213 +230,196 @@ declare function deposit<T extends Func>(state: Transaction<T>): TransactionToke
 declare function deposit<M extends TimelineManageable>(state: Timeline<M>): TimelineToken<M>;
 declare function deposit(resource: AtomIOInternalResource): AtomIOToken;
 
+//#endregion
+//#region src/internal/join/edit-relations-in-store.d.ts
 declare function editRelationsInStore<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>, change: (relations: Junction<ASide, AType, BSide, BType, Content>) => void, store: Store): void;
 
+//#endregion
+//#region src/internal/join/find-relations-in-store.d.ts
 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>;
 
+//#endregion
+//#region src/internal/molecule.d.ts
 type Molecule<K extends Canonical> = {
-    readonly key: K;
-    readonly stringKey: stringified<K>;
-    readonly dependsOn: `all` | `any`;
+  readonly key: K;
+  readonly stringKey: stringified<K>;
+  readonly dependsOn: `all` | `any`;
 };
 declare function makeRootMoleculeInStore<S extends string>(key: S, store?: Store): S;
 declare function allocateIntoStore<H extends Hierarchy, V extends Vassal<H>, A extends Above<V, H>>(store: Store, provenance: A, key: V, dependsOn?: `all` | `any`): Claim<V>;
-declare function fuseWithinStore<H extends Hierarchy, C extends CompoundFrom<H>, T extends C extends CompoundTypedKey<infer t, any, any> ? t : never, A extends C extends CompoundTypedKey<any, infer a, any> ? a : never, B extends C extends CompoundTypedKey<any, any, infer b> ? b : never>(store: Store, type: T, sideA: SingularTypedKey<A>, sideB: SingularTypedKey<B>): Claim<CompoundTypedKey<T, A, B>>;
+declare function fuseWithinStore<H extends Hierarchy, C extends CompoundFrom<H>, T extends (C extends CompoundTypedKey<infer t, any, any> ? t : never), A extends (C extends CompoundTypedKey<any, infer a, any> ? a : never), B extends (C extends CompoundTypedKey<any, any, infer b> ? b : never)>(store: Store, type: T, sideA: SingularTypedKey<A>, sideB: SingularTypedKey<B>): Claim<CompoundTypedKey<T, A, B>>;
 declare function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(store: Store, claim: Claim<V>): void;
 declare function claimWithinStore<H extends Hierarchy, V extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V, H>>(store: Store, newProvenance: A, claim: Claim<V>, exclusive?: `exclusive`): Claim<V>;
 
-type JoinStateFamilies<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> = Cardinality extends `1:1` ? (Content extends Json.Object ? {
-    readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<[
-        AType,
-        Content
-    ] | null, BType>;
-} & {
-    readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[
-        BType,
-        Content
-    ] | null, AType>;
-} : {}) & {
-    readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<AType | null, BType>;
-} & {
-    readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<BType | null, AType>;
-} : Cardinality extends `1:n` ? (Content extends Json.Object ? {
-    readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<[
-        AType,
-        Content
-    ] | null, BType>;
-} & {
-    readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[
-        BType,
-        Content
-    ][], AType>;
-} : {}) & {
-    readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<AType | null, BType>;
-} & {
-    readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<BType[], AType>;
-} : Cardinality extends `n:n` ? (Content extends Json.Object ? {
-    readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<[
-        AType,
-        Content
-    ][], BType>;
-} & {
-    readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[
-        BType,
-        Content
-    ][], AType>;
-} : {}) & {
-    readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<AType[], BType>;
-} & {
-    readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<BType[], AType>;
-} : never;
-declare class Join<const ASide extends string, const AType extends string, const BSide extends string, const BType extends string, const Cardinality extends `1:1` | `1:n` | `n:n`, const Content extends Json.Object | null = null, const ContentKey extends CompoundTypedKey<`content`, ASide, BSide> = CompoundTypedKey<`content`, ASide, BSide>> {
-    private toolkit;
-    options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>;
-    defaultContent: Content | undefined;
-    molecules: Map<string, Molecule<any>>;
-    relations: Junction<ASide, AType, BSide, BType, Content>;
-    states: JoinStateFamilies<ASide, AType, BSide, BType, Cardinality, Content>;
-    core: {
-        relatedKeysAtoms: MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string>;
-    };
-    transact(toolkit: SetterToolkit, run: (join: Join<ASide, AType, BSide, BType, Cardinality, Content>) => void): void;
-    store: Store;
-    realm: Anarchy;
-    [Symbol.dispose](): void;
-    constructor(options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>, defaultContent: Content | undefined, store?: Store);
+//#endregion
+//#region src/internal/join/join-internal.d.ts
+type JoinStateFamilies<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> = Cardinality extends `1:1` ? (Content extends Json.Object ? { readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<[AType, Content] | null, BType> } & { readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[BType, Content] | null, AType> } : {}) & { readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<AType | null, BType> } & { readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<BType | null, AType> } : Cardinality extends `1:n` ? (Content extends Json.Object ? { readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<[AType, Content] | null, BType> } & { readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[BType, Content][], AType> } : {}) & { readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<AType | null, BType> } & { readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<BType[], AType> } : Cardinality extends `n:n` ? (Content extends Json.Object ? { readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<[AType, Content][], BType> } & { readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[BType, Content][], AType> } : {}) & { readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<AType[], BType> } & { readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<BType[], AType> } : never;
+declare class Join<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 = null, ContentKey extends CompoundTypedKey<`content`, ASide, BSide> = CompoundTypedKey<`content`, ASide, BSide>> {
+  private toolkit;
+  options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>;
+  defaultContent: Content | undefined;
+  molecules: Map<string, Molecule<any>>;
+  relations: Junction<ASide, AType, BSide, BType, Content>;
+  states: JoinStateFamilies<ASide, AType, BSide, BType, Cardinality, Content>;
+  core: {
+    relatedKeysAtoms: MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string>;
+  };
+  transact(toolkit: SetterToolkit, run: (join: Join<ASide, AType, BSide, BType, Cardinality, Content>) => void): void;
+  store: Store;
+  realm: Anarchy;
+  [Symbol.dispose](): void;
+  constructor(options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>, defaultContent: Content | undefined, store?: Store);
 }
 
+//#endregion
+//#region src/internal/join/get-join.d.ts
 declare function getJoin<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>, store: Store): Join<ASide, AType, BSide, BType, Cardinality, Content>;
 
+//#endregion
+//#region src/internal/lineage.d.ts
 interface Lineage {
-    parent: typeof this | null;
-    child: typeof this | null;
+  parent: typeof this | null;
+  child: typeof this | null;
 }
 declare function newest<T extends Lineage>(scion: T): T;
 
+//#endregion
+//#region src/internal/operation.d.ts
 type OperationProgress = {
-    open: false;
+  open: false;
 } | {
-    open: true;
-    done: Set<string>;
-    prev: Map<string, any>;
-    time: number;
-    token: WritableToken<any>;
+  open: true;
+  done: Set<string>;
+  prev: Map<string, any>;
+  time: number;
+  token: WritableToken<any>;
 };
 declare const openOperation: (store: Store, token: WritableToken<any>) => number | undefined;
 declare const closeOperation: (store: Store) => void;
 declare const isDone: (store: Store, key: string) => boolean;
 declare const markDone: (store: Store, key: string) => void;
 
+//#endregion
+//#region src/internal/timeline/create-timeline.d.ts
 type TimelineAtomUpdate<ManagedAtom extends TimelineManageable> = Flat<StateUpdate<TokenType<ManagedAtom>> & {
-    key: string;
-    type: `atom_update`;
-    timestamp: number;
-    family?: FamilyMetadata;
+  key: string;
+  type: `atom_update`;
+  timestamp: number;
+  family?: FamilyMetadata;
 }>;
 type TimelineSelectorUpdate<ManagedAtom extends TimelineManageable> = {
-    key: string;
-    type: `selector_update`;
-    timestamp: number;
-    atomUpdates: Omit<TimelineAtomUpdate<ManagedAtom>, `timestamp`>[];
+  key: string;
+  type: `selector_update`;
+  timestamp: number;
+  atomUpdates: Omit<TimelineAtomUpdate<ManagedAtom>, `timestamp`>[];
 };
 type TimelineTransactionUpdate = Flat<TransactionUpdate<Func> & {
-    key: string;
-    type: `transaction_update`;
-    timestamp: number;
+  key: string;
+  type: `transaction_update`;
+  timestamp: number;
 }>;
 type TimelineStateCreation<T extends ReadableToken<any>> = Flat<StateCreation<T> & {
-    timestamp: number;
+  timestamp: number;
 }>;
 type TimelineStateDisposal<T extends ReadableToken<any>> = Flat<StateDisposal<T> & {
-    timestamp: number;
+  timestamp: number;
 }>;
 type TimelineMoleculeCreation = Flat<MoleculeCreation & {
-    timestamp: number;
+  timestamp: number;
 }>;
 type TimelineMoleculeDisposal = Flat<MoleculeDisposal & {
-    timestamp: number;
+  timestamp: number;
 }>;
 type Timeline<ManagedAtom extends TimelineManageable> = {
-    type: `timeline`;
-    key: string;
-    at: number;
-    shouldCapture?: (update: TimelineUpdate<ManagedAtom>, timeline: Timeline<ManagedAtom>) => boolean;
-    timeTraveling: `into_future` | `into_past` | null;
-    history: TimelineUpdate<ManagedAtom>[];
-    selectorTime: number | null;
-    transactionKey: string | null;
-    install: (store: Store) => void;
-    subject: Subject<TimelineUpdate<ManagedAtom> | `redo` | `undo`>;
-    subscriptions: Map<string, () => void>;
+  type: `timeline`;
+  key: string;
+  at: number;
+  shouldCapture?: (update: TimelineUpdate<ManagedAtom>, timeline: Timeline<ManagedAtom>) => boolean;
+  timeTraveling: `into_future` | `into_past` | null;
+  history: TimelineUpdate<ManagedAtom>[];
+  selectorTime: number | null;
+  transactionKey: string | null;
+  install: (store: Store) => void;
+  subject: Subject<TimelineUpdate<ManagedAtom> | `redo` | `undo`>;
+  subscriptions: Map<string, () => void>;
 };
 declare function createTimeline<ManagedAtom extends TimelineManageable>(store: Store, options: TimelineOptions<ManagedAtom>, data?: Timeline<ManagedAtom>): TimelineToken<ManagedAtom>;
 
+//#endregion
+//#region src/internal/timeline/time-travel.d.ts
 declare const timeTravel: (store: Store, action: `redo` | `undo`, token: TimelineToken<any>) => void;
 
+//#endregion
+//#region src/internal/store/store.d.ts
 declare class Store implements Lineage {
-    parent: Store | null;
-    child: Store | null;
-    valueMap: Map<string, any>;
-    defaults: Map<string, any>;
-    atoms: Map<string, Atom<any>>;
-    selectors: Map<string, WritableSelector<any>>;
-    readonlySelectors: Map<string, ReadonlySelector<any>>;
-    atomsThatAreDefault: Set<string>;
-    selectorAtoms: Junction<"selectorKey", string, "atomKey", string, null>;
-    selectorGraph: Junction<"upstreamSelectorKey", string, "downstreamSelectorKey", string, {
-        source: string;
-    }>;
-    trackers: Map<string, Tracker<Transceiver<any>>>;
-    families: Map<string, MutableAtomFamily<any, any, any> | RegularAtomFamily<any, any> | ReadonlySelectorFamily<any, any> | WritableSelectorFamily<any, any>>;
-    joins: Map<string, Join<any, any, any, any, any, any, `T$--content==${any}::${string}++${any}::${string}`>>;
-    transactions: Map<string, Transaction<Func>>;
-    transactionMeta: TransactionEpoch | TransactionProgress<Func>;
-    timelines: Map<string, Timeline<any>>;
-    timelineTopics: Junction<"timelineKey", string, "topicKey", string, {
-        topicType: `atom_family` | `atom` | `molecule_family` | `molecule`;
-    }>;
-    disposalTraces: CircularBuffer<{
-        key: string;
-        trace: string;
-    }>;
-    molecules: Map<string, Molecule<Canonical>>;
-    moleculeJoins: Junction<"moleculeKey", stringified<Canonical>, "joinKey", string, null>;
-    moleculeGraph: Junction<"upstreamMoleculeKey", stringified<Canonical> | "root", "downstreamMoleculeKey", stringified<Canonical>, {
-        source: stringified<Canonical>;
-    }>;
-    moleculeData: Junction<"moleculeKey", stringified<Canonical>, "stateFamilyKey", string, null>;
-    miscResources: Map<string, Disposable>;
-    on: {
-        atomCreation: Subject<AtomToken<unknown>>;
-        atomDisposal: Subject<AtomToken<unknown>>;
-        selectorCreation: Subject<ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>>;
-        selectorDisposal: Subject<ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>>;
-        timelineCreation: Subject<TimelineToken<unknown>>;
-        transactionCreation: Subject<TransactionToken<Func>>;
-        transactionApplying: StatefulSubject<TransactionProgress<Func> | null>;
-        operationClose: Subject<OperationProgress>;
-        moleculeCreation: Subject<MoleculeCreation>;
-        moleculeDisposal: Subject<MoleculeDisposal>;
-    };
-    operation: OperationProgress;
-    config: {
-        name: string;
-        lifespan: `ephemeral` | `immortal`;
-    };
-    loggers: AtomIOLogger[];
-    logger: Logger;
-    constructor(config: Store[`config`], store?: Store | null);
+  parent: Store | null;
+  child: Store | null;
+  valueMap: Map<string, any>;
+  defaults: Map<string, any>;
+  atoms: Map<string, Atom<any>>;
+  selectors: Map<string, WritableSelector<any>>;
+  readonlySelectors: Map<string, ReadonlySelector<any>>;
+  atomsThatAreDefault: Set<string>;
+  selectorAtoms: Junction<`selectorKey`, string, `atomKey`, string>;
+  selectorGraph: Junction<`upstreamSelectorKey`, string, `downstreamSelectorKey`, string, {
+    source: string;
+  }>;
+  trackers: Map<string, Tracker<Transceiver<any>>>;
+  families: Map<string, MutableAtomFamily<any, any, any> | ReadonlySelectorFamily<any, any> | RegularAtomFamily<any, any> | WritableSelectorFamily<any, any>>;
+  joins: Map<string, Join<any, any, any, any, any, any>>;
+  transactions: Map<string, Transaction<Func>>;
+  transactionMeta: TransactionEpoch | TransactionProgress<Func>;
+  timelines: Map<string, Timeline<any>>;
+  timelineTopics: Junction<`timelineKey`, string, `topicKey`, string, {
+    topicType: `atom_family` | `atom` | `molecule_family` | `molecule`;
+  }>;
+  disposalTraces: CircularBuffer<{
+    key: string;
+    trace: string;
+  }>;
+  molecules: Map<string, Molecule<Canonical>>;
+  moleculeJoins: Junction<`moleculeKey`, stringified<Canonical>, `joinKey`, string>;
+  moleculeGraph: Junction<`upstreamMoleculeKey`, stringified<Canonical> | `root`, `downstreamMoleculeKey`, stringified<Canonical>, {
+    source: stringified<Canonical>;
+  }>;
+  moleculeData: Junction<`moleculeKey`, stringified<Canonical>, `stateFamilyKey`, string>;
+  miscResources: Map<string, Disposable>;
+  on: StoreEventCarrier;
+  operation: OperationProgress;
+  config: {
+    name: string;
+    lifespan: `ephemeral` | `immortal`;
+  };
+  loggers: AtomIOLogger[];
+  logger: Logger;
+  constructor(config: Store[`config`], store?: Store | null);
 }
+type StoreEventCarrier = {
+  atomCreation: Subject<AtomToken<unknown>>;
+  atomDisposal: Subject<AtomToken<unknown>>;
+  selectorCreation: Subject<ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>>;
+  selectorDisposal: Subject<ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>>;
+  timelineCreation: Subject<TimelineToken<unknown>>;
+  transactionCreation: Subject<TransactionToken<Func>>;
+  transactionApplying: StatefulSubject<TransactionProgress<Func> | null>;
+  operationClose: Subject<OperationProgress>;
+  moleculeCreation: Subject<MoleculeCreation>;
+  moleculeDisposal: Subject<MoleculeDisposal>;
+};
 declare global {
-    var ATOM_IO_IMPLICIT_STORE: Store | undefined;
+  var ATOM_IO_IMPLICIT_STORE: Store | undefined;
 }
 declare const IMPLICIT: {
-    readonly STORE: Store;
+  STORE: () => Store;
 };
 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>(store: Store, token: AtomToken<T>): Atom<T>;
@@ -453,108 +442,156 @@ declare function withdraw<T>(store: Store, token: WritableToken<T>): WritableSta
 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> {
-    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;
+  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;
 }
 declare function isTransceiver(value: unknown): value is Transceiver<Json.Serializable>;
 type TransceiverMode = `playback` | `record` | `transaction`;
-type Signal<TVR extends Transceiver<any>> = TVR extends Transceiver<infer S> ? S : never;
+type Signal$1<TVR extends Transceiver<any>> = TVR extends Transceiver<infer S> ? S : never;
 
+//#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>;
 
+//#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>;
 
+//#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) => WritableSelectorFamily<SerializableCore, 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>) => WritableSelectorToken<SerializableCore>;
 
-declare const getUpdateFamily: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable, Key extends string>(mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>, store: Store) => AtomFamily<Signal<Core>, Key>;
+//#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 getUpdateToken: <Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => RegularAtomToken<Signal<Core>>;
+//#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>>;
 
+//#endregion
+//#region src/internal/mutable/tracker.d.ts
 /**
- * @internal Give the tracker a transceiver state and a store, and it will
- * subscribe to the transceiver's inner value. When the inner value changes,
- * the tracker will update its own state to reflect the change.
- */
+* @internal Give the tracker a transceiver state and a store, and it will
+* 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 Update;
-    private initializeState;
-    private unsubscribeFromInnerValue;
-    private unsubscribeFromState;
-    private observeCore;
-    private updateCore;
-    mutableState: MutableAtomToken<Mutable, Json.Serializable>;
-    latestUpdateState: RegularAtomToken<typeof this.Update | null>;
-    [Symbol.dispose]: () => void;
-    constructor(mutableState: MutableAtomToken<Mutable, Json.Serializable>, store: Store);
+  private initializeState;
+  private unsubscribeFromInnerValue;
+  private unsubscribeFromState;
+  private observeCore;
+  private updateCore;
+  mutableState: MutableAtomToken<Mutable, Json.Serializable>;
+  latestUpdateState: RegularAtomToken<(Mutable extends Transceiver<infer Signal> ? Signal : never) | null>;
+  [Symbol.dispose]: () => void;
+  constructor(mutableState: MutableAtomToken<Mutable, Json.Serializable>, store: Store);
 }
 
+//#endregion
+//#region src/internal/mutable/tracker-family.d.ts
 declare class FamilyTracker<Core extends Transceiver<any>, FamilyMemberKey extends Canonical> {
-    private trackers;
-    private readonly Update;
-    readonly latestUpdateAtoms: RegularAtomFamily<typeof this.Update | null, FamilyMemberKey>;
-    readonly mutableAtoms: MutableAtomFamily<Core, any, FamilyMemberKey>;
-    constructor(mutableAtoms: MutableAtomFamily<Core, any, FamilyMemberKey>, store: Store);
+  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);
 }
 
+//#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>;
 
+//#endregion
+//#region src/internal/atom/create-standalone-atom.d.ts
 declare function createStandaloneAtom<T>(store: Store, options: RegularAtomOptions<T>): RegularAtomToken<T>;
 declare function createStandaloneAtom<T extends Transceiver<any>, J extends Json.Serializable>(store: Store, options: MutableAtomOptions<T, J>): MutableAtomToken<T, J>;
 
+//#endregion
+//#region src/internal/atom/dispose-atom.d.ts
 declare function disposeAtom(store: Store, atomToken: AtomToken<unknown>): void;
 
+//#endregion
+//#region src/internal/atom/is-default.d.ts
 declare const isAtomDefault: (store: Store, key: string) => boolean;
 declare const markAtomAsDefault: (store: Store, key: string) => void;
 declare const markAtomAsNotDefault: (store: Store, key: string) => void;
 
+//#endregion
+//#region src/internal/future.d.ts
 /**
- * A Promise whose incoming value can be hot swapped.
- * @internal
- * @private
- * @typeParam T The type of the value that the promise will resolve to.
- *
- * @remarks
- * Can be constructed like a Promise, or from an existing Promise.
- */
+* A Promise whose incoming value can be hot swapped.
+* @internal
+* @private
+* @typeParam T The type of the value that the promise will resolve to.
+*
+* @remarks
+* Can be constructed like a Promise, or from an existing Promise.
+*/
 declare class Future<T> extends Promise<T> {
-    private fate;
-    private resolve;
-    private reject;
-    done: boolean;
-    constructor(executor: Promise<T> | ((resolve: (value: T) => void, reject: (reason?: any) => void) => void));
-    private pass;
-    private fail;
-    use(value: Promise<T> | T): void;
+  private fate;
+  private resolve;
+  private reject;
+  done: boolean;
+  constructor(executor: Promise<T> | ((resolve: (value: T) => void, reject: (reason?: any) => void) => void));
+  private pass;
+  private fail;
+  use(value: Promise<T> | T): void;
 }
 
+//#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>(token: ReadableState<any>, target: Store) => T;
 declare const evictCachedValue: (key: string, target: Store) => void;
 
+//#endregion
+//#region src/internal/capitalize.d.ts
 declare function capitalize<S extends string>(string: S): Capitalize<S>;
 
+//#endregion
+//#region src/internal/families/create-atom-family.d.ts
 declare function createAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(store: Store, options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamilyToken<T, J, K>;
 declare function createAtomFamily<T, K extends Canonical>(store: Store, options: RegularAtomFamilyOptions<T, K>): RegularAtomFamilyToken<T, K>;
 
+//#endregion
+//#region src/internal/families/create-readonly-selector-family.d.ts
 declare function createReadonlySelectorFamily<T, K extends Canonical>(store: Store, options: ReadonlySelectorFamilyOptions<T, K>, internalRoles?: string[]): ReadonlySelectorFamilyToken<T, K>;
 
+//#endregion
+//#region src/internal/families/create-regular-atom-family.d.ts
 declare function createRegularAtomFamily<T, K extends Canonical>(store: Store, options: RegularAtomFamilyOptions<T, K>, internalRoles?: string[]): RegularAtomFamilyToken<T, K>;
 
+//#endregion
+//#region src/internal/families/create-selector-family.d.ts
 declare function createSelectorFamily<T, K extends Canonical>(store: Store, options: WritableSelectorFamilyOptions<T, K>): WritableSelectorFamilyToken<T, K>;
 declare function createSelectorFamily<T, K extends Canonical>(store: Store, options: ReadonlySelectorFamilyOptions<T, K>): ReadonlySelectorFamilyToken<T, K>;
 
+//#endregion
+//#region src/internal/families/create-writable-selector-family.d.ts
+declare function createWritableSelectorFamily<T, K extends Canonical>(store: Store, options: WritableSelectorFamilyOptions<T, K>, internalRoles?: string[]): WritableSelectorFamilyToken<T, K>;
+
+//#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>(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, 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>;
@@ -564,6 +601,8 @@ 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: WritableFamilyToken<T, K>, key: Key): WritableToken<T, K>;
 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, 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>;
@@ -573,6 +612,8 @@ declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableFamilyToken<T, K>, key: Key): WritableToken<T, 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, 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;
@@ -582,41 +623,71 @@ declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store
 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;
 
+//#endregion
+//#region src/internal/get-environment-data.d.ts
 type EnvironmentData = {
-    store: Store;
+  store: Store;
 };
 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;
 
+//#endregion
+//#region src/internal/get-state/read-or-compute-value.d.ts
 declare const readOrComputeValue: <T>(target: Store, state: ReadableState<T>) => T;
 
+//#endregion
+//#region src/internal/get-trace.d.ts
 declare function getTrace(error: Error): string;
 
+//#endregion
+//#region src/internal/ingest-updates/ingest-atom-update.d.ts
 declare function ingestAtomUpdate(applying: `newValue` | `oldValue`, atomUpdate: KeyedStateUpdate<any>, store: Store): void;
 
+//#endregion
+//#region src/internal/ingest-updates/ingest-creation-disposal.d.ts
 declare function ingestCreationEvent(update: StateCreation<any>, applying: `newValue` | `oldValue`, store: Store): void;
 declare function ingestDisposalEvent(update: StateDisposal<ReadableToken<any>>, applying: `newValue` | `oldValue`, store: Store): void;
 declare function ingestMoleculeCreationEvent(update: MoleculeCreation, applying: `newValue` | `oldValue`, store: Store): void;
 declare function ingestMoleculeDisposalEvent(update: MoleculeDisposal, applying: `newValue` | `oldValue`, store: Store): void;
 declare function ingestMoleculeTransferEvent(update: MoleculeTransfer, applying: `newValue` | `oldValue`, store: Store): void;
 
+//#endregion
+//#region src/internal/ingest-updates/ingest-selector-update.d.ts
 declare function ingestSelectorUpdate(applying: `newValue` | `oldValue`, selectorUpdate: TimelineSelectorUpdate<any>, store: Store): void;
 
+//#endregion
+//#region src/internal/ingest-updates/ingest-transaction-update.d.ts
 declare function ingestTransactionUpdate(applying: `newValue` | `oldValue`, transactionUpdate: TransactionUpdate<any>, store: Store): void;
 
+//#endregion
+//#region src/internal/install-into-store.d.ts
+/**
+* @public
+* Install the given tokens into the target store
+* @param tokens - States, families, transactions, and timelines to install into the target store
+* @param target - The store to install the tokens into
+* @param source - The store to install the tokens from
+*
+*/
+declare function installIntoStore(tokens: AtomIOToken[], target: Store, source: Store): void;
+
+//#endregion
+//#region src/internal/keys.d.ts
 type AtomKey<T> = string & {
-    __atomKey?: never;
-    __brand?: T;
+  __atomKey?: never;
+  __brand?: T;
 };
 type SelectorKey<T> = string & {
-    __selectorKey?: never;
-    __brand?: T;
+  __selectorKey?: never;
+  __brand?: T;
 };
 type ReadonlySelectorKey<T> = string & {
-    __readonlySelectorKey?: never;
-    __brand?: T;
+  __readonlySelectorKey?: never;
+  __brand?: T;
 };
 declare const isAtomKey: (store: Store, key: string) => key is AtomKey<unknown>;
 declare const isSelectorKey: (store: Store, key: string) => key is SelectorKey<unknown>;
@@ -624,127 +695,173 @@ 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;
+  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);
+  constructor(token: AtomIOToken, store: Store);
 }
 
+//#endregion
+//#region src/internal/pretty-print.d.ts
 declare function prettyPrintTokenType(token: AtomIOToken): string;
 
+//#endregion
+//#region src/internal/reserved-keys.d.ts
 type ReservedIntrospectionKey = `🔍 ${string}`;
 declare function isReservedIntrospectionKey(value: string): value is ReservedIntrospectionKey;
 
+//#endregion
+//#region src/internal/selector/create-readonly-selector.d.ts
 declare const createReadonlySelector: <T>(store: Store, options: ReadonlySelectorOptions<T>, family: FamilyMetadata | undefined) => ReadonlySelectorToken<T>;
 
+//#endregion
+//#region src/internal/selector/create-standalone-selector.d.ts
 declare function createStandaloneSelector<T>(store: Store, options: WritableSelectorOptions<T>): WritableSelectorToken<T>;
 declare function createStandaloneSelector<T>(store: Store, options: ReadonlySelectorOptions<T>): ReadonlySelectorToken<T>;
 
+//#endregion
+//#region src/internal/selector/create-writable-selector.d.ts
 declare const createWritableSelector: <T>(store: Store, options: WritableSelectorOptions<T>, family: FamilyMetadata | undefined) => WritableSelectorToken<T>;
 
+//#endregion
+//#region src/internal/selector/dispose-selector.d.ts
 declare function disposeSelector(store: Store, selectorToken: SelectorToken<unknown>): void;
 
+//#endregion
+//#region src/internal/selector/get-selector-dependency-keys.d.ts
 declare const getSelectorDependencyKeys: (key: string, store: Store) => (AtomKey<unknown> | ReadonlySelectorKey<unknown> | SelectorKey<unknown>)[];
 
+//#endregion
+//#region src/internal/selector/register-selector.d.ts
 declare const registerSelector: (selectorKey: string, covered: Set<string>, store: Store) => SetterToolkit;
 
+//#endregion
+//#region src/internal/selector/trace-selector-atoms.d.ts
 declare const traceSelectorAtoms: (directDependencyKey: StateKey<unknown>, covered: Set<string>, store: Store) => AtomKey<unknown>[];
 declare const traceAllSelectorAtoms: (selector: Selector<any>, store: Store) => AtomKey<unknown>[];
 
+//#endregion
+//#region src/internal/selector/update-selector-atoms.d.ts
 declare const updateSelectorAtoms: (selectorKey: string, dependency: ReadonlySelectorToken<unknown> | WritableToken<unknown>, covered: Set<string>, store: Store) => void;
 
+//#endregion
+//#region src/internal/set-state/become.d.ts
 type Modify<T> = (thing: T) => T;
 declare const become: <T>(nextVersionOfThing: Modify<T> | T) => (originalThing: T) => T;
 
+//#endregion
+//#region src/internal/set-state/set-atom-or-selector.d.ts
 declare const setAtomOrSelector: <T>(store: Store, state: WritableState<T>, value: T | ((oldValue: T) => T)) => void;
 
+//#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 | ((oldValue: T) => New)): void;
 declare function setIntoStore<T, K extends Canonical, New extends T>(store: Store, token: WritableFamilyToken<T, K>, key: K, value: New | ((oldValue: T) => New)): void;
 
+//#endregion
+//#region src/internal/subscribe/recall-state.d.ts
 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<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
+//#region src/internal/subscribe/subscribe-to-root-atoms.d.ts
 declare const subscribeToRootAtoms: <T>(store: Store, selector: Selector<T>) => (() => 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;
 
+//#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: 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);
 
+//#endregion
+//#region src/internal/index.d.ts
 type AtomIOState = {
-    key: string;
-    family?: FamilyMetadata;
-    install: (store: Store) => void;
-    subject: Subject<{
-        newValue: any;
-        oldValue: any;
-    }>;
+  key: string;
+  family?: FamilyMetadata;
+  install: (store: Store) => void;
+  subject: Subject<{
+    newValue: any;
+    oldValue: any;
+  }>;
 };
 type RegularAtom<T> = AtomIOState & {
-    type: `atom`;
-    default: T | (() => T);
-    cleanup?: () => void;
+  type: `atom`;
+  default: T | (() => T);
+  cleanup?: () => void;
 };
 type MutableAtom<T extends Transceiver<any>, J extends Json.Serializable> = AtomIOState & JsonInterface<T, J> & {
-    type: `mutable_atom`;
-    default: () => T;
-    cleanup?: () => void;
+  type: `mutable_atom`;
+  default: () => T;
+  cleanup?: () => void;
 };
 type Atom<T> = RegularAtom<T> | (T extends Transceiver<any> ? MutableAtom<T, any> : never);
 type WritableSelector<T> = AtomIOState & {
-    type: `selector`;
-    get: () => T;
-    set: (newValue: T | ((oldValue: T) => T)) => void;
+  type: `selector`;
+  get: () => T;
+  set: (newValue: T | ((oldValue: T) => T)) => void;
 };
 type ReadonlySelector<T> = AtomIOState & {
-    type: `readonly_selector`;
-    get: () => T;
+  type: `readonly_selector`;
+  get: () => T;
 };
 type Selector<T> = ReadonlySelector<T> | WritableSelector<T>;
 type WritableState<T> = Atom<T> | WritableSelector<T>;
 type ReadableState<T> = Atom<T> | Selector<T>;
 type RegularAtomFamily<T, K extends Canonical> = RegularAtomFamilyToken<T, K> & {
-    (key: K): RegularAtomToken<T>;
-    subject: Subject<StateCreation<AtomToken<T>> | StateDisposal<AtomToken<T>>>;
-    install: (store: Store) => void;
-    internalRoles: string[] | undefined;
+  (key: K): RegularAtomToken<T>;
+  subject: Subject<StateCreation<AtomToken<T>> | StateDisposal<AtomToken<T>>>;
+  install: (store: Store) => void;
+  internalRoles: string[] | undefined;
 };
 type MutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical> = JsonInterface<T, J> & MutableAtomFamilyToken<T, J, K> & {
-    (key: K): MutableAtomToken<T, J>;
-    subject: Subject<StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>>;
-    install: (store: Store) => void;
-    internalRoles: string[] | undefined;
+  (key: K): MutableAtomToken<T, J>;
+  subject: Subject<StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>>;
+  install: (store: Store) => void;
+  internalRoles: string[] | undefined;
 };
 type AtomFamily<T, K extends Canonical = Canonical> = MutableAtomFamily<T extends Transceiver<any> ? T : never, any, K> | RegularAtomFamily<T, K>;
 type WritableSelectorFamily<T, K extends Canonical> = WritableSelectorFamilyToken<T, K> & ((key: K) => WritableSelectorToken<T>) & {
-    default: (key: K) => T;
-    subject: Subject<StateCreation<WritableSelectorToken<T>> | StateDisposal<WritableSelectorToken<T>>>;
-    install: (store: Store) => void;
-    internalRoles: string[] | undefined;
+  default: (key: K) => T;
+  subject: Subject<StateCreation<WritableSelectorToken<T>> | StateDisposal<WritableSelectorToken<T>>>;
+  install: (store: Store) => void;
+  internalRoles: string[] | undefined;
 };
 type ReadonlySelectorFamily<T, K extends Canonical> = ReadonlySelectorFamilyToken<T, K> & ((key: K) => ReadonlySelectorToken<T>) & {
-    default: (key: K) => T;
-    subject: Subject<StateCreation<ReadonlySelectorToken<T>> | StateDisposal<ReadonlySelectorToken<T>>>;
-    install: (store: Store) => void;
-    internalRoles: string[] | undefined;
+  default: (key: K) => T;
+  subject: Subject<StateCreation<ReadonlySelectorToken<T>> | StateDisposal<ReadonlySelectorToken<T>>>;
+  install: (store: Store) => void;
+  internalRoles: string[] | undefined;
 };
 type SelectorFamily<T, K extends Canonical> = ReadonlySelectorFamily<T, K> | WritableSelectorFamily<T, K>;
 type WritableFamily<T, K extends Canonical> = AtomFamily<T, K> | WritableSelectorFamily<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>;
 
-export { type Atom, type AtomFamily, type AtomIOInternalResource, type AtomIOState, type AtomKey, type BaseExternalStoreConfiguration, type ChildStore, CircularBuffer, type Count, type Each, type Empty, type EnvironmentData, type ExternalStoreConfiguration, type ExternalStoreWithContentConfiguration, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, type Flat, type Func, Future, IMPLICIT, Join, type JoinStateFamilies, Junction, type JunctionAdvancedConfiguration, type JunctionEntries, type JunctionEntriesBase, type JunctionJSON, type JunctionSchema, type JunctionSchemaBase, LazyMap, type Lineage, type Modify, type Molecule, type MutableAtom, type MutableAtomFamily, NotFoundError, type OperationProgress, type ReadableFamily, type ReadableState, type ReadonlySelector, type ReadonlySelectorFamily, type ReadonlySelectorKey, type Refinement, type RegularAtom, type RegularAtomFamily, type ReservedIntrospectionKey, type RootStore, type Selector, type SelectorFamily, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineMoleculeCreation, type TimelineMoleculeDisposal, type TimelineSelectorUpdate, type TimelineStateCreation, type TimelineStateDisposal, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type WritableFamily, type WritableSelector, type WritableSelectorFamily, type WritableState, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, capitalize, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, 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, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+//#endregion
+export { Atom, AtomFamily, AtomIOInternalResource, AtomIOState, AtomKey, BaseExternalStoreConfiguration, ChildStore, CircularBuffer, Count, Each, Empty, EnvironmentData, ExternalStoreConfiguration, ExternalStoreWithContentConfiguration, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Flat, Func, Future, IMPLICIT, Join, JoinStateFamilies, Junction, JunctionAdvancedConfiguration, JunctionEntries, JunctionEntriesBase, JunctionJSON, JunctionSchema, JunctionSchemaBase, LazyMap, Lineage, Modify, Molecule, MutableAtom, MutableAtomFamily, NotFoundError, OperationProgress, ReadableFamily, ReadableState, 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, WritableSelector, WritableSelectorFamily, WritableState, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, capitalize, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, createWritableSelectorFamily, 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, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+//# sourceMappingURL=index.d.ts.map