atom.io 0.29.5 → 0.30.1

package/dist/index.js

@@ -1,7 +1,7 @@
+export { $provenance, T$, allocateIntoStore, deallocateFromStore, makeMolecule, makeRootMoleculeInStore, moleculeFamily, realm } from './chunk-ADMEAXYU.js';
 import './chunk-XWL6SNVU.js';
 import * as Internal from 'atom.io/internal';
-import { createStandaloneAtom, IMPLICIT, createAtomFamily, createMoleculeFamily, makeMoleculeInStore, Molecule, createStandaloneSelector, createSelectorFamily, Store, createTransaction, createTimeline, findInStore, getFromStore, setIntoStore, disposeFromStore, subscribeInStore, timeTravel, actUponStore, arbitrary } from 'atom.io/internal';
-import { stringifyJson } from 'atom.io/json';
+import { createStandaloneAtom, IMPLICIT, createAtomFamily, createStandaloneSelector, createSelectorFamily, Store, createTransaction, createTimeline, findInStore, getFromStore, setIntoStore, disposeFromStore, subscribeInStore, timeTravel, createMoleculeFamily, makeMoleculeInStore, actUponStore, arbitrary } from 'atom.io/internal';
 
 function atom(options) {
   return createStandaloneAtom(IMPLICIT.STORE, options);
@@ -58,20 +58,6 @@ var AtomIOLogger = class {
     }
   };
 };
-function moleculeFamily(options) {
-  return createMoleculeFamily(IMPLICIT.STORE, options);
-}
-function makeMolecule(context, family, key, ...params) {
-  return makeMoleculeInStore(IMPLICIT.STORE, context, family, key, ...params);
-}
-function makeRootMolecule(key, store = IMPLICIT.STORE) {
-  const molecule = new Molecule(void 0, key);
-  store.molecules.set(stringifyJson(key), molecule);
-  return {
-    key,
-    type: `molecule`
-  };
-}
 function selector(options) {
   return createStandaloneSelector(IMPLICIT.STORE, options);
 }
@@ -163,4 +149,4 @@ function belongsTo(family, unknownToken) {
   return family.key === unknownToken.family?.key;
 }
 
-export { AtomIOLogger, LOG_LEVELS, Silo, atom, atomFamily, belongsTo, disposeState, getState, isToken, makeMolecule, makeRootMolecule, moleculeFamily, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };
+export { AtomIOLogger, LOG_LEVELS, Silo, atom, atomFamily, belongsTo, disposeState, getState, isToken, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };

package/internal/dist/index.d.ts

@@ -1,5 +1,5 @@
 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, AtomIOLogger, Logger, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, KeyedStateUpdate, ReadonlySelectorOptions, WritableSelectorOptions, SetterToolkit, UpdateHandler, TransactionUpdateHandler } 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 { Join } from 'atom.io/data';
 import { Refinement } from 'atom.io/introspection';
