atom.io 0.32.0 → 0.32.1

package/dist/index.d.ts

@@ -1,478 +1,7 @@
-type primitive = boolean | number | string | null;
-declare namespace Json {
-    namespace Tree {
-        type Array<Element = unknown> = ReadonlyArray<Element>;
-        type Object<K extends string = string, V = unknown> = Record<K, V>;
-        type Fork = Array | Object;
-        type Leaf = primitive;
-        type Node = Fork | Leaf;
-    }
-    type Serializable = primitive | Readonly<{
-        [key: string]: Serializable;
-    }> | ReadonlyArray<Serializable>;
-    type Object<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
-    type Array<Element extends Serializable = Serializable> = ReadonlyArray<Element>;
-}
-type stringified<J extends Json.Serializable> = J extends string ? `"${J}"` : J extends number ? `${J}` : J extends true ? `true` : J extends false ? `false` : J extends boolean ? `false` | `true` : J extends null ? `null` : string & {
-    __json?: J;
-};
-type Canonical = primitive | ReadonlyArray<Canonical>;
-type JsonInterface<T, J extends Json.Serializable = Json.Serializable> = {
-    toJson: (t: T) => J;
-    fromJson: (json: J) => T;
-};
-
-declare class CircularBuffer<T> {
-    protected _buffer: T[];
-    protected _index: number;
-    constructor(array: T[]);
-    constructor(length: number);
-    get buffer(): ReadonlyArray<T | undefined>;
-    get index(): number;
-    add(item: T): void;
-    copy(): CircularBuffer<T>;
-}
-
-type Func = (...parameters: any[]) => any;
-type Flat<R extends {
-    [K in PropertyKey]: any;
-}> = {
-    [K in keyof R]: R[K];
-};
-type Count<N extends number, A extends any[] = []> = [
-    ...A,
-    any
-][`length`] extends N ? A[`length`] : A[`length`] | Count<N, [...A, any]>;
-type Each<E extends any[]> = {
-    [P in Count<E[`length`]>]: E[P];
-};
-type Refinement<A, B extends A> = (a: A) => a is B;
-
-type JunctionEntriesBase<AType extends string, BType extends string, Content extends Json.Object | null> = {
-    readonly relations: ([AType, BType[]] | [BType, AType[]])[];
-    readonly contents: [string, Content][];
-};
-interface JunctionEntries<AType extends string, BType extends string, Content extends Json.Object | null> extends Json.Object, JunctionEntriesBase<AType, BType, Content> {
-}
-type JunctionSchemaBase<ASide extends string, BSide extends string> = {
-    readonly between: [a: ASide, b: BSide];
-    readonly cardinality: `1:1` | `1:n` | `n:n`;
-};
-interface JunctionSchema<ASide extends string, BSide extends string> extends Json.Object, JunctionSchemaBase<ASide, BSide> {
-}
-type BaseExternalStoreConfiguration = {
-    addRelation: (a: string, b: string) => void;
-    deleteRelation: (a: string, b: string) => void;
-    replaceRelationsSafely: (a: string, bs: string[]) => void;
-    replaceRelationsUnsafely: (a: string, bs: string[]) => void;
-    getRelatedKeys(key: string): Set<string> | undefined;
-    has: (a: string, b?: string) => boolean;
-};
-type ExternalStoreWithContentConfiguration<Content extends Json.Object> = {
-    getContent: (contentKey: string) => Content | undefined;
-    setContent: (contentKey: string, content: Content) => void;
-    deleteContent: (contentKey: string) => void;
-};
-type Empty<Obj extends object> = {
-    [Key in keyof Obj]?: undefined;
-};
-type ExternalStoreConfiguration<Content extends Json.Object | null> = Content extends Json.Object ? BaseExternalStoreConfiguration & ExternalStoreWithContentConfiguration<Content> : BaseExternalStoreConfiguration & Empty<ExternalStoreWithContentConfiguration<Json.Object>>;
-type JunctionAdvancedConfiguration<AType extends string, BType extends string, Content extends Json.Object | null> = {
-    warn?: (...args: any[]) => void;
-    externalStore?: ExternalStoreConfiguration<Content>;
-    isAType?: Refinement<string, AType>;
-    isBType?: Refinement<string, BType>;
-    isContent?: Refinement<unknown, Content>;
-    makeContentKey?: (a: AType, b: BType) => string;
-};
-type JunctionJSON<ASide extends string, AType extends string, BSide extends string, BType extends string, Content extends Json.Object | null> = JunctionEntries<AType, BType, Content> & JunctionSchema<ASide, BSide>;
-declare class Junction<const ASide extends string, const AType extends string, const BSide extends string, const BType extends string, const Content extends Json.Object | null = null> {
-    readonly a: ASide;
-    readonly b: BSide;
-    readonly cardinality: `1:1` | `1:n` | `n:n`;
-    readonly relations: Map<AType | BType, Set<AType> | Set<BType>>;
-    readonly contents: Map<string, Content>;
-    isAType?: Refinement<string, AType> | null;
-    isBType?: Refinement<string, BType> | null;
-    isContent: Refinement<unknown, Content> | null;
-    makeContentKey: (a: AType, b: BType) => string;
-    warn?: (...args: any[]) => void;
-    getRelatedKeys(key: AType): Set<BType> | undefined;
-    getRelatedKeys(key: BType): Set<AType> | undefined;
-    getRelatedKeys(key: AType | BType): Set<AType> | Set<BType> | undefined;
-    protected addRelation(a: AType, b: BType): void;
-    protected deleteRelation(a: AType, b: BType): void;
-    protected replaceRelationsUnsafely(a: AType, bs: BType[]): void;
-    protected replaceRelationsUnsafely(b: BType, as: AType[]): void;
-    protected replaceRelationsSafely(a: AType, bs: BType[]): void;
-    protected replaceRelationsSafely(b: BType, as: AType[]): void;
-    protected getContentInternal(contentKey: string): Content | undefined;
-    protected setContent(contentKey: string, content: Content): void;
-    protected deleteContent(contentKey: string): void;
-    constructor(data: JunctionSchema<ASide, BSide> & Partial<JunctionEntries<NoInfer<AType>, NoInfer<BType>, Content>>, config?: JunctionAdvancedConfiguration<AType, BType, Content>);
-    toJSON(): JunctionJSON<ASide, AType, BSide, BType, Content>;
-    set(a: AType, ...rest: Content extends null ? [b: BType] : [b: BType, content: Content]): this;
-    set(relation: {
-        [Key in ASide]: AType;
-    } & {
-        [Key in BSide]: BType;
-    }, ...rest: Content extends null ? [] | [void?: undefined] : [content: Content]): this;
-    delete(a: AType, b?: BType): this;
-    delete(b: BType, a?: AType): this;
-    delete(relation: {
-        [Key in ASide]: AType;
-    } | {
-        [Key in BSide]: BType;
-    } | ({
-        [Key in ASide]: AType;
-    } & {
-        [Key in BSide]: BType;
-    }), b?: undefined): this;
-    getRelatedKey(key: AType): BType | undefined;
-    getRelatedKey(key: BType): AType | undefined;
-    replaceRelations(a: AType, relations: Content extends null ? BType[] : Record<BType, Content>, config?: {
-        reckless: boolean;
-    }): this;
-    replaceRelations(b: BType, relations: Content extends null ? AType[] : Record<AType, Content>, config?: {
-        reckless: boolean;
-    }): this;
-    getContent(a: AType, b: BType): Content | undefined;
-    getRelationEntries(input: Record<ASide, AType>): [BType, Content][];
-    getRelationEntries(input: Record<BSide, BType>): [AType, Content][];
-    has(a: AType, b?: BType): boolean;
-    has(b: BType, a?: AType): boolean;
-}
-
-declare class Subject<T> {
-    Subscriber: (value: T) => void;
-    subscribers: Map<string, this[`Subscriber`]>;
-    subscribe(key: string, subscriber: this[`Subscriber`]): () => void;
-    private unsubscribe;
-    next(value: T): void;
-}
-declare class StatefulSubject<T> extends Subject<T> {
-    state: T;
-    constructor(initialState: T);
-    next(value: T): void;
-}
-
-type Transaction<F extends Func> = {
-    key: string;
-    type: `transaction`;
-    install: (store: Store) => void;
-    subject: Subject<TransactionUpdate<F>>;
-    run: (parameters: Parameters<F>, id?: string) => ReturnType<F>;
-};
-
-type TransactionProgress<F extends Func> = {
-    phase: `applying` | `building`;
-    update: TransactionUpdate<F>;
-    toolkit: ActorToolkit;
-};
-type TransactionEpoch = {
-    epoch: Map<string, number>;
-    actionContinuities: Junction<`continuity`, string, `action`, string>;
-};
-
-type SetUpdate = `add:${string}` | `clear:${string}` | `del:${string}` | `tx:${string}`;
-type NumberedSetUpdate = `${number}=${SetUpdate}`;
-interface SetRTXJson<P extends primitive> extends Json.Object {
-    members: P[];
-    cache: (NumberedSetUpdate | null)[];
-    cacheLimit: number;
-    cacheIdx: number;
-    cacheUpdateNumber: number;
-}
-declare class SetRTX<P extends primitive> extends Set<P> implements Transceiver<NumberedSetUpdate>, Lineage {
-    mode: TransceiverMode;
-    readonly subject: Subject<SetUpdate>;
-    cacheLimit: number;
-    cache: (NumberedSetUpdate | null)[];
-    cacheIdx: number;
-    cacheUpdateNumber: number;
-    constructor(values?: Iterable<P>, cacheLimit?: number);
-    toJSON(): SetRTXJson<P>;
-    static fromJSON<P extends primitive>(json: SetRTXJson<P>): SetRTX<P>;
-    add(value: P): this;
-    clear(): void;
-    delete(value: P): boolean;
-    readonly parent: SetRTX<P> | null;
-    child: SetRTX<P> | null;
-    transactionUpdates: SetUpdate[] | null;
-    transaction(run: (child: SetRTX<P>) => boolean): void;
-    protected _subscribe(key: string, fn: (update: SetUpdate) => void): () => void;
-    subscribe(key: string, fn: (update: NumberedSetUpdate) => void): () => void;
-    emit(update: SetUpdate): void;
-    private doStep;
-    getUpdateNumber(update: NumberedSetUpdate): number;
-    do(update: NumberedSetUpdate): number | `OUT_OF_RANGE` | null;
-    undoStep(update: SetUpdate): void;
-    undo(update: NumberedSetUpdate): number | null;
-}
-
-type Molecule<K extends Canonical> = {
-    readonly key: K;
-    readonly stringKey: stringified<K>;
-    readonly dependsOn: `all` | `any`;
-};
-
-type JoinStateFamilies<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null> = Cardinality extends `1:1` ? (Content extends Json.Object ? {
-    readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<[
-        AType,
-        Content
-    ] | null, BType>;
-} & {
-    readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[
-        BType,
-        Content
-    ] | null, AType>;
-} : {}) & {
-    readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<AType | null, BType>;
-} & {
-    readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<BType | null, AType>;
-} : Cardinality extends `1:n` ? (Content extends Json.Object ? {
-    readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<[
-        AType,
-        Content
-    ] | null, BType>;
-} & {
-    readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[
-        BType,
-        Content
-    ][], AType>;
-} : {}) & {
-    readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<AType | null, BType>;
-} & {
-    readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<BType[], AType>;
-} : Cardinality extends `n:n` ? (Content extends Json.Object ? {
-    readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<[
-        AType,
-        Content
-    ][], BType>;
-} & {
-    readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[
-        BType,
-        Content
-    ][], AType>;
-} : {}) & {
-    readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<AType[], BType>;
-} & {
-    readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<BType[], AType>;
-} : never;
-declare class Join<const ASide extends string, const AType extends string, const BSide extends string, const BType extends string, const Cardinality extends `1:1` | `1:n` | `n:n`, const Content extends Json.Object | null = null, const ContentKey extends CompoundTypedKey<`content`, ASide, BSide> = CompoundTypedKey<`content`, ASide, BSide>> {
-    private toolkit;
-    options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>;
-    defaultContent: Content | undefined;
-    molecules: Map<string, Molecule<any>>;
-    relations: Junction<ASide, AType, BSide, BType, Content>;
-    states: JoinStateFamilies<ASide, AType, BSide, BType, Cardinality, Content>;
-    core: {
-        relatedKeysAtoms: MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string>;
-    };
-    transact(toolkit: SetterToolkit, run: (join: Join<ASide, AType, BSide, BType, Cardinality, Content>) => void): void;
-    store: Store;
-    realm: Anarchy;
-    [Symbol.dispose](): void;
-    constructor(options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>, defaultContent: Content | undefined, store?: Store);
-}
-
-interface Lineage {
-    parent: typeof this | null;
-    child: typeof this | null;
-}
-
-type OperationProgress = {
-    open: false;
-} | {
-    open: true;
-    done: Set<string>;
-    prev: Map<string, any>;
-    time: number;
-    token: WritableToken<any>;
-};
-
-type TimelineAtomUpdate<ManagedAtom extends TimelineManageable> = Flat<StateUpdate<TokenType<ManagedAtom>> & {
-    key: string;
-    type: `atom_update`;
-    timestamp: number;
-    family?: FamilyMetadata;
-}>;
-type TimelineSelectorUpdate<ManagedAtom extends TimelineManageable> = {
-    key: string;
-    type: `selector_update`;
-    timestamp: number;
-    atomUpdates: Omit<TimelineAtomUpdate<ManagedAtom>, `timestamp`>[];
-};
-type TimelineTransactionUpdate = Flat<TransactionUpdate<Func> & {
-    key: string;
-    type: `transaction_update`;
-    timestamp: number;
-}>;
-type TimelineStateCreation<T extends ReadableToken<any>> = Flat<StateCreation<T> & {
-    timestamp: number;
-}>;
-type TimelineStateDisposal<T extends ReadableToken<any>> = Flat<StateDisposal<T> & {
-    timestamp: number;
-}>;
-type TimelineMoleculeCreation = Flat<MoleculeCreation & {
-    timestamp: number;
-}>;
-type TimelineMoleculeDisposal = Flat<MoleculeDisposal & {
-    timestamp: number;
-}>;
-type Timeline<ManagedAtom extends TimelineManageable> = {
-    type: `timeline`;
-    key: string;
-    at: number;
-    shouldCapture?: (update: TimelineUpdate<ManagedAtom>, timeline: Timeline<ManagedAtom>) => boolean;
-    timeTraveling: `into_future` | `into_past` | null;
-    history: TimelineUpdate<ManagedAtom>[];
-    selectorTime: number | null;
-    transactionKey: string | null;
-    install: (store: Store) => void;
-    subject: Subject<TimelineUpdate<ManagedAtom> | `redo` | `undo`>;
-    subscriptions: Map<string, () => void>;
-};
-
-declare class Store implements Lineage {
-    parent: Store | null;
-    child: Store | null;
-    valueMap: Map<string, any>;
-    defaults: Map<string, any>;
-    atoms: Map<string, Atom<any>>;
-    selectors: Map<string, WritableSelector<any>>;
-    readonlySelectors: Map<string, ReadonlySelector<any>>;
-    atomsThatAreDefault: Set<string>;
-    selectorAtoms: Junction<"selectorKey", string, "atomKey", string, null>;
-    selectorGraph: Junction<"upstreamSelectorKey", string, "downstreamSelectorKey", string, {
-        source: string;
-    }>;
-    trackers: Map<string, Tracker<Transceiver<any>>>;
-    families: Map<string, MutableAtomFamily<any, any, any> | ReadonlySelectorFamily<any, any> | RegularAtomFamily<any, any> | WritableSelectorFamily<any, any>>;
-    joins: Map<string, Join<any, any, any, any, any, any, `T$--content==${any}::${string}++${any}::${string}`>>;
-    transactions: Map<string, Transaction<Func>>;
-    transactionMeta: TransactionEpoch | TransactionProgress<Func>;
-    timelines: Map<string, Timeline<any>>;
-    timelineTopics: Junction<"timelineKey", string, "topicKey", string, {
-        topicType: `atom_family` | `atom` | `molecule_family` | `molecule`;
-    }>;
-    disposalTraces: CircularBuffer<{
-        key: string;
-        trace: string;
-    }>;
-    molecules: Map<string, Molecule<Canonical>>;
-    moleculeJoins: Junction<"moleculeKey", stringified<Canonical>, "joinKey", string, null>;
-    moleculeGraph: Junction<"upstreamMoleculeKey", stringified<Canonical> | "root", "downstreamMoleculeKey", stringified<Canonical>, {
-        source: stringified<Canonical>;
-    }>;
-    moleculeData: Junction<"moleculeKey", stringified<Canonical>, "stateFamilyKey", string, null>;
-    miscResources: Map<string, Disposable>;
-    on: {
-        atomCreation: Subject<AtomToken<unknown>>;
-        atomDisposal: Subject<AtomToken<unknown>>;
-        selectorCreation: Subject<ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>>;
-        selectorDisposal: Subject<ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>>;
-        timelineCreation: Subject<TimelineToken<unknown>>;
-        transactionCreation: Subject<TransactionToken<Func>>;
-        transactionApplying: StatefulSubject<TransactionProgress<Func> | null>;
-        operationClose: Subject<OperationProgress>;
-        moleculeCreation: Subject<MoleculeCreation>;
-        moleculeDisposal: Subject<MoleculeDisposal>;
-    };
-    operation: OperationProgress;
-    config: {
-        name: string;
-        lifespan: `ephemeral` | `immortal`;
-    };
-    loggers: AtomIOLogger[];
-    logger: Logger;
-    constructor(config: Store[`config`], store?: Store | null);
-}
-
-interface Transceiver<S extends Json.Serializable> {
-    do: (update: S) => number | `OUT_OF_RANGE` | null;
-    undo: (update: S) => void;
-    subscribe: (key: string, fn: (update: S) => void) => () => void;
-    cacheUpdateNumber: number;
-    getUpdateNumber: (update: S) => number;
-}
-type TransceiverMode = `playback` | `record` | `transaction`;
-
-/**
- * @internal Give the tracker a transceiver state and a store, and it will
- * subscribe to the transceiver's inner value. When the inner value changes,
- * the tracker will update its own state to reflect the change.
- */
-declare class Tracker<Mutable extends Transceiver<any>> {
-    private Update;
-    private initializeState;
-    private unsubscribeFromInnerValue;
-    private unsubscribeFromState;
-    private observeCore;
-    private updateCore;
-    mutableState: MutableAtomToken<Mutable, Json.Serializable>;
-    latestUpdateState: RegularAtomToken<typeof this.Update | null>;
-    [Symbol.dispose]: () => void;
-    constructor(mutableState: MutableAtomToken<Mutable, Json.Serializable>, store: Store);
-}
-
-type EnvironmentData = {
-    store: Store;
-};
-
-type AtomIOState = {
-    key: string;
-    family?: FamilyMetadata;
-    install: (store: Store) => void;
-    subject: Subject<{
-        newValue: any;
-        oldValue: any;
-    }>;
-};
-type RegularAtom<T> = AtomIOState & {
-    type: `atom`;
-    default: T | (() => T);
-    cleanup?: () => void;
-};
-type MutableAtom<T extends Transceiver<any>, J extends Json.Serializable> = AtomIOState & JsonInterface<T, J> & {
-    type: `mutable_atom`;
-    default: T | (() => T);
-    cleanup?: () => void;
-};
-type Atom<T> = RegularAtom<T> | (T extends Transceiver<any> ? MutableAtom<T, any> : never);
-type WritableSelector<T> = AtomIOState & {
-    type: `selector`;
-    get: () => T;
-    set: (newValue: T | ((oldValue: T) => T)) => void;
-};
-type ReadonlySelector<T> = AtomIOState & {
-    type: `readonly_selector`;
-    get: () => T;
-};
-type RegularAtomFamily<T, K extends Canonical> = RegularAtomFamilyToken<T, K> & {
-    (key: K): RegularAtomToken<T>;
-    subject: Subject<StateCreation<AtomToken<T>> | StateDisposal<AtomToken<T>>>;
-    install: (store: Store) => void;
-    internalRoles: string[] | undefined;
-};
-type MutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical> = JsonInterface<T, J> & MutableAtomFamilyToken<T, J, K> & {
-    (key: K): MutableAtomToken<T, J>;
-    subject: Subject<StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>>;
-    install: (store: Store) => void;
-    internalRoles: string[] | undefined;
-};
-type WritableSelectorFamily<T, K extends Canonical> = WritableSelectorFamilyToken<T, K> & ((key: K) => WritableSelectorToken<T>) & {
-    default: (key: K) => T;
-    subject: Subject<StateCreation<WritableSelectorToken<T>> | StateDisposal<WritableSelectorToken<T>>>;
-    install: (store: Store) => void;
-    internalRoles: string[] | undefined;
-};
-type ReadonlySelectorFamily<T, K extends Canonical> = ReadonlySelectorFamilyToken<T, K> & ((key: K) => ReadonlySelectorToken<T>) & {
-    default: (key: K) => T;
-    subject: Subject<StateCreation<ReadonlySelectorToken<T>> | StateDisposal<ReadonlySelectorToken<T>>>;
-    install: (store: Store) => void;
-    internalRoles: string[] | undefined;
-};
+import { Transceiver, Func, EnvironmentData, TimelineAtomUpdate, TimelineMoleculeCreation, TimelineMoleculeDisposal, TimelineSelectorUpdate, TimelineStateCreation, TimelineStateDisposal, TimelineTransactionUpdate, Timeline, JunctionSchemaBase, JunctionEntriesBase, Refinement, Store, Junction, Each, Flat } from 'atom.io/internal';
+import { Canonical, Json, JsonInterface, stringified } from 'atom.io/json';
+import { getState as getState$1, setState as setState$1, findState as findState$1, MutableAtomFamilyToken as MutableAtomFamilyToken$1, MutableAtomToken as MutableAtomToken$1, RegularAtomFamilyToken as RegularAtomFamilyToken$1, RegularAtomToken as RegularAtomToken$1, WritableSelectorFamilyToken as WritableSelectorFamilyToken$1, WritableSelectorToken as WritableSelectorToken$1, ReadonlySelectorFamilyToken as ReadonlySelectorFamilyToken$1, ReadonlySelectorToken as ReadonlySelectorToken$1, WritableFamilyToken as WritableFamilyToken$1, WritableToken as WritableToken$1, ReadableFamilyToken as ReadableFamilyToken$1, ReadableToken as ReadableToken$1 } from 'atom.io';
+import { SetRTX, SetRTXJson } from 'atom.io/transceivers/set-rtx';
 
 /**
  * @public
@@ -611,15 +140,15 @@ type TransactionUpdate<F extends Func> = {
 };
 type GetterToolkit = Pick<SetterToolkit, `find` | `get` | `json`>;
 type SetterToolkit = Readonly<{
-    get: typeof getState;
-    set: typeof setState;
-    find: typeof findState;
+    get: typeof getState$1;
+    set: typeof setState$1;
+    find: typeof findState$1;
     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;
+    get: typeof getState$1;
+    set: typeof setState$1;
+    find: typeof findState$1;
     json: <T extends Transceiver<any>, J extends Json.Serializable>(state: MutableAtomToken<T, J>) => WritableSelectorToken<J>;
     dispose: typeof disposeState;
     run: typeof runTransaction;
@@ -732,7 +261,7 @@ declare function disposeState<K extends Canonical>(token: ReadableFamilyToken<an
  * 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>;
+declare function findState<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken$1<T, J, K>, key: Key): MutableAtomToken$1<T, J, K>;
 /**
  * @public
  * Finds a state in the store
@@ -742,7 +271,7 @@ declare function findState<T extends Transceiver<any>, J extends Json.Serializab
  * 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>;
+declare function findState<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken$1<T, K>, key: Key): RegularAtomToken$1<T, K>;
 /**
  * @public
  * Finds a state in the store
@@ -752,7 +281,7 @@ declare function findState<T, K extends Canonical, Key extends K>(token: Regular
  * 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>;
+declare function findState<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken$1<T, K>, key: Key): WritableSelectorToken$1<T, K>;
 /**
  * @public
  * Finds a state in the store
@@ -762,7 +291,7 @@ declare function findState<T, K extends Canonical, Key extends K>(token: Writabl
  * 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>;
+declare function findState<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken$1<T, K>, key: Key): ReadonlySelectorToken$1<T, K>;
 /**
  * @public
  * Finds a state in the store
@@ -772,7 +301,7 @@ declare function findState<T, K extends Canonical, Key extends K>(token: Readonl
  * 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>;
+declare function findState<T, K extends Canonical, Key extends K>(token: WritableFamilyToken$1<T, K>, key: Key): WritableToken$1<T, K>;
 /**
  * @public
  * Finds a {@link ReadableToken} in the store
@@ -783,7 +312,7 @@ declare function findState<T, K extends Canonical, Key extends K>(token: Writabl
  * @overload Unknown
  * @default
  */
