atom.io 0.4.1 → 0.6.0

package/dist/index.mjs

@@ -34,6 +34,9 @@ var __export = (target2, all) => {
     __defProp(target2, name, { get: all[name], enumerable: true });
 };
 
+// ../anvl/src/string/capitalize.ts
+var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
+
 // src/internal/index.ts
 var internal_exports = {};
 __export(internal_exports, {
@@ -107,9 +110,9 @@ function lookup(key, store) {
   return { key, type };
 }
 function withdraw(token, store) {
-  var _a, _b, _c;
+  var _a, _b, _c, _d, _e;
   const core = target(store);
-  return (_c = (_b = (_a = HAMT.get(token.key, core.atoms)) != null ? _a : HAMT.get(token.key, core.selectors)) != null ? _b : HAMT.get(token.key, core.readonlySelectors)) != null ? _c : HAMT.get(token.key, core.transactions);
+  return (_e = (_d = (_c = (_b = (_a = HAMT.get(token.key, core.atoms)) != null ? _a : HAMT.get(token.key, core.selectors)) != null ? _b : HAMT.get(token.key, core.readonlySelectors)) != null ? _c : HAMT.get(token.key, core.transactions)) != null ? _d : HAMT.get(token.key, core.timelines)) != null ? _e : null;
 }
 function deposit(state) {
   return __spreadValues({
@@ -201,7 +204,7 @@ var recordToEntries = (obj) => Object.entries(obj);
 var entriesToRecord = (entries) => Object.fromEntries(entries);
 
 // ../anvl/src/object/mapObject.ts
-import { pipe } from "fp-ts/lib/function";
+import { pipe } from "fp-ts/function";
 var mapObject = (obj, fn) => pipe(
   obj,
   recordToEntries,
@@ -305,13 +308,19 @@ var EMPTY_RELATION_DATA = {
   a: `from`,
   b: `to`
 };
-var isRelationData = (isContent, a = `from`, b = `to`) => (input) => hasExactProperties({
-  contents: isContent ? isRecord(isString, isContent) : hasExactProperties({}),
-  relations: isRecord(isString, isArray(isString)),
-  relationType: isRelationType,
-  a: isLiteral(a),
-  b: isLiteral(b)
-})(input);
+var isRelationData = ({
+  from: a = `from`,
+  to: b = `to`,
+  isContent
+} = {}) => (input) => {
+  return hasExactProperties({
+    contents: isContent ? isRecord(isString, isContent) : hasExactProperties({}),
+    relations: isRecord(isString, isArray(isString)),
+    relationType: isRelationType,
+    a: isLiteral(a),
+    b: isLiteral(b)
+  })(input);
+};
 
 // ../anvl/src/join/get-related-ids.ts
 var getRelatedIds = (relationMap, id) => {
@@ -328,6 +337,21 @@ var getRelatedId = (relationMap, id) => {
   return relations[0];
 };
 
+// ../anvl/src/join/make-json-interface.ts
+var makeJsonInterface = (join, ...params) => {
+  const isContent = params[0];
+  const { a, b } = join;
+  const options = {
+    from: a,
+    to: b,
+    isContent
+  };
+  return {
+    toJson: (join2) => join2.toJSON(),
+    fromJson: (json) => Join.fromJSON(json, options)
+  };
+};
+
 // ../anvl/src/join/relation-contents.ts
 import { pipe as pipe5 } from "fp-ts/function";
 
@@ -518,11 +542,16 @@ var setRelations = (current, subject, relations) => {
 };
 
 // ../anvl/src/join/index.ts
-var Join = class {
+var Join = class _Join {
   constructor(json) {
     this.a = `from`;
     this.b = `to`;
-    Object.assign(this, __spreadValues(__spreadValues({}, EMPTY_RELATION_DATA), json));
+    this.makeJsonInterface = (...params) => {
+      return makeJsonInterface(this, ...params);
+    };
+    Object.assign(this, __spreadProps(__spreadValues(__spreadValues({}, EMPTY_RELATION_DATA), json), {
+      makeJsonInterface: this.makeJsonInterface
+    }));
   }
   toJSON() {
     return {
@@ -533,20 +562,20 @@ var Join = class {
       b: this.b
     };
   }
-  static fromJSON(json, isContent = cannotExist, a = `from`, b = `to`) {
-    const isValid = isRelationData(isContent, a, b)(json);
+  static fromJSON(json, options) {
+    const isValid = isRelationData(options)(json);
     if (isValid) {
-      return new Join(json);
+      return new _Join(json);
     }
     throw new Error(
       `Saved JSON for this Join is invalid: ${JSON.stringify(json)}`
     );
   }
   from(newA) {
-    return new Join(__spreadProps(__spreadValues({}, this), { a: newA }));
+    return new _Join(__spreadProps(__spreadValues({}, this), { a: newA }));
   }
   to(newB) {
-    return new Join(__spreadProps(__spreadValues({}, this), { b: newB }));
+    return new _Join(__spreadProps(__spreadValues({}, this), { b: newB }));
   }
   getRelatedId(id) {
     return getRelatedId(this, id);
@@ -570,51 +599,72 @@ var Join = class {
     return getRelations(this, id);
   }
   setRelations(subject, relations) {
-    return new Join(setRelations(this, subject, relations));
+    return new _Join(setRelations(this, subject, relations));
   }
   set(relation, ...rest) {
-    return new Join(setRelationWithContent(this, relation, ...rest));
+    return new _Join(setRelationWithContent(this, relation, ...rest));
   }
   remove(relation) {
-    return new Join(
+    return new _Join(
       removeRelation(this, relation)
     );
   }
 };
 
 // src/internal/store.ts
-var createStore = (name) => ({
-  atoms: HAMT2.make(),
-  atomsThatAreDefault: /* @__PURE__ */ new Set(),
-  readonlySelectors: HAMT2.make(),
-  selectorAtoms: new Join({ relationType: `n:n` }).from(`selectorKey`).to(`atomKey`),
-  selectorGraph: new Join({ relationType: `n:n` }),
-  selectors: HAMT2.make(),
-  timelines: HAMT2.make(),
-  timelineAtoms: new Join({ relationType: `1:n` }).from(`timelineKey`).to(`atomKey`),
-  timelineStore: HAMT2.make(),
-  transactions: HAMT2.make(),
-  valueMap: HAMT2.make(),
-  subject: {
-    atomCreation: new Rx.Subject(),
-    selectorCreation: new Rx.Subject(),
-    transactionCreation: new Rx.Subject(),
-    timelineCreation: new Rx.Subject()
-  },
-  operation: {
-    open: false
-  },
-  transactionStatus: {
-    phase: `idle`
-  },
-  config: {
-    name,
-    logger: __spreadProps(__spreadValues({}, console), {
-      info: doNothing
-    }),
-    logger__INTERNAL: console
-  }
-});
+var createStore = (name, store = null) => {
+  var _a;
+  const copiedStore = __spreadProps(__spreadValues({}, store != null ? store : (() => ({
+    atomsThatAreDefault: /* @__PURE__ */ new Set(),
+    selectorAtoms: new Join({ relationType: `n:n` }).from(`selectorKey`).to(`atomKey`),
+    selectorGraph: new Join({ relationType: `n:n` }),
+    valueMap: HAMT2.make()
+  }))()), {
+    atoms: HAMT2.make(),
+    readonlySelectors: HAMT2.make(),
+    selectors: HAMT2.make(),
+    transactions: HAMT2.make(),
+    timelines: HAMT2.make(),
+    timelineAtoms: new Join({ relationType: `1:n` }).from(`timelineKey`).to(`atomKey`),
+    subject: __spreadValues({
+      atomCreation: new Rx.Subject(),
+      selectorCreation: new Rx.Subject(),
+      transactionCreation: new Rx.Subject(),
+      timelineCreation: new Rx.Subject()
+    }, store == null ? void 0 : store.subject),
+    operation: __spreadValues({
+      open: false
+    }, store == null ? void 0 : store.operation),
+    transactionStatus: __spreadValues({
+      phase: `idle`
+    }, store == null ? void 0 : store.transactionStatus),
+    config: __spreadProps(__spreadValues({
+      logger: __spreadValues(__spreadProps(__spreadValues({}, console), {
+        info: doNothing
+      }), (_a = store == null ? void 0 : store.config) == null ? void 0 : _a.logger),
+      logger__INTERNAL: console
+    }, store == null ? void 0 : store.config), {
+      name
+    })
+  });
+  store == null ? void 0 : store.atoms.forEach((atom2) => {
+    const copiedAtom = __spreadProps(__spreadValues({}, atom2), { subject: new Rx.Subject() });
+    copiedStore.atoms = HAMT2.set(atom2.key, copiedAtom, copiedStore.atoms);
+  });
+  store == null ? void 0 : store.readonlySelectors.forEach((selector2) => {
+    selector2.install(copiedStore);
+  });
+  store == null ? void 0 : store.selectors.forEach((selector2) => {
+    selector2.install(copiedStore);
+  });
+  store == null ? void 0 : store.transactions.forEach((tx) => {
+    tx.install(copiedStore);
+  });
+  store == null ? void 0 : store.timelines.forEach((timeline2) => {
+    timeline2.install(copiedStore);
+  });
+  return copiedStore;
+};
 var IMPLICIT = {
   STORE_INTERNAL: void 0,
   get STORE() {
@@ -645,7 +695,9 @@ var openOperation = (token, store) => {
     time: Date.now(),
     token
   };
-  (_b = store.config.logger) == null ? void 0 : _b.info(`\u2B55 operation start from "${token.key}"`);
+  (_b = store.config.logger) == null ? void 0 : _b.info(
+    `\u2B55 operation start from "${token.key}" in store "${store.config.name}"`
+  );
 };
 var closeOperation = (store) => {
   var _a;
@@ -720,98 +772,6 @@ var hasKeyBeenUsed = (key, store = IMPLICIT.STORE) => {
 // src/internal/transaction-internal.ts
 import HAMT4 from "hamt_plus";
 import * as Rx2 from "rxjs";
-var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
-var buildTransaction = (key, params, store) => {
-  var _a;
-  store.transactionStatus = {
-    key,
-    phase: `building`,
-    core: {
-      atoms: store.atoms,
-      atomsThatAreDefault: store.atomsThatAreDefault,
-      operation: { open: false },
-      readonlySelectors: store.readonlySelectors,
-      timelines: store.timelines,
-      timelineAtoms: store.timelineAtoms,
-      transactions: store.transactions,
-      selectorAtoms: store.selectorAtoms,
-      selectorGraph: store.selectorGraph,
-      selectors: store.selectors,
-      valueMap: store.valueMap
-    },
-    atomUpdates: [],
-    params,
-    output: void 0
-  };
-  (_a = store.config.logger) == null ? void 0 : _a.info(`\u{1F6EB}`, `transaction "${key}" started`);
-};
-var applyTransaction = (output, store) => {
-  var _a, _b, _c, _d;
-  if (store.transactionStatus.phase !== `building`) {
-    (_a = store.config.logger) == null ? void 0 : _a.warn(
-      `abortTransaction called outside of a transaction. This is probably a bug.`
-    );
-    return;
-  }
-  (_b = store.config.logger) == null ? void 0 : _b.info(
-    `\u{1F6C3} apply transaction "${store.transactionStatus.key}"`
-  );
-  store.transactionStatus.phase = `applying`;
-  store.transactionStatus.output = output;
-  const { atomUpdates } = store.transactionStatus;
-  for (const { key, newValue } of atomUpdates) {
-    const token = { key, type: `atom` };
-    if (!HAMT4.has(token.key, store.valueMap)) {
-      const atom2 = HAMT4.get(token.key, store.transactionStatus.core.atoms);
-      store.atoms = HAMT4.set(atom2.key, atom2, store.atoms);
-      store.valueMap = HAMT4.set(atom2.key, atom2.default, store.valueMap);
-      (_c = store.config.logger) == null ? void 0 : _c.info(`\u{1F527}`, `add atom "${atom2.key}"`);
-    }
-    const state = withdraw(token, store);
-    setState(state, newValue, store);
-  }
-  const myTransaction = withdraw(
-    { key: store.transactionStatus.key, type: `transaction` },
-    store
-  );
-  myTransaction.subject.next({
-    key: store.transactionStatus.key,
-    atomUpdates,
-    output,
-    params: store.transactionStatus.params
-  });
-  store.transactionStatus = { phase: `idle` };
-  (_d = store.config.logger) == null ? void 0 : _d.info(`\u{1F6EC}`, `transaction done`);
-};
-var undoTransactionUpdate = (update, store) => {
-  var _a;
-  (_a = store.config.logger) == null ? void 0 : _a.info(` \u23EE undo transaction "${update.key}" (undo)`);
-  for (const { key, oldValue } of update.atomUpdates) {
-    const token = { key, type: `atom` };
-    const state = withdraw(token, store);
-    setState(state, oldValue, store);
-  }
-};
-var redoTransactionUpdate = (update, store) => {
-  var _a;
-  (_a = store.config.logger) == null ? void 0 : _a.info(` \u23ED redo transaction "${update.key}" (redo)`);
-  for (const { key, newValue } of update.atomUpdates) {
-    const token = { key, type: `atom` };
-    const state = withdraw(token, store);
-    setState(state, newValue, store);
-  }
-};
-var abortTransaction = (store) => {
-  var _a, _b;
-  if (store.transactionStatus.phase === `idle`) {
-    (_a = store.config.logger) == null ? void 0 : _a.warn(
-      `abortTransaction called outside of a transaction. This is probably a bug.`
-    );
-    return;
-  }
-  store.transactionStatus = { phase: `idle` };
-  (_b = store.config.logger) == null ? void 0 : _b.info(`\u{1FA82}`, `transaction fail`);
-};
 function transaction__INTERNAL(options, store = IMPLICIT.STORE) {
   const newTransaction = {
     key: options.key,
@@ -835,6 +795,7 @@ function transaction__INTERNAL(options, store = IMPLICIT.STORE) {
         throw thrown;
       }
     },
+    install: (store2) => transaction__INTERNAL(options, store2),
     subject: new Rx2.Subject()
   };
   const core = target(store);
@@ -1094,9 +1055,59 @@ var attachMetaState = (store = IMPLICIT.STORE) => {
 };
 
 // src/internal/selector-internal.ts
+import HAMT9 from "hamt_plus";
+
+// src/internal/selector/create-read-write-selector.ts
 import HAMT6 from "hamt_plus";
 import * as Rx5 from "rxjs";
+var createReadWriteSelector = (options, family, store, core) => {
+  var _a;
+  const subject = new Rx5.Subject();
+  const { get, set } = registerSelector(options.key, store);
+  const getSelf = () => {
+    const value = options.get({ get });
+    cacheValue(options.key, value, store);
+    return value;
+  };
+  const setSelf = (next) => {
+    var _a2;
+    (_a2 = store.config.logger) == null ? void 0 : _a2.info(`   <- "${options.key}" became`, next);
+    const oldValue = getSelf();
+    const newValue = become(next)(oldValue);
+    cacheValue(options.key, newValue, store);
+    markDone(options.key, store);
+    if (store.transactionStatus.phase === `idle`) {
+      subject.next({ newValue, oldValue });
+    }
+    options.set({ get, set }, newValue);
+  };
+  const mySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
+    subject,
+    install: (s) => selector__INTERNAL(options, family, s),
+    get: getSelf,
+    set: setSelf,
+    type: `selector`
+  }), family && { family });
+  core.selectors = HAMT6.set(options.key, mySelector, core.selectors);
+  const initialValue = getSelf();
+  (_a = store.config.logger) == null ? void 0 : _a.info(`   \u2728 "${options.key}" =`, initialValue);
+  const token = {
+    key: options.key,
+    type: `selector`,
+    family
+  };
+  store.subject.selectorCreation.next(token);
+  return token;
+};
+
+// src/internal/selector/create-readonly-selector.ts
+import HAMT8 from "hamt_plus";
+import * as Rx6 from "rxjs";
+
+// src/internal/selector/lookup-selector-sources.ts
 var lookupSelectorSources = (key, store) => target(store).selectorGraph.getRelations(key).filter(({ source }) => source !== key).map(({ source }) => lookup(source, store));
+
+// src/internal/selector/trace-selector-atoms.ts
 var traceSelectorAtoms = (selectorKey, dependency, store) => {
   const roots = [];
   const sources = lookupSelectorSources(dependency.key, store);
@@ -1123,6 +1134,8 @@ var traceAllSelectorAtoms = (selectorKey, store) => {
     (source) => source.type === `atom` ? source : traceSelectorAtoms(selectorKey, source, store)
   );
 };
+
+// src/internal/selector/update-selector-atoms.ts
 var updateSelectorAtoms = (selectorKey, dependency, store) => {
   var _a, _b;
   const core = target(store);
@@ -1148,104 +1161,6 @@ var updateSelectorAtoms = (selectorKey, dependency, store) => {
     });
   }
 };
-var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
-  get: (dependency) => {
-    var _a, _b;
-    const core = target(store);
-    const alreadyRegistered = core.selectorGraph.getRelations(selectorKey).some(({ source }) => source === dependency.key);
-    const dependencyState = withdraw(dependency, store);
-    const dependencyValue = getState__INTERNAL(dependencyState, store);
-    if (alreadyRegistered) {
-      (_a = store.config.logger) == null ? void 0 : _a.info(
-        `   || ${selectorKey} <- ${dependency.key} =`,
-        dependencyValue
-      );
-    } else {
-      (_b = store.config.logger) == null ? void 0 : _b.info(
-        `\u{1F50C} registerSelector "${selectorKey}" <- ( "${dependency.key}" =`,
-        dependencyValue,
-        `)`
-      );
-      core.selectorGraph = core.selectorGraph.set(
-        { from: dependency.key, to: selectorKey },
-        {
-          source: dependency.key
-        }
-      );
-    }
-    updateSelectorAtoms(selectorKey, dependency, store);
-    return dependencyValue;
-  },
-  set: (stateToken, newValue) => {
-    const state = withdraw(stateToken, store);
-    setState__INTERNAL(state, newValue, store);
-  }
-});
-function selector__INTERNAL(options, family, store = IMPLICIT.STORE) {
-  var _a, _b, _c;
-  const core = target(store);
-  if (HAMT6.has(options.key, core.selectors)) {
-    (_a = store.config.logger) == null ? void 0 : _a.error(
-      `Key "${options.key}" already exists in the store.`
-    );
-  }
-  const subject = new Rx5.Subject();
-  const { get, set } = registerSelector(options.key, store);
-  const getSelf = () => {
-    const value = options.get({ get });
-    cacheValue(options.key, value, store);
-    return value;
-  };
-  if (!(`set` in options)) {
-    const readonlySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
-      subject,
-      get: getSelf,
-      type: `readonly_selector`
-    }), family && { family });
-    core.readonlySelectors = HAMT6.set(
-      options.key,
-      readonlySelector,
-      core.readonlySelectors
-    );
-    const initialValue2 = getSelf();
-    (_b = store.config.logger) == null ? void 0 : _b.info(`   \u2728 "${options.key}" =`, initialValue2);
-    const token2 = {
-      key: options.key,
-      type: `readonly_selector`,
-      family
-    };
-    store.subject.selectorCreation.next(token2);
-    return token2;
-  }
-  const setSelf = (next) => {
-    var _a2;
-    (_a2 = store.config.logger) == null ? void 0 : _a2.info(`   <- "${options.key}" became`, next);
-    const oldValue = getSelf();
-    const newValue = become(next)(oldValue);
-    cacheValue(options.key, newValue, store);
-    markDone(options.key, store);
-    if (store.transactionStatus.phase === `idle`) {
-      subject.next({ newValue, oldValue });
-    }
-    options.set({ get, set }, newValue);
-  };
-  const mySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
-    subject,
-    get: getSelf,
-    set: setSelf,
-    type: `selector`
-  }), family && { family });
-  core.selectors = HAMT6.set(options.key, mySelector, core.selectors);
-  const initialValue = getSelf();
-  (_c = store.config.logger) == null ? void 0 : _c.info(`   \u2728 "${options.key}" =`, initialValue);
-  const token = {
-    key: options.key,
-    type: `selector`,
-    family
-  };
-  store.subject.selectorCreation.next(token);
-  return token;
-}
 
 // src/internal/set.ts
 import HAMT7 from "hamt_plus";
@@ -1285,7 +1200,7 @@ var setAtomState = (atom2, next, store = IMPLICIT.STORE) => {
   const newValue = become(next)(oldValue);
   (_a = store.config.logger) == null ? void 0 : _a.info(`<< setting atom "${atom2.key}" to`, newValue);
   cacheValue(atom2.key, newValue, store);
-  if (isAtomDefault(atom2.key)) {
+  if (isAtomDefault(atom2.key, store)) {
     markAtomAsNotDefault(atom2.key, store);
   }
   markDone(atom2.key, store);
@@ -1316,6 +1231,98 @@ var setState__INTERNAL = (state, value, store = IMPLICIT.STORE) => {
   }
 };
 
+// src/internal/selector/register-selector.ts
+var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
+  get: (dependency) => {
+    var _a, _b;
+    const core = target(store);
+    const alreadyRegistered = core.selectorGraph.getRelations(selectorKey).some(({ source }) => source === dependency.key);
+    const dependencyState = withdraw(dependency, store);
+    if (dependencyState === null) {
+      throw new Error(
+        `State "${dependency.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
+      );
+    }
+    const dependencyValue = getState__INTERNAL(dependencyState, store);
+    if (alreadyRegistered) {
+      (_a = store.config.logger) == null ? void 0 : _a.info(
+        `   || ${selectorKey} <- ${dependency.key} =`,
+        dependencyValue
+      );
+    } else {
+      (_b = store.config.logger) == null ? void 0 : _b.info(
+        `\u{1F50C} registerSelector "${selectorKey}" <- ( "${dependency.key}" =`,
+        dependencyValue,
+        `)`
+      );
+      core.selectorGraph = core.selectorGraph.set(
+        { from: dependency.key, to: selectorKey },
+        {
+          source: dependency.key
+        }
+      );
+    }
+    updateSelectorAtoms(selectorKey, dependency, store);
+    return dependencyValue;
+  },
+  set: (stateToken, newValue) => {
+    const state = withdraw(stateToken, store);
+    if (state === null) {
+      throw new Error(
+        `State "${stateToken.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
+      );
+    }
+    setState__INTERNAL(state, newValue, store);
+  }
+});
+
+// src/internal/selector/create-readonly-selector.ts
+var createReadonlySelector = (options, family, store, core) => {
+  var _a;
+  const subject = new Rx6.Subject();
+  const { get } = registerSelector(options.key, store);
+  const getSelf = () => {
+    const value = options.get({ get });
+    cacheValue(options.key, value, store);
+    return value;
+  };
+  const readonlySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
+    subject,
+    install: (s) => selector__INTERNAL(options, family, s),
+    get: getSelf,
+    type: `readonly_selector`
+  }), family && { family });
+  core.readonlySelectors = HAMT8.set(
+    options.key,
+    readonlySelector,
+    core.readonlySelectors
+  );
+  const initialValue = getSelf();
+  (_a = store.config.logger) == null ? void 0 : _a.info(`   \u2728 "${options.key}" =`, initialValue);
+  const token = {
+    key: options.key,
+    type: `readonly_selector`,
+    family
+  };
+  store.subject.selectorCreation.next(token);
+  return token;
+};
+
+// src/internal/selector-internal.ts
+function selector__INTERNAL(options, family, store = IMPLICIT.STORE) {
+  var _a;
+  const core = target(store);
+  if (HAMT9.has(options.key, core.selectors)) {
+    (_a = store.config.logger) == null ? void 0 : _a.error(
+      `Key "${options.key}" already exists in the store.`
+    );
+  }
+  if (!(`set` in options)) {
+    return createReadonlySelector(options, family, store, core);
+  }
+  return createReadWriteSelector(options, family, store, core);
+}
+
 // src/internal/subscribe-internal.ts
 var prepareUpdate = (state, store) => {
   const oldValue = recallState(state, store);
@@ -1350,6 +1357,11 @@ var emitUpdate = (state, update, store) => {
 var subscribeToRootAtoms = (state, store) => {
   const dependencySubscriptions = `default` in state ? null : traceAllSelectorAtoms(state.key, store).map((atomToken) => {
     const atom2 = withdraw(atomToken, store);
+    if (atom2 === null) {
+      throw new Error(
+        `Atom "${atomToken.key}", a dependency of selector "${state.key}", not found in store "${store.config.name}".`
+      );
+    }
     return atom2.subject.subscribe((atomChange) => {
       var _a, _b;
       (_a = store.config.logger) == null ? void 0 : _a.info(
@@ -1372,7 +1384,7 @@ var subscribeToRootAtoms = (state, store) => {
 var redo__INTERNAL = (token, store = IMPLICIT.STORE) => {
   var _a, _b, _c, _d;
   (_a = store.config.logger) == null ? void 0 : _a.info(`\u23E9 redo "${token.key}"`);
-  const timelineData = store.timelineStore.get(token.key);
+  const timelineData = store.timelines.get(token.key);
   if (!timelineData) {
     (_b = store.config.logger) == null ? void 0 : _b.error(
       `Failed to redo on timeline "${token.key}". This timeline has not been initialized.`
@@ -1390,14 +1402,14 @@ var redo__INTERNAL = (token, store = IMPLICIT.STORE) => {
   switch (update.type) {
     case `atom_update`: {
       const { key, newValue } = update;
-      setState({ key, type: `atom` }, newValue);
+      setState({ key, type: `atom` }, newValue, store);
       break;
     }
     case `selector_update`:
     case `transaction_update`: {
       for (const atomUpdate of update.atomUpdates) {
         const { key, newValue } = atomUpdate;
-        setState({ key, type: `atom` }, newValue);
+        setState({ key, type: `atom` }, newValue, store);
       }
       break;
     }
@@ -1411,7 +1423,7 @@ var redo__INTERNAL = (token, store = IMPLICIT.STORE) => {
 var undo__INTERNAL = (token, store = IMPLICIT.STORE) => {
   var _a, _b, _c, _d;
   (_a = store.config.logger) == null ? void 0 : _a.info(`\u23EA undo "${token.key}"`);
-  const timelineData = store.timelineStore.get(token.key);
+  const timelineData = store.timelines.get(token.key);
   if (!timelineData) {
     (_b = store.config.logger) == null ? void 0 : _b.error(
       `Failed to undo on timeline "${token.key}". This timeline has not been initialized.`
@@ -1430,14 +1442,14 @@ var undo__INTERNAL = (token, store = IMPLICIT.STORE) => {
   switch (update.type) {
     case `atom_update`: {
       const { key, oldValue } = update;
-      setState({ key, type: `atom` }, oldValue);
+      setState({ key, type: `atom` }, oldValue, store);
       break;
     }
     case `selector_update`:
     case `transaction_update`: {
       for (const atomUpdate of update.atomUpdates) {
         const { key, oldValue } = atomUpdate;
-        setState({ key, type: `atom` }, oldValue);
+        setState({ key, type: `atom` }, oldValue, store);
       }
       break;
     }
@@ -1449,132 +1461,166 @@ var undo__INTERNAL = (token, store = IMPLICIT.STORE) => {
 };
 
 // src/internal/timeline-internal.ts
-import HAMT8 from "hamt_plus";
-function timeline__INTERNAL(options, store = IMPLICIT.STORE) {
-  var _a, _b;
-  const timelineData = {
-    at: 0,
-    timeTraveling: false,
-    history: [],
-    selectorTime: null,
-    transactionKey: null
-  };
-  const subscribeToAtom = (token2) => {
-    const state = withdraw(token2, store);
-    state.subject.subscribe((update) => {
-      var _a2, _b2, _c, _d, _e;
-      const storeCurrentSelectorKey = store.operation.open && store.operation.token.type === `selector` ? store.operation.token.key : null;
-      const storeCurrentSelectorTime = store.operation.open && store.operation.token.type === `selector` ? store.operation.time : null;
-      const storeCurrentTransactionKey = store.transactionStatus.phase === `applying` ? store.transactionStatus.key : null;
-      (_a2 = store.config.logger) == null ? void 0 : _a2.info(
-        `\u23F3 timeline "${options.key}" saw atom "${token2.key}" go (`,
-        update.oldValue,
-        `->`,
-        update.newValue,
-        storeCurrentTransactionKey ? `) in transaction "${storeCurrentTransactionKey}"` : storeCurrentSelectorKey ? `) in selector "${storeCurrentSelectorKey}"` : `)`
-      );
-      if (storeCurrentTransactionKey && store.transactionStatus.phase === `applying`) {
+import HAMT10 from "hamt_plus";
+import * as Rx7 from "rxjs";
+
+// src/internal/timeline/add-atom-to-timeline.ts
+var addAtomToTimeline = (atomToken, atoms, tl, store = IMPLICIT.STORE) => {
+  const atom2 = withdraw(atomToken, store);
+  if (atom2 === null) {
+    throw new Error(
+      `Cannot subscribe to atom "${atomToken.key}" because it has not been initialized in store "${store.config.name}"`
+    );
+  }
+  atom2.subject.subscribe((update) => {
+    var _a, _b, _c, _d, _e;
+    const currentSelectorKey = store.operation.open && store.operation.token.type === `selector` ? store.operation.token.key : null;
+    const currentSelectorTime = store.operation.open && store.operation.token.type === `selector` ? store.operation.time : null;
+    const currentTransactionKey = store.transactionStatus.phase === `applying` ? store.transactionStatus.key : null;
+    const currentTransactionTime = store.transactionStatus.phase === `applying` ? store.transactionStatus.time : null;
+    (_a = store.config.logger) == null ? void 0 : _a.info(
+      `\u23F3 timeline "${tl.key}" saw atom "${atomToken.key}" go (`,
+      update.oldValue,
+      `->`,
+      update.newValue,
+      currentTransactionKey ? `) in transaction "${currentTransactionKey}"` : currentSelectorKey ? `) in selector "${currentSelectorKey}"` : `)`
+    );
+    if (tl.timeTraveling === false) {
+      if (tl.selectorTime && tl.selectorTime !== currentSelectorTime) {
+        const mostRecentUpdate = tl.history.at(-1);
+        if (mostRecentUpdate.type === `selector_update`) {
+          tl.subject.next(mostRecentUpdate);
+        }
+      }
+      if (currentTransactionKey && store.transactionStatus.phase === `applying`) {
         const currentTransaction = withdraw(
-          { key: storeCurrentTransactionKey, type: `transaction` },
+          { key: currentTransactionKey, type: `transaction` },
           store
         );
-        if (timelineData.transactionKey !== storeCurrentTransactionKey) {
-          if (timelineData.transactionKey) {
-            (_b2 = store.config.logger) == null ? void 0 : _b2.error(
-              `Timeline "${options.key}" was unable to resolve transaction "${timelineData.transactionKey}. This is probably a bug.`
+        if (currentTransaction === null) {
+          throw new Error(
+            `Transaction "${currentTransactionKey}" not found in store "${store.config.name}". This is surprising, because we are in the application phase of "${currentTransactionKey}".`
+          );
+        }
+        if (tl.transactionKey !== currentTransactionKey) {
+          if (tl.transactionKey) {
+            (_b = store.config.logger) == null ? void 0 : _b.error(
+              `Timeline "${tl.key}" was unable to resolve transaction "${tl.transactionKey}. This is probably a bug.`
             );
           }
-          timelineData.transactionKey = storeCurrentTransactionKey;
+          tl.transactionKey = currentTransactionKey;
           const subscription = currentTransaction.subject.subscribe((update2) => {
-            var _a3;
-            if (timelineData.timeTraveling === false) {
-              if (timelineData.at !== timelineData.history.length) {
-                timelineData.history.splice(timelineData.at);
+            var _a2;
+            if (tl.timeTraveling === false && currentTransactionTime) {
+              if (tl.at !== tl.history.length) {
+                tl.history.splice(tl.at);
               }
-              timelineData.history.push(__spreadProps(__spreadValues({
-                type: `transaction_update`
+              const timelineTransactionUpdate = __spreadProps(__spreadValues({
+                type: `transaction_update`,
+                timestamp: currentTransactionTime
               }, update2), {
                 atomUpdates: update2.atomUpdates.filter(
-                  (atomUpdate) => options.atoms.some((atom2) => atom2.key === atomUpdate.key)
+                  (atomUpdate) => atoms.some((atom3) => atom3.key === atomUpdate.key)
                 )
-              }));
+              });
+              tl.history.push(timelineTransactionUpdate);
+              tl.subject.next(timelineTransactionUpdate);
             }
-            timelineData.at = timelineData.history.length;
+            tl.at = tl.history.length;
             subscription.unsubscribe();
-            timelineData.transactionKey = null;
-            (_a3 = store.config.logger) == null ? void 0 : _a3.info(
-              `\u231B timeline "${options.key}" got a transaction_update "${update2.key}"`
+            tl.transactionKey = null;
+            (_a2 = store.config.logger) == null ? void 0 : _a2.info(
+              `\u231B timeline "${tl.key}" got a transaction_update "${update2.key}"`
             );
           });
         }
-      } else if (storeCurrentSelectorKey) {
-        if (timelineData.timeTraveling === false) {
-          if (storeCurrentSelectorTime !== timelineData.selectorTime) {
-            const newSelectorUpdate = {
-              type: `selector_update`,
-              key: storeCurrentSelectorKey,
-              atomUpdates: []
-            };
-            newSelectorUpdate.atomUpdates.push(__spreadValues({
-              key: token2.key,
+      } else if (currentSelectorKey && currentSelectorTime) {
+        if (currentSelectorTime !== tl.selectorTime) {
+          const newSelectorUpdate = {
+            type: `selector_update`,
+            timestamp: currentSelectorTime,
+            key: currentSelectorKey,
+            atomUpdates: []
+          };
+          newSelectorUpdate.atomUpdates.push(__spreadValues({
+            key: atom2.key,
+            type: `atom_update`
+          }, update));
+          if (tl.at !== tl.history.length) {
+            tl.history.splice(tl.at);
+          }
+          tl.history.push(newSelectorUpdate);
+          (_c = store.config.logger) == null ? void 0 : _c.info(
+            `\u231B timeline "${tl.key}" got a selector_update "${currentSelectorKey}" with`,
+            newSelectorUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
+          );
+          tl.at = tl.history.length;
+          tl.selectorTime = currentSelectorTime;
+        } else {
+          const latestUpdate = tl.history.at(-1);
+          if ((latestUpdate == null ? void 0 : latestUpdate.type) === `selector_update`) {
+            latestUpdate.atomUpdates.push(__spreadValues({
+              key: atom2.key,
               type: `atom_update`
             }, update));
-            if (timelineData.at !== timelineData.history.length) {
-              timelineData.history.splice(timelineData.at);
-            }
-            timelineData.history.push(newSelectorUpdate);
-            (_c = store.config.logger) == null ? void 0 : _c.info(
-              `\u231B timeline "${options.key}" got a selector_update "${storeCurrentSelectorKey}" with`,
-              newSelectorUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
+            (_d = store.config.logger) == null ? void 0 : _d.info(
+              `   \u231B timeline "${tl.key}" set selector_update "${currentSelectorKey}" to`,
+              latestUpdate == null ? void 0 : latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
             );
-            timelineData.at = timelineData.history.length;
-            timelineData.selectorTime = storeCurrentSelectorTime;
-          } else {
-            const latestUpdate = timelineData.history.at(-1);
-            if ((latestUpdate == null ? void 0 : latestUpdate.type) === `selector_update`) {
-              latestUpdate.atomUpdates.push(__spreadValues({
-                key: token2.key,
-                type: `atom_update`
-              }, update));
-              (_d = store.config.logger) == null ? void 0 : _d.info(
-                `   \u231B timeline "${options.key}" set selector_update "${storeCurrentSelectorKey}" to`,
-                latestUpdate == null ? void 0 : latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
-              );
-            }
           }
         }
       } else {
-        if (timelineData.timeTraveling === false) {
-          timelineData.selectorTime = null;
-          if (timelineData.at !== timelineData.history.length) {
-            timelineData.history.splice(timelineData.at);
-          }
-          timelineData.history.push({
-            type: `atom_update`,
-            key: token2.key,
-            oldValue: update.oldValue,
-            newValue: update.newValue
-          });
-          (_e = store.config.logger) == null ? void 0 : _e.info(
-            `\u231B timeline "${options.key}" got a state_update to "${token2.key}"`
-          );
-          timelineData.at = timelineData.history.length;
+        const timestamp = Date.now();
+        tl.selectorTime = null;
+        if (tl.at !== tl.history.length) {
+          tl.history.splice(tl.at);
         }
+        const atomUpdate = {
+          type: `atom_update`,
+          timestamp,
+          key: atom2.key,
+          oldValue: update.oldValue,
+          newValue: update.newValue
+        };
+        tl.history.push(atomUpdate);
+        tl.subject.next(atomUpdate);
+        (_e = store.config.logger) == null ? void 0 : _e.info(
+          `\u231B timeline "${tl.key}" got a state_update to "${atom2.key}"`
+        );
+        tl.at = tl.history.length;
       }
-    });
-  };
+    }
+  });
+};
+
+// src/internal/timeline-internal.ts
+function timeline__INTERNAL(options, store = IMPLICIT.STORE, data = null) {
+  var _a, _b, _c;
+  const tl = __spreadProps(__spreadValues({
+    key: options.key,
+    at: 0,
+    timeTraveling: false,
+    selectorTime: null,
+    transactionKey: null
+  }, data), {
+    history: (_a = data == null ? void 0 : data.history.map((update) => __spreadValues({}, update))) != null ? _a : [],
+    install: (store2) => timeline__INTERNAL(options, store2, tl),
+    subject: new Rx7.Subject()
+  });
   const core = target(store);
   for (const tokenOrFamily of options.atoms) {
     const timelineKey = core.timelineAtoms.getRelatedId(tokenOrFamily.key);
     if (timelineKey) {
-      (_a = store.config.logger) == null ? void 0 : _a.error(
+      (_b = store.config.logger) == null ? void 0 : _b.error(
         `\u274C Failed to add atom "${tokenOrFamily.key}" to timeline "${options.key}" because it belongs to timeline "${timelineKey}"`
       );
       continue;
     }
     if (tokenOrFamily.type === `atom_family`) {
       const family = tokenOrFamily;
-      family.subject.subscribe((token2) => subscribeToAtom(token2));
+      family.subject.subscribe(
+        (token2) => addAtomToTimeline(token2, options.atoms, tl, store)
+      );
     } else {
       const token2 = tokenOrFamily;
       if (`family` in token2 && token2.family) {
@@ -1582,20 +1628,20 @@ function timeline__INTERNAL(options, store = IMPLICIT.STORE) {
           token2.family.key
         );
         if (familyTimelineKey) {
-          (_b = store.config.logger) == null ? void 0 : _b.error(
+          (_c = store.config.logger) == null ? void 0 : _c.error(
             `\u274C Failed to add atom "${token2.key}" to timeline "${options.key}" because its family "${token2.family.key}" belongs to timeline "${familyTimelineKey}"`
           );
           continue;
         }
       }
-      subscribeToAtom(token2);
+      addAtomToTimeline(token2, options.atoms, tl, store);
     }
     core.timelineAtoms = core.timelineAtoms.set({
       atomKey: tokenOrFamily.key,
       timelineKey: options.key
     });
   }
-  store.timelineStore = HAMT8.set(options.key, timelineData, store.timelineStore);
+  store.timelines = HAMT10.set(options.key, tl, store.timelines);
   const token = {
     key: options.key,
     type: `timeline`
@@ -1604,6 +1650,129 @@ function timeline__INTERNAL(options, store = IMPLICIT.STORE) {
   return token;
 }
 
+// src/internal/transaction/abort-transaction.ts
+var abortTransaction = (store) => {
+  var _a, _b;
+  if (store.transactionStatus.phase === `idle`) {
+    (_a = store.config.logger) == null ? void 0 : _a.warn(
+      `abortTransaction called outside of a transaction. This is probably a bug.`
+    );
+    return;
+  }
+  store.transactionStatus = { phase: `idle` };
+  (_b = store.config.logger) == null ? void 0 : _b.info(`\u{1FA82}`, `transaction fail`);
+};
+
+// src/internal/transaction/apply-transaction.ts
+import HAMT11 from "hamt_plus";
+var applyTransaction = (output, store) => {
+  var _a, _b, _c, _d;
+  if (store.transactionStatus.phase !== `building`) {
+    (_a = store.config.logger) == null ? void 0 : _a.warn(
+      `abortTransaction called outside of a transaction. This is probably a bug.`
+    );
+    return;
+  }
+  (_b = store.config.logger) == null ? void 0 : _b.info(
+    `\u{1F6C3} apply transaction "${store.transactionStatus.key}"`
+  );
+  store.transactionStatus.phase = `applying`;
+  store.transactionStatus.output = output;
+  const { atomUpdates } = store.transactionStatus;
+  for (const { key, newValue } of atomUpdates) {
+    const token = { key, type: `atom` };
+    if (!HAMT11.has(token.key, store.valueMap)) {
+      const newAtom = HAMT11.get(token.key, store.transactionStatus.core.atoms);
+      store.atoms = HAMT11.set(newAtom.key, newAtom, store.atoms);
+      store.valueMap = HAMT11.set(newAtom.key, newAtom.default, store.valueMap);
+      (_c = store.config.logger) == null ? void 0 : _c.info(`\u{1F527}`, `add atom "${newAtom.key}"`);
+    }
+    setState(token, newValue, store);
+  }
+  const myTransaction = withdraw(
+    { key: store.transactionStatus.key, type: `transaction` },
+    store
+  );
+  if (myTransaction === null) {
+    throw new Error(
+      `Transaction "${store.transactionStatus.key}" not found. Absurd. How is this running?`
+    );
+  }
+  myTransaction.subject.next({
+    key: store.transactionStatus.key,
+    atomUpdates,
+    output,
+    params: store.transactionStatus.params
+  });
+  store.transactionStatus = { phase: `idle` };
+  (_d = store.config.logger) == null ? void 0 : _d.info(`\u{1F6EC}`, `transaction done`);
+};
+
+// src/internal/transaction/build-transaction.ts
+var buildTransaction = (key, params, store) => {
+  var _a;
+  store.transactionStatus = {
+    key,
+    phase: `building`,
+    time: Date.now(),
+    core: {
+      atoms: store.atoms,
+      atomsThatAreDefault: store.atomsThatAreDefault,
+      operation: { open: false },
+      readonlySelectors: store.readonlySelectors,
+      timelines: store.timelines,
+      timelineAtoms: store.timelineAtoms,
+      transactions: store.transactions,
+      selectorAtoms: store.selectorAtoms,
+      selectorGraph: store.selectorGraph,
+      selectors: store.selectors,
+      valueMap: store.valueMap
+    },
+    atomUpdates: [],
+    params,
+    output: void 0
+  };
+  (_a = store.config.logger) == null ? void 0 : _a.info(
+    `\u{1F6EB}`,
+    `transaction "${key}" started in store "${store.config.name}"`
+  );
+};
+
+// src/internal/transaction/redo-transaction.ts
+var redoTransactionUpdate = (update, store) => {
+  var _a;
+  (_a = store.config.logger) == null ? void 0 : _a.info(` \u23ED redo transaction "${update.key}" (redo)`);
+  for (const { key, newValue } of update.atomUpdates) {
+    const token = { key, type: `atom` };
+    const state = withdraw(token, store);
+    if (state === null) {
+      throw new Error(
+        `State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`
+      );
+    }
+    setState(state, newValue, store);
+  }
+};
+
+// src/internal/transaction/undo-transaction.ts
+var undoTransactionUpdate = (update, store) => {
+  var _a;
+  (_a = store.config.logger) == null ? void 0 : _a.info(` \u23EE undo transaction "${update.key}" (undo)`);
+  for (const { key, oldValue } of update.atomUpdates) {
+    const token = { key, type: `atom` };
+    const state = withdraw(token, store);
+    if (state === null) {
+      throw new Error(
+        `State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`
+      );
+    }
+    setState(state, oldValue, store);
+  }
+};
+
+// src/internal/transaction/index.ts
+var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
+
 // src/atom.ts
 function atom(options) {
   return atom__INTERNAL(options);
@@ -1653,10 +1822,34 @@ function selectorFamily(options) {
   return selectorFamily__INTERNAL(options);
 }
 
+// src/silo.ts
+var silo = (name, fromStore = null) => {
+  const store = createStore(name, fromStore);
+  return {
+    store,
+    atom: (options) => atom__INTERNAL(options, void 0, store),
+    atomFamily: (options) => atomFamily__INTERNAL(options, store),
+    selector: (options) => selector__INTERNAL(options, void 0, store),
+    selectorFamily: (options) => selectorFamily__INTERNAL(options, store),
+    transaction: (options) => transaction__INTERNAL(options, store),
+    timeline: (options) => timeline__INTERNAL(options, store),
+    getState: (token) => getState(token, store),
+    setState: (token, newValue) => setState(token, newValue, store),
+    subscribe: (token, handler) => subscribe(token, handler, store),
+    undo: (token) => undo__INTERNAL(token, store),
+    redo: (token) => redo__INTERNAL(token, store)
+  };
+};
+
 // src/subscribe.ts
 var subscribe = (token, handleUpdate, store = IMPLICIT.STORE) => {
   var _a;
   const state = withdraw(token, store);
+  if (state === null) {
+    throw new Error(
+      `State "${token.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
+    );
+  }
   const subscription = state.subject.subscribe(handleUpdate);
   (_a = store.config.logger) == null ? void 0 : _a.info(`\u{1F440} subscribe to "${state.key}"`);
   const dependencySubscriptions = state.type !== `atom` ? subscribeToRootAtoms(state, store) : null;
@@ -1679,6 +1872,11 @@ var subscribe = (token, handleUpdate, store = IMPLICIT.STORE) => {
 var subscribeToTransaction = (token, handleUpdate, store = IMPLICIT.STORE) => {
   var _a;
   const tx = withdraw(token, store);
+  if (tx === null) {
+    throw new Error(
+      `Cannot subscribe to transaction "${token.key}": transaction not found in store "${store.config.name}".`
+    );
+  }
   (_a = store.config.logger) == null ? void 0 : _a.info(`\u{1F440} subscribe to transaction "${token.key}"`);
   const subscription = tx.subject.subscribe(handleUpdate);
   const unsubscribe = () => {
@@ -1688,6 +1886,23 @@ var subscribeToTransaction = (token, handleUpdate, store = IMPLICIT.STORE) => {
   };
   return unsubscribe;
 };
+var subscribeToTimeline = (token, handleUpdate, store = IMPLICIT.STORE) => {
+  var _a;
+  const tl = withdraw(token, store);
+  if (tl === null) {
+    throw new Error(
+      `Cannot subscribe to timeline "${token.key}": timeline not found in store "${store.config.name}".`
+    );
+  }
+  (_a = store.config.logger) == null ? void 0 : _a.info(`\u{1F440} subscribe to timeline "${token.key}"`);
+  const subscription = tl.subject.subscribe(handleUpdate);
+  const unsubscribe = () => {
+    var _a2;
+    (_a2 = store.config.logger) == null ? void 0 : _a2.info(`\u{1F648} unsubscribe from timeline "${token.key}"`);
+    subscription.unsubscribe();
+  };
+  return unsubscribe;
+};
 
 // src/timeline.ts
 var timeline = (options) => {
@@ -1704,11 +1919,24 @@ var undo = (token) => {
 function transaction(options) {
   return transaction__INTERNAL(options);
 }
-var runTransaction = (token, store = IMPLICIT.STORE) => (...parameters) => withdraw(token, store).run(...parameters);
+var runTransaction = (token, store = IMPLICIT.STORE) => (...parameters) => {
+  const tx = withdraw(token, store);
+  if (tx) {
+    return tx.run(...parameters);
+  }
+  throw new Error(
+    `Cannot run transaction "${token.key}": transaction not found in store "${store.config.name}".`
+  );
+};
 
 // src/index.ts
 var getState = (token, store = IMPLICIT.STORE) => {
   const state = withdraw(token, store);
+  if (state === null) {
+    throw new Error(
+      `${capitalize(token.type)} "${token.key}" not found in store "${store.config.name}".`
+    );
+  }
   return getState__INTERNAL(state, store);
 };
 var setState = (token, value, store = IMPLICIT.STORE) => {
@@ -1721,6 +1949,11 @@ var setState = (token, value, store = IMPLICIT.STORE) => {
     return;
   }
   const state = withdraw(token, store);
+  if (state === null) {
+    throw new Error(
+      `${capitalize(token.type)} "${token.key}" not found in store "${store.config.name}".`
+    );
+  }
   setState__INTERNAL(state, value, store);
   closeOperation(store);
 };
@@ -1738,7 +1971,9 @@ export {
   selectorFamily,
   setLogLevel,
   setState,
+  silo,
   subscribe,
+  subscribeToTimeline,
   subscribeToTransaction,
   timeline,
   transaction,