atom.io 0.25.2 → 0.25.4

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 {
@@ -404,12 +435,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 +473,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/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

@@ -2065,13 +2065,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

@@ -1790,13 +1790,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/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,