-declare function findState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T, K>;
+declare function findState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken$1<T, K>, key: Key): ReadableToken$1<T, K>;
 
 /**
  * @public
@@ -823,51 +352,51 @@ type JoinToken<ASide extends string, AType extends string, BSide extends string,
 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>;
 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<[
+    readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorToken$1<[
         AType,
         Content
     ] | null, BType>;
 } & {
-    readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorToken<[
+    readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorToken$1<[
         BType,
         Content
     ] | null, AType>;
 } : {}) & {
-    readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken<AType | null, BType>;
+    readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken$1<AType | null, BType>;
 } & {
-    readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorToken<BType | null, AType>;
+    readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorToken$1<BType | null, AType>;
 } : Cardinality extends `1:n` ? (Content extends Json.Object ? {
-    readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorToken<[
+    readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorToken$1<[
         AType,
         Content
     ] | null, BType>;
 } & {
-    readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken<[
+    readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken$1<[
         BType,
         Content
     ][], AType>;
 } : {}) & {
-    readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken<AType | null, BType>;
+    readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken$1<AType | null, BType>;
 } & {
-    readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<BType[], AType>;
+    readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken$1<BType[], AType>;
 } : Cardinality extends `n:n` ? (Content extends Json.Object ? {
-    readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlySelectorToken<[
+    readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlySelectorToken$1<[
         AType,
         Content
     ][], BType>;
 } & {
-    readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken<[
+    readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken$1<[
         BType,
         Content
     ][], AType>;
 } : {}) & {
-    readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlySelectorToken<AType[], BType>;
+    readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlySelectorToken$1<AType[], BType>;
 } & {
-    readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<BType[], AType>;
+    readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken$1<BType[], AType>;
 } : never;
 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 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 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>;
+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$1<SetRTX<string>, SetRTXJson<string>, string>;
 
 declare const LoggerIconDictionary: {
     readonly "\u231B": "Timeline event fully captured";
@@ -1033,7 +562,7 @@ declare class Silo {
     selectorFamily: typeof selectorFamily;
     transaction: typeof transaction;
     timeline: typeof timeline;
-    findState: typeof findState;
+    findState: typeof findState$1;
     getState: typeof getState;
     setState: typeof setState;
     disposeState: typeof disposeState;
@@ -1060,19 +589,19 @@ declare function subscribe<T>(token: ReadableToken<T>, handleUpdate: UpdateHandl
 declare function subscribe<F extends Func>(token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key?: string): () => void;
 declare function subscribe<M extends TimelineManageable>(token: TimelineToken<M>, handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void, key?: string): () => void;
 
-type TokenType<Comparison extends ReadableFamilyToken<any, any> | ReadableToken<any>> = Comparison extends ReadableToken<infer RepresentedValue> ? RepresentedValue : Comparison extends ReadableFamilyToken<infer RepresentedValue, any> ? RepresentedValue : never;
-declare function isToken<KnownToken extends RegularAtomToken<any>>(knownToken: KnownToken, unknownToken: ReadableToken<any>): unknownToken is RegularAtomToken<TokenType<KnownToken>>;
-declare function isToken<KnownToken extends MutableAtomToken<any, any>>(knownToken: KnownToken, unknownToken: ReadableToken<any>): unknownToken is MutableAtomToken<TokenType<KnownToken>, any>;
-declare function isToken<KnownToken extends WritableSelectorToken<any>>(knownToken: KnownToken, unknownToken: ReadableToken<any>): unknownToken is WritableSelectorToken<TokenType<KnownToken>>;
-declare function isToken<KnownToken extends ReadonlySelectorToken<any>>(knownToken: KnownToken, unknownToken: ReadableToken<any>): unknownToken is ReadonlySelectorToken<TokenType<KnownToken>>;
-declare function isToken<KnownToken extends WritableToken<any>>(knownToken: KnownToken, unknownToken: ReadableToken<any>): unknownToken is WritableToken<TokenType<KnownToken>>;
-declare function isToken<KnownToken extends ReadableToken<any>>(knownToken: KnownToken, unknownToken: ReadableToken<any>): unknownToken is ReadableToken<TokenType<KnownToken>>;
-declare function belongsTo<Family extends RegularAtomFamilyToken<any, any>>(family: Family, unknownToken: ReadableToken<any>): unknownToken is RegularAtomToken<TokenType<Family>>;
-declare function belongsTo<Family extends MutableAtomFamilyToken<any, any, any>>(family: Family, unknownToken: ReadableToken<any>): unknownToken is MutableAtomToken<TokenType<Family>, any>;
-declare function belongsTo<Family extends WritableSelectorFamilyToken<any, any>>(family: Family, unknownToken: ReadableToken<any>): unknownToken is WritableSelectorToken<TokenType<Family>>;
-declare function belongsTo<Family extends ReadonlySelectorFamilyToken<any, any>>(family: Family, unknownToken: ReadableToken<any>): unknownToken is ReadonlySelectorToken<TokenType<Family>>;
-declare function belongsTo<Family extends WritableFamilyToken<any, any>>(family: Family, unknownToken: ReadableToken<any>): unknownToken is WritableToken<TokenType<Family>>;
-declare function belongsTo<Family extends ReadableFamilyToken<any, any>>(family: Family, unknownToken: ReadableToken<any>): unknownToken is ReadableToken<TokenType<Family>>;
+type TokenType<Comparison extends ReadableFamilyToken$1<any, any> | ReadableToken$1<any>> = Comparison extends ReadableToken$1<infer RepresentedValue> ? RepresentedValue : Comparison extends ReadableFamilyToken$1<infer RepresentedValue, any> ? RepresentedValue : never;
+declare function isToken<KnownToken extends RegularAtomToken$1<any>>(knownToken: KnownToken, unknownToken: ReadableToken$1<any>): unknownToken is RegularAtomToken$1<TokenType<KnownToken>>;
+declare function isToken<KnownToken extends MutableAtomToken$1<any, any>>(knownToken: KnownToken, unknownToken: ReadableToken$1<any>): unknownToken is MutableAtomToken$1<TokenType<KnownToken>, any>;
+declare function isToken<KnownToken extends WritableSelectorToken$1<any>>(knownToken: KnownToken, unknownToken: ReadableToken$1<any>): unknownToken is WritableSelectorToken$1<TokenType<KnownToken>>;
+declare function isToken<KnownToken extends ReadonlySelectorToken$1<any>>(knownToken: KnownToken, unknownToken: ReadableToken$1<any>): unknownToken is ReadonlySelectorToken$1<TokenType<KnownToken>>;
+declare function isToken<KnownToken extends WritableToken$1<any>>(knownToken: KnownToken, unknownToken: ReadableToken$1<any>): unknownToken is WritableToken$1<TokenType<KnownToken>>;
+declare function isToken<KnownToken extends ReadableToken$1<any>>(knownToken: KnownToken, unknownToken: ReadableToken$1<any>): unknownToken is ReadableToken$1<TokenType<KnownToken>>;
+declare function belongsTo<Family extends RegularAtomFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is RegularAtomToken$1<TokenType<Family>>;
+declare function belongsTo<Family extends MutableAtomFamilyToken$1<any, any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is MutableAtomToken$1<TokenType<Family>, any>;
+declare function belongsTo<Family extends WritableSelectorFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is WritableSelectorToken$1<TokenType<Family>>;
+declare function belongsTo<Family extends ReadonlySelectorFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is ReadonlySelectorToken$1<TokenType<Family>>;
+declare function belongsTo<Family extends WritableFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is WritableToken$1<TokenType<Family>>;
+declare function belongsTo<Family extends ReadableFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is ReadableToken$1<TokenType<Family>>;
 
 /**
  * @public