atom.io 0.30.0 → 0.30.2

package/dist/chunk-ADMEAXYU.js

@@ -0,0 +1,167 @@
+import { createMoleculeFamily, IMPLICIT, makeMoleculeInStore, Molecule, newest, isChildStore, disposeFromStore } 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`
+  };
+}
+var $provenance = Symbol(`provenance`);
+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 (typeof provenance === `string` && provenance.startsWith(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.startsWith(`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(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(store);
+    const isTransaction = isChildStore(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(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(store);
+  const isTransaction = isChildStore(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);
+  }
+}
+function realm(store) {
+  const root = makeRootMoleculeInStore(`root`, store);
+  return {
+    root,
+    allocate: (provenance, key) => {
+      return allocateIntoStore(store, provenance, key);
+    },
+    deallocate: (claim) => {
+      deallocateFromStore(store, claim);
+    }
+  };
+}
+var T$ = `T$`;
+
+export { $provenance, T$, allocateIntoStore, deallocateFromStore, makeMolecule, makeRootMoleculeInStore, moleculeFamily, realm };

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

@@ -1,7 +1,8 @@
+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';
-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';
+import { subscribeToTimeline, subscribeToTransaction, subscribeToState, arbitrary as arbitrary$1 } from 'atom.io/internal';
 
 // internal/src/arbitrary.ts
 function arbitrary(random = Math.random) {
@@ -120,6 +121,8 @@ var Junction = class {
   cardinality;
   relations = /* @__PURE__ */ new Map();
   contents = /* @__PURE__ */ new Map();
+  isAType;
+  isBType;
   isContent;
   makeContentKey = (a, b) => `${a}:${b}`;
   warn;
@@ -158,36 +161,40 @@ 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);
-    }
-  }
-  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);
+  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(x, ys) {
+    const xRelationsPrev = this.relations.get(x);
+    let a = this.isAType?.(x) ? x : void 0;
+    let b = a === void 0 ? x : void 0;
+    if (xRelationsPrev) {
+      for (const y of xRelationsPrev) {
+        a ??= y;
+        b ??= y;
+        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.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,9 +212,13 @@ 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.isAType = config?.isAType ?? null;
+    this.isBType = config?.isBType ?? null;
     this.isContent = config?.isContent ?? null;
     if (config?.makeContentKey) {
       this.makeContentKey = config.makeContentKey;
@@ -227,7 +238,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);
@@ -240,7 +253,13 @@ var Junction = class {
         };
       }
       for (const [x, ys] of data.relations ?? []) {
-        for (const y of ys) this.addRelation(x, y);
+        let a = this.isAType?.(x) ? x : void 0;
+        let b = a === void 0 ? x : void 0;
+        for (const y of ys) {
+          a ??= y;
+          b ??= y;
+          this.addRelation(a, b);
+        }
       }
       for (const [contentKey, content] of data.contents ?? []) {
         this.setContent(contentKey, content);
@@ -254,7 +273,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 +287,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 +303,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) {
@@ -316,23 +340,26 @@ var Junction = class {
           ].map((k) => `"${k}"`).join(`, `)}). Only one related key was expected.`
         );
       }
+      let singleRelation;
       for (const relation of relations) {
-        return relation;
+        singleRelation = relation;
+        break;
       }
+      return singleRelation;
     }
   }
-  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);
       }
     }
@@ -349,7 +376,7 @@ var Junction = class {
       const aRelations = this.getRelatedKeys(a);
       if (aRelations) {
         return [...aRelations].map((aRelation) => {
-          return [aRelation, this.getContent(a, aRelation) ?? null];
+          return [aRelation, this.getContent(a, aRelation)];
         });
       }
     }
@@ -357,7 +384,7 @@ var Junction = class {
       const bRelations = this.getRelatedKeys(b);
       if (bRelations) {
         return [...bRelations].map((bRelation) => {
-          return [bRelation, this.getContent(bRelation, b) ?? null];
+          return [bRelation, this.getContent(bRelation, b)];
         });
       }
     }
@@ -1729,142 +1756,6 @@ 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`: {

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-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, MoleculeCreationClassic as MoleculeCreationClassic$1, MoleculeDisposalClassic as MoleculeDisposalClassic$1 } from 'atom.io';
 import { findState } from 'atom.io/ephemeral';
@@ -196,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[]>;
@@ -243,6 +243,54 @@ type MoleculeType<T extends MoleculeFamilyToken<any>> = T extends MoleculeFamily
 type MoleculeKey<M extends MoleculeConstructor> = InstanceType<M>[`key`];
 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;
 declare function disposeState<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>): void;
@@ -444,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 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 };
+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 };

package/dist/index.js

@@ -1,4 +1,4 @@
-export { makeMolecule, makeRootMoleculeInStore, moleculeFamily } from './chunk-ZKG6ZA4I.js';
+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, createStandaloneSelector, createSelectorFamily, Store, createTransaction, createTimeline, findInStore, getFromStore, setIntoStore, disposeFromStore, subscribeInStore, timeTravel, createMoleculeFamily, makeMoleculeInStore, actUponStore, arbitrary } from 'atom.io/internal';