atom.io 0.25.3 → 0.25.5

package/dist/index.cjs

@@ -144,6 +144,12 @@ var Silo = class {
     this.redo = (token) => {
       Internal.timeTravel(`redo`, token, s);
     };
+    this.moleculeFamily = (...params) => {
+      return Internal.createMoleculeFamily(...params, s);
+    };
+    this.makeMolecule = (...params) => {
+      return Internal.makeMoleculeInStore(s, ...params);
+    };
   }
 };
 function subscribe(token, handleUpdate, key = Internal.arbitrary(), store = Internal.IMPLICIT.STORE) {

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { Transceiver, Subject, Store, EnvironmentData, Timeline, TimelineAtomUpdate, TimelineMoleculeCreation, TimelineMoleculeDisposal, TimelineSelectorUpdate, TimelineStateCreation, TimelineStateDisposal, TimelineTransactionUpdate } from 'atom.io/internal';
+import { Transceiver, Subject, Store, Func, EnvironmentData, Flat, Timeline, TimelineAtomUpdate, TimelineMoleculeCreation, TimelineMoleculeDisposal, TimelineSelectorUpdate, TimelineStateCreation, TimelineStateDisposal, TimelineTransactionUpdate } from 'atom.io/internal';
 import { Json, JsonInterface } from 'atom.io/json';
-import { MoleculeConstructor as MoleculeConstructor$1, MoleculeToken as MoleculeToken$1, MoleculeFamilyToken as MoleculeFamilyToken$1, MoleculeParams as MoleculeParams$1, getState as getState$1, setState as setState$1, makeMolecule as makeMolecule$1, Flat as Flat$1, ActorToolkit as ActorToolkit$1, MutableAtomFamilyToken as MutableAtomFamilyToken$1, MutableAtomToken as MutableAtomToken$1, RegularAtomFamilyToken as RegularAtomFamilyToken$1, RegularAtomToken as RegularAtomToken$1, WritableSelectorFamilyToken as WritableSelectorFamilyToken$1, WritableSelectorToken as WritableSelectorToken$1, ReadonlySelectorFamilyToken as ReadonlySelectorFamilyToken$1, ReadonlySelectorToken as ReadonlySelectorToken$1, WritableFamilyToken as WritableFamilyToken$1, WritableToken as WritableToken$1, ReadableFamilyToken as ReadableFamilyToken$1, ReadableToken as ReadableToken$1, MoleculeCreation as MoleculeCreation$1, MoleculeDisposal as MoleculeDisposal$1 } from 'atom.io';
+import { MoleculeConstructor as MoleculeConstructor$1, MoleculeToken as MoleculeToken$1, MoleculeFamilyToken as MoleculeFamilyToken$1, MoleculeParams as MoleculeParams$1, getState as getState$1, setState as setState$1, makeMolecule as makeMolecule$1, ActorToolkit as ActorToolkit$1, MutableAtomFamilyToken as MutableAtomFamilyToken$1, MutableAtomToken as MutableAtomToken$1, RegularAtomFamilyToken as RegularAtomFamilyToken$1, RegularAtomToken as RegularAtomToken$1, WritableSelectorFamilyToken as WritableSelectorFamilyToken$1, WritableSelectorToken as WritableSelectorToken$1, ReadonlySelectorFamilyToken as ReadonlySelectorFamilyToken$1, ReadonlySelectorToken as ReadonlySelectorToken$1, WritableFamilyToken as WritableFamilyToken$1, WritableToken as WritableToken$1, ReadableFamilyToken as ReadableFamilyToken$1, ReadableToken as ReadableToken$1, MoleculeCreation as MoleculeCreation$1, MoleculeDisposal as MoleculeDisposal$1 } from 'atom.io';
 import { findState } from 'atom.io/ephemeral';
 import { seekState } from 'atom.io/immortal';
 import { JoinToken } from 'atom.io/data';
@@ -22,7 +22,23 @@ type MutableAtomOptions<T extends Transceiver<any>, J extends Json.Serializable>
     default: () => T;
     mutable: true;
 };
+/**
+ * @public
+ * Declare a mutable global reactive variable.
+ * @param options - Configuration for this mutable atom.
+ * @returns
+ * The token for your mutable atom.
+ * @overload Mutable
+ */
 declare function atom<T extends Transceiver<any>, J extends Json.Serializable>(options: MutableAtomOptions<T, J>): MutableAtomToken<T, J>;
