atom.io 0.29.5 → 0.30.1

package/dist/{chunk-TCINPEYE.js → chunk-SMKF3ZNG.js}

@@ -1,3 +1,4 @@
+import { deallocateFromStore, allocateIntoStore } from './chunk-ADMEAXYU.js';
 import { stringifyJson, parseJson, selectJson, selectJsonFamily } from 'atom.io/json';
 import { AtomIOLogger } from 'atom.io';
 import { getJoin, findRelations } from 'atom.io/data';
@@ -158,36 +159,36 @@ var Junction = class {
       }
     }
   }
-  replaceRelationsUnsafely(a, bs) {
-    this.relations.set(a, new Set(bs));
-    for (const b of bs) {
-      const bRelations = /* @__PURE__ */ new Set([a]);
-      this.relations.set(b, bRelations);
+  replaceRelationsUnsafely(x, ys) {
+    this.relations.set(x, new Set(ys));
+    for (const y of ys) {
+      const yRelations = (/* @__PURE__ */ new Set()).add(x);
+      this.relations.set(y, yRelations);
     }
   }
-  replaceRelationsSafely(a, bs) {
-    const aRelationsPrev = this.relations.get(a);
-    if (aRelationsPrev) {
-      for (const b of aRelationsPrev) {
-        const bRelations = this.relations.get(b);
-        if (bRelations) {
-          if (bRelations.size === 1) {
-            this.relations.delete(b);
+  replaceRelationsSafely(x, ys) {
+    const xRelationsPrev = this.relations.get(x);
+    if (xRelationsPrev) {
+      for (const y of xRelationsPrev) {
+        const yRelations = this.relations.get(y);
+        if (yRelations) {
+          if (yRelations.size === 1) {
+            this.relations.delete(y);
           } else {
-            bRelations.delete(a);
+            yRelations.delete(x);
           }
-          this.contents.delete(this.makeContentKey(a, b));
+          this.contents.delete(this.makeContentKey(x, y));
         }
       }
     }
-    this.relations.set(a, new Set(bs));
-    for (const b of bs) {
-      let bRelations = this.relations.get(b);
-      if (bRelations) {
-        bRelations.add(a);
+    this.relations.set(x, new Set(ys));
+    for (const y of ys) {
+      let yRelations = this.relations.get(y);
+      if (yRelations) {
+        yRelations.add(x);
       } else {
-        bRelations = /* @__PURE__ */ new Set([a]);
-        this.relations.set(b, bRelations);
+        yRelations = (/* @__PURE__ */ new Set()).add(x);
+        this.relations.set(y, yRelations);
       }
     }
   }
@@ -205,7 +206,9 @@ var Junction = class {
     this.b = data.between[1];
     this.cardinality = data.cardinality;
     if (!config?.externalStore) {
-      this.relations = new Map(data.relations?.map(([a, b]) => [a, new Set(b)]));
+      this.relations = new Map(
+        data.relations?.map(([x, ys]) => [x, new Set(ys)])
+      );
       this.contents = new Map(data.contents);
     }
     this.isContent = config?.isContent ?? null;
@@ -227,7 +230,9 @@ var Junction = class {
       this.replaceRelationsUnsafely = (a, bs) => {
         externalStore.replaceRelationsUnsafely(a, bs);
       };
-      this.getRelatedKeys = (key) => externalStore.getRelatedKeys(key);
+      this.getRelatedKeys = (key) => externalStore.getRelatedKeys(
+        key
+      );
       if (externalStore.getContent) {
         this.getContentInternal = (contentKey) => {
           return externalStore.getContent(contentKey);
@@ -254,7 +259,9 @@ var Junction = class {
     return {
       between: [this.a, this.b],
       cardinality: this.cardinality,
-      relations: [...this.relations.entries()].map(([a, b]) => [a, [...b]]),
+      relations: [...this.relations.entries()].map(
+        ([a, b]) => [a, [...b]]
+      ),
       contents: [...this.contents.entries()]
     };
   }
@@ -266,7 +273,7 @@ var Junction = class {
       // biome-ignore lint/suspicious/noFallthroughSwitchClause: perfect here
       case `1:1`: {
         const bPrev = this.getRelatedKey(a);
-        if (bPrev && bPrev !== b) this.delete(bPrev, a);
+        if (bPrev && bPrev !== b) this.delete(a, bPrev);
       }
       case `1:n`: {
         const aPrev = this.getRelatedKey(b);
@@ -282,7 +289,10 @@ var Junction = class {
   }
   delete(x, b) {
     b = typeof b === `string` ? b : x[this.b];
-    const a = typeof x === `string` ? x : x[this.a];
+    const a = (
+      // @ts-expect-error we deduce that this.a may index x
+      typeof x === `string` ? x : x[this.a]
+    );
     if (a === void 0 && typeof b === `string`) {
       const bRelations = this.getRelatedKeys(b);
       if (bRelations) {
@@ -321,18 +331,18 @@ var Junction = class {
       }
     }
   }
-  replaceRelations(a, relations, config) {
+  replaceRelations(x, relations, config) {
     const hasContent = !Array.isArray(relations);
-    const bs = hasContent ? Object.keys(relations) : relations;
+    const ys = hasContent ? Object.keys(relations) : relations;
     if (config?.reckless) {
-      this.replaceRelationsUnsafely(a, bs);
+      this.replaceRelationsUnsafely(x, ys);
     } else {
-      this.replaceRelationsSafely(a, bs);
+      this.replaceRelationsSafely(x, ys);
     }
     if (hasContent) {
-      for (const b of bs) {
-        const contentKey = this.makeContentKey(a, b);
-        const content = relations[b];
+      for (const y of ys) {
+        const contentKey = this.makeContentKey(x, y);
+        const content = relations[y];
         this.setContent(contentKey, content);
       }
     }
@@ -1304,6 +1314,7 @@ function disposeMolecule(token, store) {
     const Formula = withdraw(family, store);
     const disposalEvent = {
       type: `molecule_disposal`,
+      subType: `classic`,
       token,
       family,
       context,
@@ -1316,7 +1327,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 +1391,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 +1467,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 +1529,7 @@ function makeMoleculeInStore(store, context, familyToken, key, ...params) {
   };
   const update = {
     type: `molecule_creation`,
+    subType: `classic`,
     token,
     family: familyToken,
     context: contextArray,
@@ -1758,41 +1776,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 +3036,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 +3303,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 +3425,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 +3471,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/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 { Transceiver, Func, EnvironmentData, Flat, Subject, Store, Each, 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`;
@@ -179,9 +196,9 @@ type CtorToolkit<K extends Canonical> = Flat<Omit<ActorToolkit$1, `find`> & {
     bond<T>(family: ReadonlySelectorFamilyToken$1<T, K>): ReadonlySelectorToken$1<T>;
     bond<T>(family: WritableFamilyToken$1<T, K>): WritableToken$1<T>;
     bond<T>(family: ReadableFamilyToken$1<T, K>): ReadableToken$1<T>;
-    bond<J extends JoinToken<any, any, any, any>>(joinToken: J, role: {
-        as: J extends JoinToken<infer A, infer B, any, any> ? A | B : never;
-    }): J extends JoinToken<any, any, any, infer Content> ? Content extends null ? {
+    bond<J extends JoinToken<any, any, any, any, any, any>>(joinToken: J, role: {
+        as: J extends JoinToken<infer A, string, infer B, string, any, any> ? A | B : never;
+    }): J extends JoinToken<any, any, any, any, any, infer Content> ? Content extends null ? {
         relatedKeys: ReadonlySelectorToken$1<string[]>;
     } : {
         relatedKeys: ReadonlySelectorToken$1<string[]>;
@@ -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,55 @@ 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 const $provenance: unique symbol;
+type Claim<H extends Hierarchy, V extends Vassal<H>, A extends Above<V, H>> = V & {
+    [$provenance]?: A;
+};
+declare function allocateIntoStore<H extends Hierarchy, V extends Vassal<H>, A extends Above<V, H>>(store: Store, provenance: A, key: V): Claim<H, V, A>;
+declare function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>, A extends Above<V, H>>(store: Store, claim: Claim<H, V, A>): void;
+declare function realm<H extends Hierarchy>(store: Store): {
+    root: MoleculeToken<ObjectConstructor>;
+    allocate: <V extends Vassal<H>, A extends Above<V, H>>(provenance: A, key: V) => Claim<H, V, A>;
+    deallocate: <V extends Vassal<H>, A extends Above<V, H>>(claim: Claim<H, V, A>) => void;
+};
+declare const T$ = "T$";
+type T$ = typeof T$;
+type TypeTag<T extends string> = `${T$}--${T}`;
+type SingularTypedKey<T extends string = string> = `${T}::${string}`;
+type CompoundTypedKey<A extends string = string, B extends string = string, C extends string = string> = `${TypeTag<A>}==${SingularTypedKey<B>}++${SingularTypedKey<C>}`;
+type TypedKey<A extends string = string, B extends string = string, C extends string = string> = CompoundTypedKey<A, B, C> | SingularTypedKey<A>;
+type Scope = SingularTypedKey[];
+type MutualFealty = {
+    above: Scope;
+    below: CompoundTypedKey;
+    style: `all` | `any`;
+};
+type ExclusiveFealty = {
+    above: TypedKey | `root`;
+    below: Scope;
+};
+type Fealty = ExclusiveFealty | MutualFealty;
+type Hierarchy<F extends Fealty[] = Fealty[]> = Each<F>;
+type Vassal<H extends Hierarchy> = {
+    [K in keyof H]: H[K] extends MutualFealty ? H[K][`below`] : H[K] extends {
+        below: Array<infer V>;
+    } ? V extends TypedKey ? V : never : never;
+}[keyof H];
+type Above<TK extends TypedKey, H extends Hierarchy> = {
+    [K in keyof H]: H[K] extends MutualFealty ? TK extends H[K][`below`] ? H[K][`above`] : never : H[K] extends {
+        below: Array<infer V>;
+    } ? TK extends V ? H[K] extends ExclusiveFealty ? H[K][`above`] : never : never : never;
+}[keyof H];
+type Below<TK extends TypedKey | TypedKey[], H extends Hierarchy> = {
+    [K in keyof H]: H[K] extends MutualFealty ? TK extends H[K][`above`] ? H[K][`below`] : TK extends H[K][`above`][number] ? H[K][`below`] : never : H[K] extends {
+        above: infer V;
+    } ? TK extends V ? H[K] extends ExclusiveFealty ? H[K][`below`][number] : never : never : never;
+}[keyof H];
+type Mutuals<TK extends TypedKey | TypedKey[], H extends Hierarchy> = {
+    [K in keyof H]: H[K] extends MutualFealty ? TK extends H[K][`above`][number] ? [mutual: Exclude<H[K][`above`][number], TK>, below: H[K][`below`]] : never : never;
+}[keyof H];
 
 declare function disposeState(token: MoleculeToken<any> | ReadableToken<any>): void;
 declare function disposeState<K extends Canonical>(token: ReadableFamilyToken<any, K>, key: K): void;
@@ -427,4 +492,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 { $provenance, type Above, type ActorToolkit, type AtomEffect, type AtomFamilyToken, AtomIOLogger, type AtomOnly, type AtomToken, type Below, type Claim, type CompoundTypedKey, type CtorToolkit, type Effectors, type FamilyMetadata, type GetterToolkit, type Hierarchy, 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 Mutuals, 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 SingularTypedKey, type StateCreation, type StateDisposal, type StateUpdate, T$, 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 TypeTag, type TypedKey, type UpdateHandler, type Vassal, type WritableFamilyToken, type WritableSelectorFamilyOptions, type WritableSelectorFamilyToken, type WritableSelectorOptions, type WritableSelectorToken, type WritableToken, type Write, allocateIntoStore, atom, atomFamily, belongsTo, deallocateFromStore, disposeState, getState, isToken, makeMolecule, makeRootMoleculeInStore, moleculeFamily, realm, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };