atom.io 0.31.0 → 0.32.0

package/internal/dist/index.d.ts

@@ -1,7 +1,655 @@
-import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, AtomFamilyToken, AtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, SelectorFamilyToken, SelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, ReadableToken, TransactionToken, TransactionUpdate, TransactionOptions, ActorToolkit, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, StateCreation, StateDisposal, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, TimelineToken, AtomIOLogger, Logger, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, KeyedStateUpdate, MoleculeTransfer, ReadonlySelectorOptions, WritableSelectorOptions, SetterToolkit, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
-import { Json, Canonical, stringified, JsonInterface } from 'atom.io/json';
-import { Join } from 'atom.io/data';
-import { Store as Store$1, Func as Func$1 } from 'atom.io/internal';
+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;
+};
+
+/** @public */
+type Effectors<T> = {
+    /**
+     * Set the value of the atom
+     * @param next - The new value of the atom, or a setter function
+     */
+    setSelf: <New extends T>(next: New | Setter<T, New>) => void;
+    /** Subscribe to changes to the atom */
+    onSet: (callback: (options: {
+        newValue: T;
+        oldValue: T;
+    }) => void) => void;
+};
+/**
+ * @public
+ * A function that runs side effects when the atom is set
+ * @param tools - {@link Effectors} that can be used to run side effects
+ * @returns
+ * Optionally, a cleanup function that will be called when the atom is disposed
+ */
+type AtomEffect<T> = (tools: Effectors<T>) => (() => void) | void;
+/** @public */
+type RegularAtomOptions<T> = {
+    /** The unique identifier of the atom */
+    key: string;
+    /** The starting value of the atom */
+    default: T | (() => T);
+    /** Hooks used to run side effects when the atom is set */
+    effects?: AtomEffect<T>[];
+};
+type MutableAtomOptions<T extends Transceiver<any>, J extends Json.Serializable> = JsonInterface<T, J> & Omit<RegularAtomOptions<T>, `default`> & {
+    default: () => T;
+    mutable: true;
+};
+/** @public */
+type RegularAtomFamilyOptions<T, K extends Canonical> = {
+    /** The unique identifier of the atom family */
+    key: string;
+    /** The starting value of the atom family */
+    default: T | ((key: K) => T);
+    /** Hooks used to run side effects when an atom in the family is set  */
+    effects?: (key: K) => AtomEffect<T>[];
+};
+type RegularAtomFamilyToken<T, K extends Canonical> = {
+    key: string;
+    type: `atom_family`;
+    __T?: T;
+    __K?: K;
+};
+type MutableAtomFamilyOptions<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical> = JsonInterface<T, J> & {
+    key: string;
+    default: (key: K) => T;
+    effects?: (key: K) => AtomEffect<T>[];
+    mutable: true;
+};
+type MutableAtomFamilyToken<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical> = {
+    key: string;
+    type: `mutable_atom_family`;
+    __T?: T;
+    __J?: J;
+    __K?: K;
+};
+type AtomFamilyToken<T, K extends Canonical = Canonical> = MutableAtomFamilyToken<T extends Transceiver<any> ? T : never, any, K> | RegularAtomFamilyToken<T, K>;
+
+type TransactionToken<F extends Func> = {
+    key: string;
+    type: `transaction`;
+    __F?: F;
+};
+type StateCreation<Token extends ReadableToken<any>> = {
+    type: `state_creation`;
+    token: Token;
+};
+type AtomDisposal<Token extends ReadableToken<any>> = {
+    type: `state_disposal`;
+    subType: `atom`;
+    token: Token;
+    value: TokenType<Token>;
+};
+type SelectorDisposal<Token extends ReadableToken<any>> = {
+    type: `state_disposal`;
+    subType: `selector`;
+    token: Token;
+};
+type StateDisposal<Token extends ReadableToken<any>> = AtomDisposal<Token> | SelectorDisposal<Token>;
+type MoleculeCreation = {
+    type: `molecule_creation`;
+    key: Canonical;
+    provenance: Canonical;
+};
+type MoleculeDisposal = {
+    type: `molecule_disposal`;
+    key: Canonical;
+    provenance: stringified<Canonical>[];
+    values: [key: string, value: any][];
+};
+type MoleculeTransfer = {
+    type: `molecule_transfer`;
+    key: Canonical;
+    from: Canonical[];
+    to: Canonical[];
+};
+type TransactionUpdateContent = KeyedStateUpdate<unknown> | MoleculeCreation | MoleculeDisposal | MoleculeTransfer | StateCreation<ReadableToken<unknown>> | StateDisposal<ReadableToken<unknown>> | TransactionUpdate<Func>;
+type TransactionUpdate<F extends Func> = {
+    type: `transaction_update`;
+    key: string;
+    id: string;
+    epoch: number;
+    updates: TransactionUpdateContent[];
+    params: Parameters<F>;
+    output: ReturnType<F>;
+};
+type GetterToolkit = Pick<SetterToolkit, `find` | `get` | `json`>;
+type SetterToolkit = Readonly<{
+    get: typeof getState;
+    set: typeof setState;
+    find: typeof findState;
+    json: <T extends Transceiver<any>, J extends Json.Serializable>(state: MutableAtomToken<T, J>) => WritableSelectorToken<J>;
+}>;
+type ActorToolkit = Readonly<{
+    get: typeof getState;
+    set: typeof setState;
+    find: typeof findState;
+    json: <T extends Transceiver<any>, J extends Json.Serializable>(state: MutableAtomToken<T, J>) => WritableSelectorToken<J>;
+    dispose: typeof disposeState;
+    run: typeof runTransaction;
+    env: () => EnvironmentData;
+}>;
+type Read<F extends Func> = (toolkit: GetterToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
+type Write<F extends Func> = (toolkit: SetterToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
+type Transact<F extends Func> = (toolkit: ActorToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
+type TransactionOptions<F extends Func> = {
+    key: string;
+    do: Transact<F>;
+};
+declare function runTransaction<F extends Func>(token: TransactionToken<F>, id?: string): (...parameters: Parameters<F>) => ReturnType<F>;
+
+type WritableSelectorOptions<T> = {
+    key: string;
+    get: Read<() => T>;
+    set: Write<(newValue: T) => void>;
+};
+type ReadonlySelectorOptions<T> = {
+    key: string;
+    get: Read<() => T>;
+};
+type WritableSelectorFamilyOptions<T, K extends Canonical> = {
+    key: string;
+    get: (key: K) => Read<() => T>;
+    set: (key: K) => Write<(newValue: T) => void>;
+};
+type ReadonlySelectorFamilyOptions<T, K extends Canonical> = {
+    key: string;
+    get: (key: K) => Read<() => T>;
+};
+type WritableSelectorFamilyToken<T, K extends Canonical> = {
+    key: string;
+    type: `selector_family`;
+    __T?: T;
+    __K?: K;
+};
+type ReadonlySelectorFamilyToken<T, K extends Canonical> = {
+    key: string;
+    type: `readonly_selector_family`;
+    __T?: T;
+    __K?: K;
+};
+type SelectorFamilyToken<T, K extends Canonical> = ReadonlySelectorFamilyToken<T, K> | WritableSelectorFamilyToken<T, K>;
+
+type TimelineManageable = AtomFamilyToken<any, any> | AtomToken<any>;
+type AtomOnly<M extends TimelineManageable> = M extends AtomFamilyToken<any, any> ? AtomToken<any> : M extends AtomToken<any> ? M : never;
+type TimelineToken<M> = {
+    key: string;
+    type: `timeline`;
+    __M?: M;
+};
+type TimelineOptions<ManagedAtom extends TimelineManageable> = {
+    key: string;
+    scope: ManagedAtom[];
+    shouldCapture?: (update: TimelineUpdate<ManagedAtom>, timeline: Timeline<TimelineManageable>) => boolean;
+};
+type TimelineUpdate<ManagedAtom extends TimelineManageable> = TimelineAtomUpdate<ManagedAtom> | TimelineMoleculeCreation | TimelineMoleculeDisposal | TimelineSelectorUpdate<ManagedAtom> | TimelineStateCreation<AtomOnly<ManagedAtom>> | TimelineStateDisposal<AtomOnly<ManagedAtom>> | TimelineTransactionUpdate;
+
+/**
+ * @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;
+};
+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 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 UpdateHandler<T> = (update: StateUpdate<T>) => void;
+type TransactionUpdateHandler<F extends Func> = (data: TransactionUpdate<F>) => void;
+
+type TokenType<Comparison extends ReadableFamilyToken<any, any> | ReadableToken<any>> = Comparison extends ReadableToken<infer RepresentedValue> ? RepresentedValue : Comparison extends ReadableFamilyToken<infer RepresentedValue, any> ? RepresentedValue : never;
+
+/**
+ * @public
+ * A token is an object that uniquely identifies a particular state, family, timeline, or transaction.
+ *
+ * While they represent one of these resources, they are not the resource itself. Think of them like paper currency representing money in the bank.
+ *
+ * Tokens are returned from resource creation functions, such as {@link atom} and {@link transaction}.
+ *
+ * Tokens can be used as parameters to functions that take a token, such as {@link getState}, {@link setState}, or {@link runTransaction}.
+ *
+ * Tokens are fully serializable, so they can be passed between processes.
+ */
+type AtomIOToken = ReadableFamilyToken<any, any> | ReadableToken<any> | TimelineToken<any> | TransactionToken<any>;
+/** @public */
+type RegularAtomToken<T, K extends Canonical = any> = {
+    /** The unique identifier of the atom. */
+    key: string;
+    /** Discriminator. */
+    type: `atom`;
+    /** Present if the atom belongs to a family. */
+    family?: FamilyMetadata<K>;
+    /** Never present. This is a marker that preserves the type of the atom's value. */
+    __T?: T;
+};
+/** @public */
+type MutableAtomToken<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical = any> = {
+    /** The unique identifier of the atom. */
+    key: string;
+    /** Discriminator. */
+    type: `mutable_atom`;
+    /** Present if the atom belongs to a family. */
+    family?: FamilyMetadata<K>;
+    /** Never present. This is a marker that preserves the JSON form of the atom's transceiver value. */
+    __J?: J;
+    /** Never present. This is a marker that preserves the type of the atom's transceiver value. */
+    __U?: T extends Transceiver<infer Update> ? Update : never;
+};
+/** @public */
+type AtomToken<T, K extends Canonical = any> = MutableAtomToken<T extends Transceiver<any> ? T : never, any, K> | RegularAtomToken<T, K>;
+/** @public */
+type WritableSelectorToken<T, K extends Canonical = any> = {
+    /** The unique identifier of the selector. */
+    key: string;
+    /** Discriminator. */
+    type: `selector`;
+    /** Present if the selector belongs to a family. */
+    family?: FamilyMetadata<K>;
+    /** Never present. This is a marker that preserves the type of the selector's value. */
+    __T?: T;
+};
+/** @public */
+type ReadonlySelectorToken<T, K extends Canonical = any> = {
+    /** The unique identifier of the selector. */
+    key: string;
+    /** Discriminator. */
+    type: `readonly_selector`;
+    /** Present if the selector belongs to a family. */
+    family?: FamilyMetadata<K>;
+    /** Never present. This is a marker that preserves the type of the selector's value. */
+    __T?: T;
+};
+/** @public */
+type SelectorToken<T, K extends Canonical = any> = ReadonlySelectorToken<T, K> | WritableSelectorToken<T, K>;
+/**
+ * @public
+ * These states can be set.
+ */
+type WritableToken<T, K extends Canonical = any> = AtomToken<T, K> | WritableSelectorToken<T, K>;
+/**
+ * @public
+ * These states cannot be set.
+ */
+type ReadableToken<T, K extends Canonical = any> = AtomToken<T, K> | SelectorToken<T, K>;
+/**
+ * @public
+ * States belonging to this family can be set.
+ */
+type WritableFamilyToken<T, K extends Canonical> = AtomFamilyToken<T, K> | WritableSelectorFamilyToken<T, K>;
+/**
+ * @public
+ * States belonging to this family cannot be set.
+ */
+type ReadableFamilyToken<T, K extends Canonical> = AtomFamilyToken<T, K> | SelectorFamilyToken<T, K>;
+/**
+ * @public
+ * Identifies a state's connection to its family.
+ */
+type FamilyMetadata<K extends Canonical = any> = {
+    /** The family's unique key. */
+    key: string;
+    /** The family member's unique identifier, in the form of a string. */
+    subKey: stringified<K>;
+};
 
 declare class CircularBuffer<T> {
     protected _buffer: T[];
@@ -142,11 +790,11 @@ declare class Junction<const ASide extends string, const AType extends string, c
 
 declare const abortTransaction: (store: Store) => void;
 
-declare function actUponStore<F extends Func>(token: TransactionToken<F>, id: string, store: Store): (...parameters: Parameters<F>) => ReturnType<F>;
+declare function actUponStore<F extends Func>(store: Store, token: TransactionToken<F>, id: string): (...parameters: Parameters<F>) => ReturnType<F>;
 
 declare const applyTransaction: <F extends Func>(output: ReturnType<F>, store: Store) => void;
 
-declare function assignTransactionToContinuity(continuityKey: string, transactionKey: string, store: Store): void;
+declare function assignTransactionToContinuity(store: Store, continuityKey: string, transactionKey: string): void;
 
 interface RootStore extends Store {
     transactionMeta: TransactionEpoch;
@@ -161,7 +809,7 @@ interface ChildStore extends Store {
 declare function isRootStore(store: Store): store is RootStore;
 declare function isChildStore(store: Store): store is ChildStore;
 
-declare const buildTransaction: (key: string, params: any[], store: Store, id: string) => ChildStore;
+declare const buildTransaction: (store: Store, key: string, params: any[], id: string) => ChildStore;
 
 declare class Subject<T> {
     Subscriber: (value: T) => void;
@@ -183,14 +831,14 @@ type Transaction<F extends Func> = {
     subject: Subject<TransactionUpdate<F>>;
     run: (parameters: Parameters<F>, id?: string) => ReturnType<F>;
 };
-declare function createTransaction<F extends Func>(options: TransactionOptions<F>, store: Store): TransactionToken<F>;
+declare function createTransaction<F extends Func>(store: Store, options: TransactionOptions<F>): TransactionToken<F>;
 
-declare function getContinuityKey(transactionKey: string, store: Store): string | undefined;
-declare function getEpochNumberOfContinuity(continuityKey: string, store: Store): number | undefined;
-declare function getEpochNumberOfAction(transactionKey: string, store: Store): number | undefined;
+declare function getContinuityKey(store: Store, transactionKey: string): string | undefined;
+declare function getEpochNumberOfContinuity(store: Store, continuityKey: string): number | undefined;
+declare function getEpochNumberOfAction(store: Store, transactionKey: string): number | undefined;
 
-declare function setEpochNumberOfContinuity(continuityKey: string, newEpoch: number, store: Store): void;
-declare function setEpochNumberOfAction(transactionKey: string, newEpoch: number, store: Store): void;
+declare function setEpochNumberOfContinuity(store: Store, continuityKey: string, newEpoch: number): void;
+declare function setEpochNumberOfAction(store: Store, transactionKey: string, newEpoch: number): void;
 
 declare const TRANSACTION_PHASES: readonly ["idle", "building", "applying"];
 type TransactionPhase = (typeof TRANSACTION_PHASES)[number];
@@ -221,20 +869,93 @@ declare function deposit<T>(state: SelectorFamily<T, any>): SelectorFamilyToken<
 declare function deposit<T>(state: WritableFamily<T, any>): WritableFamilyToken<T, any>;
 declare function deposit<T>(state: ReadableFamily<T, any>): ReadableFamilyToken<T, any>;
 declare function deposit<T extends Func>(state: Transaction<T>): TransactionToken<T>;
-declare function deposit(state: ReadableState<any>): ReadableToken<any>;
-declare function deposit(state: ReadableFamily<any, any> | ReadableState<any> | Transaction<Func>): ReadableFamilyToken<any, any> | ReadableToken<any> | TransactionToken<Func>;
+declare function deposit<M extends TimelineManageable>(state: Timeline<M>): TimelineToken<M>;
+declare function deposit(resource: AtomIOInternalResource): AtomIOToken;
 
-interface Lineage {
-    parent: typeof this | null;
-    child: typeof this | null;
-}
-declare function newest<T extends Lineage>(scion: T): T;
+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 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 getInternalRelationsFromStore(token: JoinToken<any, any, any, any, any, any>, store: Store): MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string>;
 
 type Molecule<K extends Canonical> = {
     readonly key: K;
     readonly stringKey: stringified<K>;
     readonly dependsOn: `all` | `any`;
 };
+declare function makeRootMoleculeInStore<S extends string>(key: S, store?: Store): S;
+declare function allocateIntoStore<H extends Hierarchy, V extends Vassal<H>, A extends Above<V, H>>(store: Store, provenance: A, key: V, dependsOn?: `all` | `any`): Claim<V>;
+declare function fuseWithinStore<H extends Hierarchy, C extends CompoundFrom<H>, T extends C extends CompoundTypedKey<infer t, any, any> ? t : never, A extends C extends CompoundTypedKey<any, infer a, any> ? a : never, B extends C extends CompoundTypedKey<any, any, infer b> ? b : never>(store: Store, type: T, sideA: SingularTypedKey<A>, sideB: SingularTypedKey<B>): Claim<CompoundTypedKey<T, A, B>>;
+declare function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(store: Store, claim: Claim<V>): void;
+declare function claimWithinStore<H extends Hierarchy, V extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V, H>>(store: Store, newProvenance: A, claim: Claim<V>, exclusive?: `exclusive`): Claim<V>;
+
+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);
+}
+
+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>;
+
+interface Lineage {
+    parent: typeof this | null;
+    child: typeof this | null;
+}
+declare function newest<T extends Lineage>(scion: T): T;
 
 type OperationProgress = {
     open: false;
@@ -292,7 +1013,7 @@ type Timeline<ManagedAtom extends TimelineManageable> = {
     subject: Subject<TimelineUpdate<ManagedAtom> | `redo` | `undo`>;
     subscriptions: Map<string, () => void>;
 };
-declare function createTimeline<ManagedAtom extends TimelineManageable>(options: TimelineOptions<ManagedAtom>, store: Store, data?: Timeline<ManagedAtom>): TimelineToken<ManagedAtom>;
+declare function createTimeline<ManagedAtom extends TimelineManageable>(store: Store, options: TimelineOptions<ManagedAtom>, data?: Timeline<ManagedAtom>): TimelineToken<ManagedAtom>;
 
 declare const timeTravel: (store: Store, action: `redo` | `undo`, token: TimelineToken<any>) => void;
 
@@ -310,7 +1031,7 @@ declare class Store implements Lineage {
         source: string;
     }>;
     trackers: Map<string, Tracker<Transceiver<any>>>;
-    families: Map<string, MutableAtomFamily<any, any, any> | ReadonlySelectorFamily<any, any> | RegularAtomFamily<any, any> | WritableSelectorFamily<any, any>>;
+    families: Map<string, MutableAtomFamily<any, any, any> | RegularAtomFamily<any, any> | ReadonlySelectorFamily<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>;
@@ -355,26 +1076,27 @@ declare const IMPLICIT: {
 };
 declare const clearStore: (store: Store) => void;
 
-type Withdrawable = Atom<any> | AtomFamily<any, any> | Molecule<any> | MutableAtom<any, any> | MutableAtomFamily<any, any, any> | ReadableFamily<any, any> | ReadableState<any> | ReadonlySelector<any> | ReadonlySelectorFamily<any, any> | RegularAtom<any> | RegularAtomFamily<any, any> | Selector<any> | SelectorFamily<any, any> | Timeline<any> | Transaction<any> | WritableFamily<any, any> | WritableSelector<any> | WritableSelectorFamily<any, any> | WritableState<any>;
-declare function withdraw<T>(token: RegularAtomToken<T>, store: Store): RegularAtom<T>;
-declare function withdraw<T extends Transceiver<any>>(token: MutableAtomToken<T, any>, store: Store): MutableAtom<T, any>;
-declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T>;
-declare function withdraw<T>(token: WritableSelectorToken<T>, store: Store): WritableSelector<T>;
-declare function withdraw<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T>;
-declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T>;
-declare function withdraw<T>(token: WritableToken<T>, store: Store): WritableState<T>;
-declare function withdraw<T>(token: ReadableToken<T>, store: Store): ReadableState<T>;
-declare function withdraw<T, K extends Canonical>(token: RegularAtomFamilyToken<T, K>, store: Store): RegularAtomFamily<T, K>;
-declare function withdraw<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(token: MutableAtomFamilyToken<T, J, K>, store: Store): MutableAtomFamily<T, J, K>;
-declare function withdraw<T, K extends Canonical>(token: AtomFamilyToken<T>, store: Store): AtomFamily<T, any>;
-declare function withdraw<T, K extends Canonical>(token: ReadonlySelectorFamilyToken<T, K>, store: Store): ReadonlySelectorFamily<T, any>;
-declare function withdraw<T, K extends Canonical>(token: WritableSelectorFamilyToken<T, K>, store: Store): WritableSelectorFamily<T, any>;
-declare function withdraw<T, K extends Canonical>(token: SelectorFamilyToken<T, K>, store: Store): SelectorFamily<T, any>;
-declare function withdraw<T, K extends Canonical>(token: ReadableFamilyToken<T, K>, store: Store): ReadableFamily<T, any>;
-declare function withdraw<T, K extends Canonical>(token: WritableFamilyToken<T, K>, store: Store): WritableFamily<T, any>;
-declare function withdraw<T extends Func>(token: TransactionToken<T>, store: Store): Transaction<T extends Func ? T : never>;
-declare function withdraw<T>(token: TimelineToken<T>, store: Store): Timeline<T extends TimelineManageable ? T : never>;
-declare function withdraw<T>(token: ReadableToken<T>, store: Store): ReadableState<T>;
+declare function withdraw<T>(store: Store, token: RegularAtomToken<T>): RegularAtom<T>;
+declare function withdraw<T extends Transceiver<any>>(store: Store, token: MutableAtomToken<T, any>): MutableAtom<T, any>;
+declare function withdraw<T>(store: Store, token: AtomToken<T>): Atom<T>;
+declare function withdraw<T>(store: Store, token: WritableSelectorToken<T>): WritableSelector<T>;
+declare function withdraw<T>(store: Store, token: ReadonlySelectorToken<T>): ReadonlySelector<T>;
+declare function withdraw<T>(store: Store, token: SelectorToken<T>): Selector<T>;
+declare function withdraw<T>(store: Store, token: WritableToken<T>): WritableState<T>;
+declare function withdraw<T>(store: Store, token: ReadableToken<T>): ReadableState<T>;
+declare function withdraw<T, K extends Canonical>(store: Store, token: RegularAtomFamilyToken<T, K>): RegularAtomFamily<T, K>;
+declare function withdraw<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(store: Store, token: MutableAtomFamilyToken<T, J, K>): MutableAtomFamily<T, J, K>;
+declare function withdraw<T, K extends Canonical>(store: Store, token: AtomFamilyToken<T>): AtomFamily<T, any>;
+declare function withdraw<T, K extends Canonical>(store: Store, token: ReadonlySelectorFamilyToken<T, K>): ReadonlySelectorFamily<T, any>;
+declare function withdraw<T, K extends Canonical>(store: Store, token: WritableSelectorFamilyToken<T, K>): WritableSelectorFamily<T, any>;
+declare function withdraw<T, K extends Canonical>(store: Store, token: SelectorFamilyToken<T, K>): SelectorFamily<T, any>;
+declare function withdraw<T, K extends Canonical>(store: Store, token: ReadableFamilyToken<T, K>): ReadableFamily<T, any>;
+declare function withdraw<T, K extends Canonical>(store: Store, token: WritableFamilyToken<T, K>): WritableFamily<T, any>;
+declare function withdraw<T extends Func>(store: Store, token: TransactionToken<T>): Transaction<T extends Func ? T : never>;
+declare function withdraw<T>(store: Store, token: TimelineToken<T>): Timeline<T extends TimelineManageable ? T : never>;
+declare function withdraw<T>(store: Store, token: WritableToken<T>): WritableState<T>;
+declare function withdraw<T>(store: Store, token: ReadableToken<T>): ReadableState<T>;
+declare function withdraw(store: Store, token: AtomIOToken): AtomIOInternalResource;
 
 interface Transceiver<S extends Json.Serializable> {
     do: (update: S) => number | `OUT_OF_RANGE` | null;
@@ -413,11 +1135,12 @@ declare class Tracker<Mutable extends Transceiver<any>> {
     private updateCore;
     mutableState: MutableAtomToken<Mutable, Json.Serializable>;
     latestUpdateState: RegularAtomToken<typeof this.Update | null>;
-    dispose: () => void;
+    [Symbol.dispose]: () => void;
     constructor(mutableState: MutableAtomToken<Mutable, Json.Serializable>, store: Store);
 }
 
 declare class FamilyTracker<Core extends Transceiver<any>, FamilyMemberKey extends Canonical> {
+    private trackers;
     private readonly Update;
     readonly latestUpdateAtoms: RegularAtomFamily<typeof this.Update | null, FamilyMemberKey>;
     readonly mutableAtoms: MutableAtomFamily<Core, any, FamilyMemberKey>;
@@ -431,11 +1154,11 @@ declare function createRegularAtom<T>(store: Store, options: RegularAtomOptions<
 declare function createStandaloneAtom<T>(store: Store, options: RegularAtomOptions<T>): RegularAtomToken<T>;
 declare function createStandaloneAtom<T extends Transceiver<any>, J extends Json.Serializable>(store: Store, options: MutableAtomOptions<T, J>): MutableAtomToken<T, J>;
 
-declare function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void;
+declare function disposeAtom(store: Store, atomToken: AtomToken<unknown>): void;
 
-declare const isAtomDefault: (key: string, store: Store) => boolean;
-declare const markAtomAsDefault: (key: string, store: Store) => void;
-declare const markAtomAsNotDefault: (key: string, store: Store) => void;
+declare const isAtomDefault: (store: Store, key: string) => boolean;
+declare const markAtomAsDefault: (store: Store, key: string) => void;
+declare const markAtomAsNotDefault: (store: Store, key: string) => void;
 
 /**
  * A Promise whose incoming value can be hot swapped.
@@ -457,11 +1180,13 @@ declare class Future<T> extends Promise<T> {
     use(value: Promise<T> | T): void;
 }
 
-declare function cacheValue<T>(key: string, value: T, subject: Subject<StateUpdate<unknown>>, store: Store): T;
-declare function cacheValue<T extends Promise<any>>(key: string, value: T, subject: Subject<StateUpdate<unknown>>, store: Store): Future<T>;
+declare function cacheValue<T>(store: Store, key: string, value: T, subject: Subject<StateUpdate<unknown>>): T;
+declare function cacheValue<T extends Promise<any>>(store: Store, key: string, value: T, subject: Subject<StateUpdate<unknown>>): Future<T>;
 declare const readCachedValue: <T>(token: ReadableState<any>, target: Store) => T;
 declare const evictCachedValue: (key: string, target: Store) => void;
 
+declare function capitalize<S extends string>(string: S): Capitalize<S>;
+
 declare function createAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(store: Store, options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamilyToken<T, J, K>;
 declare function createAtomFamily<T, K extends Canonical>(store: Store, options: RegularAtomFamilyOptions<T, K>): RegularAtomFamilyToken<T, K>;
 
@@ -510,7 +1235,7 @@ declare function getEnvironmentData(store: Store): EnvironmentData;
 declare function getFromStore<T>(store: Store, token: ReadableToken<T>): T;
 declare function getFromStore<T, K extends Canonical>(store: Store, token: ReadableFamilyToken<T, K>, key: K): T;
 
-declare const readOrComputeValue: <T>(state: ReadableState<T>, target: Store) => T;
+declare const readOrComputeValue: <T>(target: Store, state: ReadableState<T>) => T;
 
 declare function getTrace(error: Error): string;
 
@@ -538,11 +1263,11 @@ type ReadonlySelectorKey<T> = string & {
     __readonlySelectorKey?: never;
     __brand?: T;
 };
-declare const isAtomKey: (key: string, store: Store) => key is AtomKey<unknown>;
-declare const isSelectorKey: (key: string, store: Store) => key is SelectorKey<unknown>;
-declare const isReadonlySelectorKey: (key: string, store: Store) => key is ReadonlySelectorKey<unknown>;
+declare const isAtomKey: (store: Store, key: string) => key is AtomKey<unknown>;
+declare const isSelectorKey: (store: Store, key: string) => key is SelectorKey<unknown>;
+declare const isReadonlySelectorKey: (store: Store, key: string) => key is ReadonlySelectorKey<unknown>;
 type StateKey<T> = AtomKey<T> | ReadonlySelectorKey<T> | SelectorKey<T>;
-declare const isStateKey: (key: string, store: Store) => key is StateKey<unknown>;
+declare const isStateKey: (store: Store, key: string) => key is StateKey<unknown>;
 
 declare class LazyMap<K, V> extends Map<K, V> {
     protected readonly source: Map<K, V>;
@@ -555,14 +1280,12 @@ declare class LazyMap<K, V> extends Map<K, V> {
     delete(key: K): boolean;
 }
 
-type AtomIOToken = ReadableFamilyToken<any, any> | ReadableToken<any> | TimelineToken<any> | TransactionToken<any>;
-declare function prettyPrintTokenType(token: AtomIOToken): string;
-
 declare class NotFoundError extends Error {
     constructor(token: AtomIOToken, store: Store);
-    constructor(familyToken: AtomIOToken, key: Json.Serializable, store: Store);
 }
 
+declare function prettyPrintTokenType(token: AtomIOToken): string;
+
 declare const createReadonlySelector: <T>(store: Store, options: ReadonlySelectorOptions<T>, family: FamilyMetadata | undefined) => ReadonlySelectorToken<T>;
 
 declare function createStandaloneSelector<T>(store: Store, options: WritableSelectorOptions<T>): WritableSelectorToken<T>;
@@ -570,7 +1293,7 @@ declare function createStandaloneSelector<T>(store: Store, options: ReadonlySele
 
 declare const createWritableSelector: <T>(store: Store, options: WritableSelectorOptions<T>, family: FamilyMetadata | undefined) => WritableSelectorToken<T>;
 
-declare function disposeSelector(selectorToken: ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>, store: Store): void;
+declare function disposeSelector(store: Store, selectorToken: SelectorToken<unknown>): void;
 
 declare const getSelectorDependencyKeys: (key: string, store: Store) => (AtomKey<unknown> | ReadonlySelectorKey<unknown> | SelectorKey<unknown>)[];
 
@@ -584,25 +1307,25 @@ declare const updateSelectorAtoms: (selectorKey: string, dependency: ReadonlySel
 type Modify<T> = (thing: T) => T;
 declare const become: <T>(nextVersionOfThing: Modify<T> | T) => (originalThing: T) => T;
 
-declare const setAtomOrSelector: <T>(state: WritableState<T>, value: T | ((oldValue: T) => T), store: Store) => void;
+declare const setAtomOrSelector: <T>(store: Store, state: WritableState<T>, value: T | ((oldValue: T) => T)) => void;
 
 declare function setIntoStore<T, New extends T>(store: Store, token: WritableToken<T>, value: New | ((oldValue: T) => New)): void;
 declare function setIntoStore<T, K extends Canonical, New extends T>(store: Store, token: WritableFamilyToken<T, K>, key: K, value: New | ((oldValue: T) => New)): void;
 
-declare const recallState: <T>(state: ReadableState<T>, store: Store) => T;
+declare const recallState: <T>(store: Store, state: ReadableState<T>) => T;
 
-declare function subscribeInStore<T>(store: Store$1, token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key?: string): () => void;
-declare function subscribeInStore<F extends Func$1>(store: Store$1, token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key?: string): () => void;
-declare function subscribeInStore<M extends TimelineManageable>(store: Store$1, token: TimelineToken<M>, handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void, key?: string): () => void;
-declare function subscribeInStore<M extends TimelineManageable>(store: Store$1, token: ReadableToken<any> | TimelineToken<M> | TransactionToken<any>, handleUpdate: TransactionUpdateHandler<any> | UpdateHandler<any> | ((update: TimelineUpdate<M> | `redo` | `undo`) => void), key?: string): () => void;
+declare function subscribeInStore<T>(store: Store, token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key?: string): () => void;
+declare function subscribeInStore<F extends Func>(store: Store, token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key?: string): () => void;
+declare function subscribeInStore<M extends TimelineManageable>(store: Store, token: TimelineToken<M>, handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void, key?: string): () => void;
+declare function subscribeInStore<M extends TimelineManageable>(store: Store, token: ReadableToken<any> | TimelineToken<M> | TransactionToken<any>, handleUpdate: TransactionUpdateHandler<any> | UpdateHandler<any> | ((update: TimelineUpdate<M> | `redo` | `undo`) => void), key?: string): () => void;
 
-declare const subscribeToRootAtoms: <T>(selector: Selector<T>, store: Store) => (() => void)[];
+declare const subscribeToRootAtoms: <T>(store: Store, selector: Selector<T>) => (() => void)[];
 
-declare function subscribeToState<T>(token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key: string, store: Store): () => void;
+declare function subscribeToState<T>(store: Store, token: ReadableToken<T>, key: string, handleUpdate: UpdateHandler<T>): () => void;
 
-declare const subscribeToTimeline: <ManagedAtom extends TimelineManageable>(token: TimelineToken<ManagedAtom>, handleUpdate: (update: TimelineUpdate<any> | `redo` | `undo`) => void, key: string, store: Store) => (() => void);
+declare const subscribeToTimeline: <ManagedAtom extends TimelineManageable>(store: Store, token: TimelineToken<ManagedAtom>, key: string, handleUpdate: (update: TimelineUpdate<any> | `redo` | `undo`) => void) => (() => void);
 
-declare const subscribeToTransaction: <F extends Func>(token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key: string, store: Store) => (() => void);
+declare const subscribeToTransaction: <F extends Func>(store: Store, token: TransactionToken<F>, key: string, handleUpdate: TransactionUpdateHandler<F>) => (() => void);
 
 type AtomIOState = {
     key: string;
@@ -664,5 +1387,6 @@ type ReadonlySelectorFamily<T, K extends Canonical> = ReadonlySelectorFamilyToke
 type SelectorFamily<T, K extends Canonical> = ReadonlySelectorFamily<T, K> | WritableSelectorFamily<T, K>;
 type WritableFamily<T, K extends Canonical> = AtomFamily<T, K> | WritableSelectorFamily<T, K>;
 type ReadableFamily<T, K extends Canonical> = AtomFamily<T, K> | SelectorFamily<T, K>;
+type AtomIOInternalResource = ReadableFamily<any, any> | ReadableState<any> | Timeline<any> | Transaction<any>;
 
-export { type Atom, type AtomFamily, type AtomIOState, type AtomIOToken, type AtomKey, type BaseExternalStoreConfiguration, type ChildStore, CircularBuffer, type Count, type Each, type Empty, type EnvironmentData, type ExternalStoreConfiguration, type ExternalStoreWithContentConfiguration, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, type Flat, type Func, Future, IMPLICIT, Junction, type JunctionAdvancedConfiguration, type JunctionEntries, type JunctionEntriesBase, type JunctionJSON, type JunctionSchema, type JunctionSchemaBase, LazyMap, type Lineage, type Modify, type Molecule, type MutableAtom, type MutableAtomFamily, NotFoundError, type OperationProgress, type ReadableFamily, type ReadableState, type ReadonlySelector, type ReadonlySelectorFamily, type ReadonlySelectorKey, type Refinement, type RegularAtom, type RegularAtomFamily, type RootStore, type Selector, type SelectorFamily, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineMoleculeCreation, type TimelineMoleculeDisposal, type TimelineSelectorUpdate, type TimelineStateCreation, type TimelineStateDisposal, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableFamily, type WritableSelector, type WritableSelectorFamily, type WritableState, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeSelector, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+export { type Atom, type AtomFamily, type AtomIOInternalResource, type AtomIOState, type AtomKey, type BaseExternalStoreConfiguration, type ChildStore, CircularBuffer, type Count, type Each, type Empty, type EnvironmentData, type ExternalStoreConfiguration, type ExternalStoreWithContentConfiguration, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, type Flat, type Func, Future, IMPLICIT, Join, type JoinStateFamilies, Junction, type JunctionAdvancedConfiguration, type JunctionEntries, type JunctionEntriesBase, type JunctionJSON, type JunctionSchema, type JunctionSchemaBase, LazyMap, type Lineage, type Modify, type Molecule, type MutableAtom, type MutableAtomFamily, NotFoundError, type OperationProgress, type ReadableFamily, type ReadableState, type ReadonlySelector, type ReadonlySelectorFamily, type ReadonlySelectorKey, type Refinement, type RegularAtom, type RegularAtomFamily, type RootStore, type Selector, type SelectorFamily, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineMoleculeCreation, type TimelineMoleculeDisposal, type TimelineSelectorUpdate, type TimelineStateCreation, type TimelineStateDisposal, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type WritableFamily, type WritableSelector, type WritableSelectorFamily, type WritableState, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, capitalize, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, evictCachedValue, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };