atom.io 0.29.5 → 0.30.0

package/dist/{chunk-TCINPEYE.js → chunk-7PUUHSXC.js}

@@ -1,7 +1,7 @@
 import { stringifyJson, parseJson, selectJson, selectJsonFamily } from 'atom.io/json';
 import { AtomIOLogger } from 'atom.io';
 import { getJoin, findRelations } from 'atom.io/data';
-import { subscribeToTimeline, subscribeToTransaction, subscribeToState, arbitrary as arbitrary$1 } from 'atom.io/internal';
+import { subscribeToTimeline, subscribeToTransaction, subscribeToState, arbitrary as arbitrary$1, Molecule as Molecule$1, newest as newest$1, isChildStore as isChildStore$1, disposeFromStore as disposeFromStore$1 } from 'atom.io/internal';
 
 // internal/src/arbitrary.ts
 function arbitrary(random = Math.random) {
@@ -1304,6 +1304,7 @@ function disposeMolecule(token, store) {
     const Formula = withdraw(family, store);
     const disposalEvent = {
       type: `molecule_disposal`,
+      subType: `classic`,
       token,
       family,
       context,
@@ -1316,7 +1317,7 @@ function disposeMolecule(token, store) {
       disposeFromStore(store, state);
     }
     for (const child of molecule.below.values()) {
-      if (child.family?.dependsOn === `all`) {
+      if (child.dependsOn === `all`) {
         disposeMolecule(child, store);
       } else {
         child.above.delete(molecule.stringKey);
@@ -1380,20 +1381,24 @@ var Molecule = class {
     this.stringKey = stringifyJson(key);
     if (family) {
       this.family = family;
+      this._dependsOn = family.dependsOn;
     }
     if (ctx) {
-      if (Array.isArray(ctx)) {
-        for (const molecule of ctx) {
-          this.above.set(molecule.stringKey, molecule);
-        }
-      } else {
-        this.above.set(ctx.stringKey, ctx);
+      for (const molecule of ctx) {
+        this.above.set(molecule.stringKey, molecule);
       }
     }
   }
   type = `molecule`;
   stringKey;
   family;
+  _dependsOn;
+  get dependsOn() {
+    if (this.family) {
+      return this.family.dependsOn;
+    }
+    return this._dependsOn;
+  }
   subject = new Subject();
   tokens = /* @__PURE__ */ new Map();
   above = /* @__PURE__ */ new Map();
@@ -1452,9 +1457,11 @@ function makeMoleculeInStore(store, context, familyToken, key, ...params) {
         const unsubFromFamily = family.subject.subscribe(
           `join:${token2.key}-${stringKey}`,
           (event) => {
-            if (event.type === `molecule_disposal` && stringifyJson(event.token.key) === stringKey) {
-              unsubFromFamily();
-              join.molecules.delete(stringKey);
+            if (event.type === `molecule_disposal`) {
+              if (stringifyJson(event.token.key) === stringKey) {
+                unsubFromFamily();
+                join.molecules.delete(stringKey);
+              }
             }
           }
         );
@@ -1512,6 +1519,7 @@ function makeMoleculeInStore(store, context, familyToken, key, ...params) {
   };
   const update = {
     type: `molecule_creation`,
+    subType: `classic`,
     token,
     family: familyToken,
     context: contextArray,
@@ -1721,6 +1729,142 @@ function ingestAtomUpdate(applying, atomUpdate, store) {
   }
   setIntoStore(store, token, value);
 }
+function allocateIntoStore(store, provenance, key) {
+  const stringKey = stringifyJson(key);
+  try {
+    const above = [];
+    let allocationAttachmentStyle;
+    if (provenance === `root`) {
+      above.push(store.molecules.get(`"root"`));
+      allocationAttachmentStyle = `all`;
+    } else if (provenance[0][0] === T$) {
+      allocationAttachmentStyle = `any`;
+      const provenanceKey = stringifyJson(provenance);
+      const provenanceMolecule = store.molecules.get(provenanceKey);
+      if (!provenanceMolecule) {
+        throw new Error(
+          `Molecule ${provenanceKey} not found in store "${store.config.name}"`
+        );
+      }
+      above.push(provenanceMolecule);
+    } else {
+      const allocationIsCompound = key[0][0] === T$;
+      if (allocationIsCompound) {
+        allocationAttachmentStyle = `all`;
+        for (const claim of provenance) {
+          const provenanceKey = stringifyJson(claim);
+          const provenanceMolecule = store.molecules.get(provenanceKey);
+          if (!provenanceMolecule) {
+            throw new Error(
+              `Molecule ${provenanceKey} not found in store "${store.config.name}"`
+            );
+          }
+          above.push(provenanceMolecule);
+        }
+      } else {
+        allocationAttachmentStyle = `any`;
+        const provenanceKey = stringifyJson(provenance);
+        const provenanceMolecule = store.molecules.get(provenanceKey);
+        if (!provenanceMolecule) {
+          throw new Error(
+            `Molecule ${provenanceKey} not found in store "${store.config.name}"`
+          );
+        }
+        above.push(provenanceMolecule);
+      }
+    }
+    const molecule = new Molecule$1(above, key);
+    molecule._dependsOn = allocationAttachmentStyle;
+    store.molecules.set(stringKey, molecule);
+    for (const aboveMolecule of above) {
+      aboveMolecule.below.set(molecule.stringKey, molecule);
+    }
+    const creationEvent = {
+      type: `molecule_creation`,
+      subType: `modern`,
+      key: molecule.key,
+      provenance
+    };
+    const target = newest$1(store);
+    const isTransaction = isChildStore$1(target) && target.transactionMeta.phase === `building`;
+    if (isTransaction) {
+      target.transactionMeta.update.updates.push(creationEvent);
+    } else {
+      target.on.moleculeCreationStart.next(creationEvent);
+    }
+  } catch (thrown) {
+    if (thrown instanceof Error) {
+      store.logger.error(
+        `\u274C`,
+        `molecule`,
+        stringKey,
+        `allocation failed:`,
+        thrown.message
+      );
+    }
+  }
+  return key;
+}
+function deallocateFromStore(store, claim) {
+  const stringKey = stringifyJson(claim);
+  const molecule = store.molecules.get(stringKey);
+  if (!molecule) {
+    throw new Error(
+      `Molecule ${stringKey} not found in store "${store.config.name}"`
+    );
+  }
+  for (const join of molecule.joins.values()) {
+    join.relations.delete(molecule.key);
+    join.molecules.delete(molecule.stringKey);
+  }
+  let provenance;
+  if (molecule.above.size === 1) {
+    const above = molecule.above.values().next().value;
+    provenance = above.key;
+  } else {
+    provenance = [...molecule.above.values()].map(({ key }) => key);
+  }
+  const values = [];
+  for (const stateToken of molecule.tokens.values()) {
+    const tokenFamily = stateToken.family;
+    values.push([tokenFamily.key, store.valueMap.get(stateToken.key)]);
+  }
+  for (const state of molecule.tokens.values()) {
+    disposeFromStore$1(store, state);
+  }
+  for (const child of molecule.below.values()) {
+    if (child.dependsOn === `all`) {
+      deallocateFromStore(store, child.key);
+    } else {
+      child.above.delete(molecule.stringKey);
+      if (child.above.size === 0) {
+        deallocateFromStore(store, child.key);
+      }
+    }
+  }
+  molecule.below.clear();
+  const disposalEvent = {
+    type: `molecule_disposal`,
+    subType: `modern`,
+    key: molecule.key,
+    values,
+    provenance
+  };
+  const target = newest$1(store);
+  const isTransaction = isChildStore$1(target) && target.transactionMeta.phase === `building`;
+  if (isTransaction) {
+    target.transactionMeta.update.updates.push(disposalEvent);
+  } else {
+    target.on.moleculeDisposal.next(disposalEvent);
+  }
+  target.molecules.delete(molecule.stringKey);
+  for (const parent of molecule.above.values()) {
+    parent.below.delete(molecule.stringKey);
+  }
+}
+var T$ = `T$`;
+
+// internal/src/ingest-updates/ingest-creation-disposal.ts
 function ingestCreationEvent(update, applying, store) {
   switch (applying) {
     case `newValue`: {
@@ -1758,41 +1902,83 @@ function createInStore(update, store) {
 function ingestMoleculeCreationEvent(update, applying, store) {
   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(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(store, update.key);
+          break;
+      }
       break;
   }
 }
 function ingestMoleculeDisposalEvent(update, applying, store) {
   switch (applying) {
     case `newValue`:
-      disposeFromStore(store, update.token);
+      switch (update.subType) {
+        case `classic`:
+          disposeFromStore(store, update.token);
+          break;
+        case `modern`:
+          deallocateFromStore(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);
+        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(
+              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;
@@ -2976,7 +3162,7 @@ function disposeAtom(atomToken, store) {
     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);
@@ -3243,71 +3429,77 @@ function addMoleculeFamilyToTimeline(familyToken, tl, store) {
           `got a molecule creation or disposal`,
           creationOrDisposal
         );
-        switch (creationOrDisposal.type) {
-          case `molecule_creation`:
-            {
-              store.timelineTopics.set(
-                {
-                  topicKey: creationOrDisposal.token.key,
-                  timelineKey: tl.key
-                },
-                { topicType: `molecule` }
-              );
-              const txUpdateInProgress = newest(store).on.transactionApplying.state?.update;
-              if (txUpdateInProgress) {
-                joinTransaction(tl, txUpdateInProgress, store);
-              } else if (tl.timeTraveling === null) {
-                const event = Object.assign(creationOrDisposal, {
-                  timestamp: Date.now()
-                });
-                tl.history.push(event);
-                tl.at = tl.history.length;
-                tl.subject.next(event);
-              }
-              const molecule = withdraw(creationOrDisposal.token, store);
-              for (const token of molecule.tokens.values()) {
-                switch (token.type) {
-                  case `atom`:
-                  case `mutable_atom`:
-                    addAtomToTimeline(token, tl, store);
-                    break;
+        if (creationOrDisposal.subType === `classic`) {
+          switch (creationOrDisposal.type) {
+            case `molecule_creation`:
+              {
+                store.timelineTopics.set(
+                  {
+                    topicKey: creationOrDisposal.token.key,
+                    timelineKey: tl.key
+                  },
+                  { topicType: `molecule` }
+                );
+                const txUpdateInProgress = newest(store).on.transactionApplying.state?.update;
+                if (txUpdateInProgress) {
+                  joinTransaction(tl, txUpdateInProgress, store);
+                } else if (tl.timeTraveling === null) {
+                  const event = Object.assign(creationOrDisposal, {
+                    timestamp: Date.now()
+                  });
+                  tl.history.push(event);
+                  tl.at = tl.history.length;
+                  tl.subject.next(event);
                 }
-              }
-              tl.subscriptions.set(
-                molecule.key,
-                molecule.subject.subscribe(
-                  `timeline:${tl.key}`,
-                  (stateCreationOrDisposal) => {
-                    handleStateLifecycleEvent(stateCreationOrDisposal, tl, store);
+                const molecule = withdraw(creationOrDisposal.token, store);
+                for (const token of molecule.tokens.values()) {
+                  switch (token.type) {
+                    case `atom`:
+                    case `mutable_atom`:
+                      addAtomToTimeline(token, tl, store);
+                      break;
                   }
-                )
-              );
-            }
-            break;
-          case `molecule_disposal`:
-            {
-              const txUpdateInProgress = newest(store).on.transactionApplying.state?.update;
-              if (txUpdateInProgress) {
-                joinTransaction(tl, txUpdateInProgress, store);
-              } else if (tl.timeTraveling === null) {
-                const event = Object.assign(creationOrDisposal, {
-                  timestamp: Date.now()
-                });
-                tl.history.push(event);
-                tl.at = tl.history.length;
-                tl.subject.next(event);
+                }
+                tl.subscriptions.set(
+                  molecule.key,
+                  molecule.subject.subscribe(
+                    `timeline:${tl.key}`,
+                    (stateCreationOrDisposal) => {
+                      handleStateLifecycleEvent(
+                        stateCreationOrDisposal,
+                        tl,
+                        store
+                      );
+                    }
+                  )
+                );
               }
-              const moleculeKey = creationOrDisposal.token.key;
-              tl.subscriptions.get(moleculeKey)?.();
-              tl.subscriptions.delete(moleculeKey);
-              for (const [familyKey] of creationOrDisposal.values) {
-                const stateKey = `${familyKey}(${stringifyJson(moleculeKey)})`;
-                tl.subscriptions.get(stateKey)?.();
-                tl.subscriptions.delete(stateKey);
-                store.timelineTopics.delete(stateKey);
+              break;
+            case `molecule_disposal`:
+              {
+                const txUpdateInProgress = newest(store).on.transactionApplying.state?.update;
+                if (txUpdateInProgress) {
+                  joinTransaction(tl, txUpdateInProgress, store);
+                } else if (tl.timeTraveling === null) {
+                  const event = Object.assign(creationOrDisposal, {
+                    timestamp: Date.now()
+                  });
+                  tl.history.push(event);
+                  tl.at = tl.history.length;
+                  tl.subject.next(event);
+                }
+                const moleculeKey = stringifyJson(creationOrDisposal.token.key);
+                tl.subscriptions.get(moleculeKey)?.();
+                tl.subscriptions.delete(moleculeKey);
+                for (const [familyKey] of creationOrDisposal.values) {
+                  const stateKey = `${familyKey}(${stringifyJson(moleculeKey)})`;
+                  tl.subscriptions.get(stateKey)?.();
+                  tl.subscriptions.delete(stateKey);
+                  store.timelineTopics.delete(stateKey);
+                }
               }
-            }
-            break;
+              break;
+          }
         }
       })
     );
@@ -3359,17 +3551,32 @@ function filterTransactionUpdates(updates, timelineTopics) {
       return true;
     }
     let key;
+    let familyKey;
     switch (updateFromTx.type) {
       case `state_creation`:
       case `state_disposal`:
+        key = updateFromTx.token.key;
+        familyKey = updateFromTx.token.family?.key;
+        break;
       case `molecule_creation`:
       case `molecule_disposal`:
-        key = updateFromTx.token.key;
+        switch (updateFromTx.subType) {
+          case `classic`:
+            key = updateFromTx.token.key;
+            break;
+          case `modern`:
+            return true;
+        }
         break;
       default:
         key = updateFromTx.key;
+        familyKey = updateFromTx.family?.key;
         break;
     }
+    timelineTopics.has(key);
+    if (familyKey && timelineTopics.has(familyKey)) {
+      return true;
+    }
     return timelineTopics.has(key);
   }).map((updateFromTx) => {
     if (`updates` in updateFromTx) {
@@ -3390,13 +3597,16 @@ function handleStateLifecycleEvent(event, tl, store) {
     timestamp
   });
   if (!tl.timeTraveling) {
-    const txUpdateInProgress = newest(store).on.transactionApplying.state?.update;
-    if (txUpdateInProgress) {
-      joinTransaction(tl, txUpdateInProgress, store);
-    } else {
-      tl.history.push(timelineEvent);
-      tl.at = tl.history.length;
-      tl.subject.next(timelineEvent);
+    const target = newest(store);
+    if (isChildStore(target)) ; else {
+      const txUpdateInProgress = target.on.transactionApplying.state;
+      if (txUpdateInProgress) {
+        joinTransaction(tl, txUpdateInProgress.update, store);
+      } else {
+        tl.history.push(timelineEvent);
+        tl.at = tl.history.length;
+        tl.subject.next(timelineEvent);
+      }
     }
   }
   switch (event.type) {

package/dist/chunk-ZKG6ZA4I.js

@@ -0,0 +1,20 @@
+import { createMoleculeFamily, IMPLICIT, makeMoleculeInStore, Molecule } from 'atom.io/internal';
+import { stringifyJson } from 'atom.io/json';
+
+// src/molecule.ts
+function moleculeFamily(options) {
+  return createMoleculeFamily(IMPLICIT.STORE, options);
+}
+function makeMolecule(context, family, key, ...params) {
+  return makeMoleculeInStore(IMPLICIT.STORE, context, family, key, ...params);
+}
+function makeRootMoleculeInStore(key, store = IMPLICIT.STORE) {
+  const molecule = new Molecule(void 0, key);
+  store.molecules.set(stringifyJson(key), molecule);
+  return {
+    key,
+    type: `molecule`
+  };
+}
+
+export { makeMolecule, makeRootMoleculeInStore, moleculeFamily };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Transceiver, Func, EnvironmentData, Flat, Subject, Store, Timeline, TimelineAtomUpdate, TimelineMoleculeCreation, TimelineMoleculeDisposal, TimelineSelectorUpdate, TimelineStateCreation, TimelineStateDisposal, TimelineTransactionUpdate } from 'atom.io/internal';
 import { Json, JsonInterface, Canonical, stringified } 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, 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, MoleculeCreationClassic as MoleculeCreationClassic$1, MoleculeDisposalClassic as MoleculeDisposalClassic$1 } from 'atom.io';
 import { findState } from 'atom.io/ephemeral';
 import { seekState } from 'atom.io/immortal';
 import { JoinToken } from 'atom.io/data';
@@ -82,20 +82,37 @@ type StateDisposal<Token extends ReadableToken<any>> = {
     token: Token;
     value?: TokenType<Token>;
 };
-type MoleculeCreation<M extends MoleculeConstructor$1> = {
+type MoleculeCreationClassic<M extends MoleculeConstructor$1> = {
     type: `molecule_creation`;
+    subType: `classic`;
     token: MoleculeToken$1<M>;
     family: MoleculeFamilyToken$1<M>;
     context: MoleculeToken$1<any>[];
     params: MoleculeParams$1<M>;
 };
-type MoleculeDisposal = {
+type MoleculeCreationModern = {
+    type: `molecule_creation`;
+    subType: `modern`;
+    key: Canonical;
+    provenance: Canonical;
+};
+type MoleculeCreation<M extends MoleculeConstructor$1> = MoleculeCreationClassic<M> | MoleculeCreationModern;
+type MoleculeDisposalClassic = {
     type: `molecule_disposal`;
+    subType: `classic`;
     token: MoleculeToken$1<any>;
     family: MoleculeFamilyToken$1<any>;
     context: MoleculeToken$1<any>[];
     values: [key: string, value: any][];
 };
+type MoleculeDisposalModern = {
+    type: `molecule_disposal`;
+    subType: `modern`;
+    key: Canonical;
+    provenance: Canonical;
+    values: [key: string, value: any][];
+};
+type MoleculeDisposal = MoleculeDisposalClassic | MoleculeDisposalModern;
 type TransactionUpdateContent = KeyedStateUpdate<unknown> | MoleculeCreation<any> | MoleculeDisposal | StateCreation<ReadableToken<unknown>> | StateDisposal<ReadableToken<unknown>> | TransactionUpdate<Func>;
 type TransactionUpdate<F extends Func> = {
     type: `transaction_update`;
@@ -210,7 +227,7 @@ type MoleculeFamilyToken<M extends MoleculeConstructor> = {
     __M?: M;
 };
 type MoleculeFamily<M extends MoleculeConstructor> = Flat<MoleculeFamilyToken<M> & {
-    subject: Subject<MoleculeCreation$1<M> | MoleculeDisposal$1>;
+    subject: Subject<MoleculeCreationClassic$1<M> | MoleculeDisposalClassic$1>;
     dependsOn: `all` | `any`;
     new: M;
 }>;
@@ -224,7 +241,7 @@ 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`];
-declare function makeRootMolecule(key: string, store?: Store): MoleculeToken<ObjectConstructor>;
+declare function makeRootMoleculeInStore(key: string, store?: Store): MoleculeToken<ObjectConstructor>;
 
 declare function disposeState(token: MoleculeToken<any> | ReadableToken<any>): void;
 declare function disposeState<K extends Canonical>(token: ReadableFamilyToken<any, K>, key: K): void;
@@ -427,4 +444,4 @@ type FamilyMetadata<K extends Canonical = any> = {
     subKey: stringified<K>;
 };
 
-export { type ActorToolkit, type AtomEffect, 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 MutableAtomFamilyOptions, type MutableAtomFamilyToken, type MutableAtomOptions, type MutableAtomToken, type Read, type ReadableFamilyToken, type ReadableToken, type ReadonlySelectorFamilyOptions, type ReadonlySelectorFamilyToken, type ReadonlySelectorOptions, type ReadonlySelectorToken, type RegularAtomFamilyOptions, type RegularAtomFamilyToken, type RegularAtomOptions, type RegularAtomToken, 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 WritableFamilyToken, type WritableSelectorFamilyOptions, type WritableSelectorFamilyToken, 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 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 MoleculeCreationClassic, type MoleculeCreationModern, type MoleculeDisposal, type MoleculeDisposalClassic, type MoleculeDisposalModern, type MoleculeFamily, type MoleculeFamilyOptions, type MoleculeFamilyToken, type MoleculeKey, type MoleculeParams, type MoleculeToken, type MoleculeType, type MutableAtomFamilyOptions, type MutableAtomFamilyToken, type MutableAtomOptions, type MutableAtomToken, type Read, type ReadableFamilyToken, type ReadableToken, type ReadonlySelectorFamilyOptions, type ReadonlySelectorFamilyToken, type ReadonlySelectorOptions, type ReadonlySelectorToken, type RegularAtomFamilyOptions, type RegularAtomFamilyToken, type RegularAtomOptions, type RegularAtomToken, 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 WritableFamilyToken, type WritableSelectorFamilyOptions, type WritableSelectorFamilyToken, type WritableSelectorOptions, type WritableSelectorToken, type WritableToken, type Write, atom, atomFamily, belongsTo, disposeState, getState, isToken, makeMolecule, makeRootMoleculeInStore, moleculeFamily, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };

package/dist/index.js

@@ -1,7 +1,7 @@
+export { makeMolecule, makeRootMoleculeInStore, moleculeFamily } from './chunk-ZKG6ZA4I.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 };