atom.io 0.27.4 → 0.28.0

package/internal/dist/index.d.ts

@@ -1,23 +1,43 @@
 import * as atom_io from 'atom.io';
-import { TransactionToken, TransactionUpdate, TransactionOptions, ActorToolkit, RegularAtomToken, MutableAtomToken, AtomToken, WritableSelectorToken, ReadonlySelectorToken, SelectorToken, WritableToken, MoleculeConstructor, MoleculeFamily, MoleculeFamilyToken, MoleculeToken, ReadableToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, StateCreation, StateDisposal, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, TimelineToken, AtomIOLogger, Logger, RegularAtomFamilyToken, MutableAtomFamilyToken, AtomFamilyToken, ReadonlySelectorFamilyToken, WritableSelectorFamilyToken, SelectorFamilyToken, ReadableFamilyToken, WritableFamilyToken, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, MoleculeKey, KeyedStateUpdate, MoleculeFamilyOptions, MoleculeParams, ReadonlySelectorOptions, WritableSelectorOptions, SetterToolkit, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
-import { Canonical, Json, JsonInterface } from 'atom.io/json';
+import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, AtomFamilyToken, AtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, SelectorFamilyToken, SelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, ReadableToken, MoleculeConstructor, MoleculeFamilyToken, MoleculeKey, TransactionToken, TransactionUpdate, TransactionOptions, ActorToolkit, MoleculeFamily, MoleculeToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, StateCreation, StateDisposal, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, TimelineToken, AtomIOLogger, Logger, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, KeyedStateUpdate, MoleculeFamilyOptions, MoleculeParams, ReadonlySelectorOptions, WritableSelectorOptions, SetterToolkit, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
+import { Json as Json$1, Canonical, JsonInterface } from 'atom.io/json';
 import { Join } from 'atom.io/data';
+import { Store as Store$1, Func as Func$1 } from 'atom.io/internal';
+
+declare const FAMILY_MEMBER_TOKEN_TYPES: {
+    readonly atom_family: "atom";
+    readonly mutable_atom_family: "mutable_atom";
+    readonly selector_family: "selector";
+    readonly readonly_selector_family: "readonly_selector";
+    readonly molecule_family: "molecule";
+};
+declare function counterfeit<T extends Transceiver<any>, J extends Json$1.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>;
+declare function counterfeit<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T>;
+declare function counterfeit<T, K extends Canonical, Key extends K>(token: AtomFamilyToken<T, K>, key: Key): AtomToken<T>;
+declare function counterfeit<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T>;
+declare function counterfeit<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T>;
+declare function counterfeit<T, K extends Canonical, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key): SelectorToken<T>;
+declare function counterfeit<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T>;
+declare function counterfeit<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T>;
+declare function counterfeit<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>): MoleculeKey<M>;
 
 type primitive = boolean | number | string | null;
