atom.io 0.31.1 → 0.32.0

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

@@ -1,12 +1,955 @@
-import { Subject, Transceiver, Store } from 'atom.io/internal';
-import { Json, stringified, JsonIO, Canonical } from 'atom.io/json';
-import { ContinuityToken, UserInRoomMeta } from 'atom.io/realtime';
 import { ChildProcessWithoutNullStreams } from 'node:child_process';
-import * as AtomIO from 'atom.io';
-import { TransactionUpdateContent, TransactionUpdate, Hierarchy, WritableToken } from 'atom.io';
-import * as atom_io_data from 'atom.io/data';
-import { Loadable } from 'atom.io/data';
-import { SetRTX, SetRTXJson } from 'atom.io/transceivers/set-rtx';
+
+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 JsonIO = (...params: Json.Serializable[]) => Json.Serializable | void;
+type JsonInterface<T, J extends Json.Serializable = Json.Serializable> = {
+    toJson: (t: T) => J;
+    fromJson: (json: J) => T;
+};
+
+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;
+}>;
+type TransactionIO<Token extends TransactionToken<any>> = Token extends TransactionToken<infer F> ? F : never;
+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;
+
+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;
+}
+
+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>;
+}
+type JoinToken<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> = {
+    key: string;
+    type: `join`;
+    cardinality: Cardinality;
+    a: ASide;
+    b: BSide;
+    __aType?: AType;
+    __bType?: BType;
+    __content?: Content;
+};
+
+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 Loadable<T> = Promise<T> | 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 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 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 UserInRoomMeta = {
+    enteredAtEpoch: number;
+};
 
 type ExposeRealtimeContinuity = (continuity: ContinuityToken) => () => void;
 declare function prepareToExposeRealtimeContinuity({ socket: initialSocket, store, }: ServerConfig): ExposeRealtimeContinuity;
@@ -75,35 +1018,35 @@ declare class ParentSocket<I extends Events & {
 }
 
 type ActionReceiver = ReturnType<typeof realtimeActionReceiver>;
-declare function realtimeActionReceiver({ socket, store, }: ServerConfig): <F extends JsonIO>(tx: AtomIO.TransactionToken<F>) => () => void;
+declare function realtimeActionReceiver({ socket, store, }: ServerConfig): <F extends JsonIO>(tx: TransactionToken<F>) => () => void;
 
 type FamilyProvider = ReturnType<typeof realtimeAtomFamilyProvider>;
-declare function realtimeAtomFamilyProvider({ socket, store, }: ServerConfig): <J extends Json.Serializable, K extends Canonical>(family: AtomIO.RegularAtomFamilyToken<J, K>, index: AtomIO.ReadableToken<Iterable<K>>) => () => void;
+declare function realtimeAtomFamilyProvider({ socket, store, }: ServerConfig): <J extends Json.Serializable, K extends Canonical>(family: RegularAtomFamilyToken<J, K>, index: ReadableToken<Iterable<K>>) => () => void;
 
 type MutableFamilyProvider = ReturnType<typeof realtimeMutableFamilyProvider>;
-declare function realtimeMutableFamilyProvider({ socket, store, }: ServerConfig): <T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(family: AtomIO.MutableAtomFamilyToken<T, J, K>, index: AtomIO.ReadableToken<Iterable<K>>) => () => void;
+declare function realtimeMutableFamilyProvider({ socket, store, }: ServerConfig): <T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(family: MutableAtomFamilyToken<T, J, K>, index: ReadableToken<Iterable<K>>) => () => void;
 
 type MutableProvider = ReturnType<typeof realtimeMutableProvider>;
-declare function realtimeMutableProvider({ socket, store, }: ServerConfig): <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable>(token: AtomIO.MutableAtomToken<Core, SerializableCore>) => () => void;
+declare function realtimeMutableProvider({ socket, store, }: ServerConfig): <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable>(token: MutableAtomToken<Core, SerializableCore>) => () => void;
 
