atom.io 0.30.6 → 0.31.0

package/dist/chunk-ICGFFQ3H.js

@@ -0,0 +1,272 @@
+import { IMPLICIT, newest, isChildStore, findInStore, disposeFromStore, getTrace } from 'atom.io/internal';
+import { stringifyJson, parseJson } from 'atom.io/json';
+
+// src/molecule.ts
+function makeRootMoleculeInStore(key, store = IMPLICIT.STORE) {
+  const molecule = {
+    key,
+    stringKey: stringifyJson(key),
+    dependsOn: `any`
+  };
+  store.molecules.set(stringifyJson(key), molecule);
+  return key;
+}
+var $claim = Symbol(`claim`);
+function allocateIntoStore(store, provenance, key, dependsOn = `any`) {
+  const origin = provenance;
+  const stringKey = stringifyJson(key);
+  const invalidKeys = [];
+  const target = newest(store);
+  if (Array.isArray(origin)) {
+    for (const formerClaim of origin) {
+      const claimString = stringifyJson(formerClaim);
+      const claim = target.molecules.get(claimString);
+      if (claim) {
+        store.moleculeGraph.set(claimString, stringKey, { source: claimString });
+      } else {
+        invalidKeys.push(claimString);
+      }
+    }
+  } else {
+    const claimString = stringifyJson(origin);
+    const claim = target.molecules.get(claimString);
+    if (claim) {
+      store.moleculeGraph.set(claimString, stringKey, { source: claimString });
+    } else {
+      invalidKeys.push(claimString);
+    }
+  }
+  if (invalidKeys.length === 0) {
+    target.molecules.set(stringKey, { key, stringKey, dependsOn });
+  }
+  const creationEvent = {
+    type: `molecule_creation`,
+    key,
+    provenance: origin
+  };
+  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
+  if (isTransaction) {
+    target.transactionMeta.update.updates.push(creationEvent);
+  } else {
+    target.on.moleculeCreation.next(creationEvent);
+  }
+  for (const claim of invalidKeys) {
+    const disposal = store.disposalTraces.buffer.find(
+      (item) => item?.key === claim
+    );
+    store.logger.error(
+      `\u274C`,
+      `molecule`,
+      key,
+      `allocation failed:`,
+      `Could not allocate to ${claim} in store "${store.config.name}".`,
+      disposal ? `
+   ${claim} was most recently disposed
+${disposal.trace}` : `No previous disposal trace for ${claim} was found.`
+    );
+  }
+  return key;
+}
+function fuseWithinStore(store, type, sideA, sideB) {
+  const compoundKey = `T$--${type}==${sideA}++${sideB}`;
+  const above = [sideA, sideB];
+  allocateIntoStore(
+    store,
+    above,
+    compoundKey,
+    `all`
+  );
+  return compoundKey;
+}
+function deallocateFromStore(store, claim) {
+  const stringKey = stringifyJson(claim);
+  const molecule = store.molecules.get(stringKey);
+  if (!molecule) {
+    const disposal = store.disposalTraces.buffer.find(
+      (item) => item?.key === stringKey
+    );
+    store.logger.error(
+      `\u274C`,
+      `molecule`,
+      claim,
+      `deallocation failed:`,
+      `Could not find allocation for ${stringKey} in store "${store.config.name}".`,
+      disposal ? `
+   This state was most recently deallocated
+${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`
+    );
+    return;
+  }
+  const joinKeys = store.moleculeJoins.getRelatedKeys(
+    molecule.key
+  );
+  if (joinKeys) {
+    for (const joinKey of joinKeys) {
+      const join = store.joins.get(joinKey);
+      if (join) {
+        join.relations.delete(molecule.key);
+        join.molecules.delete(molecule.stringKey);
+      }
+    }
+  }
+  store.moleculeJoins.delete(molecule.stringKey);
+  const provenance = [];
+  const values = [];
+  const disposalEvent = {
+    type: `molecule_disposal`,
+    key: molecule.key,
+    values,
+    provenance
+  };
+  const target = newest(store);
+  target.molecules.delete(stringKey);
+  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
+  if (isTransaction) {
+    target.transactionMeta.update.updates.push(disposalEvent);
+  }
+  const relatedMolecules = store.moleculeGraph.getRelationEntries({
+    downstreamMoleculeKey: molecule.stringKey
+  });
+  if (relatedMolecules) {
+    for (const [relatedStringKey, { source }] of relatedMolecules) {
+      if (source === molecule.stringKey) {
+        const relatedKey = parseJson(relatedStringKey);
+        deallocateFromStore(store, relatedKey);
+      } else {
+        provenance.push(source);
+      }
+    }
+  }
+  const familyKeys = target.moleculeData.getRelatedKeys(molecule.stringKey);
+  if (familyKeys) {
+    for (const familyKey of familyKeys) {
+      const family = target.families.get(familyKey);
+      const token = findInStore(store, family, molecule.key);
+      values.push([family.key, token]);
+      disposeFromStore(store, token);
+    }
+  }
+  target.moleculeGraph.delete(molecule.stringKey);
+  target.moleculeJoins.delete(molecule.stringKey);
+  target.moleculeData.delete(molecule.stringKey);
+  if (!isTransaction) {
+    target.on.moleculeDisposal.next(disposalEvent);
+  }
+  target.molecules.delete(molecule.stringKey);
+  const trace = getTrace(new Error());
+  store.disposalTraces.add({ key: stringKey, trace });
+}
+function claimWithinStore(store, newProvenance, claim, exclusive) {
+  const stringKey = stringifyJson(claim);
+  const target = newest(store);
+  const molecule = target.molecules.get(stringKey);
+  if (!molecule) {
+    const disposal = store.disposalTraces.buffer.find(
+      (item) => item?.key === stringKey
+    );
+    store.logger.error(
+      `\u274C`,
+      `molecule`,
+      claim,
+      `claim failed:`,
+      `Could not allocate to ${stringKey} in store "${store.config.name}".`,
+      disposal ? `
+   ${stringKey} was most recently disposed
+${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`
+    );
+    return claim;
+  }
+  const newProvenanceKey = stringifyJson(newProvenance);
+  const newProvenanceMolecule = target.molecules.get(newProvenanceKey);
+  if (!newProvenanceMolecule) {
+    const disposal = store.disposalTraces.buffer.find(
+      (item) => item?.key === newProvenanceKey
+    );
+    store.logger.error(
+      `\u274C`,
+      `molecule`,
+      claim,
+      `claim failed:`,
+      `Could not allocate to ${newProvenanceKey} in store "${store.config.name}".`,
+      disposal ? `
+   ${newProvenanceKey} was most recently disposed
+${disposal.trace}` : `No previous disposal trace for ${newProvenanceKey} was found.`
+    );
+    return claim;
+  }
+  const priorProvenance = store.moleculeGraph.getRelationEntries({
+    downstreamMoleculeKey: molecule.stringKey
+  }).filter(([, { source }]) => source !== stringKey).map(([key]) => parseJson(key));
+  if (exclusive) {
+    target.moleculeGraph.delete(stringKey);
+  }
+  target.moleculeGraph.set(
+    {
+      upstreamMoleculeKey: newProvenanceMolecule.stringKey,
+      downstreamMoleculeKey: molecule.stringKey
+    },
+    {
+      source: newProvenanceMolecule.stringKey
+    }
+  );
+  const transferEvent = {
+    type: `molecule_transfer`,
+    key: molecule.key,
+    from: priorProvenance,
+    to: [newProvenanceMolecule.key]
+  };
+  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
+  if (isTransaction) {
+    target.transactionMeta.update.updates.push(transferEvent);
+  }
+  return claim;
+}
+var Realm = class {
+  store;
+  constructor(store = IMPLICIT.STORE) {
+    this.store = store;
+    makeRootMoleculeInStore(`root`, store);
+  }
+  allocate(provenance, key, attachmentStyle) {
+    return allocateIntoStore(
+      this.store,
+      provenance,
+      key,
+      attachmentStyle
+    );
+  }
+  fuse(type, reagentA, reagentB) {
+    return fuseWithinStore(this.store, type, reagentA, reagentB);
+  }
+  deallocate(claim) {
+    deallocateFromStore(this.store, claim);
+  }
+  claim(newProvenance, claim, exclusive) {
+    return claimWithinStore(this.store, newProvenance, claim, exclusive);
+  }
+};
+var T$ = `T$`;
+var Anarchy = class {
+  store;
+  realm;
+  constructor(store = IMPLICIT.STORE) {
+    this.store = store;
+    this.realm = new Realm(store);
+  }
+  allocate(provenance, key, attachmentStyle) {
+    allocateIntoStore(
+      this.store,
+      provenance,
+      key,
+      attachmentStyle
+    );
+  }
+  deallocate(key) {
+    deallocateFromStore(this.store, key);
+  }
+  claim(newProvenance, key, exclusive) {
+    claimWithinStore(this.store, newProvenance, key, exclusive);
+  }
+};
+
+export { $claim, Anarchy, Realm, T$, allocateIntoStore, claimWithinStore, deallocateFromStore, fuseWithinStore, makeRootMoleculeInStore };

