atom.io 0.32.0 → 0.32.2

package/realtime-testing/dist/index.d.ts

@@ -1,1097 +1,9 @@
 import { RenderResult } from '@testing-library/react';
+import * as AtomIO from 'atom.io';
 import * as React from 'react';
 import * as SocketIO from 'socket.io';
 import { Socket } from 'socket.io-client';
 
-type primitive = boolean | number | string | null;
-declare namespace Json {
-    namespace Tree {
-        type Array<Element = unknown> = ReadonlyArray<Element>;
-        type Object<K extends string = string, V = unknown> = Record<K, V>;
-        type Fork = Array | Object;
-        type Leaf = primitive;
-        type Node = Fork | Leaf;
-    }
-    type Serializable = primitive | Readonly<{
-        [key: string]: Serializable;
-    }> | ReadonlyArray<Serializable>;
-    type Object<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
-    type Array<Element extends Serializable = Serializable> = ReadonlyArray<Element>;
-}
-type stringified<J extends Json.Serializable> = J extends string ? `"${J}"` : J extends number ? `${J}` : J extends true ? `true` : J extends false ? `false` : J extends boolean ? `false` | `true` : J extends null ? `null` : string & {
-    __json?: J;
-};
-type Canonical = primitive | ReadonlyArray<Canonical>;
-type JsonInterface<T, J extends Json.Serializable = Json.Serializable> = {
-    toJson: (t: T) => J;
-    fromJson: (json: J) => T;
-};
-
-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>;
-}
-
-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 Refinement<A, B extends A> = (a: A) => a is B;
-
-type JunctionEntriesBase<AType extends string, BType extends string, Content extends Json.Object | null> = {
-    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> {
-}
-type JunctionSchemaBase<ASide extends string, BSide extends string> = {
-    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> {
-}
-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;
-};
-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;
-};
-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;
-};
-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 Subject<T> {
-    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;
-}
-
-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>;
-};
-
-type TransactionProgress<F extends Func> = {
-    phase: `applying` | `building`;
-    update: TransactionUpdate<F>;
-    toolkit: ActorToolkit;
-};
-type TransactionEpoch = {
-    epoch: Map<string, number>;
-    actionContinuities: Junction<`continuity`, string, `action`, string>;
-};
-
-type SetUpdate = `add:${string}` | `clear:${string}` | `del:${string}` | `tx:${string}`;
-type NumberedSetUpdate = `${number}=${SetUpdate}`;
-interface SetRTXJson<P extends primitive> extends Json.Object {
-    members: P[];
-    cache: (NumberedSetUpdate | null)[];
-    cacheLimit: number;
-    cacheIdx: number;
-    cacheUpdateNumber: number;
-}
-declare class SetRTX<P extends primitive> extends Set<P> implements Transceiver<NumberedSetUpdate>, Lineage {
-    mode: TransceiverMode;
-    readonly subject: Subject<SetUpdate>;
-    cacheLimit: number;
-    cache: (NumberedSetUpdate | null)[];
-    cacheIdx: number;
-    cacheUpdateNumber: number;
-    constructor(values?: Iterable<P>, cacheLimit?: number);
-    toJSON(): SetRTXJson<P>;
-    static fromJSON<P extends primitive>(json: SetRTXJson<P>): SetRTX<P>;
-    add(value: P): this;
-    clear(): void;
-    delete(value: P): boolean;
-    readonly parent: SetRTX<P> | null;
-    child: SetRTX<P> | null;
-    transactionUpdates: SetUpdate[] | null;
-    transaction(run: (child: SetRTX<P>) => boolean): void;
-    protected _subscribe(key: string, fn: (update: SetUpdate) => void): () => void;
-    subscribe(key: string, fn: (update: NumberedSetUpdate) => void): () => void;
-    emit(update: SetUpdate): void;
-    private doStep;
-    getUpdateNumber(update: NumberedSetUpdate): number;
-    do(update: NumberedSetUpdate): number | `OUT_OF_RANGE` | null;
-    undoStep(update: SetUpdate): void;
-    undo(update: NumberedSetUpdate): number | null;
-}
-
-type Molecule<K extends Canonical> = {
-    readonly key: K;
-    readonly stringKey: stringified<K>;
-    readonly dependsOn: `all` | `any`;
-};
-
-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);
-}
-
-interface Lineage {
-    parent: typeof this | null;
-    child: typeof this | null;
-}
-
-type OperationProgress = {
-    open: false;
-} | {
-    open: true;
-    done: Set<string>;
-    prev: Map<string, any>;
-    time: number;
-    token: WritableToken<any>;
-};
-
-type TimelineAtomUpdate<ManagedAtom extends TimelineManageable> = Flat<StateUpdate<TokenType<ManagedAtom>> & {
-    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`>[];
-};
-type TimelineTransactionUpdate = Flat<TransactionUpdate<Func> & {
-    key: string;
-    type: `transaction_update`;
-    timestamp: number;
-}>;
-type TimelineStateCreation<T extends ReadableToken<any>> = Flat<StateCreation<T> & {
-    timestamp: number;
-}>;
-type TimelineStateDisposal<T extends ReadableToken<any>> = Flat<StateDisposal<T> & {
-    timestamp: number;
-}>;
-type TimelineMoleculeCreation = Flat<MoleculeCreation & {
-    timestamp: number;
-}>;
-type TimelineMoleculeDisposal = Flat<MoleculeDisposal & {
-    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>;
-};
-
-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> | ReadonlySelectorFamily<any, any> | RegularAtomFamily<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);
-}
-
-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;
-}
-type TransceiverMode = `playback` | `record` | `transaction`;
-
-/**
- * @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);
-}
-
-type EnvironmentData = {
-    store: Store;
-};
-
-type AtomIOState = {
-    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 MutableAtom<T extends Transceiver<any>, J extends Json.Serializable> = AtomIOState & JsonInterface<T, J> & {
-    type: `mutable_atom`;
-    default: T | (() => 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 ReadonlySelector<T> = AtomIOState & {
-    type: `readonly_selector`;
-    get: () => 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;
-};
-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;
-};
-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;
-};
-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;
-};
-
-/**
- * @public
- * Create a mutable atom, a global reactive variable in the implicit store
- *
- * The value of a mutable atom must be some kind of {@link Transceiver}.
- *
- * @param options - {@link MutableAtomOptions}.
- * @returns
- * A reference to the atom created: a {@link MutableAtomToken}
- * @overload Mutable
- */
-declare function atom<T extends Transceiver<any>, J extends Json.Serializable>(options: MutableAtomOptions<T, J>): MutableAtomToken<T, J>;
-/**
- * @public
- * Create a regular atom, a global reactive variable in the implicit store
- * @param options - {@link RegularAtomOptions}.
- * @returns
- * A reference to the atom created: a {@link RegularAtomToken}
- * @overload Regular
- */
-declare function atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T>;
-/** @public */
-type Effectors<T> = {
-    /**
-     * Set the value of the atom
-     * @param next - The new value of the atom, or a setter function
-     */
-    setSelf: <New extends T>(next: New | Setter<T, New>) => void;
-    /** Subscribe to changes to the atom */
-    onSet: (callback: (options: {
-        newValue: T;
-        oldValue: T;
-    }) => void) => void;
-};
-/**
- * @public
- * A function that runs side effects when the atom is set
- * @param tools - {@link Effectors} that can be used to run side effects
- * @returns
- * Optionally, a cleanup function that will be called when the atom is disposed
- */
-type AtomEffect<T> = (tools: Effectors<T>) => (() => void) | void;
-/** @public */
-type RegularAtomOptions<T> = {
-    /** The unique identifier of the atom */
-    key: string;
-    /** The starting value of the atom */
-    default: T | (() => T);
-    /** Hooks used to run side effects when the atom is set */
-    effects?: AtomEffect<T>[];
-};
-type MutableAtomOptions<T extends Transceiver<any>, J extends Json.Serializable> = JsonInterface<T, J> & Omit<RegularAtomOptions<T>, `default`> & {
-    default: () => T;
-    mutable: true;
-};
-/** @public */
-type RegularAtomFamilyOptions<T, K extends Canonical> = {
-    /** The unique identifier of the atom family */
-    key: string;
-    /** The starting value of the atom family */
-    default: T | ((key: K) => T);
-    /** Hooks used to run side effects when an atom in the family is set  */
-    effects?: (key: K) => AtomEffect<T>[];
-};
-type RegularAtomFamilyToken<T, K extends Canonical> = {
-    key: string;
-    type: `atom_family`;
-    __T?: T;
-    __K?: K;
-};
-type MutableAtomFamilyOptions<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical> = JsonInterface<T, J> & {
-    key: string;
-    default: (key: K) => T;
-    effects?: (key: K) => AtomEffect<T>[];
-    mutable: true;
-};
-type MutableAtomFamilyToken<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical> = {
-    key: string;
-    type: `mutable_atom_family`;
-    __T?: T;
-    __J?: J;
-    __K?: K;
-};
-type AtomFamilyToken<T, K extends Canonical = Canonical> = MutableAtomFamilyToken<T extends Transceiver<any> ? T : never, any, K> | RegularAtomFamilyToken<T, K>;
-declare function atomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamilyToken<T, J, K>;
-declare function atomFamily<T, K extends Canonical>(options: RegularAtomFamilyOptions<T, K>): RegularAtomFamilyToken<T, K>;
-
-type TransactionToken<F extends Func> = {
-    key: string;
-    type: `transaction`;
-    __F?: F;
-};
-type StateCreation<Token extends ReadableToken<any>> = {
-    type: `state_creation`;
-    token: Token;
-};
-type AtomDisposal<Token extends ReadableToken<any>> = {
-    type: `state_disposal`;
-    subType: `atom`;
-    token: Token;
-    value: TokenType<Token>;
-};
-type SelectorDisposal<Token extends ReadableToken<any>> = {
-    type: `state_disposal`;
-    subType: `selector`;
-    token: Token;
-};
-type StateDisposal<Token extends ReadableToken<any>> = AtomDisposal<Token> | SelectorDisposal<Token>;
-type MoleculeCreation = {
-    type: `molecule_creation`;
-    key: Canonical;
-    provenance: Canonical;
-};
-type MoleculeDisposal = {
-    type: `molecule_disposal`;
-    key: Canonical;
-    provenance: stringified<Canonical>[];
-    values: [key: string, value: any][];
-};
-type MoleculeTransfer = {
-    type: `molecule_transfer`;
-    key: Canonical;
-    from: Canonical[];
-    to: Canonical[];
-};
-type TransactionUpdateContent = KeyedStateUpdate<unknown> | MoleculeCreation | MoleculeDisposal | MoleculeTransfer | StateCreation<ReadableToken<unknown>> | StateDisposal<ReadableToken<unknown>> | TransactionUpdate<Func>;
-type TransactionUpdate<F extends Func> = {
-    type: `transaction_update`;
-    key: string;
-    id: string;
-    epoch: number;
-    updates: TransactionUpdateContent[];
-    params: Parameters<F>;
-    output: ReturnType<F>;
-};
-type GetterToolkit = Pick<SetterToolkit, `find` | `get` | `json`>;
-type SetterToolkit = Readonly<{
-    get: typeof getState;
-    set: typeof setState;
-    find: typeof findState;
-    json: <T extends Transceiver<any>, J extends Json.Serializable>(state: MutableAtomToken<T, J>) => WritableSelectorToken<J>;
-}>;
-type ActorToolkit = Readonly<{
-    get: typeof getState;
-    set: typeof setState;
-    find: typeof findState;
-    json: <T extends Transceiver<any>, J extends Json.Serializable>(state: MutableAtomToken<T, J>) => WritableSelectorToken<J>;
-    dispose: typeof disposeState;
-    run: typeof runTransaction;
-    env: () => EnvironmentData;
-}>;
-type Read<F extends Func> = (toolkit: GetterToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
-type Write<F extends Func> = (toolkit: SetterToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
-type Transact<F extends Func> = (toolkit: ActorToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
-type TransactionOptions<F extends Func> = {
-    key: string;
-    do: Transact<F>;
-};
-declare function transaction<F extends Func>(options: TransactionOptions<F>): TransactionToken<F>;
-declare function runTransaction<F extends Func>(token: TransactionToken<F>, id?: string): (...parameters: Parameters<F>) => ReturnType<F>;
-
-type WritableSelectorOptions<T> = {
-    key: string;
-    get: Read<() => T>;
-    set: Write<(newValue: T) => void>;
-};
-type ReadonlySelectorOptions<T> = {
-    key: string;
-    get: Read<() => T>;
-};
-/**
- * @public
- * Declare a selector. The value of a selector should depend
- * on the value of atoms or other selectors in the store.
- *
- * A writable selector can be "set" to a new value.
- * It is advised to set its dependencies to values
- * that would produce the new value of the selector.
- * @param options - {@link WritableSelectorOptions}.
- * @returns
- * The token for your selector.
- * @overload Writable
- */
-declare function selector<T>(options: WritableSelectorOptions<T>): WritableSelectorToken<T>;
-/**
- * @public
- * Declare a selector. The value of a selector should depend
- * on the value of atoms or other selectors in the store.
- * @param options - {@link ReadonlySelectorOptions}.
- */
-declare function selector<T>(options: ReadonlySelectorOptions<T>): ReadonlySelectorToken<T>;
-type WritableSelectorFamilyOptions<T, K extends Canonical> = {
-    key: string;
-    get: (key: K) => Read<() => T>;
-    set: (key: K) => Write<(newValue: T) => void>;
-};
-type ReadonlySelectorFamilyOptions<T, K extends Canonical> = {
-    key: string;
-    get: (key: K) => Read<() => T>;
-};
-type WritableSelectorFamilyToken<T, K extends Canonical> = {
-    key: string;
-    type: `selector_family`;
-    __T?: T;
-    __K?: K;
-};
-type ReadonlySelectorFamilyToken<T, K extends Canonical> = {
-    key: string;
-    type: `readonly_selector_family`;
-    __T?: T;
-    __K?: K;
-};
-type SelectorFamilyToken<T, K extends Canonical> = ReadonlySelectorFamilyToken<T, K> | WritableSelectorFamilyToken<T, K>;
-declare function selectorFamily<T, K extends Canonical>(options: WritableSelectorFamilyOptions<T, K>): WritableSelectorFamilyToken<T, K>;
-declare function selectorFamily<T, K extends Canonical>(options: ReadonlySelectorFamilyOptions<T, K>): ReadonlySelectorFamilyToken<T, K>;
-
-type TimelineManageable = AtomFamilyToken<any, any> | AtomToken<any>;
-type AtomOnly<M extends TimelineManageable> = M extends AtomFamilyToken<any, any> ? AtomToken<any> : M extends AtomToken<any> ? M : never;
-type TimelineToken<M> = {
-    key: string;
-    type: `timeline`;
-    __M?: M;
-};
-type TimelineOptions<ManagedAtom extends TimelineManageable> = {
-    key: string;
-    scope: ManagedAtom[];
-    shouldCapture?: (update: TimelineUpdate<ManagedAtom>, timeline: Timeline<TimelineManageable>) => boolean;
-};
-type TimelineUpdate<ManagedAtom extends TimelineManageable> = TimelineAtomUpdate<ManagedAtom> | TimelineMoleculeCreation | TimelineMoleculeDisposal | TimelineSelectorUpdate<ManagedAtom> | TimelineStateCreation<AtomOnly<ManagedAtom>> | TimelineStateDisposal<AtomOnly<ManagedAtom>> | TimelineTransactionUpdate;
-declare const timeline: <ManagedAtom extends TimelineManageable>(options: TimelineOptions<ManagedAtom>) => TimelineToken<ManagedAtom>;
-declare const redo: (tl: TimelineToken<any>) => void;
-declare const undo: (tl: TimelineToken<any>) => void;
-
-/**
- * @public
- * Disposes of a state in the implicit store
- * @param token - The token of the state to dispose
- * @overload Default
- */
-declare function disposeState(token: ReadableToken<any>): void;
-/**
- * @public
- * Disposes of a state family in the implicit store
- * @param token - The token of the state family to dispose
- * @param key - The unique key of the state to dispose
- */
-declare function disposeState<K extends Canonical>(token: ReadableFamilyToken<any, K>, key: K): void;
-
-/**
- * @public
- * Finds a {@link MutableAtomToken} in the store
- * @param token - A {@link MutableAtomFamilyToken}
- * @param key - The key of the state
- * @returns
- * The current value of the state
- * @overload Mutable Atom
- */
-declare function findState<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, K>;
-/**
- * @public
- * Finds a state in the store
- * @param token - The token of the state family
- * @param key - The key of the state
- * @returns
- * The current value of the state
- * @overload Regular Atom
- */
-declare function findState<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T, K>;
-/**
- * @public
- * Finds a state in the store
- * @param token - The token of the state family
- * @param key - The key of the state
- * @returns
- * The current value of the state
- * @overload Writable Selector
- */
-declare function findState<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T, K>;
-/**
- * @public
- * Finds a state in the store
- * @param token - The token of the state family
- * @param key - The key of the state
- * @returns
- * The current value of the state
- * @overload Readonly Selector
- */
-declare function findState<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T, K>;
-/**
- * @public
- * Finds a state in the store
- * @param token - The token of the state family
- * @param key - The key of the state
- * @returns
- * The current value of the state
- * @overload Writable State
- */
-declare function findState<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T, K>;
-/**
- * @public
- * Finds a {@link ReadableToken} in the store
- * @param token - A {@link ReadableFamilyToken}
- * @param key - The key of the state
- * @returns
- * The current value of the state
- * @overload Unknown
- * @default
- */
-declare function findState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T, K>;
-
-/**
- * @public
- * Get the current value of a state
- * @param token - The token of the state to get
- * @return The current value of the state
- * @overload Default
- * @default
- */
-declare function getState<T>(token: ReadableToken<T>): T;
-/**
- * @public
- * Get the current value of a state family
- * @param token - The token of a state family
- * @param key - The unique key of the state to get
- * @return The current value of the state
- * @overload Streamlined
- */
-declare function getState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): T;
-
-interface JoinOptions<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> extends JunctionSchemaBase<ASide, BSide>, Partial<JunctionEntriesBase<AType, BType, Content>> {
-    readonly key: string;
-    readonly cardinality: Cardinality;
-    readonly isAType: Refinement<string, AType>;
-    readonly isBType: Refinement<string, BType>;
-}
-
-declare const LoggerIconDictionary: {
-    readonly "\u231B": "Timeline event fully captured";
-    readonly "\u23E9": "Timeline redo";
-    readonly "\u23EA": "Timeline undo";
-    readonly "\u23ED\uFE0F": "Transaction redo";
-    readonly "\u23EE\uFE0F": "Transaction undo";
-    readonly "\u23F3": "Timeline event partially captured";
-    readonly "\u23F9\uFE0F": "Time-travel complete";
-    readonly "\u2705": "Realtime transaction success";
-    readonly "\u2728": "Computation complete";
-    readonly "\u274C": "Conflict prevents attempted action";
-    readonly "\u2B55": "Operation start";
-    readonly "\uD83D\uDD34": "Operation complete";
-    readonly "\u2757": "Operation blocked";
-    readonly "\uD83D\uDFE2": "Operation unblocked";
-    readonly "\uD83D\uDC1E": "Possible bug in AtomIO";
-    readonly "\uD83D\uDC40": "Subscription added";
-    readonly "\uD83D\uDC4B": "Greeting";
-    readonly "\uD83D\uDC4D": "Realtime acknowledgment";
-    readonly "\uD83D\uDC6A": "Family member added";
-    readonly "\uD83D\uDC81": "Notice";
-    readonly "\uD83D\uDCA5": "Caught";
-    readonly "\uD83D\uDCC1": "Stow update";
-    readonly "\uD83D\uDCC3": "Copy mutable";
-    readonly "\uD83D\uDCD6": "Read state";
-    readonly "\uD83D\uDCDD": "Write state";
-    readonly "\uD83D\uDCE2": "Notify subscribers";
-    readonly "\uD83D\uDD04": "Realtime transaction synchronized";
-    readonly "\uD83D\uDD0C": "Register dependency";
-    readonly "\uD83D\uDD0D": "Discover root";
-    readonly "\uD83D\uDD25": "Delete state";
-    readonly "\uD83D\uDD27": "Create mutable atom";
-    readonly "\uD83D\uDD28": "Create immutable atom";
-    readonly "\uD83D\uDDD1": "Evict cached value";
-    readonly "\uD83D\uDE48": "Subscription canceled";
-    readonly "\uD83D\uDE80": "Performance measure";
-    readonly "\uD83D\uDEC4": "Apply transaction";
-    readonly "\uD83D\uDEE0\uFE0F": "Install atom into store";
-    readonly "\uD83D\uDEEB": "Begin transaction";
-    readonly "\uD83D\uDEEC": "Complete transaction";
-    readonly "\uD83E\uDDEE": "Computing selector";
-    readonly "\uD83E\uDDF9": "Prepare to evict";
-    readonly "\uD83E\uDE82": "Abort transaction";
-    readonly "\uD83E\uDD1E": "Realtime optimistic update enqueued";
-    readonly "\uD83D\uDC48": "Realtime confirmed update enqueued";
-    readonly "\uD83E\uDDD1\u200D\u2696\uFE0F": "Realtime update beginning reconciliation";
-    readonly "\uD83D\uDECE\uFE0F": "Realtime transaction received";
-    readonly "\uD83D\uDD2D": "Determining realtime perspective";
-    readonly "\uD83D\uDD8C": "Redacting realtime update";
-    readonly "\uD83D\uDC41": "Determining perspective";
-};
-type LoggerIcon = keyof typeof LoggerIconDictionary;
-type TokenDenomination = `atom_family` | `atom` | `continuity` | `molecule_family` | `molecule` | `mutable_atom_family` | `mutable_atom` | `readonly_selector_family` | `readonly_selector` | `selector_family` | `selector` | `state` | `timeline` | `transaction` | `unknown`;
-declare const LOG_LEVELS: readonly ["info", "warn", "error"];
-type LogLevel = (typeof LOG_LEVELS)[number];
-type LogFn = (icon: LoggerIcon, denomination: TokenDenomination, tokenKey: string, message: string, ...rest: unknown[]) => void;
-type LogFilter = (...params: Parameters<LogFn>) => boolean;
-type Logger = Record<LogLevel, LogFn>;
-declare class AtomIOLogger implements Logger {
-    logLevel: `error` | `info` | `warn` | null;
-    private readonly filter?;
-    private readonly logger;
-    constructor(logLevel: `error` | `info` | `warn` | null, filter?: LogFilter | undefined, logger?: Logger);
-    error: LogFn;
-    info: LogFn;
-    warn: LogFn;
-}
-
-declare const $claim: unique symbol;
-type Claim<K extends Canonical> = K & {
-    [$claim]?: true;
-};
-declare class Realm<H extends Hierarchy> {
-    store: Store;
-    constructor(store?: Store);
-    allocate<V extends Vassal<H>, A extends Above<V, H>>(provenance: A, key: V, attachmentStyle?: `all` | `any`): Claim<V>;
-    fuse<C extends CompoundFrom<H>, T extends C extends CompoundTypedKey<infer t, any, any> ? t : never, A extends C extends CompoundTypedKey<any, infer v, any> ? v : never, B extends C extends CompoundTypedKey<any, any, infer m> ? m : never>(type: T, reagentA: SingularTypedKey<A>, reagentB: SingularTypedKey<B>): Claim<CompoundTypedKey<T, A, B>>;
-    deallocate<V extends Vassal<H>>(claim: Claim<V>): void;
-    claim<V extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V, H>>(newProvenance: A, claim: Claim<V>, exclusive?: `exclusive`): Claim<V>;
-}
-declare class Anarchy {
-    store: Store;
-    realm: Realm<any>;
-    constructor(store?: Store);
-    allocate(provenance: Canonical, key: Canonical, attachmentStyle?: `all` | `any`): void;
-    deallocate(key: Canonical): void;
-    claim(newProvenance: Canonical, key: Canonical, exclusive?: `exclusive`): void;
-}
-declare const T$ = "T$";
-type T$ = typeof T$;
-type TypeTag<T extends string> = `${T$}--${T}`;
-type SingularTypedKey<T extends string = string> = `${T}::${string}`;
-type CompoundTypedKey<A extends string = string, B extends string = string, C extends string = string> = `${TypeTag<A>}==${SingularTypedKey<B>}++${SingularTypedKey<C>}`;
-type TypedKey<A extends string = string, B extends string = string, C extends string = string> = CompoundTypedKey<A, B, C> | SingularTypedKey<A>;
-type Scope = SingularTypedKey[];
-type MutualFealty = {
-    above: Scope;
-    below: CompoundTypedKey;
-};
-type ExclusiveFealty = {
-    above: TypedKey | `root`;
-    below: Scope;
-};
-type Fealty = ExclusiveFealty | MutualFealty;
-type Hierarchy<F extends Fealty[] = Fealty[]> = Each<F>;
-type Vassal<H extends Hierarchy> = {
-    [K in keyof H]: H[K] extends MutualFealty ? H[K][`below`] : H[K] extends {
-        below: Array<infer V>;
-    } ? V extends TypedKey ? V : never : never;
-}[keyof H];
-type Above<TK extends TypedKey, H extends Hierarchy> = {
-    [K in keyof H]: H[K] extends MutualFealty ? TK extends H[K][`below`] ? H[K][`above`] : never : H[K] extends {
-        below: Array<infer V>;
-    } ? TK extends V ? H[K] extends ExclusiveFealty ? H[K][`above`] : never : never : never;
-}[keyof H];
-type CompoundFrom<H extends Hierarchy> = {
-    [K in keyof H]: H[K] extends MutualFealty ? H[K][`below`] : never;
-}[keyof H];
-
-/**
- * @public
- * A function that sets the value of a state.
- * @param oldValue - The current value of the state.
- * @returns
- * The new value of the state.
- */
-type Setter<T, New extends T> = (oldValue: T) => New;
-/**
- * @public
- * Set the value of a state into the implicit store.
- * @param token - An atom or writable selector token.
- * @param value - The new value of the state.
- * @overload Default
- * @default
- */
-declare function setState<T, New extends T>(token: WritableToken<T>, value: New | Setter<T, New>): void;
-/**
- * @public
- * Set the value of a state into the implicit store.
- * @param token - An atom family or writable selector family token.
- * @param key - The unique key of the state to set.
- * @param value - The new value of the state.
- * @overload Streamlined
- */
-declare function setState<T, K extends Canonical, New extends T, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, value: New | Setter<T, New>): void;
-
-declare class Silo {
-    store: Store;
-    atom: typeof atom;
-    atomFamily: typeof atomFamily;
-    selector: typeof selector;
-    selectorFamily: typeof selectorFamily;
-    transaction: typeof transaction;
-    timeline: typeof timeline;
-    findState: typeof findState;
-    getState: typeof getState;
-    setState: typeof setState;
-    disposeState: typeof disposeState;
-    subscribe: typeof subscribe;
-    undo: typeof undo;
-    redo: typeof redo;
-    runTransaction: typeof runTransaction;
-    install: (tokens: AtomIOToken[], store?: Store) => void;
-    constructor(config: Store[`config`], fromStore?: Store | null);
-}
-
-type StateUpdate<T> = {
-    newValue: T;
-    oldValue: T;
-};
-type KeyedStateUpdate<T> = Flat<StateUpdate<T> & {
-    key: string;
-    type: `atom_update` | `selector_update`;
-    family?: FamilyMetadata;
-}>;
-type UpdateHandler<T> = (update: StateUpdate<T>) => void;
-type TransactionUpdateHandler<F extends Func> = (data: TransactionUpdate<F>) => void;
-declare function subscribe<T>(token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key?: string): () => void;
-declare function subscribe<F extends Func>(token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key?: string): () => void;
-declare function subscribe<M extends TimelineManageable>(token: TimelineToken<M>, handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void, key?: string): () => void;
-
-type TokenType<Comparison extends ReadableFamilyToken<any, any> | ReadableToken<any>> = Comparison extends ReadableToken<infer RepresentedValue> ? RepresentedValue : Comparison extends ReadableFamilyToken<infer RepresentedValue, any> ? RepresentedValue : never;
-
-/**
- * @public
- * A token is an object that uniquely identifies a particular state, family, timeline, or transaction.
- *
- * While they represent one of these resources, they are not the resource itself. Think of them like paper currency representing money in the bank.
- *
- * Tokens are returned from resource creation functions, such as {@link atom} and {@link transaction}.
- *
- * Tokens can be used as parameters to functions that take a token, such as {@link getState}, {@link setState}, or {@link runTransaction}.
- *
- * Tokens are fully serializable, so they can be passed between processes.
- */
-type AtomIOToken = ReadableFamilyToken<any, any> | ReadableToken<any> | TimelineToken<any> | TransactionToken<any>;
-/** @public */
-type RegularAtomToken<T, K extends Canonical = any> = {
-    /** The unique identifier of the atom. */
-    key: string;
-    /** Discriminator. */
-    type: `atom`;
-    /** Present if the atom belongs to a family. */
-    family?: FamilyMetadata<K>;
-    /** Never present. This is a marker that preserves the type of the atom's value. */
-    __T?: T;
-};
-/** @public */
-type MutableAtomToken<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical = any> = {
-    /** The unique identifier of the atom. */
-    key: string;
-    /** Discriminator. */
-    type: `mutable_atom`;
-    /** Present if the atom belongs to a family. */
-    family?: FamilyMetadata<K>;
-    /** Never present. This is a marker that preserves the JSON form of the atom's transceiver value. */
-    __J?: J;
-    /** Never present. This is a marker that preserves the type of the atom's transceiver value. */
-    __U?: T extends Transceiver<infer Update> ? Update : never;
-};
-/** @public */
-type AtomToken<T, K extends Canonical = any> = MutableAtomToken<T extends Transceiver<any> ? T : never, any, K> | RegularAtomToken<T, K>;
-/** @public */
-type WritableSelectorToken<T, K extends Canonical = any> = {
-    /** The unique identifier of the selector. */
-    key: string;
-    /** Discriminator. */
-    type: `selector`;
-    /** Present if the selector belongs to a family. */
-    family?: FamilyMetadata<K>;
-    /** Never present. This is a marker that preserves the type of the selector's value. */
-    __T?: T;
-};
-/** @public */
-type ReadonlySelectorToken<T, K extends Canonical = any> = {
-    /** The unique identifier of the selector. */
-    key: string;
-    /** Discriminator. */
-    type: `readonly_selector`;
-    /** Present if the selector belongs to a family. */
-    family?: FamilyMetadata<K>;
-    /** Never present. This is a marker that preserves the type of the selector's value. */
-    __T?: T;
-};
-/** @public */
-type SelectorToken<T, K extends Canonical = any> = ReadonlySelectorToken<T, K> | WritableSelectorToken<T, K>;
-/**
- * @public
- * These states can be set.
- */
-type WritableToken<T, K extends Canonical = any> = AtomToken<T, K> | WritableSelectorToken<T, K>;
-/**
- * @public
- * These states cannot be set.
- */
-type ReadableToken<T, K extends Canonical = any> = AtomToken<T, K> | SelectorToken<T, K>;
-/**
- * @public
- * States belonging to this family can be set.
- */
-type WritableFamilyToken<T, K extends Canonical> = AtomFamilyToken<T, K> | WritableSelectorFamilyToken<T, K>;
-/**
- * @public
- * States belonging to this family cannot be set.
- */
-type ReadableFamilyToken<T, K extends Canonical> = AtomFamilyToken<T, K> | SelectorFamilyToken<T, K>;
-/**
- * @public
- * Identifies a state's connection to its family.
- */
-type FamilyMetadata<K extends Canonical = any> = {
-    /** The family's unique key. */
-    key: string;
-    /** The family member's unique identifier, in the form of a string. */
-    subKey: stringified<K>;
-};
-
 type TestSetupOptions = {
     port: number;
     immortal?: {
@@ -1099,7 +11,7 @@ type TestSetupOptions = {
     };
     server: (tools: {
         socket: SocketIO.Socket;
-        silo: Silo;
+        silo: AtomIO.Silo;
         enableLogging: () => void;
     }) => void;
 };
@@ -1113,7 +25,7 @@ type TestSetupOptions__MultiClient<ClientNames extends string> = TestSetupOption
 };
 type RealtimeTestTools = {
     name: string;
-    silo: Silo;
+    silo: AtomIO.Silo;
 };
 type RealtimeTestClient = RealtimeTestTools & {
     renderResult: RenderResult;