-declare const createRoomTX: AtomIO.TransactionToken<(roomId: string, script: string, options?: string[]) => Loadable<ChildSocket<any, any>>>;
-type CreateRoomIO = AtomIO.TransactionIO<typeof createRoomTX>;
-declare const joinRoomTX: AtomIO.TransactionToken<(roomId: string, userId: string, enteredAtEpoch: number) => UserInRoomMeta>;
-type JoinRoomIO = AtomIO.TransactionIO<typeof joinRoomTX>;
-declare const leaveRoomTX: AtomIO.TransactionToken<(roomId: string, userId: string) => void>;
-type LeaveRoomIO = AtomIO.TransactionIO<typeof leaveRoomTX>;
-declare const destroyRoomTX: AtomIO.TransactionToken<(roomId: string) => void>;
+declare const createRoomTX: TransactionToken<(roomId: string, script: string, options?: string[]) => Loadable<ChildSocket<any, any>>>;
+type CreateRoomIO = TransactionIO<typeof createRoomTX>;
+declare const joinRoomTX: TransactionToken<(roomId: string, userId: string, enteredAtEpoch: number) => UserInRoomMeta>;
+type JoinRoomIO = TransactionIO<typeof joinRoomTX>;
+declare const leaveRoomTX: TransactionToken<(roomId: string, userId: string) => void>;
+type LeaveRoomIO = TransactionIO<typeof leaveRoomTX>;
+declare const destroyRoomTX: TransactionToken<(roomId: string) => void>;
 
 type RoomArguments = [script: string, options: string[]] | [script: string];
-declare const roomArgumentsAtoms: AtomIO.RegularAtomFamilyToken<RoomArguments, string>;
-declare const roomSelectors: AtomIO.ReadonlySelectorFamilyToken<Loadable<ChildSocket<any, any>>, string>;
+declare const roomArgumentsAtoms: RegularAtomFamilyToken<RoomArguments, string>;
+declare const roomSelectors: ReadonlySelectorFamilyToken<Loadable<ChildSocket<any, any>>, string>;
 
 declare function redactTransactionUpdateContent(visibleStateKeys: string[], updates: TransactionUpdateContent[]): TransactionUpdateContent[];
-declare const redactorAtoms: AtomIO.RegularAtomFamilyToken<{
+declare const redactorAtoms: RegularAtomFamilyToken<{
     occlude: (updates: TransactionUpdateContent[]) => TransactionUpdateContent[];
 }, `user::${string}`>;
 type ContinuitySyncTransactionUpdate = Pick<TransactionUpdate<any>, `epoch` | `id` | `key` | `output` | `updates`>;
-declare const userUnacknowledgedQueues: AtomIO.RegularAtomFamilyToken<ContinuitySyncTransactionUpdate[], `user::${string}`>;
+declare const userUnacknowledgedQueues: RegularAtomFamilyToken<ContinuitySyncTransactionUpdate[], `user::${string}`>;
 
 type SocketKey = `socket::${string}`;
 type UserKey = `user::${string}`;
@@ -114,13 +1057,13 @@ type SocketSystemHierarchy = Hierarchy<[
         below: [UserKey, SocketKey, RoomKey];
     }
 ]>;
-declare const socketAtoms: AtomIO.RegularAtomFamilyToken<Socket | null, `socket::${string}`>;
-declare const socketIndex: AtomIO.MutableAtomToken<SetRTX<`socket::${string}`>, SetRTXJson<`socket::${string}`>>;
-declare const userIndex: AtomIO.MutableAtomToken<SetRTX<`user::${string}`>, SetRTXJson<`user::${string}`>>;
-declare const usersOfSockets: atom_io_data.JoinToken<"user", `user::${string}`, "socket", `socket::${string}`, "1:1", null>;
+declare const socketAtoms: RegularAtomFamilyToken<Socket | null, `socket::${string}`>;
+declare const socketIndex: MutableAtomToken<SetRTX<`socket::${string}`>, SetRTXJson<`socket::${string}`>>;
+declare const userIndex: MutableAtomToken<SetRTX<`user::${string}`>, SetRTXJson<`user::${string}`>>;
+declare const usersOfSockets: JoinToken<"user", `user::${string}`, "socket", `socket::${string}`, "1:1", null>;
 
 type StateProvider = ReturnType<typeof realtimeStateProvider>;
-declare function realtimeStateProvider({ socket, store, }: ServerConfig): <J extends Json.Serializable>(token: AtomIO.WritableToken<J>) => () => void;
+declare function realtimeStateProvider({ socket, store, }: ServerConfig): <J extends Json.Serializable>(token: WritableToken<J>) => () => void;
 
 type StateReceiver = ReturnType<typeof realtimeStateReceiver>;
 declare function realtimeStateReceiver({ socket, store, }: ServerConfig): <J extends Json.Serializable>(token: WritableToken<J>) => () => void;