atom.io 0.25.6 → 0.27.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import './chunk-S4N6XNPH.js';
+import './chunk-XWL6SNVU.js';
 import * as Internal from 'atom.io/internal';
 import { createStandaloneAtom, IMPLICIT, createAtomFamily, createMoleculeFamily, makeMoleculeInStore, Molecule, createStandaloneSelector, createSelectorFamily, Store, createTransaction, createTimeline, findInStore, getFromStore, setIntoStore, disposeFromStore, timeTravel, subscribeToTimeline, subscribeToTransaction, subscribeToState, arbitrary, actUponStore } from 'atom.io/internal';
 import { stringifyJson } from 'atom.io/json';
@@ -45,25 +45,22 @@ var AtomIOLogger = class {
     this.logLevel = logLevel;
     this.filter = filter;
     this.logger = logger;
-    this.error = (...args) => {
-      var _a, _b;
-      if (((_b = (_a = this.filter) == null ? void 0 : _a.call(this, ...args)) != null ? _b : true) && this.logLevel !== null) {
-        this.logger.error(...args);
-      }
-    };
-    this.info = (...args) => {
-      var _a, _b;
-      if (((_b = (_a = this.filter) == null ? void 0 : _a.call(this, ...args)) != null ? _b : true) && this.logLevel === `info`) {
-        this.logger.info(...args);
-      }
-    };
-    this.warn = (...args) => {
-      var _a, _b;
-      if (((_b = (_a = this.filter) == null ? void 0 : _a.call(this, ...args)) != null ? _b : true) && this.logLevel !== `error` && this.logLevel !== null) {
-        this.logger.warn(...args);
-      }
-    };
   }
