atom.io 0.31.0 → 0.32.0

package/data/dist/index.d.ts

@@ -1,19 +1,221 @@
-import * as AtomIO from 'atom.io';
-import { ReadonlySelectorFamilyToken, SingularTypedKey, Hierarchy, CompoundTypedKey, MutableAtomFamilyToken, SetterToolkit, Anarchy, ReadonlySelectorToken } from 'atom.io';
-import { Store, JunctionSchemaBase, JunctionEntriesBase, Refinement, Molecule, Junction } from 'atom.io/internal';
-import { Canonical, stringified, Json } from 'atom.io/json';
-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 JsonInterface<T, J extends Json.Serializable = Json.Serializable> = {
+    toJson: (t: T) => J;
+    fromJson: (json: J) => T;
+};
 
-declare function dict<State, Key extends Canonical>(family: AtomIO.ReadonlySelectorFamilyToken<State, Key> | AtomIO.RegularAtomFamilyToken<State, Key> | AtomIO.WritableSelectorFamilyToken<State, Key>, index: AtomIO.ReadonlySelectorToken<Key[]> | AtomIO.RegularAtomToken<Key[]> | AtomIO.WritableSelectorToken<Key[]>, store?: Store): AtomIO.ReadonlySelectorToken<{
-    [K in stringified<Key>]: State;
-}>;
+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>;
+}
 
-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 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,
@@ -57,17 +259,6 @@ type JoinStateFamilies<ASide extends string, AType extends string, BSide extends
 } & {
     readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<BType[], AType>;
 } : never;
-type JoinHierarchy<AType extends SingularTypedKey, BType extends SingularTypedKey> = Hierarchy<[
-    {
-        above: `root`;
-        below: [AType, BType];
-    },
-    {
-        above: [AType, BType];
-        style: `all`;
-        below: CompoundTypedKey<`content`, AType, BType>;
-    }
-]>;
 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>;
@@ -84,68 +275,653 @@ declare class Join<const ASide extends string, const AType extends string, const
     [Symbol.dispose](): void;
     constructor(options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>, defaultContent: Content | undefined, store?: Store);
 }
-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 function 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`>(options: JoinOptions<ASide, AType, BSide, BType, Cardinality, null>, defaultContent?: undefined, store?: Store): JoinToken<ASide, AType, BSide, BType, Cardinality, null>;
-declare function 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>(options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>, defaultContent: Content, store?: Store): JoinToken<ASide, AType, BSide, BType, Cardinality, Content>;
-declare function getJoin<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>, store: Store): Join<ASide, AType, BSide, BType, Cardinality, Content>;
-type JoinStates<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>}`]: ReadonlySelectorToken<[
-        AType,
-        Content
-    ] | null, BType>;
-} & {
-    readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorToken<[
-        BType,
-        Content
-    ] | null, AType>;
-} : {}) & {
-    readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken<AType | null, BType>;
-} & {
-    readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorToken<BType | null, AType>;
-} : Cardinality extends `1:n` ? (Content extends Json.Object ? {
-    readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorToken<[
-        AType,
-        Content
-    ] | null, BType>;
-} & {
-    readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken<[
-        BType,
-        Content
-    ][], AType>;
-} : {}) & {
-    readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken<AType | null, BType>;
-} & {
-    readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<BType[], AType>;
-} : Cardinality extends `n:n` ? (Content extends Json.Object ? {
-    readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlySelectorToken<[
-        AType,
-        Content
-    ][], BType>;
-} & {
-    readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken<[
-        BType,
-        Content
-    ][], AType>;
-} : {}) & {
-    readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlySelectorToken<AType[], BType>;
-} & {
-    readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<BType[], AType>;
-} : never;
-declare function findRelationsInStore<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>, key: AType | BType, store: Store): JoinStates<ASide, AType, BSide, BType, Cardinality, Content>;
-declare function findRelations<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>, key: AType | BType): JoinStates<ASide, AType, BSide, BType, Cardinality, Content>;
-declare function editRelationsInStore<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>, change: (relations: Junction<ASide, AType, BSide, BType, Content>) => void, store: Store): void;
-declare function editRelations<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>, change: (relations: Junction<ASide, AType, BSide, BType, Content>) => void): void;
-declare function getInternalRelationsFromStore(token: JoinToken<any, any, any, any, any, any>, store: Store): MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string>;
-declare function getInternalRelations<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>): MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string>;
+
+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>;
+};
+
+declare function dict<State, Key extends Canonical>(family: ReadonlySelectorFamilyToken<State, Key> | RegularAtomFamilyToken<State, Key> | WritableSelectorFamilyToken<State, Key>, index: ReadonlySelectorToken<Key[]> | RegularAtomToken<Key[]> | WritableSelectorToken<Key[]>, store?: Store): ReadonlySelectorToken<{
+    [K in stringified<Key>]: State;
+}>;
 
 declare function struct<Struct extends {
     [key: string]: unknown;
@@ -154,9 +930,9 @@ declare function struct<Struct extends {
     default: Struct;
 }, store?: Store): [
     {
-        [K in keyof Struct as `${Key}${Capitalize<K & string>}State`]: AtomIO.RegularAtomToken<Struct[K]>;
+        [K in keyof Struct as `${Key}${Capitalize<K & string>}State`]: RegularAtomToken<Struct[K]>;
     },
-    AtomIO.ReadonlySelectorToken<Struct>
+    ReadonlySelectorToken<Struct>
 ];
 
 declare function structFamily<Struct extends object, Key extends string>(options: {
@@ -164,19 +940,9 @@ declare function structFamily<Struct extends object, Key extends string>(options
     default: Struct;
 }): [
     {
-        [K in keyof Struct as `find${Capitalize<Key & string>}${Capitalize<K & string>}State`]: AtomIO.RegularAtomFamilyToken<Struct[K], string>;
+        [K in keyof Struct as `find${Capitalize<Key & string>}${Capitalize<K & string>}State`]: RegularAtomFamilyToken<Struct[K], string>;
     },
-    AtomIO.ReadonlySelectorFamilyToken<Struct, string>
+    ReadonlySelectorFamilyToken<Struct, string>
 ];
 
-type Loadable<T> = Promise<T> | T;
-type Fated<T, E extends Error = Error> = Loadable<E | T>;
-/**
- * Utility for handling loadable values
- * @param loadable Loadable value
- * @param fallback Fallback value until Loadable is resolved
- * @returns Fallback value if your loadable is a promise, otherwise the loadable's resolved value
- */
-declare function until<T>(loadable: Loadable<T>, fallback: T): T;
-
-export { type Fated, Join, type JoinHierarchy, type JoinOptions, type JoinStateFamilies, type JoinStates, type JoinToken, type Loadable, dict, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, join, struct, structFamily, until };
+export { dict, struct, structFamily };