-
-type Serializable = primitive | Readonly<{
-    [key: string]: Serializable;
-}> | ReadonlyArray<Serializable>;
-type Object$1<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
+declare namespace Json {
+    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 Refinement<Unrefined, Refined extends Unrefined> = (value: Unrefined) => value is Refined;
 type Cardinality = `1:1` | `1:n` | `n:n`;
 
-interface JunctionEntries<Content extends Object$1 | null> extends Object$1 {
+interface JunctionEntries<Content extends Json.Object | null> extends Json.Object {
     readonly relations: [string, string[]][];
     readonly contents: [string, Content][];
 }
-interface JunctionSchema<ASide extends string, BSide extends string> extends Object$1 {
+interface JunctionSchema<ASide extends string, BSide extends string> extends Json.Object {
     readonly between: [a: ASide, b: BSide];
     readonly cardinality: Cardinality;
 }
@@ -29,7 +49,7 @@ type BaseExternalStoreConfiguration = {
     getRelatedKeys: (key: string) => Set<string> | undefined;
     has: (a: string, b?: string) => boolean;
 };
-type ExternalStoreWithContentConfiguration<Content extends Object$1> = {
+type ExternalStoreWithContentConfiguration<Content extends Json.Object> = {
     getContent: (contentKey: string) => Content | undefined;
     setContent: (contentKey: string, content: Content) => void;
     deleteContent: (contentKey: string) => void;
@@ -37,14 +57,14 @@ type ExternalStoreWithContentConfiguration<Content extends Object$1> = {
 type Empty<Obj extends object> = {
     [Key in keyof Obj]?: undefined;
 };
-type ExternalStoreConfiguration<Content extends Object$1 | null> = Content extends Object$1 ? BaseExternalStoreConfiguration & ExternalStoreWithContentConfiguration<Content> : BaseExternalStoreConfiguration & Empty<ExternalStoreWithContentConfiguration<Object$1>>;
-type JunctionAdvancedConfiguration<Content extends Object$1 | null> = {
+type ExternalStoreConfiguration<Content extends Json.Object | null> = Content extends Json.Object ? BaseExternalStoreConfiguration & ExternalStoreWithContentConfiguration<Content> : BaseExternalStoreConfiguration & Empty<ExternalStoreWithContentConfiguration<Json.Object>>;
+type JunctionAdvancedConfiguration<Content extends Json.Object | null> = {
     externalStore?: ExternalStoreConfiguration<Content>;
     isContent?: Refinement<unknown, Content>;
     makeContentKey?: (a: string, b: string) => string;
 };
-type JunctionJSON<ASide extends string, BSide extends string, Content extends Object$1 | null> = JunctionEntries<Content> & JunctionSchema<ASide, BSide>;
-declare class Junction<const ASide extends string, const BSide extends string, const Content extends Object$1 | null = null> {
+type JunctionJSON<ASide extends string, BSide extends string, Content extends Json.Object | null> = JunctionEntries<Content> & JunctionSchema<ASide, BSide>;
+declare class Junction<const ASide extends string, const BSide extends string, const Content extends Json.Object | null = null> {
     readonly a: ASide;
     readonly b: BSide;
     readonly cardinality: Cardinality;
@@ -156,11 +176,20 @@ declare function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T
 declare function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>;
 declare function deposit<T>(state: Selector<T>): SelectorToken<T>;
 declare function deposit<T>(state: WritableState<T>): WritableToken<T>;
+declare function deposit<T>(state: ReadableState<T>): ReadableToken<T>;
+declare function deposit<T, K extends Canonical>(state: RegularAtomFamily<T, K>): RegularAtomFamilyToken<T, K>;
+declare function deposit<T extends Transceiver<any>, J extends Json$1.Serializable, K extends Canonical>(state: MutableAtomFamily<T, J, K>): MutableAtomFamilyToken<T, J, K>;
+declare function deposit<T>(state: AtomFamily<T, any>): AtomFamilyToken<T, any>;
+declare function deposit<T>(state: WritableSelectorFamily<T, any>): WritableSelectorFamilyToken<T, any>;
+declare function deposit<T>(state: ReadonlySelectorFamily<T, any>): ReadonlySelectorFamilyToken<T, any>;
+declare function deposit<T>(state: SelectorFamily<T, any>): SelectorFamilyToken<T, any>;
+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<M extends MoleculeConstructor>(state: MoleculeFamily<M>): MoleculeFamilyToken<M>;
 declare function deposit<M extends MoleculeConstructor>(state: Molecule<M>): MoleculeToken<M>;
 declare function deposit<T extends Func>(state: Transaction<T>): TransactionToken<T>;
-declare function deposit<T>(state: ReadableState<T>): ReadableToken<T>;
 declare function deposit(state: Molecule<any> | ReadableState<any>): MoleculeToken<any> | ReadableToken<any>;
+declare function deposit(state: Molecule<any> | MoleculeFamily<any> | ReadableFamily<any, any> | ReadableState<any> | Transaction<Func>): MoleculeFamilyToken<any> | MoleculeToken<any> | ReadableFamilyToken<any, any> | ReadableToken<any> | TransactionToken<Func>;
 
 interface Lineage {
     parent: typeof this | null;
@@ -227,7 +256,18 @@ type Timeline<ManagedAtom extends TimelineManageable> = {
 };
 declare function createTimeline<ManagedAtom extends TimelineManageable>(options: TimelineOptions<ManagedAtom>, store: Store, data?: Timeline<ManagedAtom>): TimelineToken<ManagedAtom>;
 
-declare const timeTravel: (action: `redo` | `undo`, token: TimelineToken<any>, store: Store) => void;
+declare const timeTravel: (store: Store, action: `redo` | `undo`, token: TimelineToken<any>) => void;
+
+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>;
+}
 
 declare class Store implements Lineage {
     parent: Store | null;
@@ -250,6 +290,10 @@ declare class Store implements Lineage {
     timelineTopics: Junction<"timelineKey", "topicKey", {
         topicType: `atom_family` | `atom` | `molecule_family` | `molecule`;
     }>;
+    disposalTraces: CircularBuffer<{
+        key: string;
+        trace: string;
+    }>;
     molecules: Map<string, Molecule<any>>;
     moleculeFamilies: Map<string, Flat<atom_io.MoleculeFamilyToken<any> & {
         subject: Subject<atom_io.MoleculeCreation<any> | atom_io.MoleculeDisposal>;
@@ -295,7 +339,7 @@ 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 extends Transceiver<any>, J extends Json$1.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>;
@@ -306,29 +350,30 @@ declare function withdraw<M extends MoleculeConstructor>(token: MoleculeToken<M>
 declare function withdraw<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, store: Store): MoleculeFamily<M>;
 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, M extends MoleculeConstructor>(token: MoleculeToken<M> | ReadableToken<T>, store: Store): Molecule<M> | ReadableState<T>;
 
-interface Transceiver<Signal extends Json.Serializable> {
+interface Transceiver<Signal extends Json$1.Serializable> {
     do: (update: Signal) => number | `OUT_OF_RANGE` | null;
     undo: (update: Signal) => void;
     subscribe: (key: string, fn: (update: Signal) => void) => () => void;
     cacheUpdateNumber: number;
     getUpdateNumber: (update: Signal) => number;
 }
-declare function isTransceiver(value: unknown): value is Transceiver<Json.Serializable>;
+declare function isTransceiver(value: unknown): value is Transceiver<Json$1.Serializable>;
 type TransceiverMode = `playback` | `record` | `transaction`;
 type Signal<TVR extends Transceiver<any>> = TVR extends Transceiver<infer S> ? S : never;
 
-declare function createMutableAtom<T extends Transceiver<any>, J extends Json.Serializable>(options: MutableAtomOptions<T, J>, family: FamilyMetadata | undefined, store: Store): MutableAtomToken<T, J>;
+declare function createMutableAtom<T extends Transceiver<any>, J extends Json$1.Serializable>(store: Store, options: MutableAtomOptions<T, J>, family: FamilyMetadata | undefined): MutableAtomToken<T, J>;
 
-declare function createMutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends string>(options: MutableAtomFamilyOptions<T, J, K>, store: Store, internalRoles?: string[]): MutableAtomFamilyToken<T, J, K>;
+declare function createMutableAtomFamily<T extends Transceiver<any>, J extends Json$1.Serializable, K extends string>(store: Store, options: MutableAtomFamilyOptions<T, J, K>, internalRoles?: string[]): MutableAtomFamilyToken<T, J, K>;
 
-declare const getJsonFamily: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable, Key extends string>(mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>, store: Store) => WritableSelectorFamily<SerializableCore, Key>;
+declare const getJsonFamily: <Core extends Transceiver<Json$1.Serializable>, SerializableCore extends Json$1.Serializable, Key extends string>(mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>, store: Store) => WritableSelectorFamily<SerializableCore, Key>;
 
-declare const getJsonToken: <Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>, store: Store) => WritableSelectorToken<SerializableCore>;
+declare const getJsonToken: <Core extends Transceiver<any>, SerializableCore extends Json$1.Serializable>(store: Store, mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => WritableSelectorToken<SerializableCore>;
 
-declare const getUpdateFamily: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable, Key extends string>(mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>, store: Store) => AtomFamily<Signal<Core>, Key>;
+declare const getUpdateFamily: <Core extends Transceiver<Json$1.Serializable>, SerializableCore extends Json$1.Serializable, Key extends string>(mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>, store: Store) => AtomFamily<Signal<Core>, Key>;
 
-declare const getUpdateToken: <Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => RegularAtomToken<Signal<Core>>;
+declare const getUpdateToken: <Core extends Transceiver<any>, SerializableCore extends Json$1.Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => RegularAtomToken<Signal<Core>>;
 
 /**
  * @internal Give the tracker a transceiver state and a store, and it will
@@ -342,10 +387,10 @@ declare class Tracker<Mutable extends Transceiver<any>> {
     private unsubscribeFromState;
     private observeCore;
     private updateCore;
-    mutableState: MutableAtomToken<Mutable, Json.Serializable>;
+    mutableState: MutableAtomToken<Mutable, Json$1.Serializable>;
     latestUpdateState: RegularAtomToken<typeof this.Update | null>;
     dispose: () => void;
-    constructor(mutableState: MutableAtomToken<Mutable, Json.Serializable>, store: Store);
+    constructor(mutableState: MutableAtomToken<Mutable, Json$1.Serializable>, store: Store);
 }
 
 declare class FamilyTracker<Core extends Transceiver<any>, FamilyMemberKey extends Canonical> {
@@ -357,10 +402,10 @@ declare class FamilyTracker<Core extends Transceiver<any>, FamilyMemberKey exten
 
 declare function arbitrary(random?: () => number): string;
 
-declare function createRegularAtom<T>(options: RegularAtomOptions<T>, family: FamilyMetadata | undefined, store: Store): RegularAtomToken<T>;
+declare function createRegularAtom<T>(store: Store, options: RegularAtomOptions<T>, family: FamilyMetadata | undefined): RegularAtomToken<T>;
 
-declare function createStandaloneAtom<T>(options: RegularAtomOptions<T>, store: Store): RegularAtomToken<T>;
-declare function createStandaloneAtom<T extends Transceiver<any>, J extends Json.Serializable>(options: MutableAtomOptions<T, J>, store: Store): MutableAtomToken<T, J>;
+declare function createStandaloneAtom<T>(store: Store, options: RegularAtomOptions<T>): RegularAtomToken<T>;
+declare function createStandaloneAtom<T extends Transceiver<any>, J extends Json$1.Serializable>(store: Store, options: MutableAtomOptions<T, J>): MutableAtomToken<T, J>;
 
 declare function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void;
 
@@ -392,57 +437,59 @@ declare function cacheValue<T extends Promise<any>>(key: string, value: T, subje
 declare const readCachedValue: <T>(token: ReadableState<any>, target: Store) => T;
 declare const evictCachedValue: (key: string, target: Store) => void;
 
-declare function createAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(options: MutableAtomFamilyOptions<T, J, K>, store: Store): MutableAtomFamilyToken<T, J, K>;
-declare function createAtomFamily<T, K extends Canonical>(options: RegularAtomFamilyOptions<T, K>, store: Store): RegularAtomFamilyToken<T, K>;
-
-declare function createReadonlySelectorFamily<T, K extends Canonical>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store, internalRoles?: string[]): ReadonlySelectorFamilyToken<T, K>;
-
-declare function createRegularAtomFamily<T, K extends Canonical>(options: RegularAtomFamilyOptions<T, K>, store: Store, internalRoles?: string[]): RegularAtomFamilyToken<T, K>;
-
-declare function createSelectorFamily<T, K extends Canonical>(options: WritableSelectorFamilyOptions<T, K>, store: Store): WritableSelectorFamilyToken<T, K>;
-declare function createSelectorFamily<T, K extends Canonical>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamilyToken<T, K>;
-
-declare function disposeFromStore(token: MoleculeToken<any> | ReadableToken<any>, store: Store): void;
-declare function disposeFromStore<K extends Canonical>(token: ReadableFamilyToken<any, K>, key: K, store: Store): void;
-declare function disposeFromStore<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>, store: Store): void;
-
-declare function findInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J>;
-declare function findInStore<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T>;
-declare function findInStore<T, K extends Canonical, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T>;
-declare function findInStore<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key, store: Store): WritableSelectorToken<T>;
-declare function findInStore<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key, store: Store): ReadonlySelectorToken<T>;
-declare function findInStore<T, K extends Canonical, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T>;
-declare function findInStore<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T>;
-declare function findInStore<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T>;
-
-declare function initFamilyMemberInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J>;
-declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T>;
-declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T>;
-declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key, store: Store): WritableSelectorToken<T>;
-declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key, store: Store): ReadonlySelectorToken<T>;
-declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T>;
-declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T>;
-declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T>;
-
-declare function seekInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key, store: Store): WritableSelectorToken<T> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key, store: Store): ReadonlySelectorToken<T> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T> | undefined;
-declare function seekInStore<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>, store: Store): MoleculeKey<M> | undefined;
+declare function createAtomFamily<T extends Transceiver<any>, J extends Json$1.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>;
+
+declare function createReadonlySelectorFamily<T, K extends Canonical>(store: Store, options: ReadonlySelectorFamilyOptions<T, K>, internalRoles?: string[]): ReadonlySelectorFamilyToken<T, K>;
+
+declare function createRegularAtomFamily<T, K extends Canonical>(store: Store, options: RegularAtomFamilyOptions<T, K>, internalRoles?: string[]): RegularAtomFamilyToken<T, K>;
+
+declare function createSelectorFamily<T, K extends Canonical>(store: Store, options: WritableSelectorFamilyOptions<T, K>): WritableSelectorFamilyToken<T, K>;
+declare function createSelectorFamily<T, K extends Canonical>(store: Store, options: ReadonlySelectorFamilyOptions<T, K>): ReadonlySelectorFamilyToken<T, K>;
+
+declare function disposeFromStore(store: Store, token: MoleculeToken<any> | ReadableToken<any>): void;
+declare function disposeFromStore<K extends Canonical>(store: Store, token: ReadableFamilyToken<any, K>, key: K): void;
+declare function disposeFromStore<M extends MoleculeConstructor>(store: Store, token: MoleculeFamilyToken<M>, key: MoleculeKey<M>): void;
+
+declare function findInStore<T extends Transceiver<any>, J extends Json$1.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>;
+declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: AtomFamilyToken<T, K>, key: Key): AtomToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: SelectorFamilyToken<T, K>, key: Key): SelectorToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableFamilyToken<T, K>, key: Key): WritableToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T>;
+
+declare function initFamilyMemberInStore<T extends Transceiver<any>, J extends Json$1.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: AtomFamilyToken<T, K>, key: Key): AtomToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: SelectorFamilyToken<T, K>, key: Key): SelectorToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableFamilyToken<T, K>, key: Key): WritableToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T>;
+
+declare function seekInStore<T extends Transceiver<any>, J extends Json$1.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: AtomFamilyToken<T, K>, key: Key): AtomToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: SelectorFamilyToken<T, K>, key: Key): SelectorToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableFamilyToken<T, K>, key: Key): WritableToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T> | undefined;
+declare function seekInStore<M extends MoleculeConstructor>(store: Store, token: MoleculeFamilyToken<M>, key: MoleculeKey<M>): MoleculeKey<M> | undefined;
 
 type EnvironmentData = {
     store: Store;
 };
 declare function getEnvironmentData(store: Store): EnvironmentData;
 
-declare function getFromStore<T>(token: ReadableToken<T>, store: Store): T;
-declare function getFromStore<M extends MoleculeConstructor>(token: MoleculeToken<M>, store: Store): InstanceType<M> | undefined;
-declare function getFromStore<T, K extends Canonical>(token: ReadableFamilyToken<T, K>, key: K, store: Store): T;
-declare function getFromStore<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>, store: Store): InstanceType<M>;
+declare function getFromStore<T>(store: Store, token: ReadableToken<T>): T;
+declare function getFromStore<M extends MoleculeConstructor>(store: Store, token: MoleculeToken<M>): InstanceType<M>;
+declare function getFromStore<T, K extends Canonical>(store: Store, token: ReadableFamilyToken<T, K>, key: K): T;
+declare function getFromStore<M extends MoleculeConstructor>(store: Store, token: MoleculeFamilyToken<M>, key: MoleculeKey<M>): InstanceType<M>;
+declare function getFromStore(store: Store, token: MoleculeToken<any> | ReadableToken<any>): any;
+declare function getFromStore(store: Store, token: MoleculeFamilyToken<any> | ReadableFamilyToken<any, any>, key: Canonical): any;
 
 declare const readOrComputeValue: <T>(state: ReadableState<T>, target: Store) => T;
 
@@ -486,7 +533,7 @@ declare class LazyMap<K, V> extends Map<K, V> {
     delete(key: K): boolean;
 }
 
-declare function createMoleculeFamily<M extends MoleculeConstructor>(options: MoleculeFamilyOptions<M>, store: Store): MoleculeFamilyToken<M>;
+declare function createMoleculeFamily<M extends MoleculeConstructor>(store: Store, options: MoleculeFamilyOptions<M>): MoleculeFamilyToken<M>;
 
 declare function disposeMolecule<M extends MoleculeConstructor>(token: MoleculeToken<M>, store: Store): void;
 
@@ -504,7 +551,7 @@ declare class Molecule<M extends MoleculeConstructor> implements MoleculeToken<M
     constructor(ctx: Molecule<any> | Molecule<any>[] | undefined, key: MoleculeKey<M>, family?: MoleculeFamilyToken<M>);
 }
 
-declare function growMoleculeInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(molecule: Molecule<any>, family: MutableAtomFamilyToken<T, J, K>, store: Store): MutableAtomToken<T, J>;
+declare function growMoleculeInStore<T extends Transceiver<any>, J extends Json$1.Serializable, K extends Canonical>(molecule: Molecule<any>, family: MutableAtomFamilyToken<T, J, K>, store: Store): MutableAtomToken<T, J>;
 declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: RegularAtomFamilyToken<T, K>, store: Store): RegularAtomToken<T>;
 declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: AtomFamilyToken<T, K>, store: Store): AtomToken<T>;
 declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: WritableSelectorFamilyToken<T, K>, store: Store): WritableSelectorToken<T>;
@@ -520,15 +567,15 @@ declare function prettyPrintTokenType(token: AtomIOToken): string;
 
 declare class NotFoundError extends Error {
     constructor(token: AtomIOToken, store: Store);
-    constructor(familyToken: AtomIOToken, key: Json.Serializable, store: Store);
+    constructor(familyToken: AtomIOToken, key: Json$1.Serializable, store: Store);
 }
 
-declare const createReadonlySelector: <T>(options: ReadonlySelectorOptions<T>, family: FamilyMetadata | undefined, store: Store) => ReadonlySelectorToken<T>;
+declare const createReadonlySelector: <T>(store: Store, options: ReadonlySelectorOptions<T>, family: FamilyMetadata | undefined) => ReadonlySelectorToken<T>;
 
-declare function createStandaloneSelector<T>(options: WritableSelectorOptions<T>, store: Store): WritableSelectorToken<T>;
-declare function createStandaloneSelector<T>(options: ReadonlySelectorOptions<T>, store: Store): ReadonlySelectorToken<T>;
+declare function createStandaloneSelector<T>(store: Store, options: WritableSelectorOptions<T>): WritableSelectorToken<T>;
+declare function createStandaloneSelector<T>(store: Store, options: ReadonlySelectorOptions<T>): ReadonlySelectorToken<T>;
 
-declare const createWritableSelector: <T>(options: WritableSelectorOptions<T>, family: FamilyMetadata | undefined, store: Store) => WritableSelectorToken<T>;
+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;
 
@@ -546,8 +593,15 @@ declare const become: <T>(nextVersionOfThing: Modify<T> | T) => (originalThing:
 
 declare const setAtomOrSelector: <T>(state: WritableState<T>, value: T | ((oldValue: T) => T), store: Store) => void;
 
-declare function setIntoStore<T, New extends T>(token: WritableToken<T>, value: New | ((oldValue: T) => New), store: Store): void;
-declare function setIntoStore<T, K extends Canonical, New extends T>(token: WritableFamilyToken<T, K>, key: K, value: New | ((oldValue: T) => New), store: Store): 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 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 const subscribeToRootAtoms: <T>(selector: Selector<T>, store: Store) => (() => void)[];
 
@@ -571,7 +625,7 @@ type RegularAtom<T> = AtomIOState & {
     default: T | (() => T);
     cleanup?: () => void;
 };
-type MutableAtom<T extends Transceiver<any>, J extends Json.Serializable> = AtomIOState & JsonInterface<T, J> & {
+type MutableAtom<T extends Transceiver<any>, J extends Json$1.Serializable> = AtomIOState & JsonInterface<T, J> & {
     type: `mutable_atom`;
     default: T | (() => T);
     cleanup?: () => void;
@@ -595,7 +649,7 @@ type RegularAtomFamily<T, K extends Canonical> = RegularAtomFamilyToken<T, K> &
     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> & {
+type MutableAtomFamily<T extends Transceiver<any>, J extends Json$1.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;
@@ -618,4 +672,4 @@ type SelectorFamily<T, K extends Canonical> = ReadonlySelectorFamily<T, K> | Wri
 type WritableFamily<T, K extends Canonical> = AtomFamily<T, K> | WritableSelectorFamily<T, K>;
 type ReadableFamily<T, K extends Canonical> = AtomFamily<T, K> | SelectorFamily<T, K>;
 
-export { type Atom, type AtomFamily, type AtomIOState, type AtomIOToken, type AtomKey, type ChildStore, type EnvironmentData, FamilyTracker, type Flat, type Func, Future, IMPLICIT, LazyMap, type Lineage, type Modify, Molecule, type MutableAtom, type MutableAtomFamily, NotFoundError, type OperationProgress, type Range, type ReadableFamily, type ReadableState, type ReadonlySelector, type ReadonlySelectorFamily, type ReadonlySelectorKey, 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, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+export { type Atom, type AtomFamily, type AtomIOState, type AtomIOToken, type AtomKey, type ChildStore, type EnvironmentData, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, type Flat, type Func, Future, IMPLICIT, LazyMap, type Lineage, type Modify, Molecule, type MutableAtom, type MutableAtomFamily, NotFoundError, type OperationProgress, type Range, type ReadableFamily, type ReadableState, type ReadonlySelector, type ReadonlySelectorFamily, type ReadonlySelectorKey, 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, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, 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 };

package/internal/dist/index.js

@@ -1,3 +1,3 @@
-export { FamilyTracker, Future, IMPLICIT, LazyMap, Molecule, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw } from '../../dist/chunk-JRENM6KL.js';
+export { FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, LazyMap, Molecule, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, counterfeit, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, 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 } from '../../dist/chunk-BX3MTH2Z.js';
 import '../../dist/chunk-IBTHB2PI.js';
 import '../../dist/chunk-XWL6SNVU.js';

package/internal/src/atom/create-regular-atom.ts

@@ -15,9 +15,9 @@ import { subscribeToState } from "../subscribe"
 import { markAtomAsDefault } from "./is-default"
 
 export function createRegularAtom<T>(
+	store: Store,
 	options: RegularAtomOptions<T>,
 	family: FamilyMetadata | undefined,
-	store: Store,
 ): RegularAtomToken<T> {
 	store.logger.info(
 		`🔨`,
@@ -47,7 +47,7 @@ export function createRegularAtom<T>(
 				options.key,
 				`installing in store "${s.config.name}"`,
 			)
-			return createRegularAtom(options, family, s)
+			return createRegularAtom(s, options, family)
 		},
 		subject,
 	} as const
@@ -68,7 +68,7 @@ export function createRegularAtom<T>(
 		for (const effect of options.effects) {
 			const cleanup = effect({
 				setSelf: (next) => {
-					setIntoStore(token, next, store)
+					setIntoStore(store, token, next)
 				},
 				onSet: (handle: UpdateHandler<T>) =>
 					subscribeToState(token, handle, `effect[${effectIndex}]`, store),

package/internal/src/atom/create-standalone-atom.ts

@@ -13,25 +13,27 @@ import type { Store } from "../store"
 import { createRegularAtom } from "./create-regular-atom"
 
 export function createStandaloneAtom<T>(
-	options: RegularAtomOptions<T>,
 	store: Store,
+	options: RegularAtomOptions<T>,
 ): RegularAtomToken<T>
+
 export function createStandaloneAtom<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
->(options: MutableAtomOptions<T, J>, store: Store): MutableAtomToken<T, J>
+>(store: Store, options: MutableAtomOptions<T, J>): MutableAtomToken<T, J>
+
 export function createStandaloneAtom<T>(
-	options: MutableAtomOptions<any, any> | RegularAtomOptions<T>,
 	store: Store,
+	options: MutableAtomOptions<any, any> | RegularAtomOptions<T>,
 ): AtomToken<T> {
 	const isMutable = `mutable` in options
 
 	if (isMutable) {
-		const state = createMutableAtom(options, undefined, store)
+		const state = createMutableAtom(store, options, undefined)
 		store.on.atomCreation.next(state)
 		return state
 	}
-	const state = createRegularAtom(options, undefined, store)
+	const state = createRegularAtom(store, options, undefined)
 	store.on.atomCreation.next(state)
 	return state
 }

package/internal/src/atom/dispose-atom.ts

@@ -12,15 +12,8 @@ import {
 export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 	const target = newest(store)
 	const { key } = atomToken
-	const atom = target.atoms.get(key)
-	if (!atom) {
-		store.logger.error(
-			`❌`,
-			`atom`,
-			key,
-			`Tried to dispose atom, but it does not exist in the store.`,
-		)
-	} else if (!atom.family) {
+	const atom = withdraw(atomToken, target)
+	if (!atom.family) {
 		store.logger.error(`❌`, `atom`, key, `Standalone atoms cannot be disposed.`)
 	} else {
 		atom.cleanup?.()

package/internal/src/families/create-atom-family.ts

@@ -16,23 +16,23 @@ export function createAtomFamily<
 	J extends Json.Serializable,
 	K extends Canonical,
 >(
-	options: MutableAtomFamilyOptions<T, J, K>,
 	store: Store,
+	options: MutableAtomFamilyOptions<T, J, K>,
 ): MutableAtomFamilyToken<T, J, K>
 export function createAtomFamily<T, K extends Canonical>(
-	options: RegularAtomFamilyOptions<T, K>,
 	store: Store,
+	options: RegularAtomFamilyOptions<T, K>,
 ): RegularAtomFamilyToken<T, K>
 export function createAtomFamily<T, K extends Canonical>(
+	store: Store,
 	options:
 		| MutableAtomFamilyOptions<any, any, any>
 		| RegularAtomFamilyOptions<T, K>,
-	store: Store,
 ): AtomFamilyToken<any, any> {
 	const isMutable = `mutable` in options
 
 	if (isMutable) {
-		return createMutableAtomFamily(options, store)
+		return createMutableAtomFamily(store, options)
 	}
-	return createRegularAtomFamily<T, K>(options, store)
+	return createRegularAtomFamily<T, K>(store, options)
 }

package/internal/src/families/create-readonly-selector-family.ts

@@ -1,5 +1,6 @@
 import type {
 	FamilyMetadata,
+	getState,
 	ReadonlySelectorFamilyOptions,
 	ReadonlySelectorFamilyToken,
 	ReadonlySelectorToken,
@@ -15,6 +16,7 @@ import {
 	findInStore,
 	getFromStore,
 	getJsonToken,
+	prettyPrintTokenType,
 	type ReadonlySelectorFamily,
 	seekInStore,
 } from ".."
@@ -22,11 +24,10 @@ import { newest } from "../lineage"
 import { createReadonlySelector } from "../selector"
 import type { Store } from "../store"
 import { Subject } from "../subject"
-import { throwInCaseOfConflictingFamily } from "./throw-in-case-of-conflicting-family"
 
 export function createReadonlySelectorFamily<T, K extends Canonical>(
-	options: ReadonlySelectorFamilyOptions<T, K>,
 	store: Store,
+	options: ReadonlySelectorFamilyOptions<T, K>,
 	internalRoles?: string[],
 ): ReadonlySelectorFamilyToken<T, K> {
 	const familyToken = {
@@ -34,7 +35,17 @@ export function createReadonlySelectorFamily<T, K extends Canonical>(
 		type: `readonly_selector_family`,
 	} as const satisfies ReadonlySelectorFamilyToken<T, K>
 
-	throwInCaseOfConflictingFamily(familyToken, store)
+	const existing = store.families.get(options.key)
+	if (existing) {
+		store.logger.error(
+			`❗`,
+			`readonly_selector_family`,
+			options.key,
+			`Overwriting an existing ${prettyPrintTokenType(
+				existing,
+			)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`,
+		)
+	}
 
 	const subject = new Subject<
 		| StateCreation<ReadonlySelectorToken<T>>
@@ -48,12 +59,12 @@ export function createReadonlySelectorFamily<T, K extends Canonical>(
 		const target = newest(store)
 
 		const token = createReadonlySelector(
+			target,
 			{
 				key: fullKey,
 				get: options.get(key),
 			},
 			family,
-			target,
 		)
 
 		subject.next({ type: `state_creation`, token })
@@ -63,14 +74,14 @@ export function createReadonlySelectorFamily<T, K extends Canonical>(
 	const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
 		internalRoles,
 		subject,
-		install: (s: Store) => createReadonlySelectorFamily(options, s),
+		install: (s: Store) => createReadonlySelectorFamily(s, options),
 		default: (key: K) => {
 			const getFn = options.get(key)
 			return getFn({
-				get: (token) => getFromStore(token, store),
-				find: ((token, k) => findInStore(token, k, store)) as typeof findState,
-				seek: ((token, k) => seekInStore(token, k, store)) as typeof seekState,
-				json: (token) => getJsonToken(token, store),
+				get: ((...ps: [any]) => getFromStore(store, ...ps)) as typeof getState,
+				find: ((token, k) => findInStore(store, token, k)) as typeof findState,
+				seek: ((token, k) => seekInStore(store, token, k)) as typeof seekState,
+				json: (token) => getJsonToken(store, token),
 			})
 		},
 	}) satisfies ReadonlySelectorFamily<T, K>