atom.io 0.31.1 → 0.32.1

package/eslint-plugin/dist/index.js

@@ -5,7 +5,6 @@ import { ESLintUtils } from '@typescript-eslint/utils';
 var rules_exports = {};
 __export(rules_exports, {
   explicitStateTypes: () => explicitStateTypes,
-  lifespan: () => lifespan,
   synchronousSelectorDependencies: () => synchronousSelectorDependencies
 });
 var createRule = ESLintUtils.RuleCreator(
@@ -133,150 +132,6 @@ function walk(node, callback, depth = 0) {
   }
 }
 
-// eslint-plugin/src/rules/lifespan.ts
-var lifespan = {
-  meta: {
-    type: `problem`,
-    docs: {
-      description: `atom.io provides tools for short-lived (ephemeral) and long-lived (immortal) stores. This rule allows you to guard against unsafe usage of tools for the other type of store.`,
-      category: `Possible Errors`,
-      recommended: false,
-      url: ``
-      // URL to documentation page for this rule
-    },
-    schema: [
-      {
-        type: `string`,
-        enum: [`ephemeral`, `immortal`],
-        default: `ephemeral`
-      }
-    ]
-  },
-  create(context) {
-    const storeLifespan = context.options[0] ?? `ephemeral`;
-    return {
-      ImportDeclaration(node) {
-        const importSource = node.source.value;
-        if (!importSource.startsWith(`atom.io/`)) {
-          return;
-        }
-        const [_, subPackageName] = importSource.split(`/`);
-        if (storeLifespan === `immortal` && subPackageName === `ephemeral`) {
-          context.report({
-            node,
-            message: `do not import from "${importSource}" in an ${storeLifespan} store`
-          });
-        }
-      },
-      CallExpression(node) {
-        if (storeLifespan === `ephemeral`) {
-          return;
-        }
-        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 === undefined) {
-          return;
-        }
-        if (callee.name === `findState`) {
-          context.report({
-            node,
-            message: `do not use findState in an ${storeLifespan} store`
-          });
-        }
-        const storeProcedures = [];
-        if (callee.name === `selector` || callee.name === `selectorFamily` || callee.name === `transaction`) {
-          if (node.arguments[0].type === `ObjectExpression`) {
-            const argProperties = node.arguments[0].properties;
-            switch (callee.name) {
-              case `selector`:
-              case `selectorFamily`:
-                {
-                  const getAndSetProps = argProperties.filter(
-                    (prop) => {
-                      return `key` in prop && `name` in prop.key && (prop.key.name === `get` || prop.key.name === `set`);
-                    }
-                  );
-                  switch (callee.name) {
-                    case `selector`:
-                      {
-                        for (const prop of getAndSetProps) {
-                          if (prop.value.type === `FunctionExpression` || prop.value.type === `ArrowFunctionExpression`) {
-                            storeProcedures.push(prop.value);
-                          }
-                        }
-                      }
-                      break;
-                    case `selectorFamily`:
-                      {
-                        for (const prop of getAndSetProps) {
-                          const { value } = prop;
-                          if (value.type === `FunctionExpression` || value.type === `ArrowFunctionExpression`) {
-                            if (value.body.type === `BlockStatement`) {
-                              for (const statement of value.body.body) {
-                                if (statement.type === `ReturnStatement` && statement.argument && (statement.argument.type === `FunctionExpression` || statement.argument.type === `ArrowFunctionExpression`)) {
-                                  storeProcedures.push(statement.argument);
-                                }
-                              }
-                            } else if (value.body.type === `FunctionExpression` || value.body.type === `ArrowFunctionExpression`) {
-                              storeProcedures.push(value.body);
-                            }
-                          }
-                        }
-                      }
-                      break;
-                  }
-                }
-                break;
-              case `transaction`:
-                {
-                  const doProp = argProperties.find(
-                    (prop) => {
-                      return `key` in prop && `name` in prop.key && prop.key.name === `do`;
-                    }
-                  );
-                  if (doProp) {
-                    if (doProp.value.type === `FunctionExpression` || doProp.value.type === `ArrowFunctionExpression`) {
-                      storeProcedures.push(doProp.value);
-                    }
-                  }
-                }
-                break;
-            }
-          }
-        }
-        for (const storeProcedure of storeProcedures) {
-          const transactorsParam = storeProcedure.params[0];
-          const nonDestructuredTransactorsName = transactorsParam && `name` in transactorsParam ? transactorsParam.name : undefined;
-          walk(storeProcedure.body, (n) => {
-            if (n.type === `CallExpression`) {
-              let willReport = false;
-              switch (n.callee.type) {
-                case `MemberExpression`:
-                  if (n.callee.object.type === `Identifier` && n.callee.object.name === nonDestructuredTransactorsName && n.callee.property.type === `Identifier` && n.callee.property.name === `find`) {
-                    willReport = true;
-                  }
-                  break;
-                case `Identifier`:
-                  if (n.callee.name === `find`) {
-                    willReport = true;
-                  }
-                  break;
-              }
-              if (willReport) {
-                context.report({
-                  node: n,
-                  message: `Using find in a transactor is not allowed in an immortal store.`
-                });
-              }
-            }
-          });
-        }
-      }
-    };
-  }
-};
-
 // eslint-plugin/src/rules/synchronous-selector-dependencies.ts
 var synchronousSelectorDependencies = {
   meta: {
@@ -327,14 +182,14 @@ var synchronousSelectorDependencies = {
           }
         }
         if (selectorComputation?.type === `FunctionExpression` || selectorComputation?.type === `ArrowFunctionExpression`) {
-          const nonDestructuredTransactorsName = selectorComputation.params[0] && `name` in selectorComputation.params[0] ? selectorComputation.params[0].name : undefined;
+          const nonDestructuredTransactorsName = selectorComputation.params[0] && `name` in selectorComputation.params[0] ? selectorComputation.params[0].name : void 0;
           let awaited;
           let awaitNode;
           walk(selectorComputation, (n, depth) => {
             if (typeof awaited === `number`) {
               if (awaited > depth) {
-                awaited = undefined;
-                awaitNode = undefined;
+                awaited = void 0;
+                awaitNode = void 0;
               }
             }
             switch (n.type) {
@@ -376,7 +231,6 @@ var synchronousSelectorDependencies = {
 var src_default = {
   rules: {
     "explicit-state-types": explicitStateTypes,
-    lifespan,
     "synchronous-selector-dependencies": synchronousSelectorDependencies
   }
 };

package/eslint-plugin/src/index.ts

@@ -7,7 +7,6 @@ export { Rules }
 export default {
 	rules: {
 		"explicit-state-types": Rules.explicitStateTypes as any,
-		lifespan: Rules.lifespan as any,
 		"synchronous-selector-dependencies": Rules.synchronousSelectorDependencies,
 	},
 } satisfies ESLint.Plugin

package/eslint-plugin/src/rules/explicit-state-types.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/switch-exhaustiveness-check */
 import { ESLintUtils } from "@typescript-eslint/utils"
 
 const createRule = ESLintUtils.RuleCreator(

package/eslint-plugin/src/rules/index.ts

@@ -1,3 +1,2 @@
 export * from "./explicit-state-types"
-export * from "./lifespan"
 export * from "./synchronous-selector-dependencies"

package/eslint-plugin/src/rules/synchronous-selector-dependencies.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/switch-exhaustiveness-check */
 import type { Rule } from "eslint"
 import type * as ESTree from "estree"
 

package/eslint-plugin/src/walk.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/switch-exhaustiveness-check */
 import type * as ESTree from "estree"
 
 export function walk(

package/internal/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, AtomFamilyToken, AtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, SelectorFamilyToken, SelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, ReadableToken, TransactionToken, TransactionUpdate, TransactionOptions, ActorToolkit, TimelineManageable, TimelineToken, AtomIOToken, Hierarchy, Vassal, Above, Claim, CompoundFrom, CompoundTypedKey, SingularTypedKey, StateUpdate, TokenType, FamilyMetadata, StateCreation, StateDisposal, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, AtomIOLogger, Logger, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, KeyedStateUpdate, MoleculeTransfer, ReadonlySelectorOptions, WritableSelectorOptions, SetterToolkit, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
+import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, AtomFamilyToken, AtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, SelectorFamilyToken, SelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, ReadableToken, TransactionToken, TransactionUpdate, TransactionOptions, ActorToolkit, TimelineManageable, TimelineToken, AtomIOToken, JoinToken, JoinStates, Hierarchy, Vassal, Above, Claim, CompoundFrom, CompoundTypedKey, SingularTypedKey, JoinOptions, SetterToolkit, Anarchy, TimelineUpdate, StateUpdate, TokenType, FamilyMetadata, StateCreation, StateDisposal, MoleculeCreation, MoleculeDisposal, TimelineOptions, AtomIOLogger, Logger, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, KeyedStateUpdate, MoleculeTransfer, ReadonlySelectorOptions, WritableSelectorOptions, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
 import { Json, Canonical, stringified, JsonInterface } from 'atom.io/json';
-import { Join } from 'atom.io/data';
+import { SetRTX, SetRTXJson } from 'atom.io/transceivers/set-rtx';
 import { Store as Store$1, Func as Func$1 } from 'atom.io/internal';
 
 declare class CircularBuffer<T> {
@@ -142,11 +142,11 @@ declare class Junction<const ASide extends string, const AType extends string, c
 
 declare const abortTransaction: (store: Store) => void;
 
-declare function actUponStore<F extends Func>(token: TransactionToken<F>, id: string, store: Store): (...parameters: Parameters<F>) => ReturnType<F>;
+declare function actUponStore<F extends Func>(store: Store, token: TransactionToken<F>, id: string): (...parameters: Parameters<F>) => ReturnType<F>;
 
 declare const applyTransaction: <F extends Func>(output: ReturnType<F>, store: Store) => void;
 
-declare function assignTransactionToContinuity(continuityKey: string, transactionKey: string, store: Store): void;
+declare function assignTransactionToContinuity(store: Store, continuityKey: string, transactionKey: string): void;
 
 interface RootStore extends Store {
     transactionMeta: TransactionEpoch;
@@ -161,7 +161,7 @@ interface ChildStore extends Store {
 declare function isRootStore(store: Store): store is RootStore;
 declare function isChildStore(store: Store): store is ChildStore;
 
-declare const buildTransaction: (key: string, params: any[], store: Store, id: string) => ChildStore;
+declare const buildTransaction: (store: Store, key: string, params: any[], id: string) => ChildStore;
 
 declare class Subject<T> {
     Subscriber: (value: T) => void;
@@ -183,14 +183,14 @@ type Transaction<F extends Func> = {
     subject: Subject<TransactionUpdate<F>>;
     run: (parameters: Parameters<F>, id?: string) => ReturnType<F>;
 };
-declare function createTransaction<F extends Func>(options: TransactionOptions<F>, store: Store): TransactionToken<F>;
+declare function createTransaction<F extends Func>(store: Store, options: TransactionOptions<F>): TransactionToken<F>;
 
-declare function getContinuityKey(transactionKey: string, store: Store): string | undefined;
-declare function getEpochNumberOfContinuity(continuityKey: string, store: Store): number | undefined;
-declare function getEpochNumberOfAction(transactionKey: string, store: Store): number | undefined;
+declare function getContinuityKey(store: Store, transactionKey: string): string | undefined;
+declare function getEpochNumberOfContinuity(store: Store, continuityKey: string): number | undefined;
+declare function getEpochNumberOfAction(store: Store, transactionKey: string): number | undefined;
 
-declare function setEpochNumberOfContinuity(continuityKey: string, newEpoch: number, store: Store): void;
-declare function setEpochNumberOfAction(transactionKey: string, newEpoch: number, store: Store): void;
+declare function setEpochNumberOfContinuity(store: Store, continuityKey: string, newEpoch: number): void;
+declare function setEpochNumberOfAction(store: Store, transactionKey: string, newEpoch: number): void;
 
 declare const TRANSACTION_PHASES: readonly ["idle", "building", "applying"];
 type TransactionPhase = (typeof TRANSACTION_PHASES)[number];
@@ -224,11 +224,11 @@ declare function deposit<T extends Func>(state: Transaction<T>): TransactionToke
 declare function deposit<M extends TimelineManageable>(state: Timeline<M>): TimelineToken<M>;
 declare function deposit(resource: AtomIOInternalResource): AtomIOToken;
 
-interface Lineage {
-    parent: typeof this | null;
-    child: typeof this | null;
-}
-declare function newest<T extends Lineage>(scion: T): T;
+declare function editRelationsInStore<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>, change: (relations: Junction<ASide, AType, BSide, BType, Content>) => void, store: Store): void;
+
+declare function findRelationsInStore<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>, key: AType | BType, store: Store): JoinStates<ASide, AType, BSide, BType, Cardinality, Content>;
+
+declare function getInternalRelationsFromStore(token: JoinToken<any, any, any, any, any, any>, store: Store): MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string>;
 
 type Molecule<K extends Canonical> = {
     readonly key: K;
@@ -241,6 +241,74 @@ declare function fuseWithinStore<H extends Hierarchy, C extends CompoundFrom<H>,
 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>;
 
+type JoinStateFamilies<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null> = Cardinality extends `1:1` ? (Content extends Json.Object ? {
+    readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<[
+        AType,
+        Content
+    ] | null, BType>;
+} & {
+    readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[
+        BType,
+        Content
+    ] | null, AType>;
+} : {}) & {
+    readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<AType | null, BType>;
+} & {
+    readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<BType | null, AType>;
+} : Cardinality extends `1:n` ? (Content extends Json.Object ? {
+    readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<[
+        AType,
+        Content
+    ] | null, BType>;
+} & {
+    readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[
+        BType,
+        Content
+    ][], AType>;
+} : {}) & {
+    readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<AType | null, BType>;
+} & {
+    readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<BType[], AType>;
+} : Cardinality extends `n:n` ? (Content extends Json.Object ? {
+    readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<[
+        AType,
+        Content
+    ][], BType>;
+} & {
+    readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[
+        BType,
+        Content
+    ][], AType>;
+} : {}) & {
+    readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<AType[], BType>;
+} & {
+    readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<BType[], AType>;
+} : never;
+declare class Join<const ASide extends string, const AType extends string, const BSide extends string, const BType extends string, const Cardinality extends `1:1` | `1:n` | `n:n`, const Content extends Json.Object | null = null, const ContentKey extends CompoundTypedKey<`content`, ASide, BSide> = CompoundTypedKey<`content`, ASide, BSide>> {
+    private toolkit;
+    options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>;
+    defaultContent: Content | undefined;
+    molecules: Map<string, Molecule<any>>;
+    relations: Junction<ASide, AType, BSide, BType, Content>;
+    states: JoinStateFamilies<ASide, AType, BSide, BType, Cardinality, Content>;
+    core: {
+        relatedKeysAtoms: MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string>;
+    };
+    transact(toolkit: SetterToolkit, run: (join: Join<ASide, AType, BSide, BType, Cardinality, Content>) => void): void;
+    store: Store;
+    realm: Anarchy;
+    [Symbol.dispose](): void;
+    constructor(options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>, defaultContent: Content | undefined, store?: Store);
+}
+
+declare function getJoin<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>, store: Store): Join<ASide, AType, BSide, BType, Cardinality, Content>;
+
+interface Lineage {
+    parent: typeof this | null;
+    child: typeof this | null;
+}
+declare function newest<T extends Lineage>(scion: T): T;
+
 type OperationProgress = {
     open: false;
 } | {
@@ -297,7 +365,7 @@ type Timeline<ManagedAtom extends TimelineManageable> = {
     subject: Subject<TimelineUpdate<ManagedAtom> | `redo` | `undo`>;
     subscriptions: Map<string, () => void>;
 };
-declare function createTimeline<ManagedAtom extends TimelineManageable>(options: TimelineOptions<ManagedAtom>, store: Store, data?: Timeline<ManagedAtom>): TimelineToken<ManagedAtom>;
+declare function createTimeline<ManagedAtom extends TimelineManageable>(store: Store, options: TimelineOptions<ManagedAtom>, data?: Timeline<ManagedAtom>): TimelineToken<ManagedAtom>;
 
 declare const timeTravel: (store: Store, action: `redo` | `undo`, token: TimelineToken<any>) => void;
 
@@ -360,27 +428,27 @@ declare const IMPLICIT: {
 };
 declare const clearStore: (store: Store) => void;
 
-declare function withdraw<T>(token: RegularAtomToken<T>, store: Store): RegularAtom<T>;
-declare function withdraw<T extends Transceiver<any>>(token: MutableAtomToken<T, any>, store: Store): MutableAtom<T, any>;
-declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T>;
-declare function withdraw<T>(token: WritableSelectorToken<T>, store: Store): WritableSelector<T>;
-declare function withdraw<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T>;
-declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T>;
-declare function withdraw<T>(token: WritableToken<T>, store: Store): WritableState<T>;
-declare function withdraw<T>(token: ReadableToken<T>, store: Store): ReadableState<T>;
-declare function withdraw<T, K extends Canonical>(token: RegularAtomFamilyToken<T, K>, store: Store): RegularAtomFamily<T, K>;
-declare function withdraw<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(token: MutableAtomFamilyToken<T, J, K>, store: Store): MutableAtomFamily<T, J, K>;
-declare function withdraw<T, K extends Canonical>(token: AtomFamilyToken<T>, store: Store): AtomFamily<T, any>;
-declare function withdraw<T, K extends Canonical>(token: ReadonlySelectorFamilyToken<T, K>, store: Store): ReadonlySelectorFamily<T, any>;
-declare function withdraw<T, K extends Canonical>(token: WritableSelectorFamilyToken<T, K>, store: Store): WritableSelectorFamily<T, any>;
-declare function withdraw<T, K extends Canonical>(token: SelectorFamilyToken<T, K>, store: Store): SelectorFamily<T, any>;
-declare function withdraw<T, K extends Canonical>(token: ReadableFamilyToken<T, K>, store: Store): ReadableFamily<T, any>;
-declare function withdraw<T, K extends Canonical>(token: WritableFamilyToken<T, K>, store: Store): WritableFamily<T, any>;
-declare function withdraw<T extends Func>(token: TransactionToken<T>, store: Store): Transaction<T extends Func ? T : never>;
-declare function withdraw<T>(token: TimelineToken<T>, store: Store): Timeline<T extends TimelineManageable ? T : never>;
-declare function withdraw<T>(token: WritableToken<T>, store: Store): WritableState<T>;
-declare function withdraw<T>(token: ReadableToken<T>, store: Store): ReadableState<T>;
-declare function withdraw(token: AtomIOToken, store: Store): AtomIOInternalResource;
+declare function withdraw<T>(store: Store, token: RegularAtomToken<T>): RegularAtom<T>;
+declare function withdraw<T extends Transceiver<any>>(store: Store, token: MutableAtomToken<T, any>): MutableAtom<T, any>;
+declare function withdraw<T>(store: Store, token: AtomToken<T>): Atom<T>;
+declare function withdraw<T>(store: Store, token: WritableSelectorToken<T>): WritableSelector<T>;
+declare function withdraw<T>(store: Store, token: ReadonlySelectorToken<T>): ReadonlySelector<T>;
+declare function withdraw<T>(store: Store, token: SelectorToken<T>): Selector<T>;
+declare function withdraw<T>(store: Store, token: WritableToken<T>): WritableState<T>;
+declare function withdraw<T>(store: Store, token: ReadableToken<T>): ReadableState<T>;
+declare function withdraw<T, K extends Canonical>(store: Store, token: RegularAtomFamilyToken<T, K>): RegularAtomFamily<T, K>;
+declare function withdraw<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(store: Store, token: MutableAtomFamilyToken<T, J, K>): MutableAtomFamily<T, J, K>;
+declare function withdraw<T, K extends Canonical>(store: Store, token: AtomFamilyToken<T>): AtomFamily<T, any>;
+declare function withdraw<T, K extends Canonical>(store: Store, token: ReadonlySelectorFamilyToken<T, K>): ReadonlySelectorFamily<T, any>;
+declare function withdraw<T, K extends Canonical>(store: Store, token: WritableSelectorFamilyToken<T, K>): WritableSelectorFamily<T, any>;
+declare function withdraw<T, K extends Canonical>(store: Store, token: SelectorFamilyToken<T, K>): SelectorFamily<T, any>;
+declare function withdraw<T, K extends Canonical>(store: Store, token: ReadableFamilyToken<T, K>): ReadableFamily<T, any>;
+declare function withdraw<T, K extends Canonical>(store: Store, token: WritableFamilyToken<T, K>): WritableFamily<T, any>;
+declare function withdraw<T extends Func>(store: Store, token: TransactionToken<T>): Transaction<T extends Func ? T : never>;
+declare function withdraw<T>(store: Store, token: TimelineToken<T>): Timeline<T extends TimelineManageable ? T : never>;
+declare function withdraw<T>(store: Store, token: WritableToken<T>): WritableState<T>;
+declare function withdraw<T>(store: Store, token: ReadableToken<T>): ReadableState<T>;
+declare function withdraw(store: Store, token: AtomIOToken): AtomIOInternalResource;
 
 interface Transceiver<S extends Json.Serializable> {
     do: (update: S) => number | `OUT_OF_RANGE` | null;
@@ -419,11 +487,12 @@ declare class Tracker<Mutable extends Transceiver<any>> {
     private updateCore;
     mutableState: MutableAtomToken<Mutable, Json.Serializable>;
     latestUpdateState: RegularAtomToken<typeof this.Update | null>;
-    dispose: () => void;
+    [Symbol.dispose]: () => void;
     constructor(mutableState: MutableAtomToken<Mutable, Json.Serializable>, store: Store);
 }
 
 declare class FamilyTracker<Core extends Transceiver<any>, FamilyMemberKey extends Canonical> {
+    private trackers;
     private readonly Update;
     readonly latestUpdateAtoms: RegularAtomFamily<typeof this.Update | null, FamilyMemberKey>;
     readonly mutableAtoms: MutableAtomFamily<Core, any, FamilyMemberKey>;
@@ -437,11 +506,11 @@ declare function createRegularAtom<T>(store: Store, options: RegularAtomOptions<
 declare function createStandaloneAtom<T>(store: Store, options: RegularAtomOptions<T>): RegularAtomToken<T>;
 declare function createStandaloneAtom<T extends Transceiver<any>, J extends Json.Serializable>(store: Store, options: MutableAtomOptions<T, J>): MutableAtomToken<T, J>;
 
-declare function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void;
+declare function disposeAtom(store: Store, atomToken: AtomToken<unknown>): void;
 
-declare const isAtomDefault: (key: string, store: Store) => boolean;
-declare const markAtomAsDefault: (key: string, store: Store) => void;
-declare const markAtomAsNotDefault: (key: string, store: Store) => void;
+declare const isAtomDefault: (store: Store, key: string) => boolean;
+declare const markAtomAsDefault: (store: Store, key: string) => void;
+declare const markAtomAsNotDefault: (store: Store, key: string) => void;
 
 /**
  * A Promise whose incoming value can be hot swapped.
@@ -463,11 +532,13 @@ declare class Future<T> extends Promise<T> {
     use(value: Promise<T> | T): void;
 }
 
-declare function cacheValue<T>(key: string, value: T, subject: Subject<StateUpdate<unknown>>, store: Store): T;
-declare function cacheValue<T extends Promise<any>>(key: string, value: T, subject: Subject<StateUpdate<unknown>>, store: Store): Future<T>;
+declare function cacheValue<T>(store: Store, key: string, value: T, subject: Subject<StateUpdate<unknown>>): T;
+declare function cacheValue<T extends Promise<any>>(store: Store, key: string, value: T, subject: Subject<StateUpdate<unknown>>): Future<T>;
 declare const readCachedValue: <T>(token: ReadableState<any>, target: Store) => T;
 declare const evictCachedValue: (key: string, target: Store) => void;
 
+declare function capitalize<S extends string>(string: S): Capitalize<S>;
+
 declare function createAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(store: Store, options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamilyToken<T, J, K>;
 declare function createAtomFamily<T, K extends Canonical>(store: Store, options: RegularAtomFamilyOptions<T, K>): RegularAtomFamilyToken<T, K>;
 
@@ -516,7 +587,7 @@ declare function getEnvironmentData(store: Store): EnvironmentData;
 declare function getFromStore<T>(store: Store, token: ReadableToken<T>): T;
 declare function getFromStore<T, K extends Canonical>(store: Store, token: ReadableFamilyToken<T, K>, key: K): T;
 
-declare const readOrComputeValue: <T>(state: ReadableState<T>, target: Store) => T;
+declare const readOrComputeValue: <T>(target: Store, state: ReadableState<T>) => T;
 
 declare function getTrace(error: Error): string;
 
@@ -544,11 +615,11 @@ type ReadonlySelectorKey<T> = string & {
     __readonlySelectorKey?: never;
     __brand?: T;
 };
-declare const isAtomKey: (key: string, store: Store) => key is AtomKey<unknown>;
-declare const isSelectorKey: (key: string, store: Store) => key is SelectorKey<unknown>;
-declare const isReadonlySelectorKey: (key: string, store: Store) => key is ReadonlySelectorKey<unknown>;
+declare const isAtomKey: (store: Store, key: string) => key is AtomKey<unknown>;
+declare const isSelectorKey: (store: Store, key: string) => key is SelectorKey<unknown>;
+declare const isReadonlySelectorKey: (store: Store, key: string) => key is ReadonlySelectorKey<unknown>;
 type StateKey<T> = AtomKey<T> | ReadonlySelectorKey<T> | SelectorKey<T>;
-declare const isStateKey: (key: string, store: Store) => key is StateKey<unknown>;
+declare const isStateKey: (store: Store, key: string) => key is StateKey<unknown>;
 
 declare class LazyMap<K, V> extends Map<K, V> {
     protected readonly source: Map<K, V>;
@@ -574,7 +645,7 @@ declare function createStandaloneSelector<T>(store: Store, options: ReadonlySele
 
 declare const createWritableSelector: <T>(store: Store, options: WritableSelectorOptions<T>, family: FamilyMetadata | undefined) => WritableSelectorToken<T>;
 
-declare function disposeSelector(selectorToken: ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>, store: Store): void;
+declare function disposeSelector(store: Store, selectorToken: SelectorToken<unknown>): void;
 
 declare const getSelectorDependencyKeys: (key: string, store: Store) => (AtomKey<unknown> | ReadonlySelectorKey<unknown> | SelectorKey<unknown>)[];
 
@@ -588,25 +659,25 @@ declare const updateSelectorAtoms: (selectorKey: string, dependency: ReadonlySel
 type Modify<T> = (thing: T) => T;
 declare const become: <T>(nextVersionOfThing: Modify<T> | T) => (originalThing: T) => T;
 
-declare const setAtomOrSelector: <T>(state: WritableState<T>, value: T | ((oldValue: T) => T), store: Store) => void;
+declare const setAtomOrSelector: <T>(store: Store, state: WritableState<T>, value: T | ((oldValue: T) => T)) => void;
 
 declare function setIntoStore<T, New extends T>(store: Store, token: WritableToken<T>, value: New | ((oldValue: T) => New)): void;
 declare function setIntoStore<T, K extends Canonical, New extends T>(store: Store, token: WritableFamilyToken<T, K>, key: K, value: New | ((oldValue: T) => New)): void;
 
-declare const recallState: <T>(state: ReadableState<T>, store: Store) => T;
+declare const recallState: <T>(store: Store, state: ReadableState<T>) => T;
 
 declare function subscribeInStore<T>(store: Store$1, token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key?: string): () => void;
 declare function subscribeInStore<F extends Func$1>(store: Store$1, token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key?: string): () => void;
 declare function subscribeInStore<M extends TimelineManageable>(store: Store$1, token: TimelineToken<M>, handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void, key?: string): () => void;
 declare function subscribeInStore<M extends TimelineManageable>(store: Store$1, token: ReadableToken<any> | TimelineToken<M> | TransactionToken<any>, handleUpdate: TransactionUpdateHandler<any> | UpdateHandler<any> | ((update: TimelineUpdate<M> | `redo` | `undo`) => void), key?: string): () => void;
 
-declare const subscribeToRootAtoms: <T>(selector: Selector<T>, store: Store) => (() => void)[];
+declare const subscribeToRootAtoms: <T>(store: Store, selector: Selector<T>) => (() => void)[];
 
-declare function subscribeToState<T>(token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key: string, store: Store): () => void;
+declare function subscribeToState<T>(store: Store, token: ReadableToken<T>, key: string, handleUpdate: UpdateHandler<T>): () => void;
 
-declare const subscribeToTimeline: <ManagedAtom extends TimelineManageable>(token: TimelineToken<ManagedAtom>, handleUpdate: (update: TimelineUpdate<any> | `redo` | `undo`) => void, key: string, store: Store) => (() => void);
+declare const subscribeToTimeline: <ManagedAtom extends TimelineManageable>(store: Store, token: TimelineToken<ManagedAtom>, key: string, handleUpdate: (update: TimelineUpdate<any> | `redo` | `undo`) => void) => (() => void);
 
-declare const subscribeToTransaction: <F extends Func>(token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key: string, store: Store) => (() => void);
+declare const subscribeToTransaction: <F extends Func>(store: Store, token: TransactionToken<F>, key: string, handleUpdate: TransactionUpdateHandler<F>) => (() => void);
 
 type AtomIOState = {
     key: string;
@@ -670,4 +741,4 @@ type WritableFamily<T, K extends Canonical> = AtomFamily<T, K> | WritableSelecto
 type ReadableFamily<T, K extends Canonical> = AtomFamily<T, K> | SelectorFamily<T, K>;
 type AtomIOInternalResource = ReadableFamily<any, any> | ReadableState<any> | Timeline<any> | Transaction<any>;
 
-export { type Atom, type AtomFamily, type AtomIOInternalResource, type AtomIOState, type AtomKey, type BaseExternalStoreConfiguration, type ChildStore, CircularBuffer, type Count, type Each, type Empty, type EnvironmentData, type ExternalStoreConfiguration, type ExternalStoreWithContentConfiguration, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, type Flat, type Func, Future, IMPLICIT, Junction, type JunctionAdvancedConfiguration, type JunctionEntries, type JunctionEntriesBase, type JunctionJSON, type JunctionSchema, type JunctionSchemaBase, LazyMap, type Lineage, type Modify, type Molecule, type MutableAtom, type MutableAtomFamily, NotFoundError, type OperationProgress, type ReadableFamily, type ReadableState, type ReadonlySelector, type ReadonlySelectorFamily, type ReadonlySelectorKey, type Refinement, type RegularAtom, type RegularAtomFamily, type RootStore, type Selector, type SelectorFamily, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineMoleculeCreation, type TimelineMoleculeDisposal, type TimelineSelectorUpdate, type TimelineStateCreation, type TimelineStateDisposal, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type WritableFamily, type WritableSelector, type WritableSelectorFamily, type WritableState, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, evictCachedValue, findInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+export { type Atom, type AtomFamily, type AtomIOInternalResource, type AtomIOState, type AtomKey, type BaseExternalStoreConfiguration, type ChildStore, CircularBuffer, type Count, type Each, type Empty, type EnvironmentData, type ExternalStoreConfiguration, type ExternalStoreWithContentConfiguration, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, type Flat, type Func, Future, IMPLICIT, Join, type JoinStateFamilies, Junction, type JunctionAdvancedConfiguration, type JunctionEntries, type JunctionEntriesBase, type JunctionJSON, type JunctionSchema, type JunctionSchemaBase, LazyMap, type Lineage, type Modify, type Molecule, type MutableAtom, type MutableAtomFamily, NotFoundError, type OperationProgress, type ReadableFamily, type ReadableState, type ReadonlySelector, type ReadonlySelectorFamily, type ReadonlySelectorKey, type Refinement, type RegularAtom, type RegularAtomFamily, type RootStore, type Selector, type SelectorFamily, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineMoleculeCreation, type TimelineMoleculeDisposal, type TimelineSelectorUpdate, type TimelineStateCreation, type TimelineStateDisposal, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type WritableFamily, type WritableSelector, type WritableSelectorFamily, type WritableState, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, capitalize, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, evictCachedValue, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };

package/internal/dist/index.js

@@ -1,2 +1,2 @@
-export { CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, Junction, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, evictCachedValue, findInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw } from '../../dist/chunk-Y5MBNTVU.js';
+export { CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, Join, Junction, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, capitalize, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, evictCachedValue, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw } from '../../dist/chunk-UQEYZ3OI.js';
 import '../../dist/chunk-XWL6SNVU.js';

package/internal/src/atom/create-regular-atom.ts

@@ -59,8 +59,8 @@ export function createRegularAtom<T>(
 		initialValue = options.default()
 	}
 	target.atoms.set(newAtom.key, newAtom)
-	markAtomAsDefault(options.key, store)
-	cacheValue(options.key, initialValue, subject, target)
+	markAtomAsDefault(store, options.key)
+	cacheValue(target, options.key, initialValue, subject)
 	const token = deposit(newAtom)
 	if (options.effects) {
 		let effectIndex = 0
@@ -71,7 +71,7 @@ export function createRegularAtom<T>(
 					setIntoStore(store, token, next)
 				},
 				onSet: (handle: UpdateHandler<T>) =>
-					subscribeToState(token, handle, `effect[${effectIndex}]`, store),
+					subscribeToState(store, token, `effect[${effectIndex}]`, handle),
 			})
 			if (cleanup) {
 				cleanupFunctions.push(cleanup)

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

@@ -3,16 +3,16 @@ import type { AtomDisposal, AtomToken } from "atom.io"
 import type { Store } from ".."
 import { getUpdateToken, isChildStore, newest, withdraw } from ".."
 
-export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
+export function disposeAtom(store: Store, atomToken: AtomToken<unknown>): void {
 	const target = newest(store)
 	const { key, family } = atomToken
-	const atom = withdraw(atomToken, target)
+	const atom = withdraw(target, atomToken)
 	if (!family) {
 		store.logger.error(`❌`, `atom`, key, `Standalone atoms cannot be disposed.`)
 	} else {
 		atom.cleanup?.()
 		const lastValue = store.valueMap.get(atom.key)
-		const atomFamily = withdraw({ key: family.key, type: `atom_family` }, store)
+		const atomFamily = withdraw(store, { key: family.key, type: `atom_family` })
 
 		const disposal: AtomDisposal<AtomToken<unknown>> = {
 			type: `state_disposal`,
@@ -24,15 +24,6 @@ export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 		atomFamily.subject.next(disposal)
 
 		const isChild = isChildStore(target)
-		// let molecule = target.molecules.get(family.subKey)
-		// if (molecule && isChild) {
-		// 	const parentMolecule = target.parent.molecules.get(family.subKey)
-		// 	if (parentMolecule === molecule) {
-		// 		molecule = parentMolecule.copy()
-		// 		target.molecules.set(family.subKey, molecule)
-		// 	}
-		// }
-		// molecule?.tokens.delete(family.key)
 
 		target.atoms.delete(key)
 		target.valueMap.delete(key)
@@ -42,7 +33,7 @@ export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 
 		if (atomToken.type === `mutable_atom`) {
 			const updateToken = getUpdateToken(atomToken)
-			disposeAtom(updateToken, store)
+			disposeAtom(store, updateToken)
 			store.trackers.delete(key)
 		}
 		store.logger.info(`🔥`, `atom`, key, `deleted`)