atom.io 0.30.7 → 0.31.1

package/internal/dist/index.d.ts

@@ -1,8 +1,6 @@
-import * as atom_io from 'atom.io';
-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, MoleculeFamilyOptions, StateCreation, StateDisposal, MoleculeParams, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, TimelineToken, MoleculeCreationModern, MoleculeDisposalModern, AtomIOLogger, Logger, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, KeyedStateUpdate, ReadonlySelectorOptions, WritableSelectorOptions, SetterToolkit, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
-import { Json, Canonical, JsonInterface } from 'atom.io/json';
+import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, AtomFamilyToken, AtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, SelectorFamilyToken, SelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, ReadableToken, TransactionToken, TransactionUpdate, TransactionOptions, ActorToolkit, TimelineManageable, TimelineToken, AtomIOToken, Hierarchy, Vassal, Above, Claim, CompoundFrom, CompoundTypedKey, SingularTypedKey, StateUpdate, TokenType, FamilyMetadata, StateCreation, StateDisposal, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, AtomIOLogger, Logger, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, KeyedStateUpdate, MoleculeTransfer, ReadonlySelectorOptions, WritableSelectorOptions, SetterToolkit, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
+import { Json, Canonical, stringified, JsonInterface } from 'atom.io/json';
 import { Join } from 'atom.io/data';