+  error = (...args) => {
+    if ((this.filter?.(...args) ?? true) && this.logLevel !== null) {
+      this.logger.error(...args);
+    }
+  };
+  info = (...args) => {
+    if ((this.filter?.(...args) ?? true) && this.logLevel === `info`) {
+      this.logger.info(...args);
+    }
+  };
+  warn = (...args) => {
+    if ((this.filter?.(...args) ?? true) && this.logLevel !== `error` && this.logLevel !== null) {
+      this.logger.warn(...args);
+    }
+  };
 };
 function moleculeFamily(options) {
   return createMoleculeFamily(options, IMPLICIT.STORE);
@@ -93,6 +90,22 @@ function setState(token, p1, p2) {
   }
 }
 var Silo = class {
+  store;
+  atom;
+  atomFamily;
+  selector;
+  selectorFamily;
+  transaction;
+  timeline;
+  findState;
+  getState;
+  setState;
+  disposeState;
+  subscribe;
+  undo;
+  redo;
+  moleculeFamily;
+  makeMolecule;
   constructor(config, fromStore = null) {
     const s = new Store(config, fromStore);
     function _atom(options) {
@@ -165,8 +178,7 @@ function isToken(knownToken, unknownToken) {
   return knownToken.key === unknownToken.key;
 }
 function belongsTo(family, unknownToken) {
-  var _a;
-  return family.key === ((_a = unknownToken.family) == null ? void 0 : _a.key);
+  return family.key === unknownToken.family?.key;
 }
 
 export { AtomIOLogger, LOG_LEVELS, Silo, atom, atomFamily, belongsTo, disposeState, getState, isToken, makeMolecule, makeRootMolecule, moleculeFamily, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };

package/ephemeral/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, ReadableToken } from 'atom.io';
 import { Transceiver } from 'atom.io/internal';
-import { Json } from 'atom.io/json';
+import { Json, Canonical } from 'atom.io/json';
 
 /**
  * @overload Mutable Atom
@@ -10,7 +10,7 @@ import { Json } from 'atom.io/json';
  * @returns
  * The current value of the state.
  */
-declare function findState<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>;
+declare function findState<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>;
 /**
  * Finds a state in the store.
  * @param token - The token of the state family.
@@ -18,7 +18,7 @@ declare function findState<T extends Transceiver<any>, J extends Json.Serializab
  * @returns
  * The current value of the state.
  */
-declare function findState<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T>;
+declare function findState<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T>;
 /**
  * Finds a state in the store.
  * @param token - The token of the state family.
@@ -26,7 +26,7 @@ declare function findState<T, K extends Json.Serializable, Key extends K>(token:
  * @returns
  * The current value of the state.
  */
-declare function findState<T, K extends Json.Serializable, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T>;
+declare function findState<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T>;
 /**
  * Finds a state in the store.
  * @param token - The token of the state family.
@@ -34,7 +34,7 @@ declare function findState<T, K extends Json.Serializable, Key extends K>(token:
  * @returns
  * The current value of the state.
  */
-declare function findState<T, K extends Json.Serializable, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T>;
+declare function findState<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T>;
 /**
  * Finds a state in the store.
  * @param token - The token of the state family.
@@ -42,7 +42,7 @@ declare function findState<T, K extends Json.Serializable, Key extends K>(token:
  * @returns
  * The current value of the state.
  */
-declare function findState<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T>;
+declare function findState<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T>;
 /**
  * @public
  * Finds a {@link ReadableToken} in the store.
@@ -52,6 +52,6 @@ declare function findState<T, K extends Json.Serializable, Key extends K>(token:
  * The current value of the state.
  * @overload Unknown
  */
-declare function findState<T, K extends Json.Serializable, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T>;
+declare function findState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T>;
 
 export { findState };

package/ephemeral/dist/index.js

@@ -1,4 +1,4 @@
-import '../../dist/chunk-S4N6XNPH.js';
+import '../../dist/chunk-XWL6SNVU.js';
 import { findInStore, IMPLICIT } from 'atom.io/internal';
 
 function findState(token, key) {

package/ephemeral/package.json

@@ -2,14 +2,11 @@
 	"name": "atom.io-ephemeral",
 	"type": "module",
 	"private": true,
-	"main": "dist/index.cjs",
-	"module": "dist/index.js",
+	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"exports": {
 		".": {
 			"import": "./dist/index.js",
-			"browser": "./dist/index.js",
-			"require": "./dist/index.cjs",
 			"types": "./dist/index.d.ts"
 		}
 	}

package/ephemeral/src/find-state.ts

@@ -14,7 +14,7 @@ import type {
 } from "atom.io"
 import type { Transceiver } from "atom.io/internal"
 import { findInStore, IMPLICIT } from "atom.io/internal"
-import type { Json } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 
 /**
  * @overload Mutable Atom
@@ -27,7 +27,7 @@ import type { Json } from "atom.io/json"
 export function findState<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-	K extends Json.Serializable,
+	K extends Canonical,
 	Key extends K,
 >(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>
 /**
@@ -37,7 +37,7 @@ export function findState<
  * @returns
  * The current value of the state.
  */
-export function findState<T, K extends Json.Serializable, Key extends K>(
+export function findState<T, K extends Canonical, Key extends K>(
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
 ): RegularAtomToken<T>
@@ -48,7 +48,7 @@ export function findState<T, K extends Json.Serializable, Key extends K>(
  * @returns
  * The current value of the state.
  */
-export function findState<T, K extends Json.Serializable, Key extends K>(
+export function findState<T, K extends Canonical, Key extends K>(
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
 ): WritableSelectorToken<T>
@@ -59,7 +59,7 @@ export function findState<T, K extends Json.Serializable, Key extends K>(
  * @returns
  * The current value of the state.
  */
-export function findState<T, K extends Json.Serializable, Key extends K>(
+export function findState<T, K extends Canonical, Key extends K>(
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
 ): ReadonlySelectorToken<T>
@@ -70,7 +70,7 @@ export function findState<T, K extends Json.Serializable, Key extends K>(
  * @returns
  * The current value of the state.
  */
-export function findState<T, K extends Json.Serializable, Key extends K>(
+export function findState<T, K extends Canonical, Key extends K>(
 	token: WritableFamilyToken<T, K>,
 	key: Key,
 ): WritableToken<T>
@@ -83,7 +83,7 @@ export function findState<T, K extends Json.Serializable, Key extends K>(
  * The current value of the state.
  * @overload Unknown
  */
-export function findState<T, K extends Json.Serializable, Key extends K>(
+export function findState<T, K extends Canonical, Key extends K>(
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
 ): ReadableToken<T>

package/eslint-plugin/dist/index.js

@@ -1,4 +1,4 @@
-import { __export } from '../../dist/chunk-S4N6XNPH.js';
+import { __export } from '../../dist/chunk-XWL6SNVU.js';
 import { ESLintUtils } from '@typescript-eslint/utils';
 
 // eslint-plugin/src/rules/index.ts
@@ -146,8 +146,7 @@ var lifespan = {
     ]
   },
   create(context) {
-    var _a;
-    const storeLifespan = (_a = context.options[0]) != null ? _a : `ephemeral`;
+    const storeLifespan = context.options[0] ?? `ephemeral`;
     return {
       ImportDeclaration(node) {
         const importSource = node.source.value;
@@ -168,7 +167,7 @@ var lifespan = {
         }
         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 callee = functionCallee != null ? functionCallee : methodCallee;
+        const callee = functionCallee ?? methodCallee;
         if (callee === void 0) {
           return;
         }
@@ -296,8 +295,8 @@ var synchronousSelectorDependencies = {
                 return `key` in prop && `name` in prop.key && prop.key.name === `get`;
               }
             );
-            const selectorLookup = selectorLookupProperty == null ? void 0 : selectorLookupProperty.value;
-            if ((selectorLookup == null ? void 0 : selectorLookup.type) === `FunctionExpression` || (selectorLookup == null ? void 0 : selectorLookup.type) === `ArrowFunctionExpression`) {
+            const selectorLookup = selectorLookupProperty?.value;
+            if (selectorLookup?.type === `FunctionExpression` || selectorLookup?.type === `ArrowFunctionExpression`) {
               if (selectorLookup.body.type === `BlockStatement`) {
                 for (const statement of selectorLookup.body.body) {
                   if (statement.type === `ReturnStatement` && statement.argument) {
@@ -317,10 +316,10 @@ var synchronousSelectorDependencies = {
                 return `key` in prop && `name` in prop.key && prop.key.name === `get`;
               }
             );
-            selectorComputation = selectorComputationProperty == null ? void 0 : selectorComputationProperty.value;
+            selectorComputation = selectorComputationProperty?.value;
           }
         }
-        if ((selectorComputation == null ? void 0 : selectorComputation.type) === `FunctionExpression` || (selectorComputation == null ? void 0 : selectorComputation.type) === `ArrowFunctionExpression`) {
+        if (selectorComputation?.type === `FunctionExpression` || selectorComputation?.type === `ArrowFunctionExpression`) {
           const nonDestructuredTransactorsName = selectorComputation.params[0] && `name` in selectorComputation.params[0] ? selectorComputation.params[0].name : void 0;
           let awaited;
           let awaitNode;

package/eslint-plugin/package.json

@@ -2,14 +2,11 @@
 	"name": "atom.io-eslint-plugin",
 	"type": "module",
 	"private": true,
-	"main": "dist/index.cjs",
-	"module": "dist/index.js",
+	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"exports": {
 		".": {
 			"import": "./dist/index.js",
-			"browser": "./dist/index.js",
-			"require": "./dist/index.cjs",
 			"types": "./dist/index.d.ts"
 		}
 	}

package/immortal/dist/index.d.ts

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

package/immortal/dist/index.js

@@ -1,4 +1,4 @@
-import '../../dist/chunk-S4N6XNPH.js';
+import '../../dist/chunk-XWL6SNVU.js';
 import { seekInStore, IMPLICIT } from 'atom.io/internal';
 
 function seekState(token, key) {

package/immortal/package.json

@@ -2,14 +2,11 @@
 	"name": "atom.io-immortal",
 	"type": "module",
 	"private": true,
-	"main": "dist/index.cjs",
-	"module": "dist/index.js",
+	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"exports": {
 		".": {
 			"import": "./dist/index.js",
-			"browser": "./dist/index.js",
-			"require": "./dist/index.cjs",
 			"types": "./dist/index.d.ts"
 		}
 	}

package/immortal/src/seek-state.ts

@@ -18,39 +18,39 @@ import type {
 } from "atom.io"
 import type { Transceiver } from "atom.io/internal"
 import { IMPLICIT, seekInStore } from "atom.io/internal"
-import type { Json } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 
 export function seekState<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-	K extends Json.Serializable,
+	K extends Canonical,
 	Key extends K,
 >(
 	token: MutableAtomFamilyToken<T, J, K>,
 	key: Key,
 ): MutableAtomToken<T, J> | undefined
 
-export function seekState<T, K extends Json.Serializable, Key extends K>(
+export function seekState<T, K extends Canonical, Key extends K>(
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
 ): RegularAtomToken<T> | undefined
 
-export function seekState<T, K extends Json.Serializable, Key extends K>(
+export function seekState<T, K extends Canonical, Key extends K>(
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
 ): WritableSelectorToken<T> | undefined
 
-export function seekState<T, K extends Json.Serializable, Key extends K>(
+export function seekState<T, K extends Canonical, Key extends K>(
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
 ): ReadonlySelectorToken<T> | undefined
 
-export function seekState<T, K extends Json.Serializable, Key extends K>(
+export function seekState<T, K extends Canonical, Key extends K>(
 	token: WritableFamilyToken<T, K>,
 	key: Key,
 ): WritableToken<T> | undefined
 
-export function seekState<T, K extends Json.Serializable, Key extends K>(
+export function seekState<T, K extends Canonical, Key extends K>(
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
 ): ReadableToken<T> | undefined
@@ -62,7 +62,7 @@ export function seekState<M extends MoleculeConstructor>(
 
 export function seekState(
 	token: MoleculeFamilyToken<any> | ReadableFamilyToken<any, any>,
-	key: Json.Serializable,
+	key: Canonical,
 ): MoleculeToken<any> | ReadableToken<any> | undefined {
 	if (token.type === `molecule_family`) {
 		return seekInStore(token, key, IMPLICIT.STORE)

package/internal/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as atom_io from 'atom.io';
 import { TransactionToken, TransactionUpdate, TransactionOptions, ActorToolkit, RegularAtomToken, MutableAtomToken, AtomToken, WritableSelectorToken, ReadonlySelectorToken, SelectorToken, WritableToken, MoleculeToken, MoleculeFamily, MoleculeFamilyToken, ReadableToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, StateCreation, StateDisposal, MoleculeConstructor, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, TimelineToken, WritableSelectorFamily, MutableAtomFamily, RegularAtomFamily, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomFamily, ReadableFamily, SelectorFamily, WritableFamily, RegularAtomFamilyToken, MutableAtomFamilyToken, AtomFamilyToken, ReadonlySelectorFamilyToken, WritableSelectorFamilyToken, SelectorFamilyToken, ReadableFamilyToken, WritableFamilyToken, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, MoleculeKey, KeyedStateUpdate, MoleculeFamilyOptions, MoleculeParams, ReadonlySelectorOptions, WritableSelectorOptions, SetterToolkit, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
-import { Json, JsonInterface } from 'atom.io/json';
+import { Canonical, Json, JsonInterface } from 'atom.io/json';
 import { Join } from 'atom.io/data';
 
 type primitive = boolean | number | string | null;
@@ -155,10 +155,10 @@ declare function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T
 declare function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>;
 declare function deposit<T>(state: Selector<T>): SelectorToken<T>;
 declare function deposit<T>(state: WritableState<T>): WritableToken<T>;
-declare function deposit<K extends Json.Serializable, S extends {
+declare function deposit<K extends Canonical, S extends {
     [key: string]: any;
 }, P extends any[]>(state: Molecule<any>): MoleculeToken<any>;
-declare function deposit<K extends Json.Serializable, S extends {
+declare function deposit<K extends Canonical, S extends {
     [key: string]: any;
 }, P extends any[]>(state: MoleculeFamily<any>): MoleculeFamilyToken<any>;
 declare function deposit<T extends Func>(state: Transaction<T>): TransactionToken<T>;
@@ -295,14 +295,14 @@ declare function withdraw<T>(token: ReadonlySelectorToken<T>, store: Store): Rea
 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 Json.Serializable>(token: RegularAtomFamilyToken<T, K>, store: Store): RegularAtomFamily<T, K>;
-declare function withdraw<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(token: MutableAtomFamilyToken<T, J, K>, store: Store): MutableAtomFamily<T, J, K>;
-declare function withdraw<T, K extends Json.Serializable>(token: AtomFamilyToken<T>, store: Store): AtomFamily<T, any>;
-declare function withdraw<T, K extends Json.Serializable>(token: ReadonlySelectorFamilyToken<T, K>, store: Store): ReadonlySelectorFamily<T, any>;
-declare function withdraw<T, K extends Json.Serializable>(token: WritableSelectorFamilyToken<T, K>, store: Store): WritableSelectorFamily<T, any>;
-declare function withdraw<T, K extends Json.Serializable>(token: SelectorFamilyToken<T, K>, store: Store): SelectorFamily<T, any>;
-declare function withdraw<T, K extends Json.Serializable>(token: ReadableFamilyToken<T, K>, store: Store): ReadableFamily<T, any>;
-declare function withdraw<T, K extends Json.Serializable>(token: WritableFamilyToken<T, K>, store: Store): WritableFamily<T, any>;
+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<M extends MoleculeConstructor>(token: MoleculeToken<M>, store: Store): Molecule<M>;
 declare function withdraw<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, store: Store): MoleculeFamily<M>;
 declare function withdraw<T extends Func>(token: TransactionToken<T>, store: Store): Transaction<T extends Func ? T : never>;
@@ -329,9 +329,6 @@ declare const getJsonToken: <Core extends Transceiver<any>, SerializableCore ext
 
 declare const getUpdateToken: <Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => RegularAtomToken<Signal<Core>>;
 
-declare function isMutable(atom: Atom<any>): atom is MutableAtom<any, any>;
-declare function isMutable(family: AtomFamily<any, any>): family is MutableAtomFamily<any, any, any>;
-
 /**
  * @internal Give the tracker a transceiver state and a store, and it will
  * subscribe to the transceiver's inner value. When the inner value changes,
@@ -350,7 +347,7 @@ declare class Tracker<Mutable extends Transceiver<any>> {
     constructor(mutableState: MutableAtomToken<Mutable, Json.Serializable>, store: Store);
 }
 
-declare class FamilyTracker<Core extends Transceiver<any>, FamilyMemberKey extends Json.Serializable> {
+declare class FamilyTracker<Core extends Transceiver<any>, FamilyMemberKey extends Canonical> {
     private readonly Update;
     readonly latestUpdateAtoms: RegularAtomFamily<typeof this.Update | null, FamilyMemberKey>;
     readonly mutableAtoms: MutableAtomFamily<Core, any, FamilyMemberKey>;
@@ -394,46 +391,46 @@ declare function cacheValue<T extends Promise<any>>(key: string, value: T, subje
 declare const readCachedValue: <T>(token: ReadableState<any>, target: Store) => T;
 declare const evictCachedValue: (key: string, target: Store) => void;
 
-declare function createAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(options: MutableAtomFamilyOptions<T, J, K>, store: Store): MutableAtomFamily<T, J, K>;
-declare function createAtomFamily<T, K extends Json.Serializable>(options: RegularAtomFamilyOptions<T, K>, store: Store): RegularAtomFamily<T, K>;
+declare function createAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(options: MutableAtomFamilyOptions<T, J, K>, store: Store): MutableAtomFamily<T, J, K>;
+declare function createAtomFamily<T, K extends Canonical>(options: RegularAtomFamilyOptions<T, K>, store: Store): RegularAtomFamily<T, K>;
 
-declare function createReadonlySelectorFamily<T, K extends Json.Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamily<T, K>;
+declare function createReadonlySelectorFamily<T, K extends Canonical>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamily<T, K>;
 
-declare function createRegularAtomFamily<T, K extends Json.Serializable>(options: RegularAtomFamilyOptions<T, K>, store: Store): RegularAtomFamily<T, K>;
+declare function createRegularAtomFamily<T, K extends Canonical>(options: RegularAtomFamilyOptions<T, K>, store: Store): RegularAtomFamily<T, K>;
 
-declare function createSelectorFamily<T, K extends Json.Serializable>(options: WritableSelectorFamilyOptions<T, K>, store: Store): WritableSelectorFamily<T, K>;
-declare function createSelectorFamily<T, K extends Json.Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamily<T, K>;
+declare function createSelectorFamily<T, K extends Canonical>(options: WritableSelectorFamilyOptions<T, K>, store: Store): WritableSelectorFamily<T, K>;
+declare function createSelectorFamily<T, K extends Canonical>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamily<T, K>;
 
 declare function disposeFromStore(token: MoleculeToken<any> | ReadableToken<any>, store: Store): void;
-declare function disposeFromStore<K extends Json.Serializable>(token: ReadableFamilyToken<any, K>, key: K, store: Store): void;
+declare function disposeFromStore<K extends Canonical>(token: ReadableFamilyToken<any, K>, key: K, store: Store): void;
 declare function disposeFromStore<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>, store: Store): void;
 
-declare function findInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J>;
-declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T>;
-declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T>;
-declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key, store: Store): WritableSelectorToken<T>;
-declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key, store: Store): ReadonlySelectorToken<T>;
-declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T>;
-declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T>;
-declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T>;
-
-declare function initFamilyMemberInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J>;
-declare function initFamilyMemberInStore<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T>;
-declare function initFamilyMemberInStore<T, K extends Json.Serializable, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T>;
-declare function initFamilyMemberInStore<T, K extends Json.Serializable, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key, store: Store): WritableSelectorToken<T>;
-declare function initFamilyMemberInStore<T, K extends Json.Serializable, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key, store: Store): ReadonlySelectorToken<T>;
-declare function initFamilyMemberInStore<T, K extends Json.Serializable, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T>;
-declare function initFamilyMemberInStore<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T>;
-declare function initFamilyMemberInStore<T, K extends Json.Serializable, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T>;
-
-declare function seekInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J> | undefined;
-declare function seekInStore<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T> | undefined;
-declare function seekInStore<T, K extends Json.Serializable, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T> | undefined;
-declare function seekInStore<T, K extends Json.Serializable, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key, store: Store): WritableSelectorToken<T> | undefined;
-declare function seekInStore<T, K extends Json.Serializable, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key, store: Store): ReadonlySelectorToken<T> | undefined;
-declare function seekInStore<T, K extends Json.Serializable, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T> | undefined;
-declare function seekInStore<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T> | undefined;
-declare function seekInStore<T, K extends Json.Serializable, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T> | undefined;
+declare function findInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J>;
+declare function findInStore<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key, store: Store): WritableSelectorToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key, store: Store): ReadonlySelectorToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T>;
+
+declare function initFamilyMemberInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key, store: Store): WritableSelectorToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key, store: Store): ReadonlySelectorToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T>;
+
+declare function seekInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key, store: Store): WritableSelectorToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key, store: Store): ReadonlySelectorToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T> | undefined;
 declare function seekInStore<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>, store: Store): MoleculeKey<M> | undefined;
 
 type EnvironmentData = {
@@ -443,7 +440,7 @@ declare function getEnvironmentData(store: Store): EnvironmentData;
 
 declare function getFromStore<T>(token: ReadableToken<T>, store: Store): T;
 declare function getFromStore<M extends MoleculeConstructor>(token: MoleculeToken<M>, store: Store): InstanceType<M> | undefined;
-declare function getFromStore<T, K extends Json.Serializable>(token: ReadableFamilyToken<T, K>, key: K, store: Store): T;
+declare function getFromStore<T, K extends Canonical>(token: ReadableFamilyToken<T, K>, key: K, store: Store): T;
 declare function getFromStore<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>, store: Store): InstanceType<M>;
 
 declare const readOrComputeValue: <T>(state: ReadableState<T>, target: Store) => T;
@@ -506,14 +503,14 @@ declare class Molecule<M extends MoleculeConstructor> implements MoleculeToken<M
     constructor(ctx: Molecule<any> | Molecule<any>[] | undefined, key: MoleculeKey<M>, family?: MoleculeFamilyToken<M>);
 }
 
-declare function growMoleculeInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(molecule: Molecule<any>, family: MutableAtomFamily<T, J, K>, store: Store): MutableAtomToken<T, J>;
-declare function growMoleculeInStore<T, K extends Json.Serializable>(molecule: Molecule<any>, family: RegularAtomFamily<T, K>, store: Store): RegularAtomToken<T>;
-declare function growMoleculeInStore<T, K extends Json.Serializable>(molecule: Molecule<any>, family: AtomFamily<T, K>, store: Store): AtomToken<T>;
-declare function growMoleculeInStore<T, K extends Json.Serializable>(molecule: Molecule<any>, family: WritableSelectorFamily<T, K>, store: Store): WritableSelectorToken<T>;
-declare function growMoleculeInStore<T, K extends Json.Serializable>(molecule: Molecule<any>, family: ReadonlySelectorFamily<T, K>, store: Store): ReadonlySelectorToken<T>;
-declare function growMoleculeInStore<T, K extends Json.Serializable>(molecule: Molecule<any>, family: SelectorFamily<T, K>, store: Store): SelectorToken<T>;
-declare function growMoleculeInStore<T, K extends Json.Serializable>(molecule: Molecule<any>, family: WritableFamily<T, K>, store: Store): WritableToken<T>;
-declare function growMoleculeInStore<T, K extends Json.Serializable>(molecule: Molecule<any>, family: ReadableFamily<T, K>, store: Store): ReadableToken<T>;
+declare function growMoleculeInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(molecule: Molecule<any>, family: MutableAtomFamily<T, J, K>, store: Store): MutableAtomToken<T, J>;
+declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: RegularAtomFamily<T, K>, store: Store): RegularAtomToken<T>;
+declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: AtomFamily<T, K>, store: Store): AtomToken<T>;
+declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: WritableSelectorFamily<T, K>, store: Store): WritableSelectorToken<T>;
+declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: ReadonlySelectorFamily<T, K>, store: Store): ReadonlySelectorToken<T>;
+declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: SelectorFamily<T, K>, store: Store): SelectorToken<T>;
+declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: WritableFamily<T, K>, store: Store): WritableToken<T>;
+declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: ReadableFamily<T, K>, store: Store): ReadableToken<T>;
 
 declare function makeMoleculeInStore<M extends MoleculeConstructor>(store: Store, context: MoleculeToken<M> | MoleculeToken<M>[], familyToken: MoleculeFamilyToken<M>, key: MoleculeKey<M>, ...params: MoleculeParams<M>): MoleculeToken<M>;
 
@@ -547,7 +544,7 @@ declare const become: <T>(nextVersionOfThing: Modify<T> | T) => (originalThing:
 declare const setAtomOrSelector: <T>(state: WritableState<T>, value: T | ((oldValue: T) => T), store: Store) => void;
 
 declare function setIntoStore<T, New extends T>(token: WritableToken<T>, value: New | ((oldValue: T) => New), store: Store): void;
-declare function setIntoStore<T, K extends Json.Serializable, New extends T>(token: WritableFamilyToken<T, K>, key: K, value: New | ((oldValue: T) => New), store: Store): void;
+declare function setIntoStore<T, K extends Canonical, New extends T>(token: WritableFamilyToken<T, K>, key: K, value: New | ((oldValue: T) => New), store: Store): void;
 
 declare const subscribeToRootAtoms: <T>(selector: Selector<T>, store: Store) => (() => void)[];
 
@@ -590,4 +587,4 @@ type Selector<T> = ReadonlySelector<T> | WritableSelector<T>;
 type WritableState<T> = Atom<T> | WritableSelector<T>;
 type ReadableState<T> = Atom<T> | Selector<T>;
 
-export { type Atom, type AtomIOState, type AtomKey, type ChildStore, type EnvironmentData, FamilyTracker, type Flat, type Func, Future, IMPLICIT, LazyMap, type Lineage, type Modify, Molecule, type MutableAtom, NotFoundError, type OperationProgress, type ReadableState, type ReadonlySelector, type ReadonlySelectorKey, type RegularAtom, type RootStore, type Selector, 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 Withdrawable, type WritableSelector, type WritableState, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+export { type Atom, type AtomIOState, type AtomKey, type ChildStore, type EnvironmentData, FamilyTracker, type Flat, type Func, Future, IMPLICIT, LazyMap, type Lineage, type Modify, Molecule, type MutableAtom, NotFoundError, type OperationProgress, type ReadableState, type ReadonlySelector, type ReadonlySelectorKey, type RegularAtom, type RootStore, type Selector, 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 Withdrawable, type WritableSelector, type WritableState, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };