atom.io 0.32.0 → 0.32.1

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

@@ -1,978 +1,40 @@
+import * as AtomIO from 'atom.io';
+import { AtomToken } from 'atom.io';
+import * as Internal from 'atom.io/internal';
+import { Store, Func, Transceiver } from 'atom.io/internal';
+import { Socket } from 'atom.io/realtime-server';
+import { Json } from 'atom.io/json';
 import { Socket as Socket$1 } from 'socket.io-client';
+import { ContinuityToken } from 'atom.io/realtime';
 
-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;
-};
-
-type RegularAtomFamilyToken<T, K extends Canonical> = {
-    key: string;
-    type: `atom_family`;
-    __T?: T;
-    __K?: K;
-};
-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>;
-
-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 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;
-}>;
-declare function runTransaction<F extends Func>(token: TransactionToken<F>, id?: string): (...parameters: Parameters<F>) => ReturnType<F>;
-
-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>;
-
-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 TimelineUpdate<ManagedAtom extends TimelineManageable> = TimelineAtomUpdate<ManagedAtom> | TimelineMoleculeCreation | TimelineMoleculeDisposal | TimelineSelectorUpdate<ManagedAtom> | TimelineStateCreation<AtomOnly<ManagedAtom>> | TimelineStateDisposal<AtomOnly<ManagedAtom>> | TimelineTransactionUpdate;
-
-/**
- * @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;
-
-type StateUpdate<T> = {
-    newValue: T;
-    oldValue: T;
-};
-type KeyedStateUpdate<T> = Flat<StateUpdate<T> & {
-    key: string;
-    type: `atom_update` | `selector_update`;
-    family?: FamilyMetadata;
-}>;
-
-type TokenType<Comparison extends ReadableFamilyToken<any, any> | ReadableToken<any>> = Comparison extends ReadableToken<infer RepresentedValue> ? RepresentedValue : Comparison extends ReadableFamilyToken<infer RepresentedValue, any> ? RepresentedValue : never;
-
-/** @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 PerspectiveToken<F extends AtomFamilyToken<any>> = {
-    type: `realtime_perspective`;
-    resourceAtoms: F;
-    viewAtoms: ReadableFamilyToken<ReadableToken<TokenType<F>>[], UserKey>;
-};
-type ContinuityToken = {
-    readonly type: `continuity`;
-    readonly key: string;
-    readonly globals: AtomToken<any>[];
-    readonly actions: TransactionToken<any>[];
-    readonly perspectives: PerspectiveToken<AtomFamilyToken<any, Canonical>>[];
-};
-
-type UserKey = `user::${string}`;
-
-type Socket = {
-    id: string | undefined;
-    on: (event: string, listener: (...args: Json.Serializable[]) => void) => void;
-    onAny: (listener: (event: string, ...args: Json.Serializable[]) => void) => void;
-    off: (event: string, listener: (...args: Json.Serializable[]) => void) => void;
-    offAny: (listener: (event: string, ...args: Json.Serializable[]) => void) => void;
-    emit: (event: string, ...args: Json.Serializable[]) => void;
-};
-
-declare const useRegisterAndAttemptConfirmedUpdate: (store: Store, continuityKey: string, socket: Socket, optimisticUpdates: TransactionUpdate<any>[], confirmedUpdates: TransactionUpdate<any>[]) => (confirmed: TransactionUpdate<Func>) => void;
+declare const useRegisterAndAttemptConfirmedUpdate: (store: Store, continuityKey: string, socket: Socket, optimisticUpdates: AtomIO.TransactionUpdate<any>[], confirmedUpdates: AtomIO.TransactionUpdate<any>[]) => (confirmed: AtomIO.TransactionUpdate<Func>) => void;
 
 declare function useConcealState(store: Store): (concealed: AtomToken<unknown>[]) => void;
 
 declare function useRevealState(store: Store): (revealed: Json.Array) => void;
 
-declare function pullAtom<J extends Json.Serializable>(store: Store, socket: Socket$1, token: RegularAtomToken<J>): () => void;
+declare function pullAtom<J extends Json.Serializable>(store: Store, socket: Socket$1, token: AtomIO.RegularAtomToken<J>): () => void;
 
-declare function pullAtomFamilyMember<J extends Json.Serializable>(store: Store, socket: Socket$1, token: RegularAtomToken<J>): () => void;
+declare function pullAtomFamilyMember<J extends Json.Serializable>(store: Store, socket: Socket$1, token: AtomIO.RegularAtomToken<J>): () => void;
 
-declare function pullMutableAtom<T extends Transceiver<any>, J extends Json.Serializable>(store: Store, socket: Socket$1, token: MutableAtomToken<T, J>): () => void;
+declare function pullMutableAtom<T extends Transceiver<any>, J extends Json.Serializable>(store: Store, socket: Socket$1, token: AtomIO.MutableAtomToken<T, J>): () => void;
 
-declare function pullMutableAtomFamilyMember<T extends Transceiver<any>, J extends Json.Serializable>(store: Store, socket: Socket$1, token: MutableAtomToken<T, J>): () => void;
+declare function pullMutableAtomFamilyMember<T extends Transceiver<any>, J extends Json.Serializable>(store: Store, socket: Socket$1, token: AtomIO.MutableAtomToken<T, J>): () => void;
 
-declare function pullSelector<T>(store: Store, socket: Socket$1, token: SelectorToken<T>): () => void;
+declare function pullSelector<T>(store: Store, socket: Socket$1, token: AtomIO.SelectorToken<T>): () => void;
 
-declare function pullSelectorFamilyMember<T>(store: Store, socket: Socket$1, token: SelectorToken<T>): () => void;
+declare function pullSelectorFamilyMember<T>(store: Store, socket: Socket$1, token: AtomIO.SelectorToken<T>): () => void;
 
-declare function pushState<J extends Json.Serializable>(store: Store, socket: Socket$1, token: WritableToken<J>): () => void;
+declare function pushState<J extends Json.Serializable>(store: Internal.Store, socket: Socket$1, token: AtomIO.WritableToken<J>): () => void;
 
-declare const myIdState__INTERNAL: RegularAtomToken<string | undefined>;
-declare const myIdState: ReadonlySelectorToken<string | undefined>;
-declare const myUsernameState: RegularAtomToken<string | null>;
+declare const myIdState__INTERNAL: AtomIO.RegularAtomToken<string | undefined>;
+declare const myIdState: AtomIO.ReadonlySelectorToken<string | undefined>;
+declare const myUsernameState: AtomIO.RegularAtomToken<string | null>;
 
-declare const optimisticUpdateQueue: RegularAtomToken<TransactionUpdate<any>[]>;
-declare const confirmedUpdateQueue: RegularAtomToken<TransactionUpdate<any>[]>;
+declare const optimisticUpdateQueue: AtomIO.RegularAtomToken<AtomIO.TransactionUpdate<any>[]>;
+declare const confirmedUpdateQueue: AtomIO.RegularAtomToken<AtomIO.TransactionUpdate<any>[]>;
 
-declare function serverAction<F extends Func>(store: Store, socket: Socket$1, token: TransactionToken<F>): () => void;
+declare function serverAction<F extends Internal.Func>(store: Internal.Store, socket: Socket$1, token: AtomIO.TransactionToken<F>): () => void;
 
 declare function syncContinuity(store: Store, socket: Socket$1, continuity: ContinuityToken): () => void;