-import { Refinement } from 'atom.io/introspection';
 import { Store as Store$1, Func as Func$1 } from 'atom.io/internal';
 
 declare class CircularBuffer<T> {
@@ -31,7 +29,21 @@ declare function counterfeit<T, K extends Canonical, Key extends K>(token: Reado
 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 Func = (...parameters: any[]) => any;
+type Flat<R extends {
+    [K in PropertyKey]: any;
+}> = {
+    [K in keyof R]: R[K];
+};
+type Count<N extends number, A extends any[] = []> = [
+    ...A,
+    any
+][`length`] extends N ? A[`length`] : A[`length`] | Count<N, [...A, any]>;
+type Each<E extends any[]> = {
+    [P in Count<E[`length`]>]: E[P];
+};
+type Refinement<A, B extends A> = (a: A) => a is B;
 
 type JunctionEntriesBase<AType extends string, BType extends string, Content extends Json.Object | null> = {
     readonly relations: ([AType, BType[]] | [BType, AType[]])[];
@@ -128,20 +140,6 @@ declare class Junction<const ASide extends string, const AType extends string, c
     has(b: BType, a?: AType): boolean;
 }
 
-type Func = (...parameters: any[]) => any;
-type Flat<R extends {
-    [K in PropertyKey]: any;
-}> = {
-    [K in keyof R]: R[K];
-};
-type Count<N extends number, A extends any[] = []> = [
-    ...A,
-    any
-][`length`] extends N ? A[`length`] : A[`length`] | Count<N, [...A, any]>;
-type Each<E extends any[]> = {
-    [P in Count<E[`length`]>]: E[P];
-};
-
 declare const abortTransaction: (store: Store) => void;
 
 declare function actUponStore<F extends Func>(token: TransactionToken<F>, id: string, store: Store): (...parameters: Parameters<F>) => ReturnType<F>;
@@ -222,49 +220,26 @@ declare function deposit<T>(state: ReadonlySelectorFamily<T, any>): ReadonlySele
 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(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>;
+declare function deposit<M extends TimelineManageable>(state: Timeline<M>): TimelineToken<M>;
+declare function deposit(resource: AtomIOInternalResource): AtomIOToken;
 
 interface Lineage {
     parent: typeof this | null;
     child: typeof this | null;
 }
 declare function newest<T extends Lineage>(scion: T): T;
-declare function eldest<T extends Lineage>(scion: T): T;
-
-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;
-
-declare class Molecule<M extends MoleculeConstructor> implements MoleculeToken<M> {
-    readonly key: MoleculeKey<M>;
-    readonly type = "molecule";
-    stringKey: string;
-    family?: MoleculeFamilyToken<M>;
-    _dependsOn: `all` | `any`;
-    get dependsOn(): `all` | `any`;
-    readonly subject: Subject<StateCreation<any> | StateDisposal<any>>;
-    tokens: Map<string, ReadableToken<any>>;
-    above: Map<string, Molecule<any>>;
-    below: Map<string, Molecule<any>>;
-    joins: Map<string, Join<any, any, any, any, any, any>>;
-    instance: InstanceType<M>;
-    constructor(ctx: 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, 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>;
-declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: ReadonlySelectorFamilyToken<T, K>, store: Store): ReadonlySelectorToken<T>;
-declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: SelectorFamilyToken<T, K>, store: Store): SelectorToken<T>;
-declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: WritableFamilyToken<T, K>, store: Store): WritableToken<T>;
-declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: ReadableFamilyToken<T, K>, store: Store): ReadableToken<T>;
 
-declare function makeMoleculeInStore<M extends MoleculeConstructor>(store: Store, context: MoleculeToken<M> | MoleculeToken<M>[], familyToken: MoleculeFamilyToken<M>, key: MoleculeKey<M>, ...params: MoleculeParams<M>): MoleculeToken<M>;
+type Molecule<K extends Canonical> = {
+    readonly key: K;
+    readonly stringKey: stringified<K>;
+    readonly dependsOn: `all` | `any`;
+};
+declare function makeRootMoleculeInStore<S extends string>(key: S, store?: Store): S;
+declare function allocateIntoStore<H extends Hierarchy, V extends Vassal<H>, A extends Above<V, H>>(store: Store, provenance: A, key: V, dependsOn?: `all` | `any`): Claim<V>;
+declare function fuseWithinStore<H extends Hierarchy, C extends CompoundFrom<H>, T extends C extends CompoundTypedKey<infer t, any, any> ? t : never, A extends C extends CompoundTypedKey<any, infer a, any> ? a : never, B extends C extends CompoundTypedKey<any, any, infer b> ? b : never>(store: Store, type: T, sideA: SingularTypedKey<A>, sideB: SingularTypedKey<B>): Claim<CompoundTypedKey<T, A, B>>;
+declare function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(store: Store, claim: Claim<V>): void;
+declare function claimWithinStore<H extends Hierarchy, V extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V, H>>(store: Store, newProvenance: A, claim: Claim<V>, exclusive?: `exclusive`): Claim<V>;
 
 type OperationProgress = {
     open: false;
@@ -303,7 +278,7 @@ type TimelineStateCreation<T extends ReadableToken<any>> = Flat<StateCreation<T>
 type TimelineStateDisposal<T extends ReadableToken<any>> = Flat<StateDisposal<T> & {
     timestamp: number;
 }>;
-type TimelineMoleculeCreation<M extends MoleculeConstructor> = Flat<MoleculeCreation<M> & {
+type TimelineMoleculeCreation = Flat<MoleculeCreation & {
     timestamp: number;
 }>;
 type TimelineMoleculeDisposal = Flat<MoleculeDisposal & {
@@ -340,7 +315,8 @@ declare class Store implements Lineage {
         source: string;
     }>;
     trackers: Map<string, Tracker<Transceiver<any>>>;
-    families: Map<string, MutableAtomFamily<any, any, any> | ReadonlySelectorFamily<any, any> | RegularAtomFamily<any, any> | WritableSelectorFamily<any, any>>;
+    families: Map<string, MutableAtomFamily<any, any, any> | RegularAtomFamily<any, any> | ReadonlySelectorFamily<any, any> | WritableSelectorFamily<any, any>>;
+    joins: Map<string, Join<any, any, any, any, any, any, `T$--content==${any}::${string}++${any}::${string}`>>;
     transactions: Map<string, Transaction<Func>>;
     transactionMeta: TransactionEpoch | TransactionProgress<Func>;
     timelines: Map<string, Timeline<any>>;
@@ -351,13 +327,12 @@ declare class Store implements Lineage {
         key: string;
         trace: string;
     }>;
-    molecules: Map<string, Molecule<any>>;
-    moleculeFamilies: Map<string, Flat<atom_io.MoleculeFamilyToken<any> & {
-        subject: Subject<atom_io.MoleculeCreationClassic<any> | atom_io.MoleculeDisposalClassic>;
-        dependsOn: `all` | `any`;
-        new: any;
-    }>>;
-    moleculeInProgress: string | null;
+    molecules: Map<string, Molecule<Canonical>>;
+    moleculeJoins: Junction<"moleculeKey", stringified<Canonical>, "joinKey", string, null>;
+    moleculeGraph: Junction<"upstreamMoleculeKey", stringified<Canonical> | "root", "downstreamMoleculeKey", stringified<Canonical>, {
+        source: stringified<Canonical>;
+    }>;
+    moleculeData: Junction<"moleculeKey", stringified<Canonical>, "stateFamilyKey", string, null>;
     miscResources: Map<string, Disposable>;
     on: {
         atomCreation: Subject<AtomToken<unknown>>;
@@ -368,9 +343,8 @@ declare class Store implements Lineage {
         transactionCreation: Subject<TransactionToken<Func>>;
         transactionApplying: StatefulSubject<TransactionProgress<Func> | null>;
         operationClose: Subject<OperationProgress>;
-        moleculeCreationStart: Subject<MoleculeToken<any> | MoleculeCreationModern>;
-        moleculeCreationDone: Subject<MoleculeToken<any>>;
-        moleculeDisposal: Subject<MoleculeToken<any> | MoleculeDisposalModern>;
+        moleculeCreation: Subject<MoleculeCreation>;
+        moleculeDisposal: Subject<MoleculeDisposal>;
     };
     operation: OperationProgress;
     config: {
@@ -386,7 +360,6 @@ declare const IMPLICIT: {
 };
 declare const clearStore: (store: Store) => void;
 
-type Withdrawable = Atom<any> | AtomFamily<any, any> | Molecule<any> | MoleculeFamily<any> | MutableAtom<any, any> | MutableAtomFamily<any, any, any> | ReadableFamily<any, any> | ReadableState<any> | ReadonlySelector<any> | ReadonlySelectorFamily<any, any> | RegularAtom<any> | RegularAtomFamily<any, any> | Selector<any> | SelectorFamily<any, any> | Timeline<any> | Transaction<any> | WritableFamily<any, any> | WritableSelector<any> | WritableSelectorFamily<any, any> | WritableState<any>;
 declare function withdraw<T>(token: RegularAtomToken<T>, store: Store): RegularAtom<T>;
 declare function withdraw<T extends Transceiver<any>>(token: MutableAtomToken<T, any>, store: Store): MutableAtom<T, any>;
 declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T>;
@@ -403,18 +376,18 @@ declare function withdraw<T, K extends Canonical>(token: WritableSelectorFamilyT
 declare function withdraw<T, K extends Canonical>(token: SelectorFamilyToken<T, K>, store: Store): SelectorFamily<T, any>;
 declare function withdraw<T, K extends Canonical>(token: ReadableFamilyToken<T, K>, store: Store): ReadableFamily<T, any>;
 declare function withdraw<T, K extends Canonical>(token: WritableFamilyToken<T, K>, store: Store): WritableFamily<T, any>;
-declare function withdraw<M extends MoleculeConstructor>(token: MoleculeToken<M>, store: Store): Molecule<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>;
+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(token: AtomIOToken, store: Store): AtomIOInternalResource;
 
-interface Transceiver<Signal extends Json.Serializable> {
-    do: (update: Signal) => number | `OUT_OF_RANGE` | null;
-    undo: (update: Signal) => void;
-    subscribe: (key: string, fn: (update: Signal) => void) => () => void;
+interface Transceiver<S extends Json.Serializable> {
+    do: (update: S) => number | `OUT_OF_RANGE` | null;
+    undo: (update: S) => void;
+    subscribe: (key: string, fn: (update: S) => void) => () => void;
     cacheUpdateNumber: number;
-    getUpdateNumber: (update: Signal) => number;
+    getUpdateNumber: (update: S) => number;
 }
 declare function isTransceiver(value: unknown): value is Transceiver<Json.Serializable>;
 type TransceiverMode = `playback` | `record` | `transaction`;
@@ -505,9 +478,8 @@ declare function createRegularAtomFamily<T, K extends Canonical>(store: Store, o
 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(store: Store, token: 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.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, K>;
 declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T, K>;
@@ -535,7 +507,6 @@ declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store
 declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: SelectorFamilyToken<T, K>, key: Key): SelectorToken<T, K> | undefined;
 declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableFamilyToken<T, K>, key: Key): WritableToken<T, K> | undefined;
 declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T, K> | undefined;
-declare function seekInStore<M extends MoleculeConstructor>(store: Store, token: MoleculeFamilyToken<M>, key: MoleculeKey<M>): MoleculeKey<M> | undefined;
 
 type EnvironmentData = {
     store: Store;
@@ -543,20 +514,19 @@ type EnvironmentData = {
 declare function getEnvironmentData(store: Store): EnvironmentData;
 
 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;
 
+declare function getTrace(error: Error): string;
+
 declare function ingestAtomUpdate(applying: `newValue` | `oldValue`, atomUpdate: KeyedStateUpdate<any>, store: Store): void;
 
 declare function ingestCreationEvent(update: StateCreation<any>, applying: `newValue` | `oldValue`, store: Store): void;
 declare function ingestDisposalEvent(update: StateDisposal<ReadableToken<any>>, applying: `newValue` | `oldValue`, store: Store): void;
-declare function ingestMoleculeCreationEvent(update: MoleculeCreation<any>, applying: `newValue` | `oldValue`, store: Store): void;
+declare function ingestMoleculeCreationEvent(update: MoleculeCreation, applying: `newValue` | `oldValue`, store: Store): void;
 declare function ingestMoleculeDisposalEvent(update: MoleculeDisposal, applying: `newValue` | `oldValue`, store: Store): void;
+declare function ingestMoleculeTransferEvent(update: MoleculeTransfer, applying: `newValue` | `oldValue`, store: Store): void;
 
 declare function ingestSelectorUpdate(applying: `newValue` | `oldValue`, selectorUpdate: TimelineSelectorUpdate<any>, store: Store): void;
 
@@ -591,14 +561,12 @@ declare class LazyMap<K, V> extends Map<K, V> {
     delete(key: K): boolean;
 }
 
-type AtomIOToken = MoleculeFamilyToken<any> | MoleculeToken<any> | ReadableFamilyToken<any, any> | ReadableToken<any> | TimelineToken<any> | TransactionToken<any>;
-declare function prettyPrintTokenType(token: AtomIOToken): string;
-
 declare class NotFoundError extends Error {
     constructor(token: AtomIOToken, store: Store);
-    constructor(familyToken: AtomIOToken, key: Json.Serializable, store: Store);
 }
 
+declare function prettyPrintTokenType(token: AtomIOToken): string;
+
 declare const createReadonlySelector: <T>(store: Store, options: ReadonlySelectorOptions<T>, family: FamilyMetadata | undefined) => ReadonlySelectorToken<T>;
 
 declare function createStandaloneSelector<T>(store: Store, options: WritableSelectorOptions<T>): WritableSelectorToken<T>;
@@ -700,5 +668,6 @@ type ReadonlySelectorFamily<T, K extends Canonical> = ReadonlySelectorFamilyToke
 type SelectorFamily<T, K extends Canonical> = ReadonlySelectorFamily<T, K> | WritableSelectorFamily<T, K>;
 type WritableFamily<T, K extends Canonical> = AtomFamily<T, K> | WritableSelectorFamily<T, K>;
 type ReadableFamily<T, K extends Canonical> = AtomFamily<T, K> | SelectorFamily<T, K>;
+type AtomIOInternalResource = ReadableFamily<any, any> | ReadableState<any> | Timeline<any> | Transaction<any>;
 
-export { type Atom, type AtomFamily, type AtomIOState, type AtomIOToken, type AtomKey, type BaseExternalStoreConfiguration, type ChildStore, CircularBuffer, type Count, type Each, type Empty, type EnvironmentData, type ExternalStoreConfiguration, type ExternalStoreWithContentConfiguration, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, type Flat, type Func, Future, IMPLICIT, Junction, type JunctionAdvancedConfiguration, type JunctionEntries, type JunctionEntriesBase, type JunctionJSON, type JunctionSchema, type JunctionSchemaBase, LazyMap, type Lineage, type Modify, Molecule, type MutableAtom, type MutableAtomFamily, NotFoundError, type OperationProgress, 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 };
+export { type Atom, type AtomFamily, type AtomIOInternalResource, type AtomIOState, type AtomKey, type BaseExternalStoreConfiguration, type ChildStore, CircularBuffer, type Count, type Each, type Empty, type EnvironmentData, type ExternalStoreConfiguration, type ExternalStoreWithContentConfiguration, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, type Flat, type Func, Future, IMPLICIT, Junction, type JunctionAdvancedConfiguration, type JunctionEntries, type JunctionEntriesBase, type JunctionJSON, type JunctionSchema, type JunctionSchemaBase, LazyMap, type Lineage, type Modify, type Molecule, type MutableAtom, type MutableAtomFamily, NotFoundError, type OperationProgress, type ReadableFamily, type ReadableState, type ReadonlySelector, type ReadonlySelectorFamily, type ReadonlySelectorKey, type Refinement, type RegularAtom, type RegularAtomFamily, type RootStore, type Selector, type SelectorFamily, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineMoleculeCreation, type TimelineMoleculeDisposal, type TimelineSelectorUpdate, type TimelineStateCreation, type TimelineStateDisposal, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type WritableFamily, type WritableSelector, type WritableSelectorFamily, type WritableState, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, evictCachedValue, findInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };

package/internal/dist/index.js

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

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

@@ -1,28 +1,39 @@
-import type { AtomToken } from "atom.io"
+import type { AtomDisposal, AtomToken } from "atom.io"
 
 import type { Store } from ".."
 import { getUpdateToken, isChildStore, newest, withdraw } from ".."
 
 export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 	const target = newest(store)
-	const { key } = atomToken
+	const { key, family } = atomToken
 	const atom = withdraw(atomToken, target)
-	if (!atom.family) {
+	if (!family) {
 		store.logger.error(`❌`, `atom`, key, `Standalone atoms cannot be disposed.`)
 	} else {
 		atom.cleanup?.()
 		const lastValue = store.valueMap.get(atom.key)
-		const family = withdraw({ key: atom.family.key, type: `atom_family` }, store)
-		family.subject.next({
+		const atomFamily = withdraw({ key: family.key, type: `atom_family` }, store)
+
+		const disposal: AtomDisposal<AtomToken<unknown>> = {
 			type: `state_disposal`,
+			subType: `atom`,
 			token: atomToken,
 			value: lastValue,
-		})
-
-		const molecule = target.molecules.get(atom.family.subKey)
-		if (molecule) {
-			molecule.tokens.delete(key)
 		}
+
+		atomFamily.subject.next(disposal)
+
+		const isChild = isChildStore(target)
+		// let molecule = target.molecules.get(family.subKey)
+		// if (molecule && isChild) {
+		// 	const parentMolecule = target.parent.molecules.get(family.subKey)
+		// 	if (parentMolecule === molecule) {
+		// 		molecule = parentMolecule.copy()
+		// 		target.molecules.set(family.subKey, molecule)
+		// 	}
+		// }
+		// molecule?.tokens.delete(family.key)
+
 		target.atoms.delete(key)
 		target.valueMap.delete(key)
 		target.selectorAtoms.delete(key)
@@ -35,11 +46,16 @@ export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 			store.trackers.delete(key)
 		}
 		store.logger.info(`🔥`, `atom`, key, `deleted`)
-		if (isChildStore(target) && target.transactionMeta.phase === `building`) {
-			target.transactionMeta.update.updates.push({
-				type: `state_disposal`,
-				token: atomToken,
-			})
+		if (isChild && target.transactionMeta.phase === `building`) {
+			const mostRecentUpdate = target.transactionMeta.update.updates.at(-1)
+			const wasMoleculeDisposal = mostRecentUpdate?.type === `molecule_disposal`
+			const updateAlreadyCaptured =
+				wasMoleculeDisposal &&
+				mostRecentUpdate.values.some(([k]) => k === atom.family?.key)
+
+			if (!updateAlreadyCaptured) {
+				target.transactionMeta.update.updates.push(disposal)
+			}
 		} else {
 			store.on.atomDisposal.next(atomToken)
 		}

package/internal/src/families/dispose-from-store.ts

@@ -1,24 +1,13 @@
-import type {
-	MoleculeConstructor,
-	MoleculeFamilyToken,
-	MoleculeKey,
-	MoleculeToken,
-	ReadableFamilyToken,
-	ReadableToken,
-} from "atom.io"
+import type { ReadableFamilyToken, ReadableToken } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
 import { disposeAtom } from "../atom"
-import { disposeMolecule } from "../molecule/dispose-molecule"
+import { getTrace } from "../get-trace"
 import { disposeSelector } from "../selector"
-import { counterfeit, type Store, withdraw } from "../store"
+import { type Store, withdraw } from "../store"
 import { findInStore } from "./find-in-store"
-import { seekInStore } from "./seek-in-store"
 
-export function disposeFromStore(
-	store: Store,
-	token: MoleculeToken<any> | ReadableToken<any>,
-): void
+export function disposeFromStore(store: Store, token: ReadableToken<any>): void
 
 export function disposeFromStore<K extends Canonical>(
 	store: Store,
@@ -26,47 +15,35 @@ export function disposeFromStore<K extends Canonical>(
 	key: K,
 ): void
 
-export function disposeFromStore<M extends MoleculeConstructor>(
-	store: Store,
-	token: MoleculeFamilyToken<M>,
-	key: MoleculeKey<M>,
-): void
-
 export function disposeFromStore(
 	store: Store,
 	...params:
-		| [token: MoleculeFamilyToken<any>, key: MoleculeKey<any>]
-		| [token: MoleculeToken<any> | ReadableToken<any>]
 		| [token: ReadableFamilyToken<any, any>, key: Canonical]
+		| [token: ReadableToken<any>]
 ): void {
-	let token: MoleculeToken<any> | ReadableToken<any>
-	let fullKey: string
+	let token: ReadableToken<any>
 	if (params.length === 1) {
 		token = params[0]
-		fullKey = token.key
 	} else {
 		const family = params[0]
 		const key = params[1]
-		const maybeToken =
-			family.type === `molecule_family`
-				? (seekInStore(store, family, key) ?? counterfeit(family, key))
-				: findInStore(store, family, key)
+		const maybeToken = findInStore(store, family, key)
 		token = maybeToken
 	}
 	try {
 		withdraw(token, store)
 	} catch (thrown) {
-		const disposal = store.disposalTraces.buffer.find(
-			(item) => item?.key === token.key,
-		)
+		// const disposal = store.disposalTraces.buffer.find(
+		// 	(item) => item?.key === token.key,
+		// )
 		store.logger.error(
 			`❌`,
 			token.type,
 			token.key,
 			`could not be disposed because it was not found in the store "${store.config.name}".`,
-			disposal
-				? `\n   This state was most recently disposed\n${disposal.trace}`
-				: `No previous disposal trace was found.`,
+			// disposal
+			// 	? `\n   This state was most recently disposed\n${disposal.trace}`
+			// 	: `No previous disposal trace was found.`,
 		)
 		return
 	}
@@ -79,14 +56,8 @@ export function disposeFromStore(
 		case `readonly_selector`:
 			disposeSelector(token, store)
 			break
-		case `molecule`:
-			disposeMolecule(token, store)
-			break
 	}
 
-	const { stack } = new Error()
-	if (stack) {
-		const trace = stack?.split(`\n`)?.slice(3)?.join(`\n`)
-		store.disposalTraces.add({ key: token.key, trace })
-	}
+	// const trace = getTrace(new Error())
+	// store.disposalTraces.add({ key: token.key, trace })
 }

package/internal/src/families/find-in-store.ts

@@ -18,7 +18,7 @@ import type {
 } from "atom.io"
 import { type Canonical, type Json, stringifyJson } from "atom.io/json"
 
-import { growMoleculeInStore } from "../molecule"
+import { newest } from "../lineage"
 import type { Transceiver } from "../mutable"
 import { counterfeit, type Store } from "../store"
 import { initFamilyMemberInStore } from "./init-family-member"
@@ -80,17 +80,15 @@ export function findInStore<T, K extends Canonical, Key extends K>(
 export function findInStore(
 	store: Store,
 	token: ReadableFamilyToken<any, any>,
-	key: Json.Serializable,
+	key: Canonical,
 ): ReadableToken<any> {
 	let state = seekInStore(store, token, key)
 	if (state) {
 		return state
 	}
-	const molecule = store.molecules.get(stringifyJson(key))
-	if (molecule) {
-		return growMoleculeInStore(molecule, token, store)
-	}
-	if (store.config.lifespan === `immortal`) {
+	const stringKey = stringifyJson(key)
+	const molecule = store.molecules.get(stringKey)
+	if (!molecule && store.config.lifespan === `immortal`) {
 		const fakeToken = counterfeit(token, key)
 		store.logger.error(
 			`❌`,
@@ -101,5 +99,9 @@ export function findInStore(
 		return fakeToken
 	}
 	state = initFamilyMemberInStore(store, token, key)
+	if (molecule) {
+		const target = newest(store)
+		target.moleculeData.set(stringKey, token.key)
+	}
 	return state
 }

package/internal/src/families/init-family-member.ts

@@ -88,7 +88,7 @@ export function initFamilyMemberInStore(
 	}
 	const state = family(key)
 	const target = newest(store)
-	if (state.family && target.moleculeInProgress === null) {
+	if (state.family) {
 		if (isRootStore(target)) {
 			switch (state.type) {
 				case `atom`:

package/internal/src/families/seek-in-store.ts

@@ -1,10 +1,6 @@
 import type {
 	AtomFamilyToken,
 	AtomToken,
-	MoleculeConstructor,
-	MoleculeFamilyToken,
-	MoleculeKey,
-	MoleculeToken,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
 	ReadableFamilyToken,
@@ -81,17 +77,11 @@ export function seekInStore<T, K extends Canonical, Key extends K>(
 	key: Key,
 ): ReadableToken<T, K> | undefined
 
-export function seekInStore<M extends MoleculeConstructor>(
-	store: Store,
-	token: MoleculeFamilyToken<M>,
-	key: MoleculeKey<M>,
-): MoleculeKey<M> | undefined
-
 export function seekInStore(
 	store: Store,
-	token: MoleculeFamilyToken<any> | ReadableFamilyToken<any, any>,
+	token: ReadableFamilyToken<any, any>,
 	key: Canonical,
-): MoleculeToken<any> | ReadableToken<any> | undefined {
+): ReadableToken<any> | undefined {
 	const subKey = stringifyJson(key)
 	const fullKey = `${token.key}(${subKey})`
 	const target = newest(store)
@@ -107,8 +97,6 @@ export function seekInStore(
 		case `readonly_selector_family`:
 			state = target.readonlySelectors.get(fullKey)
 			break
-		case `molecule_family`:
-			state = target.molecules.get(stringifyJson(key))
 	}
 	if (state) {
 		return deposit(state)