@@ -22,20 +22,24 @@ declare function counterfeit<T, K extends Canonical, Key extends K>(token: Writa
 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>;
 
-interface JunctionEntries<Content extends Json.Object | null> extends Json.Object {
-    readonly relations: [string, string[]][];
+type JunctionEntriesBase<AType extends string, BType extends string, Content extends Json.Object | null> = {
+    readonly relations: ([AType, BType[]] | [BType, AType[]])[];
     readonly contents: [string, Content][];
+};
+interface JunctionEntries<AType extends string, BType extends string, Content extends Json.Object | null> extends Json.Object, JunctionEntriesBase<AType, BType, Content> {
 }
-interface JunctionSchema<ASide extends string, BSide extends string> extends Json.Object {
+type JunctionSchemaBase<ASide extends string, BSide extends string> = {
     readonly between: [a: ASide, b: BSide];
     readonly cardinality: `1:1` | `1:n` | `n:n`;
+};
+interface JunctionSchema<ASide extends string, BSide extends string> extends Json.Object, JunctionSchemaBase<ASide, BSide> {
 }
 type BaseExternalStoreConfiguration = {
     addRelation: (a: string, b: string) => void;
     deleteRelation: (a: string, b: string) => void;
     replaceRelationsSafely: (a: string, bs: string[]) => void;
     replaceRelationsUnsafely: (a: string, bs: string[]) => void;
-    getRelatedKeys: (key: string) => Set<string> | undefined;
+    getRelatedKeys(key: string): Set<string> | undefined;
     has: (a: string, b?: string) => boolean;
 };
 type ExternalStoreWithContentConfiguration<Content extends Json.Object> = {
@@ -47,45 +51,68 @@ type Empty<Obj extends object> = {
     [Key in keyof Obj]?: undefined;
 };
 type ExternalStoreConfiguration<Content extends Json.Object | null> = Content extends Json.Object ? BaseExternalStoreConfiguration & ExternalStoreWithContentConfiguration<Content> : BaseExternalStoreConfiguration & Empty<ExternalStoreWithContentConfiguration<Json.Object>>;
-type JunctionAdvancedConfiguration<Content extends Json.Object | null> = {
+type JunctionAdvancedConfiguration<AType extends string, BType extends string, Content extends Json.Object | null> = {
     warn?: (...args: any[]) => void;
     externalStore?: ExternalStoreConfiguration<Content>;
+    isAType?: Refinement<string, AType>;
+    isBType?: Refinement<string, BType>;
     isContent?: Refinement<unknown, Content>;
-    makeContentKey?: (a: string, b: string) => string;
+    makeContentKey?: (a: AType, b: BType) => string;
 };
-type JunctionJSON<ASide extends string, BSide extends string, Content extends Json.Object | null> = JunctionEntries<Content> & JunctionSchema<ASide, BSide>;
-declare class Junction<const ASide extends string, const BSide extends string, const Content extends Json.Object | null = null> {
+type JunctionJSON<ASide extends string, AType extends string, BSide extends string, BType extends string, Content extends Json.Object | null> = JunctionEntries<AType, BType, Content> & JunctionSchema<ASide, BSide>;
+declare class Junction<const ASide extends string, const AType extends string, const BSide extends string, const BType extends string, const Content extends Json.Object | null = null> {
     readonly a: ASide;
     readonly b: BSide;
     readonly cardinality: `1:1` | `1:n` | `n:n`;
-    readonly relations: Map<string, Set<string>>;
+    readonly relations: Map<AType | BType, Set<AType> | Set<BType>>;
     readonly contents: Map<string, Content>;
     isContent: Refinement<unknown, Content> | null;
-    makeContentKey: (a: string, b: string) => string;
+    makeContentKey: (a: AType, b: BType) => string;
     warn?: (...args: any[]) => void;
-    getRelatedKeys(key: string): Set<string> | undefined;
-    protected addRelation(a: string, b: string): void;
-    protected deleteRelation(a: string, b: string): void;
-    protected replaceRelationsUnsafely(a: string, bs: string[]): void;
-    protected replaceRelationsSafely(a: string, bs: string[]): void;
+    getRelatedKeys(key: AType): Set<BType> | undefined;
+    getRelatedKeys(key: BType): Set<AType> | undefined;
+    getRelatedKeys(key: AType | BType): Set<AType> | Set<BType> | undefined;
+    protected addRelation(a: AType, b: BType): void;
+    protected deleteRelation(a: AType, b: BType): void;
+    protected replaceRelationsUnsafely(a: AType, bs: BType[]): void;
+    protected replaceRelationsUnsafely(b: BType, as: AType[]): void;
+    protected replaceRelationsSafely(a: AType, bs: BType[]): void;
+    protected replaceRelationsSafely(b: BType, as: AType[]): void;
     protected getContentInternal(contentKey: string): Content | undefined;
     protected setContent(contentKey: string, content: Content): void;
     protected deleteContent(contentKey: string): void;
-    constructor(data: JunctionSchema<ASide, BSide> & Partial<JunctionEntries<Content>>, config?: JunctionAdvancedConfiguration<Content>);
-    toJSON(): JunctionJSON<ASide, BSide, Content>;
-    set(a: string, ...rest: Content extends null ? [b: string] : [b: string, content: Content]): this;
+    constructor(data: JunctionSchema<ASide, BSide> & Partial<JunctionEntries<AType, BType, Content>>, config?: JunctionAdvancedConfiguration<AType, BType, Content>);
+    toJSON(): JunctionJSON<ASide, AType, BSide, BType, Content>;
+    set(a: AType, ...rest: Content extends null ? [b: BType] : [b: BType, content: Content]): this;
     set(relation: {
-        [Key in ASide | BSide]: string;
-    }, ...rest: Content extends null ? [] | [b?: undefined] : [content: Content]): this;
-    delete(a: string, b?: string): this;
-    delete(relation: Record<ASide | BSide, string> | Record<ASide, string> | Record<BSide, string>, b?: undefined): this;
-    getRelatedKey(key: string): string | undefined;
-    replaceRelations(a: string, relations: Content extends null ? string[] : Record<string, Content>, config?: {
+        [Key in ASide]: AType;
+    } & {
+        [Key in BSide]: BType;
+    }, ...rest: Content extends null ? [] | [void?: undefined] : [content: Content]): this;
+    delete(a: AType, b?: BType): this;
+    delete(b: BType, a?: AType): this;
+    delete(relation: {
+        [Key in ASide]: AType;
+    } | {
+        [Key in BSide]: BType;
+    } | ({
+        [Key in ASide]: AType;
+    } & {
+        [Key in BSide]: BType;
+    }), b?: undefined): this;
+    getRelatedKey(key: AType): BType | undefined;
+    getRelatedKey(key: BType): AType | undefined;
+    replaceRelations(a: AType, relations: Content extends null ? BType[] : Record<BType, Content>, config?: {
         reckless: boolean;
     }): this;
-    getContent(a: string, b: string): Content | undefined;
-    getRelationEntries(input: Record<ASide, string> | Record<BSide, string>): [string, Content][];
-    has(a: string, b?: string): boolean;
+    replaceRelations(b: BType, relations: Content extends null ? AType[] : Record<AType, Content>, config?: {
+        reckless: boolean;
+    }): this;
+    getContent(a: AType, b: BType): Content | undefined;
+    getRelationEntries(input: Record<ASide, AType>): [BType, Content][];
+    getRelationEntries(input: Record<BSide, BType>): [AType, Content][];
+    has(a: AType, b?: BType): boolean;
+    has(b: BType, a?: AType): boolean;
 }
 
 type Func = (...parameters: any[]) => any;
@@ -94,7 +121,13 @@ type Flat<R extends {
 }> = {
     [K in keyof R]: R[K];
 };
-type Range<N extends number, A extends any[] = []> = A[`length`] extends N ? A[`length`] : A[`length`] | Range<N, [...A, any]>;
+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;
 
@@ -157,7 +190,7 @@ type TransactionProgress<F extends Func> = {
 };
 type TransactionEpoch = {
     epoch: Map<string, number>;
-    actionContinuities: Junction<`continuity`, `action`>;
+    actionContinuities: Junction<`continuity`, string, `action`, string>;
 };
 
 declare function deposit<T>(state: RegularAtom<T>): RegularAtomToken<T>;
@@ -198,13 +231,15 @@ declare class Molecule<M extends MoleculeConstructor> implements MoleculeToken<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>>;
+    joins: Map<string, Join<any, any, any, any, any, any>>;
     instance: InstanceType<M>;
-    constructor(ctx: Molecule<any> | Molecule<any>[] | undefined, key: MoleculeKey<M>, family?: MoleculeFamilyToken<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>;
@@ -298,8 +333,8 @@ declare class Store implements Lineage {
     selectors: Map<string, WritableSelector<any>>;
     readonlySelectors: Map<string, ReadonlySelector<any>>;
     atomsThatAreDefault: Set<string>;
-    selectorAtoms: Junction<"selectorKey", "atomKey", null>;
-    selectorGraph: Junction<"upstreamSelectorKey", "downstreamSelectorKey", {
+    selectorAtoms: Junction<"selectorKey", string, "atomKey", string, null>;
+    selectorGraph: Junction<"upstreamSelectorKey", string, "downstreamSelectorKey", string, {
         source: string;
     }>;
     trackers: Map<string, Tracker<Transceiver<any>>>;
@@ -307,7 +342,7 @@ declare class Store implements Lineage {
     transactions: Map<string, Transaction<Func>>;
     transactionMeta: TransactionEpoch | TransactionProgress<Func>;
     timelines: Map<string, Timeline<any>>;
-    timelineTopics: Junction<"timelineKey", "topicKey", {
+    timelineTopics: Junction<"timelineKey", string, "topicKey", string, {
         topicType: `atom_family` | `atom` | `molecule_family` | `molecule`;
     }>;
     disposalTraces: CircularBuffer<{
@@ -316,7 +351,7 @@ declare class Store implements Lineage {
     }>;
     molecules: Map<string, Molecule<any>>;
     moleculeFamilies: Map<string, Flat<atom_io.MoleculeFamilyToken<any> & {
-        subject: Subject<atom_io.MoleculeCreation<any> | atom_io.MoleculeDisposal>;
+        subject: Subject<atom_io.MoleculeCreationClassic<any> | atom_io.MoleculeDisposalClassic>;
         dependsOn: `all` | `any`;
         new: any;
     }>>;
@@ -331,9 +366,9 @@ declare class Store implements Lineage {
         transactionCreation: Subject<TransactionToken<Func>>;
         transactionApplying: StatefulSubject<TransactionProgress<Func> | null>;
         operationClose: Subject<OperationProgress>;
-        moleculeCreationStart: Subject<MoleculeToken<any>>;
+        moleculeCreationStart: Subject<MoleculeToken<any> | MoleculeCreationModern>;
         moleculeCreationDone: Subject<MoleculeToken<any>>;
-        moleculeDisposal: Subject<MoleculeToken<any>>;
+        moleculeDisposal: Subject<MoleculeToken<any> | MoleculeDisposalModern>;
     };
     operation: OperationProgress;
     config: {
@@ -385,9 +420,9 @@ type Signal<TVR extends Transceiver<any>> = TVR extends Transceiver<infer S> ? S
 
 declare function createMutableAtom<T extends Transceiver<any>, J extends Json.Serializable>(store: Store, options: MutableAtomOptions<T, J>, family: FamilyMetadata | undefined): MutableAtomToken<T, J>;
 
-declare function createMutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends string>(store: Store, options: MutableAtomFamilyOptions<T, J, K>, internalRoles?: string[]): MutableAtomFamilyToken<T, J, K>;
+declare function createMutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(store: Store, options: MutableAtomFamilyOptions<T, J, K>, internalRoles?: string[]): MutableAtomFamilyToken<T, J, K>;
 
-declare const getJsonFamily: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable, Key extends string>(mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>, store: Store) => WritableSelectorFamily<SerializableCore, Key>;
+declare const getJsonFamily: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable, Key extends Canonical>(mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>, store: Store) => WritableSelectorFamily<SerializableCore, Key>;
 
 declare const getJsonToken: <Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(store: Store, mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => WritableSelectorToken<SerializableCore>;
 
@@ -664,4 +699,4 @@ type SelectorFamily<T, K extends Canonical> = ReadonlySelectorFamily<T, K> | Wri
 type WritableFamily<T, K extends Canonical> = AtomFamily<T, K> | WritableSelectorFamily<T, K>;
 type ReadableFamily<T, K extends Canonical> = AtomFamily<T, K> | SelectorFamily<T, K>;
 
-export { type Atom, type AtomFamily, type AtomIOState, type AtomIOToken, type AtomKey, type BaseExternalStoreConfiguration, type ChildStore, 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 JunctionJSON, type JunctionSchema, LazyMap, type Lineage, type Modify, Molecule, type MutableAtom, type MutableAtomFamily, NotFoundError, type OperationProgress, type Range, type ReadableFamily, type ReadableState, type ReadonlySelector, type ReadonlySelectorFamily, type ReadonlySelectorKey, type RegularAtom, type RegularAtomFamily, type RootStore, type Selector, type SelectorFamily, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineMoleculeCreation, type TimelineMoleculeDisposal, type TimelineSelectorUpdate, type TimelineStateCreation, type TimelineStateDisposal, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableFamily, type WritableSelector, type WritableSelectorFamily, type WritableState, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, counterfeit, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+export { type Atom, type AtomFamily, type AtomIOState, type AtomIOToken, type AtomKey, type BaseExternalStoreConfiguration, type ChildStore, 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 };

package/internal/dist/index.js

@@ -1,2 +1,3 @@
-export { 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-TCINPEYE.js';
+export { 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-SMKF3ZNG.js';
+import '../../dist/chunk-ADMEAXYU.js';
 import '../../dist/chunk-XWL6SNVU.js';

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

@@ -1,13 +1,7 @@
 import type { AtomToken } from "atom.io"
 
 import type { Store } from ".."
-import {
-	disposeSelector,
-	getUpdateToken,
-	isChildStore,
-	newest,
-	withdraw,
-} from ".."
+import { getUpdateToken, isChildStore, newest, withdraw } from ".."
 
 export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 	const target = newest(store)
@@ -24,6 +18,7 @@ export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 			token: atomToken,
 			value: lastValue,
 		})
+
 		const molecule = target.molecules.get(atom.family.subKey)
 		if (molecule) {
 			molecule.tokens.delete(key)
@@ -32,7 +27,8 @@ export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 		target.valueMap.delete(key)
 		target.selectorAtoms.delete(key)
 		target.atomsThatAreDefault.delete(key)
-		target.timelineTopics.delete(key)
+		store.timelineTopics.delete(key)
+
 		if (atomToken.type === `mutable_atom`) {
 			const updateToken = getUpdateToken(atomToken)
 			disposeAtom(updateToken, store)

package/internal/src/index.ts

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

package/internal/src/ingest-updates/ingest-creation-disposal.ts

@@ -8,10 +8,11 @@ import type {
 import { parseJson, stringifyJson } from "atom.io/json"
 
 import {
-	disposeFromStore,
-	findInStore,
-	initFamilyMemberInStore,
-} from "../families"
+	allocateIntoStore,
+	deallocateFromStore,
+} from "~/packages/atom.io/src/allocate"
+
+import { disposeFromStore, findInStore } from "../families"
 import { growMoleculeInStore, makeMoleculeInStore } from "../molecule"
 import { type Store, withdraw } from "../store"
 
@@ -70,16 +71,30 @@ export function ingestMoleculeCreationEvent(
 ): void {
 	switch (applying) {
 		case `newValue`:
-			makeMoleculeInStore(
-				store,
-				update.context,
-				update.family,
-				update.token.key,
-				...update.params,
-			)
+			switch (update.subType) {
+				case `classic`:
+					makeMoleculeInStore(
+						store,
+						update.context,
+						update.family,
+						update.token.key,
+						...update.params,
+					)
+					break
+				case `modern`:
+					allocateIntoStore<any, any, any>(store, update.provenance, update.key)
+					break
+			}
 			break
 		case `oldValue`:
-			disposeFromStore(store, update.token)
+			switch (update.subType) {
+				case `classic`:
+					disposeFromStore(store, update.token)
+					break
+				case `modern`:
+					deallocateFromStore<any, any, any>(store, update.key)
+					break
+			}
 			break
 	}
 }
@@ -90,25 +105,54 @@ export function ingestMoleculeDisposalEvent(
 ): void {
 	switch (applying) {
 		case `newValue`:
-			disposeFromStore(store, update.token)
+			switch (update.subType) {
+				case `classic`:
+					disposeFromStore(store, update.token)
+					break
+				case `modern`:
+					deallocateFromStore<any, any, any>(store, update.key)
+					break
+			}
 			break
 		case `oldValue`:
 			{
-				const moleculeToken = makeMoleculeInStore(
-					store,
-					update.context,
-					update.family,
-					update.token.key,
-				)
-				for (const [familyKey, value] of update.values) {
-					const memberKey = `${familyKey}(${stringifyJson(moleculeToken.key)})`
-					const molecule = withdraw(moleculeToken, store)
-					const alreadyCreated = molecule.tokens.has(memberKey)
-					const family = store.families.get(familyKey)
-					if (family && !alreadyCreated) {
-						growMoleculeInStore(molecule, family, store)
+				// TODO: Handle classic vs modern molecules
+				switch (update.subType) {
+					case `classic`:
+						{
+							const moleculeToken = makeMoleculeInStore(
+								store,
+								update.context,
+								update.family,
+								update.token.key,
+							)
+							for (const [familyKey, value] of update.values) {
+								const memberKey = `${familyKey}(${stringifyJson(moleculeToken.key)})`
+								const molecule = withdraw(moleculeToken, store)
+								const alreadyCreated = molecule.tokens.has(memberKey)
+								const family = store.families.get(familyKey)
+								if (family && !alreadyCreated) {
+									growMoleculeInStore(molecule, family, store)
+								}
+								store.valueMap.set(memberKey, value)
+							}
+						}
+						break
+					case `modern`: {
+						allocateIntoStore<any, any, any>(
+							store,
+							update.provenance,
+							update.key,
+						)
+						for (const [familyKey, value] of update.values) {
+							const family = store.families.get(familyKey)
+							if (family) {
+								findInStore(store, family, update.key)
+								const memberKey = `${familyKey}(${stringifyJson(update.key)})`
+								store.valueMap.set(memberKey, value)
+							}
+						}
 					}
-					store.valueMap.set(memberKey, value)
 				}
 			}
 			break