+/**
+ * @public
+ * Declare a regular global reactive variable.
+ * @param options - Configuration for this regular atom.
+ * @returns
+ * The token for your regular atom.
+ * @overload Regular
+ */
 declare function atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T>;
 type RegularAtomFamilyOptions<T, K extends Json.Serializable> = {
     key: string;
@@ -197,7 +213,7 @@ type SelectorFamilyToken<T, K extends Json.Serializable> = ReadonlySelectorFamil
 declare function selectorFamily<T, K extends Json.Serializable>(options: WritableSelectorFamilyOptions<T, K>): WritableSelectorFamilyTokenWithCall<T, K>;
 declare function selectorFamily<T, K extends Json.Serializable>(options: ReadonlySelectorFamilyOptions<T, K>): ReadonlySelectorFamilyTokenWithCall<T, K>;
 
-type CtorToolkit<K extends Json.Serializable> = Flat$1<Omit<ActorToolkit$1, `find`> & {
+type CtorToolkit<K extends Json.Serializable> = Flat<Omit<ActorToolkit$1, `find`> & {
     bond<T extends Transceiver<any>, J extends Json.Serializable>(family: MutableAtomFamilyToken$1<T, J, K>): MutableAtomToken$1<T, J>;
     bond<T>(family: RegularAtomFamilyToken$1<T, K>): RegularAtomToken$1<T>;
     bond<T>(family: WritableSelectorFamilyToken$1<T, K>): WritableSelectorToken$1<T>;
@@ -234,13 +250,13 @@ type MoleculeFamilyToken<M extends MoleculeConstructor> = {
     dependsOn: `all` | `any`;
     __M?: M;
 };
-type MoleculeFamily<M extends MoleculeConstructor> = Flat$1<MoleculeFamilyToken<M> & {
+type MoleculeFamily<M extends MoleculeConstructor> = Flat<MoleculeFamilyToken<M> & {
     subject: Subject<MoleculeCreation$1<M> | MoleculeDisposal$1>;
     dependsOn: `all` | `any`;
     new: M;
 }>;
 type MoleculeToken<M extends MoleculeConstructor> = {
-    key: MK<M>;
+    key: MoleculeKey<M>;
     type: `molecule`;
     family?: MoleculeFamilyToken<M>;
     __M?: M;
@@ -249,7 +265,6 @@ declare function moleculeFamily<M extends MoleculeConstructor>(options: Molecule
 declare function makeMolecule<M extends MoleculeConstructor>(context: MoleculeToken<any> | MoleculeToken<any>[], family: MoleculeFamilyToken<M>, key: MoleculeKey<M>, ...params: MoleculeParams<M>): MoleculeToken<M>;
 type MoleculeType<T extends MoleculeFamilyToken<any>> = T extends MoleculeFamilyToken<infer M> ? M : T extends MoleculeToken<infer M> ? M : never;
 type MoleculeKey<M extends MoleculeConstructor> = InstanceType<M>[`key`];
-type MK<M extends MoleculeConstructor> = MoleculeKey<M>;
 declare function makeRootMolecule(key: string, store?: Store): MoleculeToken<ObjectConstructor>;
 
 declare function disposeState(token: MoleculeToken<any> | ReadableToken<any>): void;
@@ -337,7 +352,23 @@ type Serializable = primitive | Readonly<{
     [key: string]: Serializable;
 }> | ReadonlyArray<Serializable>;
 
+/**
+ * @public
+ * Set the value of a state into the implicit store.
+ * @param token - The unique identifier of the state to set.
+ * @param value - The new value of the state.
+ * @overload Default
+ * @default
+ */
 declare function setState<T, New extends T>(token: WritableToken<T>, value: New | ((oldValue: T) => New)): void;
+/**
+ * @public
+ * Set the value of a state into the implicit store.
+ * @param token - The unique identifier of a state family.
+ * @param key - The key of the state to set.
+ * @param value - The new value of the state.
+ * @overload Streamlined
+ */
 declare function setState<T, K extends Serializable, New extends T>(token: WritableFamilyToken<T, K>, key: K, value: New | ((oldValue: T) => New)): void;
 
 declare class Silo {
@@ -355,6 +386,8 @@ declare class Silo {
     subscribe: typeof subscribe;
     undo: typeof undo;
     redo: typeof redo;
+    moleculeFamily: typeof moleculeFamily;
+    makeMolecule: typeof makeMolecule;
     constructor(config: Store[`config`], fromStore?: Store | null);
 }
 
@@ -404,12 +437,6 @@ declare function belongsTo<Family extends ReadonlySelectorFamilyToken$1<any, any
 declare function belongsTo<Family extends WritableFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is WritableToken$1<TokenType<Family>>;
 declare function belongsTo<Family extends ReadableFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is ReadableToken$1<TokenType<Family>>;
 
-type Func = (...parameters: any[]) => any;
-type Flat<R extends {
-    [K in PropertyKey]: any;
-}> = {
-    [K in keyof R]: R[K];
-};
 type RegularAtomToken<T> = {
     key: string;
     type: `atom`;
@@ -448,4 +475,4 @@ type FamilyMetadata = {
     subKey: string;
 };
 
-export { type ActorToolkit, type AtomEffect, type AtomFamily, type AtomFamilyToken, AtomIOLogger, type AtomOnly, type AtomToken, type CtorToolkit, type Effectors, type FamilyMetadata, type Flat, type Func, type GetterToolkit, type KeyedStateUpdate, LOG_LEVELS, type LogFilter, type LogFn, type LogLevel, type Logger, type LoggerIcon, type MK, type MoleculeConstructor, type MoleculeCreation, type MoleculeDisposal, type MoleculeFamily, type MoleculeFamilyOptions, type MoleculeFamilyToken, type MoleculeKey, type MoleculeParams, type MoleculeToken, type MoleculeType, type MutableAtomFamily, type MutableAtomFamilyOptions, type MutableAtomFamilyToken, type MutableAtomFamilyTokenWithCall, type MutableAtomOptions, type MutableAtomToken, type Read, type ReadableFamily, type ReadableFamilyToken, type ReadableToken, type ReadonlySelectorFamily, type ReadonlySelectorFamilyOptions, type ReadonlySelectorFamilyToken, type ReadonlySelectorFamilyTokenWithCall, type ReadonlySelectorOptions, type ReadonlySelectorToken, type RegularAtomFamily, type RegularAtomFamilyOptions, type RegularAtomFamilyToken, type RegularAtomFamilyTokenWithCall, type RegularAtomOptions, type RegularAtomToken, type SelectorFamily, type SelectorFamilyToken, type SelectorToken, type SetterToolkit, Silo, type StateCreation, type StateDisposal, type StateUpdate, type TimelineManageable, type TimelineOptions, type TimelineToken, type TimelineUpdate, type TokenDenomination, type TokenType, type Transact, type TransactionIO, type TransactionOptions, type TransactionToken, type TransactionUpdate, type TransactionUpdateContent, type TransactionUpdateHandler, type UpdateHandler, type WritableFamily, type WritableFamilyToken, type WritableSelectorFamily, type WritableSelectorFamilyOptions, type WritableSelectorFamilyToken, type WritableSelectorFamilyTokenWithCall, type WritableSelectorOptions, type WritableSelectorToken, type WritableToken, type Write, atom, atomFamily, belongsTo, disposeState, getState, isToken, makeMolecule, makeRootMolecule, moleculeFamily, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };
+export { type ActorToolkit, type AtomEffect, type AtomFamily, type AtomFamilyToken, AtomIOLogger, type AtomOnly, type AtomToken, type CtorToolkit, type Effectors, type FamilyMetadata, type GetterToolkit, type KeyedStateUpdate, LOG_LEVELS, type LogFilter, type LogFn, type LogLevel, type Logger, type LoggerIcon, type MoleculeConstructor, type MoleculeCreation, type MoleculeDisposal, type MoleculeFamily, type MoleculeFamilyOptions, type MoleculeFamilyToken, type MoleculeKey, type MoleculeParams, type MoleculeToken, type MoleculeType, type MutableAtomFamily, type MutableAtomFamilyOptions, type MutableAtomFamilyToken, type MutableAtomFamilyTokenWithCall, type MutableAtomOptions, type MutableAtomToken, type Read, type ReadableFamily, type ReadableFamilyToken, type ReadableToken, type ReadonlySelectorFamily, type ReadonlySelectorFamilyOptions, type ReadonlySelectorFamilyToken, type ReadonlySelectorFamilyTokenWithCall, type ReadonlySelectorOptions, type ReadonlySelectorToken, type RegularAtomFamily, type RegularAtomFamilyOptions, type RegularAtomFamilyToken, type RegularAtomFamilyTokenWithCall, type RegularAtomOptions, type RegularAtomToken, type SelectorFamily, type SelectorFamilyToken, type SelectorToken, type SetterToolkit, Silo, type StateCreation, type StateDisposal, type StateUpdate, type TimelineManageable, type TimelineOptions, type TimelineToken, type TimelineUpdate, type TokenDenomination, type TokenType, type Transact, type TransactionIO, type TransactionOptions, type TransactionToken, type TransactionUpdate, type TransactionUpdateContent, type TransactionUpdateHandler, type UpdateHandler, type WritableFamily, type WritableFamilyToken, type WritableSelectorFamily, type WritableSelectorFamilyOptions, type WritableSelectorFamilyToken, type WritableSelectorFamilyTokenWithCall, type WritableSelectorOptions, type WritableSelectorToken, type WritableToken, type Write, atom, atomFamily, belongsTo, disposeState, getState, isToken, makeMolecule, makeRootMolecule, moleculeFamily, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };

package/dist/index.js

@@ -123,6 +123,12 @@ var Silo = class {
     this.redo = (token) => {
       timeTravel(`redo`, token, s);
     };
+    this.moleculeFamily = (...params) => {
+      return createMoleculeFamily(...params, s);
+    };
+    this.makeMolecule = (...params) => {
+      return makeMoleculeInStore(s, ...params);
+    };
   }
 };
 function subscribe(token, handleUpdate, key = arbitrary(), store = IMPLICIT.STORE) {

package/ephemeral/dist/index.d.ts

@@ -2,11 +2,56 @@ import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, Regul
 import { Transceiver } from 'atom.io/internal';
 import { Json } from 'atom.io/json';
 
+/**
+ * @overload Mutable Atom
+ * 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.
+ */
 declare function findState<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>;
+/**
+ * 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.
+ */
 declare function findState<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T>;
+/**
+ * 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.
+ */
 declare function findState<T, K extends Json.Serializable, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T>;
+/**
+ * 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.
+ */
 declare function findState<T, K extends Json.Serializable, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T>;
+/**
+ * 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.
+ */
 declare function findState<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T>;
+/**
+ * @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
+ */
 declare function findState<T, K extends Json.Serializable, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T>;
 
 export { findState };

package/ephemeral/src/find-state.ts

@@ -16,33 +16,73 @@ import type { Transceiver } from "atom.io/internal"
 import { findInStore, IMPLICIT } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 
+/**
+ * @overload Mutable Atom
+ * 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.
+ */
 export function findState<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
 	K extends Json.Serializable,
 	Key extends K,
 >(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>
-
+/**
+ * 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.
+ */
 export function findState<T, K extends Json.Serializable, Key extends K>(
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
 ): RegularAtomToken<T>
-
+/**
+ * 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.
+ */
 export function findState<T, K extends Json.Serializable, Key extends K>(
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
 ): WritableSelectorToken<T>
-
+/**
+ * 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.
+ */
 export function findState<T, K extends Json.Serializable, Key extends K>(
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
 ): ReadonlySelectorToken<T>
-
+/**
+ * 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.
+ */
 export function findState<T, K extends Json.Serializable, Key extends K>(
 	token: WritableFamilyToken<T, K>,
 	key: Key,
 ): WritableToken<T>
-
+/**
+ * @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
+ */
 export function findState<T, K extends Json.Serializable, Key extends K>(
 	token: ReadableFamilyToken<T, K>,
 	key: Key,

package/internal/dist/index.cjs

@@ -858,7 +858,16 @@ var registerSelector = (selectorKey, covered, store) => ({
         case `molecule_family`:
           return getFromStore(family, key, store);
         default:
-          dependency = seekInStore(family, key, store);
+          if (store.config.lifespan === `ephemeral`) {
+            dependency = findInStore(family, key, store);
+          } else {
+            const maybeDependency = seekInStore(family, key, store);
+            if (maybeDependency) {
+              dependency = maybeDependency;
+            } else {
+              throw new NotFoundError(family, key, store);
+            }
+          }
       }
     } else {
       [dependency] = params;
@@ -2065,13 +2074,14 @@ var Store = class {
   }
 };
 var IMPLICIT = {
-  STORE_INTERNAL: void 0,
   get STORE() {
-    var _a;
-    return (_a = this.STORE_INTERNAL) != null ? _a : this.STORE_INTERNAL = new Store({
-      name: `IMPLICIT_STORE`,
-      lifespan: `ephemeral`
-    });
+    if (!globalThis.ATOM_IO_IMPLICIT_STORE) {
+      globalThis.ATOM_IO_IMPLICIT_STORE = new Store({
+        name: `IMPLICIT_STORE`,
+        lifespan: `ephemeral`
+      });
+    }
+    return globalThis.ATOM_IO_IMPLICIT_STORE;
   }
 };
 var clearStore = (store) => {

package/internal/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as atom_io from 'atom.io';
-import { Func, TransactionToken, TransactionUpdate, TransactionOptions, ActorToolkit, RegularAtomToken, MutableAtomToken, AtomToken, WritableSelectorToken, ReadonlySelectorToken, SelectorToken, WritableToken, MoleculeToken, MoleculeFamily, MoleculeFamilyToken, ReadableToken, TimelineManageable, Flat, StateUpdate, TokenType, FamilyMetadata, StateCreation, StateDisposal, MoleculeConstructor, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, TimelineToken, WritableSelectorFamily, MutableAtomFamily, RegularAtomFamily, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomFamily, ReadableFamily, SelectorFamily, WritableFamily, RegularAtomFamilyToken, MutableAtomFamilyToken, AtomFamilyToken, ReadonlySelectorFamilyToken, WritableSelectorFamilyToken, SelectorFamilyToken, ReadableFamilyToken, WritableFamilyToken, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, MoleculeKey, KeyedStateUpdate, MoleculeFamilyOptions, MK, MoleculeParams, ReadonlySelectorOptions, WritableSelectorOptions, SetterToolkit, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
+import { TransactionToken, TransactionUpdate, TransactionOptions, ActorToolkit, RegularAtomToken, MutableAtomToken, AtomToken, WritableSelectorToken, ReadonlySelectorToken, SelectorToken, WritableToken, MoleculeToken, MoleculeFamily, MoleculeFamilyToken, ReadableToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, StateCreation, StateDisposal, MoleculeConstructor, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, TimelineToken, WritableSelectorFamily, MutableAtomFamily, RegularAtomFamily, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomFamily, ReadableFamily, SelectorFamily, WritableFamily, 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 { Json, JsonInterface } from 'atom.io/json';
 import { Join } from 'atom.io/data';
 
@@ -77,6 +77,13 @@ declare class Junction<const ASide extends string, const BSide extends string, c
     has(a: string, b?: string): boolean;
 }
 
+type Func = (...parameters: any[]) => any;
+type Flat<R extends {
+    [K in PropertyKey]: any;
+}> = {
+    [K in keyof R]: R[K];
+};
+
 declare const abortTransaction: (store: Store) => void;
 
 declare function actUponStore<F extends Func>(token: TransactionToken<F>, id: string, store: Store): (...parameters: Parameters<F>) => ReturnType<F>;
@@ -245,7 +252,7 @@ declare class Store implements Lineage {
         topicType: `atom_family` | `atom` | `molecule_family` | `molecule`;
     }>;
     molecules: Map<string, Molecule<any>>;
-    moleculeFamilies: Map<string, atom_io.Flat<atom_io.MoleculeFamilyToken<any> & {
+    moleculeFamilies: Map<string, Flat<atom_io.MoleculeFamilyToken<any> & {
         subject: Subject<atom_io.MoleculeDisposal | atom_io.MoleculeCreation<any>>;
         dependsOn: `all` | `any`;
         new: any;
@@ -275,7 +282,6 @@ declare class Store implements Lineage {
     constructor(config: Store[`config`], store?: Store | null);
 }
 declare const IMPLICIT: {
-    STORE_INTERNAL: Store | undefined;
     readonly STORE: Store;
 };
 declare const clearStore: (store: Store) => void;
@@ -487,7 +493,7 @@ declare function createMoleculeFamily<M extends MoleculeConstructor>(options: Mo
 declare function disposeMolecule<M extends MoleculeConstructor>(token: MoleculeToken<M>, store: Store): void;
 
 declare class Molecule<M extends MoleculeConstructor> implements MoleculeToken<M> {
-    readonly key: MK<M>;
+    readonly key: MoleculeKey<M>;
     readonly type = "molecule";
     stringKey: string;
     family?: MoleculeFamilyToken<M>;
@@ -497,7 +503,7 @@ declare class Molecule<M extends MoleculeConstructor> implements MoleculeToken<M
     below: Map<string, Molecule<any>>;
     joins: Map<string, Join<any, any, any, any>>;
     instance: InstanceType<M>;
-    constructor(ctx: Molecule<any> | Molecule<any>[] | undefined, key: MK<M>, family?: MoleculeFamilyToken<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 Json.Serializable>(molecule: Molecule<any>, family: MutableAtomFamily<T, J, K>, store: Store): MutableAtomToken<T, J>;
@@ -584,4 +590,4 @@ type Selector<T> = ReadonlySelector<T> | WritableSelector<T>;
 type WritableState<T> = Atom<T> | WritableSelector<T>;
 type ReadableState<T> = Atom<T> | Selector<T>;
 
-export { type Atom, type AtomIOState, type AtomKey, type ChildStore, type EnvironmentData, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, Molecule, type MutableAtom, NotFoundError, type OperationProgress, type ReadableState, type ReadonlySelector, type ReadonlySelectorKey, type RegularAtom, type RootStore, type Selector, 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 WritableSelector, 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, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+export { type Atom, type AtomIOState, type AtomKey, type ChildStore, type EnvironmentData, FamilyTracker, type Flat, type Func, Future, IMPLICIT, LazyMap, type Lineage, type Modify, Molecule, type MutableAtom, NotFoundError, type OperationProgress, type ReadableState, type ReadonlySelector, type ReadonlySelectorKey, type RegularAtom, type RootStore, type Selector, 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 WritableSelector, 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, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };

package/internal/dist/index.js

@@ -583,7 +583,16 @@ var registerSelector = (selectorKey, covered, store) => ({
         case `molecule_family`:
           return getFromStore(family, key, store);
         default:
-          dependency = seekInStore(family, key, store);
+          if (store.config.lifespan === `ephemeral`) {
+            dependency = findInStore(family, key, store);
+          } else {
+            const maybeDependency = seekInStore(family, key, store);
+            if (maybeDependency) {
+              dependency = maybeDependency;
+            } else {
+              throw new NotFoundError(family, key, store);
+            }
+          }
       }
     } else {
       [dependency] = params;
@@ -1790,13 +1799,14 @@ var Store = class {
   }
 };
 var IMPLICIT = {
-  STORE_INTERNAL: void 0,
   get STORE() {
-    var _a;
-    return (_a = this.STORE_INTERNAL) != null ? _a : this.STORE_INTERNAL = new Store({
-      name: `IMPLICIT_STORE`,
-      lifespan: `ephemeral`
-    });
+    if (!globalThis.ATOM_IO_IMPLICIT_STORE) {
+      globalThis.ATOM_IO_IMPLICIT_STORE = new Store({
+        name: `IMPLICIT_STORE`,
+        lifespan: `ephemeral`
+      });
+    }
+    return globalThis.ATOM_IO_IMPLICIT_STORE;
   }
 };
 var clearStore = (store) => {

package/internal/src/index.ts

@@ -27,6 +27,7 @@ export * from "./subject"
 export * from "./subscribe"
 export * from "./timeline"
 export * from "./transaction"
+export * from "./utility-types"
 
 export type AtomIOState = {
 	key: string

package/internal/src/ingest-updates/index.ts

@@ -1,4 +1,4 @@
 export * from "./ingest-atom-update"
-export * from "./ingest-creation-disposal.ts"
+export * from "./ingest-creation-disposal"
 export * from "./ingest-selector-update"
 export * from "./ingest-transaction-update"

package/internal/src/molecule/make-molecule-in-store.ts

@@ -1,7 +1,6 @@
 import type {
 	CtorToolkit,
 	getState,
-	MK,
 	MoleculeConstructor,
 	MoleculeCreation,
 	MoleculeFamilyToken,
@@ -128,7 +127,7 @@ export function makeMoleculeInStore<M extends MoleculeConstructor>(
 				withdraw(token, rootStore),
 				newest(rootStore),
 			)
-		}) as CtorToolkit<MK<M>>[`bond`],
+		}) as CtorToolkit<MoleculeKey<M>>[`bond`],
 		claim: (below, options) => {
 			const { exclusive } = options
 			const belowMolecule = newest(store).molecules.get(stringifyJson(below.key))
@@ -154,7 +153,7 @@ export function makeMoleculeInStore<M extends MoleculeConstructor>(
 				k,
 				...p,
 			),
-	} satisfies CtorToolkit<MK<M>>
+	} satisfies CtorToolkit<MoleculeKey<M>>
 
 	const family = withdraw(familyToken, store)
 	const Constructor = family.new

package/internal/src/molecule/molecule-internal.ts

@@ -1,7 +1,7 @@
 import type {
-	MK,
 	MoleculeConstructor,
 	MoleculeFamilyToken,
+	MoleculeKey,
 	MoleculeToken,
 	ReadableToken,
 	StateCreation,
@@ -28,7 +28,7 @@ export class Molecule<M extends MoleculeConstructor>
 	public instance: InstanceType<M>
 	public constructor(
 		ctx: Molecule<any> | Molecule<any>[] | undefined,
-		public readonly key: MK<M>,
+		public readonly key: MoleculeKey<M>,
 		family?: MoleculeFamilyToken<M>,
 	) {
 		this.stringKey = stringifyJson(key)

package/internal/src/selector/register-selector.ts

@@ -45,7 +45,16 @@ export const registerSelector = (
 				case `molecule_family`:
 					return getFromStore(family, key, store)
 				default:
-					dependency = seekInStore(family, key, store) as any
+					if (store.config.lifespan === `ephemeral`) {
+						dependency = findInStore(family, key, store)
+					} else {
+						const maybeDependency = seekInStore(family, key, store)
+						if (maybeDependency) {
+							dependency = maybeDependency
+						} else {
+							throw new NotFoundError(family, key, store)
+						}
+					}
 			}
 		} else {
 			;[dependency] = params

package/internal/src/store/deposit.ts

@@ -1,6 +1,5 @@
 import type {
 	AtomToken,
-	Func,
 	MoleculeFamily,
 	MoleculeFamilyToken,
 	MoleculeToken,
@@ -17,6 +16,7 @@ import type { Json } from "atom.io/json"
 
 import type {
 	Atom,
+	Func,
 	Molecule,
 	MutableAtom,
 	ReadableState,

package/internal/src/store/store.ts

@@ -1,6 +1,5 @@
 import type {
 	AtomToken,
-	Func,
 	Logger,
 	MoleculeFamily,
 	MoleculeToken,
@@ -19,6 +18,7 @@ import { Junction } from "~/packages/rel8/junction/src"
 
 import type {
 	Atom,
+	Func,
 	Molecule,
 	ReadonlySelector,
 	Tracker,
@@ -195,15 +195,14 @@ export class Store implements Lineage {
 }
 
 export const IMPLICIT = {
-	STORE_INTERNAL: undefined as Store | undefined,
 	get STORE(): Store {
-		return (
-			this.STORE_INTERNAL ??
-			(this.STORE_INTERNAL = new Store({
+		if (!globalThis.ATOM_IO_IMPLICIT_STORE) {
+			globalThis.ATOM_IO_IMPLICIT_STORE = new Store({
 				name: `IMPLICIT_STORE`,
 				lifespan: `ephemeral`,
-			}))
-		)
+			})
+		}
+		return globalThis.ATOM_IO_IMPLICIT_STORE as Store
 	},
 }
 

package/internal/src/store/withdraw.ts

@@ -2,7 +2,6 @@ import type {
 	AtomFamily,
 	AtomFamilyToken,
 	AtomToken,
-	Func,
 	MoleculeConstructor,
 	MoleculeFamily,
 	MoleculeFamilyToken,
@@ -36,6 +35,7 @@ import { type Json, stringifyJson } from "atom.io/json"
 
 import type {
 	Atom,
+	Func,
 	Molecule,
 	MutableAtom,
 	ReadableState,

package/internal/src/subscribe/subscribe-to-transaction.ts

@@ -1,6 +1,6 @@
-import type { Func, TransactionToken, TransactionUpdateHandler } from "atom.io"
+import type { TransactionToken, TransactionUpdateHandler } from "atom.io"
 
-import type { Store } from ".."
+import type { Func, Store } from ".."
 import { withdraw } from ".."
 
 export const subscribeToTransaction = <F extends Func>(

package/internal/src/timeline/create-timeline.ts

@@ -2,8 +2,6 @@ import type {
 	AtomFamilyToken,
 	AtomToken,
 	FamilyMetadata,
-	Flat,
-	Func,
 	MoleculeConstructor,
 	MoleculeCreation,
 	MoleculeDisposal,
@@ -27,6 +25,7 @@ import { newest } from "../lineage"
 import { getUpdateToken } from "../mutable"
 import { type Store, withdraw } from "../store"
 import { Subject } from "../subject"
+import type { Flat, Func } from "../utility-types"
 
 export type TimelineAtomUpdate<ManagedAtom extends TimelineManageable> = Flat<
 	StateUpdate<TokenType<ManagedAtom>> & {

package/internal/src/transaction/act-upon-store.ts

@@ -1,8 +1,9 @@
-import type { Func, TransactionToken } from "atom.io"
+import type { TransactionToken } from "atom.io"
 
 import { NotFoundError } from "../not-found-error"
 import type { Store } from "../store"
 import { withdraw } from "../store"
+import type { Func } from "../utility-types"
 
 export function actUponStore<F extends Func>(
 	token: TransactionToken<F>,

package/internal/src/transaction/apply-transaction.ts

@@ -1,9 +1,8 @@
-import type { Func } from "atom.io"
-
 import { ingestTransactionUpdate } from "../ingest-updates"
 import { newest } from "../lineage"
 import type { Store } from "../store"
 import { withdraw } from "../store"
+import type { Func } from "../utility-types"
 import { isChildStore, isRootStore } from "./is-root-store"
 import { setEpochNumberOfAction } from "./set-epoch-number"
 

package/internal/src/transaction/build-transaction.ts

@@ -1,4 +1,4 @@
-import type { disposeState, Func, getState, setState } from "atom.io"
+import type { disposeState, getState, setState } from "atom.io"
 import type { findState } from "atom.io/ephemeral"
 import type { seekState } from "atom.io/immortal"
 
@@ -14,6 +14,7 @@ import { makeMoleculeInStore } from "../molecule"
 import { getJsonToken } from "../mutable"
 import { setIntoStore } from "../set-state"
 import type { Store } from "../store"
+import type { Func } from "../utility-types"
 import type { TransactionProgress } from "."
 import { actUponStore, getEpochNumberOfAction } from "."
 import type { ChildStore, RootStore } from "./is-root-store"

package/internal/src/transaction/create-transaction.ts

@@ -1,5 +1,4 @@
 import type {
-	Func,
 	TransactionOptions,
 	TransactionToken,
 	TransactionUpdate,
@@ -9,6 +8,7 @@ import { newest } from "../lineage"
 import type { Store } from "../store"
 import { deposit } from "../store"
 import { Subject } from "../subject"
+import type { Func } from "../utility-types"
 import { abortTransaction } from "./abort-transaction"
 import { applyTransaction } from "./apply-transaction"
 import { buildTransaction } from "./build-transaction"

package/internal/src/transaction/index.ts

@@ -1,6 +1,8 @@
-import type { ActorToolkit, Func, TransactionUpdate } from "atom.io"
+import type { ActorToolkit, TransactionUpdate } from "atom.io"
 import type { Junction } from "rel8/junction"
 
+import type { Func } from "../utility-types"
+
 export * from "./abort-transaction"
 export * from "./act-upon-store"
 export * from "./apply-transaction"

package/internal/src/transaction/is-root-store.ts

@@ -1,6 +1,5 @@
-import type { Func } from "atom.io"
-
 import type { Store } from "../store"
+import type { Func } from "../utility-types"
 import type { TransactionEpoch, TransactionProgress } from "."
 
 export interface RootStore extends Store {

package/internal/src/utility-types.ts

@@ -0,0 +1,5 @@
+export type Func = (...parameters: any[]) => any
+
+export type Flat<R extends { [K in PropertyKey]: any }> = {
+	[K in keyof R]: R[K]
+}

package/introspection/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { AtomToken, SelectorToken, ReadonlySelectorToken, TransactionToken, Func, ReadonlySelectorFamilyToken, TransactionUpdate, TimelineToken, ReadableToken } from 'atom.io';
+import { AtomToken, SelectorToken, ReadonlySelectorToken, TransactionToken, ReadonlySelectorFamilyToken, TransactionUpdate, TimelineToken, ReadableToken } from 'atom.io';
 import * as Internal from 'atom.io/internal';
-import { Timeline } from 'atom.io/internal';
+import { Func, Timeline } from 'atom.io/internal';
 
 type AtomTokenIndex = WritableTokenIndex<AtomToken<unknown>>;
 

package/introspection/src/attach-introspection-states.ts

@@ -1,12 +1,11 @@
 import type {
-	Func,
 	ReadonlySelectorFamilyToken,
 	ReadonlySelectorToken,
 	TimelineToken,
 	TransactionToken,
 	TransactionUpdate,
 } from "atom.io"
-import type { Timeline } from "atom.io/internal"
+import type { Func, Timeline } from "atom.io/internal"
 import * as Internal from "atom.io/internal"
 
 import { type AtomTokenIndex, attachAtomIndex } from "./attach-atom-index"

package/introspection/src/attach-transaction-index.ts

@@ -1,5 +1,5 @@
-import type { Func, ReadonlySelectorToken, TransactionToken } from "atom.io"
-import type { Store } from "atom.io/internal"
+import type { ReadonlySelectorToken, TransactionToken } from "atom.io"
+import type { Func, Store } from "atom.io/internal"
 import {
 	createRegularAtom,
 	createStandaloneSelector,

package/introspection/src/attach-transaction-logs.ts

@@ -1,9 +1,5 @@
-import type {
-	Func,
-	ReadonlySelectorFamilyToken,
-	TransactionUpdate,
-} from "atom.io"
-import type { Store } from "atom.io/internal"
+import type { ReadonlySelectorFamilyToken, TransactionUpdate } from "atom.io"
+import type { Func, Store } from "atom.io/internal"
 import {
 	createRegularAtomFamily,
 	createSelectorFamily,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.25.3",
+  "version": "0.25.5",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -49,43 +49,42 @@
   },
   "devDependencies": {
     "@testing-library/react": "16.0.0",
-    "@types/eslint": "npm:@types/eslint@8.56.10",
-    "@types/eslint-v9": "npm:@types/eslint@8.56.10",
+    "@types/eslint": "npm:@types/eslint@9.6.0",
+    "@types/eslint-v9": "npm:@types/eslint@9.6.0",
     "@types/estree": "1.0.5",
     "@types/http-proxy": "1.17.14",
     "@types/npmlog": "7.0.0",
     "@types/react": "18.3.3",
     "@types/tmp": "0.2.6",
-    "@typescript-eslint/parser": "7.15.0",
-    "@typescript-eslint/rule-tester": "7.15.0",
-    "@vitest/coverage-v8": "1.6.0",
-    "@vitest/ui": "1.6.0",
+    "@typescript-eslint/parser": "7.17.0",
+    "@typescript-eslint/rule-tester": "7.17.0",
+    "@vitest/coverage-v8": "2.0.4",
+    "@vitest/ui": "2.0.4",
     "concurrently": "8.2.2",
-    "drizzle-kit": "0.22.8",
-    "drizzle-orm": "0.31.2",
+    "drizzle-kit": "0.23.0",
+    "drizzle-orm": "0.32.1",
     "eslint": "npm:eslint@8.57.0",
-    "eslint-v9": "npm:eslint@9.6.0",
-    "framer-motion": "11.2.12",
+    "eslint-v9": "npm:eslint@9.7.0",
+    "framer-motion": "11.3.17",
     "happy-dom": "14.12.3",
     "http-proxy": "1.18.1",
     "npmlog": "7.0.1",
     "postgres": "3.4.4",
-    "preact": "10.22.1",
+    "preact": "10.23.1",
     "react": "18.3.1",
     "react-dom": "18.3.1",
-    "react-router-dom": "6.24.0",
+    "react-router-dom": "6.25.1",
     "socket.io": "4.7.5",
     "socket.io-client": "4.7.5",
     "tmp": "0.2.3",
-    "tsup": "8.1.0",
-    "typescript": "5.5.3",
-    "vite": "5.3.2",
+    "tsup": "8.2.3",
+    "typescript": "5.5.4",
+    "vite": "5.3.4",
     "vite-tsconfig-paths": "4.3.2",
-    "vitest": "1.6.0"
+    "vitest": "2.0.4"
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "module": "dist/index.mjs",
   "files": [
     "dist",
     "src",
@@ -252,7 +251,7 @@
   "scripts": {
     "manifest": "tsx __scripts__/manifest-build.node.ts",
     "clean:build": "find . -type d -name 'dist' -not -path '*/node_modules/*' | xargs rm -rf",
-    "build": "bun run clean:build && concurrently \"npm:build:*\"",
+    "build": "bun run clean:build && concurrently \"bun:build:*\"",
     "build:main": "tsup",
     "build:types": "tsup --dts",
     "build:data": "cd data && tsup",

package/react-devtools/dist/index.d.ts

@@ -61,8 +61,8 @@ declare const AtomIODevtools: () => JSX.Element;
 
 declare const atomIndex: atom_io.ReadonlySelectorToken<AtomTokenIndex>;
 declare const selectorIndex: atom_io.ReadonlySelectorToken<SelectorTokenIndex>;
-declare const transactionIndex: atom_io.ReadonlySelectorToken<atom_io.TransactionToken<atom_io.Func>[]>;
-declare const findTransactionLogState: atom_io.ReadonlySelectorFamilyToken<atom_io.TransactionUpdate<atom_io.Func>[], string>;
+declare const transactionIndex: atom_io.ReadonlySelectorToken<atom_io.TransactionToken<Internal.Func>[]>;
+declare const findTransactionLogState: atom_io.ReadonlySelectorFamilyToken<atom_io.TransactionUpdate<Internal.Func>[], string>;
 declare const timelineIndex: atom_io.ReadonlySelectorToken<atom_io.TimelineToken<any>[]>;
 declare const findTimelineState: atom_io.ReadonlySelectorFamilyToken<Internal.Timeline<any>, string>;
 declare const devtoolsAreOpenState: atom_io.RegularAtomToken<boolean>;

package/react-devtools/src/TransactionIndex.tsx

@@ -1,11 +1,11 @@
 import type {
-	Func,
 	ReadonlySelectorToken,
 	RegularAtomToken,
 	TransactionToken,
 	TransactionUpdate,
 } from "atom.io"
 import { findState } from "atom.io/ephemeral"
+import type { Func } from "atom.io/internal"
 import { useI, useO } from "atom.io/react"
 import type { FC } from "react"
 

package/react-devtools/src/Updates.tsx

@@ -1,9 +1,9 @@
 import type {
-	Func,
 	KeyedStateUpdate,
 	TimelineUpdate,
 	TransactionUpdate,
 } from "atom.io"
+import type { Func } from "atom.io/internal"
 import * as React from "react"
 
 import { discoverType } from "~/packages/anvl/src/refinement/refinery"

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

@@ -1,6 +1,6 @@
 import * as AtomIO from 'atom.io';
 import * as Internal from 'atom.io/internal';
-import { Store, Transceiver } from 'atom.io/internal';
+import { Store, Transceiver, Func } from 'atom.io/internal';
 import { Json } from 'atom.io/json';
 import { Socket } from 'socket.io-client';
 import { ContinuityToken } from 'atom.io/realtime';
@@ -26,8 +26,8 @@ declare const myUsernameState: AtomIO.RegularAtomToken<string | null>;
 declare const optimisticUpdateQueue: AtomIO.RegularAtomToken<AtomIO.TransactionUpdate<any>[]>;
 declare const confirmedUpdateQueue: AtomIO.RegularAtomToken<AtomIO.TransactionUpdate<any>[]>;
 
-declare function serverAction<F extends AtomIO.Func>(token: AtomIO.TransactionToken<F>, socket: Socket, store: Internal.Store): () => void;
+declare function serverAction<F extends Internal.Func>(token: AtomIO.TransactionToken<F>, socket: Socket, store: Internal.Store): () => void;
 
-declare function syncContinuity<F extends AtomIO.Func>(continuity: ContinuityToken, socket: Socket, store: Store): () => void;
+declare function syncContinuity<F extends Func>(continuity: ContinuityToken, socket: Socket, store: Store): () => void;
 
 export { confirmedUpdateQueue, myIdState, myIdState__INTERNAL, myUsernameState, optimisticUpdateQueue, pullAtom, pullAtomFamilyMember, pullMutableAtom, pullMutableAtomFamilyMember, pullSelector, pullSelectorFamilyMember, pushState, serverAction, syncContinuity };

package/realtime-client/src/server-action.ts

@@ -2,7 +2,7 @@ import type * as AtomIO from "atom.io"
 import * as Internal from "atom.io/internal"
 import type { Socket } from "socket.io-client"
 
-export function serverAction<F extends AtomIO.Func>(
+export function serverAction<F extends Internal.Func>(
 	token: AtomIO.TransactionToken<F>,
 	socket: Socket,
 	store: Internal.Store,

package/realtime-client/src/sync-continuity.ts

@@ -1,5 +1,5 @@
 import type * as AtomIO from "atom.io"
-import type { Store } from "atom.io/internal"
+import type { Func, Store } from "atom.io/internal"
 import {
 	actUponStore,
 	assignTransactionToContinuity,
@@ -21,7 +21,7 @@ import {
 } from "atom.io/realtime-client"
 import type { Socket } from "socket.io-client"
 
-export function syncContinuity<F extends AtomIO.Func>(
+export function syncContinuity<F extends Func>(
 	continuity: ContinuityToken,
 	socket: Socket,
 	store: Store,

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

@@ -2,7 +2,7 @@ import * as React from 'react';
 import { Socket } from 'socket.io-client';
 import * as AtomIO from 'atom.io';
 import { Json } from 'atom.io/json';
-import { Transceiver } from 'atom.io/internal';
+import { Transceiver, Func } from 'atom.io/internal';
 import { ContinuityToken } from 'atom.io/realtime';
 
 type RealtimeReactStore = {
@@ -32,7 +32,7 @@ declare function usePullSelectorFamilyMember<T, K extends Json.Serializable, Key
 
 declare function usePush<J extends Json.Serializable>(token: AtomIO.WritableToken<J>): <New extends J>(next: New | ((old: J) => New)) => void;
 
-declare function useServerAction<F extends AtomIO.Func>(token: AtomIO.TransactionToken<F>): (...parameters: Parameters<F>) => ReturnType<F>;
+declare function useServerAction<F extends Func>(token: AtomIO.TransactionToken<F>): (...parameters: Parameters<F>) => ReturnType<F>;
 
 declare function useSyncContinuity(token: ContinuityToken): void;
 

package/realtime-react/src/use-server-action.ts

@@ -1,4 +1,5 @@
 import type * as AtomIO from "atom.io"
+import type { Func } from "atom.io/internal"
 import { actUponStore, arbitrary } from "atom.io/internal"
 import { StoreContext } from "atom.io/react"
 import * as RTC from "atom.io/realtime-client"
@@ -6,7 +7,7 @@ import * as React from "react"
 
 import { useRealtimeService } from "./use-realtime-service"
 
-export function useServerAction<F extends AtomIO.Func>(
+export function useServerAction<F extends Func>(
 	token: AtomIO.TransactionToken<F>,
 ): (...parameters: Parameters<F>) => ReturnType<F> {
 	const store = React.useContext(StoreContext)

package/src/atom.ts

@@ -35,10 +35,27 @@ export type MutableAtomOptions<T extends Transceiver<any>, J extends Json.Serial
 			mutable: true
 		}
 
+/**
+ * @public
+ * Declare a mutable global reactive variable.
+ * @param options - Configuration for this mutable atom.
+ * @returns
+ * The token for your mutable atom.
+ * @overload Mutable
+ */
 export function atom<T extends Transceiver<any>, J extends Json.Serializable>(
 	options: MutableAtomOptions<T, J>,
 ): MutableAtomToken<T, J>
+/**
+ * @public
+ * Declare a regular global reactive variable.
+ * @param options - Configuration for this regular atom.
+ * @returns
+ * The token for your regular atom.
+ * @overload Regular
+ */
 export function atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T>
+
 export function atom(
 	options: MutableAtomOptions<any, any> | RegularAtomOptions<any>,
 ): AtomToken<any> {

package/src/index.ts

@@ -22,12 +22,6 @@ export * from "./timeline"
 export * from "./transaction"
 export * from "./validators"
 
-export type Func = (...parameters: any[]) => any
-
-export type Flat<R extends { [K in PropertyKey]: any }> = {
-	[K in keyof R]: R[K]
-}
-
 export type RegularAtomToken<T> = {
 	key: string
 	type: `atom`

package/src/molecule.ts

@@ -1,6 +1,5 @@
 import type {
 	ActorToolkit,
-	Flat,
 	MoleculeCreation,
 	MoleculeDisposal,
 	MutableAtomFamilyToken,
@@ -17,7 +16,7 @@ import type {
 	WritableToken,
 } from "atom.io"
 import type { JoinToken } from "atom.io/data"
-import type { Store, Subject, Transceiver } from "atom.io/internal"
+import type { Flat, Store, Subject, Transceiver } from "atom.io/internal"
 import {
 	createMoleculeFamily,
 	IMPLICIT,
@@ -92,7 +91,7 @@ export type MoleculeFamily<M extends MoleculeConstructor> = Flat<
 	}
 >
 export type MoleculeToken<M extends MoleculeConstructor> = {
-	key: MK<M>
+	key: MoleculeKey<M>
 	type: `molecule`
 	family?: MoleculeFamilyToken<M>
 	__M?: M
@@ -120,7 +119,6 @@ export type MoleculeType<T extends MoleculeFamilyToken<any>> =
 			? M
 			: never
 export type MoleculeKey<M extends MoleculeConstructor> = InstanceType<M>[`key`]
-export type MK<M extends MoleculeConstructor> = MoleculeKey<M>
 
 export function makeRootMolecule(
 	key: string,

package/src/set-state.ts

@@ -3,11 +3,27 @@ import type { Json } from "rel8"
 
 import type { WritableFamilyToken, WritableToken } from "."
 
+/**
+ * @public
+ * Set the value of a state into the implicit store.
+ * @param token - The unique identifier of the state to set.
+ * @param value - The new value of the state.
+ * @overload Default
+ * @default
+ */
 export function setState<T, New extends T>(
 	token: WritableToken<T>,
 	value: New | ((oldValue: T) => New),
 ): void
 
+/**
+ * @public
+ * Set the value of a state into the implicit store.
+ * @param token - The unique identifier of a state family.
+ * @param key - The key of the state to set.
+ * @param value - The new value of the state.
+ * @overload Streamlined
+ */
 export function setState<T, K extends Json.Serializable, New extends T>(
 	token: WritableFamilyToken<T, K>,
 	key: K,

package/src/silo.ts

@@ -2,6 +2,7 @@ import type { findState } from "atom.io/ephemeral"
 import type { Transceiver } from "atom.io/internal"
 import {
 	createAtomFamily,
+	createMoleculeFamily,
 	createSelectorFamily,
 	createStandaloneAtom,
 	createStandaloneSelector,
@@ -10,6 +11,7 @@ import {
 	disposeFromStore,
 	findInStore,
 	getFromStore,
+	makeMoleculeInStore,
 	setIntoStore,
 	Store,
 	timeTravel,
@@ -20,6 +22,8 @@ import type {
 	AtomToken,
 	disposeState,
 	getState,
+	makeMolecule,
+	moleculeFamily,
 	MutableAtomFamily,
 	MutableAtomFamilyOptions,
 	MutableAtomOptions,
@@ -53,6 +57,8 @@ export class Silo {
 	public subscribe: typeof subscribe
 	public undo: typeof undo
 	public redo: typeof redo
+	public moleculeFamily: typeof moleculeFamily
+	public makeMolecule: typeof makeMolecule
 	public constructor(config: Store[`config`], fromStore: Store | null = null) {
 		const s = new Store(config, fromStore)
 		function _atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T>
@@ -102,5 +108,11 @@ export class Silo {
 		this.redo = (token) => {
 			timeTravel(`redo`, token, s)
 		}
+		this.moleculeFamily = ((...params: Parameters<typeof moleculeFamily>) => {
+			return createMoleculeFamily(...params, s)
+		}) as any
+		this.makeMolecule = ((...params: Parameters<typeof makeMolecule>) => {
+			return makeMoleculeInStore(s, ...params)
+		}) as any
 	}
 }

package/src/subscribe.ts

@@ -1,4 +1,4 @@
-import type { Store } from "atom.io/internal"
+import type { Flat, Func, Store } from "atom.io/internal"
 import {
 	arbitrary,
 	IMPLICIT,
@@ -9,8 +9,6 @@ import {
 
 import type {
 	FamilyMetadata,
-	Flat,
-	Func,
 	ReadableToken,
 	TimelineManageable,
 	TimelineToken,

package/src/transaction.ts

@@ -9,7 +9,7 @@ import type {
 } from "atom.io"
 import type { findState } from "atom.io/ephemeral"
 import type { seekState } from "atom.io/immortal"
-import type { EnvironmentData, Transceiver } from "atom.io/internal"
+import type { EnvironmentData, Func, Transceiver } from "atom.io/internal"
 import {
 	actUponStore,
 	arbitrary,
@@ -20,11 +20,9 @@ import type { Json } from "atom.io/json"
 
 import type {
 	disposeState,
-	Func,
 	KeyedStateUpdate,
 	MutableAtomToken,
 	ReadableToken,
-	ReadonlySelectorToken,
 	TokenType,
 	WritableSelectorToken,
 	WritableToken,