package/dist/index.d.ts

@@ -1,9 +1,8 @@
-import { Transceiver, Func, EnvironmentData, Flat, Subject, Store, Each, Timeline, TimelineAtomUpdate, TimelineMoleculeCreation, TimelineMoleculeDisposal, TimelineSelectorUpdate, TimelineStateCreation, TimelineStateDisposal, TimelineTransactionUpdate } from 'atom.io/internal';
+import { Transceiver, Func, EnvironmentData, Store, Each, Flat, 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 { getState as getState$1, setState as setState$1, ReadableFamilyToken as ReadableFamilyToken$1, ReadableToken as ReadableToken$1, RegularAtomToken as RegularAtomToken$1, MutableAtomToken as MutableAtomToken$1, WritableSelectorToken as WritableSelectorToken$1, ReadonlySelectorToken as ReadonlySelectorToken$1, WritableToken as WritableToken$1, RegularAtomFamilyToken as RegularAtomFamilyToken$1, MutableAtomFamilyToken as MutableAtomFamilyToken$1, WritableSelectorFamilyToken as WritableSelectorFamilyToken$1, ReadonlySelectorFamilyToken as ReadonlySelectorFamilyToken$1, WritableFamilyToken as WritableFamilyToken$1 } from 'atom.io';
 import { findState } from 'atom.io/ephemeral';
 import { seekState } from 'atom.io/immortal';
-import { JoinToken } from 'atom.io/data';
 
 type Effectors<T> = {
     setSelf: <V extends T>(next: V | ((oldValue: T) => V)) => void;
@@ -77,43 +76,36 @@ type StateCreation<Token extends ReadableToken<any>> = {
     type: `state_creation`;
     token: Token;
 };
-type StateDisposal<Token extends ReadableToken<any>> = {
+type AtomDisposal<Token extends ReadableToken<any>> = {
     type: `state_disposal`;
+    subType: `atom`;
     token: Token;
-    value?: TokenType<Token>;
+    value: TokenType<Token>;
 };
-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 SelectorDisposal<Token extends ReadableToken<any>> = {
+    type: `state_disposal`;
+    subType: `selector`;
+    token: Token;
 };
-type MoleculeCreationModern = {
+type StateDisposal<Token extends ReadableToken<any>> = AtomDisposal<Token> | SelectorDisposal<Token>;
+type MoleculeCreation = {
     type: `molecule_creation`;
-    subType: `modern`;
     key: Canonical;
     provenance: Canonical;
 };
-type MoleculeCreation<M extends MoleculeConstructor$1> = MoleculeCreationClassic<M> | MoleculeCreationModern;
-type MoleculeDisposalClassic = {
+type MoleculeDisposal = {
     type: `molecule_disposal`;
-    subType: `classic`;
-    token: MoleculeToken$1<any>;
-    family: MoleculeFamilyToken$1<any>;
-    context: MoleculeToken$1<any>[];
+    key: Canonical;
+    provenance: stringified<Canonical>[];
     values: [key: string, value: any][];
 };
-type MoleculeDisposalModern = {
-    type: `molecule_disposal`;
-    subType: `modern`;
+type MoleculeTransfer = {
+    type: `molecule_transfer`;
     key: Canonical;
-    provenance: Canonical;
-    values: [key: string, value: any][];
+    from: Canonical[];
+    to: Canonical[];
 };
-type MoleculeDisposal = MoleculeDisposalClassic | MoleculeDisposalModern;
-type TransactionUpdateContent = KeyedStateUpdate<unknown> | MoleculeCreation<any> | MoleculeDisposal | StateCreation<ReadableToken<unknown>> | StateDisposal<ReadableToken<unknown>> | TransactionUpdate<Func>;
+type TransactionUpdateContent = KeyedStateUpdate<unknown> | MoleculeCreation | MoleculeDisposal | MoleculeTransfer | StateCreation<ReadableToken<unknown>> | StateDisposal<ReadableToken<unknown>> | TransactionUpdate<Func>;
 type TransactionUpdate<F extends Func> = {
     type: `transaction_update`;
     key: string;
@@ -137,7 +129,6 @@ type ActorToolkit = Readonly<{
     find: typeof findState;
     seek: typeof seekState;
     json: <T extends Transceiver<any>, J extends Json.Serializable>(state: MutableAtomToken<T, J>) => WritableSelectorToken<J>;
-    make: typeof makeMolecule$1;
     dispose: typeof disposeState;
     run: typeof runTransaction;
     env: () => EnvironmentData;
@@ -189,71 +180,22 @@ type SelectorFamilyToken<T, K extends Canonical> = ReadonlySelectorFamilyToken<T
 declare function selectorFamily<T, K extends Canonical>(options: WritableSelectorFamilyOptions<T, K>): WritableSelectorFamilyToken<T, K>;
 declare function selectorFamily<T, K extends Canonical>(options: ReadonlySelectorFamilyOptions<T, K>): ReadonlySelectorFamilyToken<T, K>;
 
-type CtorToolkit<K extends Canonical> = Flat<Omit<ActorToolkit$1, `find`> & {
-    bond<T extends Transceiver<any>, J extends Json.Serializable>(family: MutableAtomFamilyToken$1<T, J, K>): MutableAtomToken$1<T, J>;
-    bond<T>(family: RegularAtomFamilyToken$1<T, K>): RegularAtomToken$1<T>;
-    bond<T>(family: WritableSelectorFamilyToken$1<T, K>): WritableSelectorToken$1<T>;
-    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, 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[]>;
-        relatedEntries: ReadonlySelectorToken$1<[
-            key: string,
-            value: Content
-        ][]>;
-    } : never;
-    claim(below: MoleculeToken<any>, options: {
-        exclusive: boolean;
-    }): void;
-    spawn<Key extends Canonical, Ctor extends MoleculeConstructor>(family: MoleculeFamilyToken<Ctor>, key: Key, ...params: MoleculeParams<Ctor>): MoleculeToken<Ctor>;
-}>;
-type MoleculeConstructor = new (toolkit: CtorToolkit<any>, key: any, ...params: any) => any;
-type Tail<T extends any[]> = T extends [any, ...infer Rest] ? Rest : any[];
-type MoleculeParams<M extends MoleculeConstructor> = Tail<Tail<ConstructorParameters<M>>>;
-type MoleculeFamilyOptions<M extends MoleculeConstructor> = {
-    key: string;
-    dependsOn?: `all` | `any`;
-    new: M;
-};
-type MoleculeFamilyToken<M extends MoleculeConstructor> = {
-    key: string;
-    type: `molecule_family`;
-    dependsOn: `all` | `any`;
-    __M?: M;
-};
-type MoleculeFamily<M extends MoleculeConstructor> = Flat<MoleculeFamilyToken<M> & {
-    subject: Subject<MoleculeCreationClassic$1<M> | MoleculeDisposalClassic$1>;
-    dependsOn: `all` | `any`;
-    new: M;
-}>;
-type MoleculeToken<M extends MoleculeConstructor> = {
-    key: MoleculeKey<M>;
-    type: `molecule`;
-    family?: MoleculeFamilyToken<M>;
-    __M?: M;
-};
-declare function moleculeFamily<M extends MoleculeConstructor>(options: MoleculeFamilyOptions<M>): MoleculeFamilyToken<M>;
-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 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 $claim: unique symbol;
+type Claim<K extends Canonical> = K & {
+    [$claim]?: true;
+};
+declare function allocateIntoStore<H extends Hierarchy, V extends Vassal<H>, A extends Above<V, H>>(store: Store, provenance: A, key: V, dependsOn?: `all` | `any`): Claim<V>;
+declare function fuseWithinStore<H extends Hierarchy, C extends CompoundFrom<H>, T extends C extends CompoundTypedKey<infer t, any, any> ? t : never, A extends C extends CompoundTypedKey<any, infer a, any> ? a : never, B extends C extends CompoundTypedKey<any, any, infer b> ? b : never>(store: Store, type: T, sideA: SingularTypedKey<A>, sideB: SingularTypedKey<B>): Claim<CompoundTypedKey<T, A, B>>;
+declare function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(store: Store, claim: Claim<V>): void;
+declare function claimWithinStore<H extends Hierarchy, V extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V, H>>(store: Store, newProvenance: A, claim: Claim<V>, exclusive?: `exclusive`): Claim<V>;
+declare class Realm<H extends Hierarchy> {
+    store: Store;
+    constructor(store?: Store);
+    allocate<V extends Vassal<H>, A extends Above<V, H>>(provenance: A, key: V, attachmentStyle?: `all` | `any`): Claim<V>;
+    fuse<C extends CompoundFrom<H>, T extends C extends CompoundTypedKey<infer t, any, any> ? t : never, A extends C extends CompoundTypedKey<any, infer v, any> ? v : never, B extends C extends CompoundTypedKey<any, any, infer m> ? m : never>(type: T, reagentA: SingularTypedKey<A>, reagentB: SingularTypedKey<B>): Claim<CompoundTypedKey<T, A, B>>;
+    deallocate<V extends Vassal<H>>(claim: Claim<V>): void;
+    claim<V extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V, H>>(newProvenance: A, claim: Claim<V>, exclusive?: `exclusive`): Claim<V>;
+}
 declare const T$ = "T$";
 type T$ = typeof T$;
 type TypeTag<T extends string> = `${T$}--${T}`;
@@ -264,7 +206,6 @@ type Scope = SingularTypedKey[];
 type MutualFealty = {
     above: Scope;
     below: CompoundTypedKey;
-    style: `all` | `any`;
 };
 type ExclusiveFealty = {
     above: TypedKey | `root`;
@@ -290,15 +231,23 @@ type Below<TK extends TypedKey | TypedKey[], H extends Hierarchy> = {
 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];
+type CompoundFrom<H extends Hierarchy> = {
+    [K in keyof H]: H[K] extends MutualFealty ? H[K][`below`] : never;
+}[keyof H];
+declare class Anarchy {
+    store: Store;
+    realm: Realm<any>;
+    constructor(store?: Store);
+    allocate(provenance: Canonical, key: Canonical, attachmentStyle?: `all` | `any`): void;
+    deallocate(key: Canonical): void;
+    claim(newProvenance: Canonical, key: Canonical, exclusive?: `exclusive`): void;
+}
 
-declare function disposeState(token: MoleculeToken<any> | ReadableToken<any>): void;
+declare function disposeState(token: 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;
 
 declare function getState<T>(token: ReadableToken<T>): T;
-declare function getState<M extends MoleculeConstructor>(token: MoleculeToken<M>): InstanceType<M>;
 declare function getState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): T;
-declare function getState<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: Canonical): InstanceType<M>;
 
 declare const LoggerIconDictionary: {
     readonly "\u231B": "Timeline event fully captured";
@@ -370,6 +319,8 @@ declare class AtomIOLogger implements Logger {
     warn: LogFn;
 }
 
+declare function makeRootMoleculeInStore<S extends string>(key: S, store?: Store): S;
+
 /**
  * @public
  * Set the value of a state into the implicit store.
@@ -404,8 +355,6 @@ declare class Silo {
     subscribe: typeof subscribe;
     undo: typeof undo;
     redo: typeof redo;
-    moleculeFamily: typeof moleculeFamily;
-    makeMolecule: typeof makeMolecule;
     runTransaction: typeof runTransaction;
     constructor(config: Store[`config`], fromStore?: Store | null);
 }
@@ -434,10 +383,10 @@ type TimelineToken<M> = {
 };
 type TimelineOptions<ManagedAtom extends TimelineManageable> = {
     key: string;
-    scope: (ManagedAtom | MoleculeFamilyToken$1<any>)[];
+    scope: ManagedAtom[];
     shouldCapture?: (update: TimelineUpdate<ManagedAtom>, timeline: Timeline<TimelineManageable>) => boolean;
 };
-type TimelineUpdate<ManagedAtom extends TimelineManageable> = TimelineAtomUpdate<ManagedAtom> | TimelineMoleculeCreation<any> | TimelineMoleculeDisposal | TimelineSelectorUpdate<ManagedAtom> | TimelineStateCreation<AtomOnly<ManagedAtom>> | TimelineStateDisposal<AtomOnly<ManagedAtom>> | TimelineTransactionUpdate;
+type TimelineUpdate<ManagedAtom extends TimelineManageable> = TimelineAtomUpdate<ManagedAtom> | TimelineMoleculeCreation | TimelineMoleculeDisposal | TimelineSelectorUpdate<ManagedAtom> | TimelineStateCreation<AtomOnly<ManagedAtom>> | TimelineStateDisposal<AtomOnly<ManagedAtom>> | TimelineTransactionUpdate;
 declare const timeline: <ManagedAtom extends TimelineManageable>(options: TimelineOptions<ManagedAtom>) => TimelineToken<ManagedAtom>;
 declare const redo: (tl: TimelineToken<any>) => void;
 declare const undo: (tl: TimelineToken<any>) => void;
@@ -492,4 +441,4 @@ type FamilyMetadata<K extends Canonical = any> = {
     subKey: stringified<K>;
 };
 
-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 };
+export { $claim, type Above, type ActorToolkit, Anarchy, type AtomDisposal, type AtomEffect, type AtomFamilyToken, AtomIOLogger, type AtomOnly, type AtomToken, type Below, type Claim, type CompoundFrom, type CompoundTypedKey, type Effectors, type FamilyMetadata, type GetterToolkit, type Hierarchy, type KeyedStateUpdate, LOG_LEVELS, type LogFilter, type LogFn, type LogLevel, type Logger, type LoggerIcon, type MoleculeCreation, type MoleculeDisposal, type MoleculeTransfer, type MutableAtomFamilyOptions, type MutableAtomFamilyToken, type MutableAtomOptions, type MutableAtomToken, type Mutuals, type Read, type ReadableFamilyToken, type ReadableToken, type ReadonlySelectorFamilyOptions, type ReadonlySelectorFamilyToken, type ReadonlySelectorOptions, type ReadonlySelectorToken, Realm, type RegularAtomFamilyOptions, type RegularAtomFamilyToken, type RegularAtomOptions, type RegularAtomToken, type SelectorDisposal, 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, claimWithinStore, deallocateFromStore, disposeState, fuseWithinStore, getState, isToken, makeRootMoleculeInStore, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };

package/dist/index.js

@@ -1,7 +1,7 @@
-export { $provenance, T$, allocateIntoStore, deallocateFromStore, makeMolecule, makeRootMoleculeInStore, moleculeFamily, realm } from './chunk-ADMEAXYU.js';
+export { $claim, Anarchy, Realm, T$, allocateIntoStore, claimWithinStore, deallocateFromStore, fuseWithinStore, makeRootMoleculeInStore } from './chunk-ICGFFQ3H.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';
+import { createStandaloneAtom, IMPLICIT, createAtomFamily, createStandaloneSelector, createSelectorFamily, Store, createTransaction, createTimeline, findInStore, getFromStore, setIntoStore, disposeFromStore, subscribeInStore, timeTravel, actUponStore, arbitrary } from 'atom.io/internal';
 
 function atom(options) {
   return createStandaloneAtom(IMPLICIT.STORE, options);
@@ -9,7 +9,7 @@ function atom(options) {
 function atomFamily(options) {
   return createAtomFamily(IMPLICIT.STORE, options);
 }
-function disposeState(token, key) {
+function disposeState(...[token, key]) {
   if (key) {
     Internal.disposeFromStore(Internal.IMPLICIT.STORE, token, key);
   } else {
@@ -86,8 +86,6 @@ var Silo = class {
   subscribe;
   undo;
   redo;
-  moleculeFamily;
-  makeMolecule;
   runTransaction;
   constructor(config, fromStore = null) {
     const s = new Store(config, fromStore);
@@ -113,12 +111,6 @@ var Silo = class {
     this.redo = (token) => {
       timeTravel(s, `redo`, token);
     };
-    this.moleculeFamily = (options) => {
-      return createMoleculeFamily(s, options);
-    };
-    this.makeMolecule = (...params) => {
-      return makeMoleculeInStore(s, ...params);
-    };
     this.runTransaction = (token, id = arbitrary()) => actUponStore(token, id, s);
   }
 };

package/eslint-plugin/dist/index.d.ts

@@ -1,3 +1,4 @@
+import * as _eslint_core from '@eslint/core';
 import * as ESTree from 'estree';
 import * as eslint from 'eslint';
 import { Rule } from 'eslint';
@@ -20,7 +21,13 @@ declare const lifespan: {
             default: string;
         }[];
     };
-    create(context: Rule.RuleContext): {
+    create(context: _eslint_core.RuleContext<{
+        LangOptions: eslint.Linter.LanguageOptions;
+        Code: eslint.SourceCode;
+        RuleOptions: any[];
+        Node: ESTree.Node;
+        MessageIds: string;
+    }>): {
         ImportDeclaration(node: ESTree.ImportDeclaration & Rule.NodeParentExtension): void;
         CallExpression(node: ESTree.CallExpression & Rule.NodeParentExtension): void;
     };
@@ -37,7 +44,13 @@ declare const synchronousSelectorDependencies: {
         };
         schema: never[];
     };
-    create(context: Rule.RuleContext): {
+    create(context: _eslint_core.RuleContext<{
+        LangOptions: eslint.Linter.LanguageOptions;
+        Code: eslint.SourceCode;
+        RuleOptions: any[];
+        Node: ESTree.Node;
+        MessageIds: string;
+    }>): {
         CallExpression(node: ESTree.CallExpression & Rule.NodeParentExtension): void;
     };
 };
@@ -64,7 +77,13 @@ declare const _default: {
                 };
                 schema: never[];
             };
-            create(context: eslint.Rule.RuleContext): {
+            create(context: _eslint_core.RuleContext<{
+                LangOptions: eslint.Linter.LanguageOptions;
+                Code: eslint.SourceCode;
+                RuleOptions: any[];
+                Node: ESTree.Node;
+                MessageIds: string;
+            }>): {
                 CallExpression(node: ESTree.CallExpression & eslint.Rule.NodeParentExtension): void;
             };
         };

package/eslint-plugin/dist/index.js

@@ -172,10 +172,10 @@ var lifespan = {
         if (storeLifespan === `ephemeral`) {
           return;
         }
-        const functionCallee = node.callee.type === `Identifier` ? node.callee : void 0;
-        const methodCallee = node.callee.type === `MemberExpression` && node.callee.property.type === `Identifier` ? node.callee.property : void 0;
+        const functionCallee = node.callee.type === `Identifier` ? node.callee : undefined;
+        const methodCallee = node.callee.type === `MemberExpression` && node.callee.property.type === `Identifier` ? node.callee.property : undefined;
         const callee = functionCallee ?? methodCallee;
-        if (callee === void 0) {
+        if (callee === undefined) {
           return;
         }
         if (callee.name === `findState`) {
@@ -247,7 +247,7 @@ var lifespan = {
         }
         for (const storeProcedure of storeProcedures) {
           const transactorsParam = storeProcedure.params[0];
-          const nonDestructuredTransactorsName = transactorsParam && `name` in transactorsParam ? transactorsParam.name : void 0;
+          const nonDestructuredTransactorsName = transactorsParam && `name` in transactorsParam ? transactorsParam.name : undefined;
           walk(storeProcedure.body, (n) => {
             if (n.type === `CallExpression`) {
               let willReport = false;
@@ -327,14 +327,14 @@ var synchronousSelectorDependencies = {
           }
         }
         if (selectorComputation?.type === `FunctionExpression` || selectorComputation?.type === `ArrowFunctionExpression`) {
-          const nonDestructuredTransactorsName = selectorComputation.params[0] && `name` in selectorComputation.params[0] ? selectorComputation.params[0].name : void 0;
+          const nonDestructuredTransactorsName = selectorComputation.params[0] && `name` in selectorComputation.params[0] ? selectorComputation.params[0].name : undefined;
           let awaited;
           let awaitNode;
           walk(selectorComputation, (n, depth) => {
             if (typeof awaited === `number`) {
               if (awaited > depth) {
-                awaited = void 0;
-                awaitNode = void 0;
+                awaited = undefined;
+                awaitNode = undefined;
               }
             }
             switch (n.type) {

package/immortal/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, ReadableToken, MoleculeConstructor, MoleculeFamilyToken, MoleculeKey, MoleculeToken } from 'atom.io';
+import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, ReadableToken } from 'atom.io';
 import { Transceiver } from 'atom.io/internal';
 import { Json, Canonical } from 'atom.io/json';
 
@@ -8,6 +8,5 @@ declare function seekState<T, K extends Canonical, Key extends K>(token: Writabl
 declare function seekState<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T, K> | undefined;
 declare function seekState<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T, K> | undefined;
 declare function seekState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T, K> | undefined;
-declare function seekState<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>): MoleculeToken<M> | undefined;
 
 export { seekState };