atom.io 0.4.1 → 0.5.0

package/dist/index.d.ts

@@ -1,6 +1,13 @@
 import * as Rx from 'rxjs';
 import { Hamt } from 'hamt_plus';
-import { Refinement } from 'fp-ts/Refinement';
+import { Refinement } from 'fp-ts/lib/Refinement';
+
+type ƒn = (...parameters: any[]) => any;
+
+type JsonInterface<T, J extends Json = Json> = {
+    toJson: (t: T) => J;
+    fromJson: (json: J) => T;
+};
 
 type Primitive = boolean | number | string | null;
 type Serializable = Primitive | Readonly<{
@@ -23,6 +30,11 @@ type RelationData<CONTENT extends JsonObj | null = null, A extends string = `fro
     a: A;
     b: B;
 };
+type IsRelationDataOptions<CONTENT extends JsonObj | null = null, A extends string = `from`, B extends string = `to`> = {
+    from?: A;
+    to?: B;
+    isContent?: (json: Json) => json is CONTENT;
+};
 
 type NullSafeUnion<Base, Extension> = Extension extends null ? Base : Base & Extension;
 type NullSafeRest<MaybeArg> = MaybeArg extends null ? [] | [undefined] : [MaybeArg];
@@ -35,9 +47,11 @@ declare class Join<CONTENT extends JsonObj | null = null, A extends string = `fr
     readonly contents: Record<string, CONTENT>;
     constructor(json?: Partial<RelationData<CONTENT, A, B>>);
     toJSON(): RelationData<CONTENT, A, B>;
-    static fromJSON<CONTENT extends JsonObj | null, A extends string, B extends string>(json: Json, isContent?: Refinement<unknown, CONTENT>, a?: A, b?: B): Join<CONTENT, A, B>;
+    static fromJSON<CONTENT extends JsonObj | null, A extends string, B extends string>(json: Json, options?: IsRelationDataOptions<CONTENT, A, B>): Join<CONTENT, A, B>;
     from<AA extends string>(newA: AA): Join<CONTENT, AA, B>;
     to<BB extends string>(newB: BB): Join<CONTENT, A, BB>;
+    makeJsonInterface: (...params: CONTENT extends null ? [
+    ] : [Refinement<unknown, CONTENT>]) => JsonInterface<Join<CONTENT, A, B>, RelationData<CONTENT, A, B>>;
     getRelatedId(id: string): string | undefined;
     getRelatedIds(id: string): string[];
     getContent(idA: string, idB: string): CONTENT | undefined;
@@ -131,18 +145,18 @@ type Atom<T> = {
 declare function atom__INTERNAL<T>(options: AtomOptions<T>, family?: FamilyMetadata, store?: Store): AtomToken<T>;
 
 declare function atomFamily__INTERNAL<T, K extends Serializable>(options: AtomFamilyOptions<T, K>, store?: Store): AtomFamily<T, K>;
-declare function readonlySelectorFamily__INTERNAL<T, K extends Serializable>(options: SelectorFamilyOptions<T, K>, store?: Store): ReadonlySelectorFamily<T, K>;
+declare function readonlySelectorFamily__INTERNAL<T, K extends Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store?: Store): ReadonlySelectorFamily<T, K>;
 declare function selectorFamily__INTERNAL<T, K extends Serializable>(options: SelectorFamilyOptions<T, K>, store?: Store): SelectorFamily<T, K>;
 declare function selectorFamily__INTERNAL<T, K extends Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store?: Store): ReadonlySelectorFamily<T, K>;
 
 declare const computeSelectorState: <T>(selector: ReadonlySelector<T> | Selector<T>) => T;
 declare function lookup(key: string, store: Store): AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>;
-declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T>;
-declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T>;
-declare function withdraw<T>(token: StateToken<T>, store: Store): Atom<T> | Selector<T>;
-declare function withdraw<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T>;
-declare function withdraw<T>(token: TransactionToken<T>, store: Store): Transaction<T extends ƒn ? T : never>;
-declare function withdraw<T>(token: ReadonlySelectorToken<T> | StateToken<T>, store: Store): Atom<T> | ReadonlySelector<T> | Selector<T>;
+declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T> | null;
+declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T> | null;
+declare function withdraw<T>(token: StateToken<T>, store: Store): Atom<T> | Selector<T> | null;
+declare function withdraw<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T> | null;
+declare function withdraw<T>(token: TransactionToken<T>, store: Store): Transaction<T extends ƒn ? T : never> | null;
+declare function withdraw<T>(token: ReadonlySelectorToken<T> | StateToken<T>, store: Store): Atom<T> | ReadonlySelector<T> | Selector<T> | null;
 declare function deposit<T>(state: Atom<T>): AtomToken<T>;
 declare function deposit<T>(state: Selector<T>): SelectorToken<T>;
 declare function deposit<T>(state: Atom<T> | Selector<T>): StateToken<T>;
@@ -210,7 +224,6 @@ declare const storeSelector: (selector: Selector<any>, store?: Store) => void;
 declare const storeReadonlySelector: (selector: ReadonlySelector<any>, store?: Store) => void;
 declare const hasKeyBeenUsed: (key: string, store?: Store) => boolean;
 
-type ƒn = (...parameters: any[]) => any;
 type Transactors = {
     get: <S>(state: ReadonlySelectorToken<S> | StateToken<S>) => S;
     set: <S>(state: StateToken<S>, newValue: S | ((oldValue: S) => S)) => void;
@@ -487,15 +500,21 @@ type SelectorOptions<T> = {
     get: Read<() => T>;
     set: Write<(newValue: T) => void>;
 };
-type ReadonlySelectorOptions<T> = Omit<SelectorOptions<T>, `set`>;
-declare function selector<T>(options: ReadonlySelectorOptions<T>): ReadonlySelectorToken<T>;
+type ReadonlySelectorOptions<T> = {
+    key: string;
+    get: Read<() => T>;
+};
 declare function selector<T>(options: SelectorOptions<T>): SelectorToken<T>;
+declare function selector<T>(options: ReadonlySelectorOptions<T>): ReadonlySelectorToken<T>;
 type SelectorFamilyOptions<T, K extends Serializable> = {
     key: string;
     get: (key: K) => Read<() => T>;
     set: (key: K) => Write<(newValue: T) => void>;
 };
-type ReadonlySelectorFamilyOptions<T, K extends Serializable> = Omit<SelectorFamilyOptions<T, K>, `set`>;
+type ReadonlySelectorFamilyOptions<T, K extends Serializable> = {
+    key: string;
+    get: (key: K) => Read<() => T>;
+};
 type SelectorFamily<T, K extends Serializable = Serializable> = ((key: K) => SelectorToken<T>) & {
     key: string;
     type: `selector_family`;
@@ -509,6 +528,20 @@ type ReadonlySelectorFamily<T, K extends Serializable = Serializable> = ((key: K
 declare function selectorFamily<T, K extends Serializable>(options: SelectorFamilyOptions<T, K>): SelectorFamily<T, K>;
 declare function selectorFamily<T, K extends Serializable>(options: ReadonlySelectorFamilyOptions<T, K>): ReadonlySelectorFamily<T, K>;
 
+type Silo = ReturnType<typeof silo>;
+declare const silo: (name: string) => {
+    store: Store;
+    atom: typeof atom;
+    atomFamily: typeof atomFamily;
+    selector: typeof selector;
+    selectorFamily: typeof selectorFamily;
+    transaction: typeof transaction;
+    timeline: typeof timeline;
+    getState: typeof getState;
+    setState: typeof setState;
+    subscribe: typeof subscribe;
+};
+
 type StateUpdate<T> = {
     newValue: T;
     oldValue: T;
@@ -534,17 +567,20 @@ type AtomToken<_> = {
     key: string;
     type: `atom`;
     family?: FamilyMetadata;
+    __brand?: _;
 };
 type SelectorToken<_> = {
     key: string;
     type: `selector`;
     family?: FamilyMetadata;
+    __brand?: _;
 };
 type StateToken<T> = AtomToken<T> | SelectorToken<T>;
 type ReadonlySelectorToken<_> = {
     key: string;
     type: `readonly_selector`;
     family?: FamilyMetadata;
+    __brand?: _;
 };
 type FamilyMetadata = {
     key: string;
@@ -553,9 +589,10 @@ type FamilyMetadata = {
 type TransactionToken<_> = {
     key: string;
     type: `transaction`;
+    __brand?: _;
 };
 declare const getState: <T>(token: ReadonlySelectorToken<T> | StateToken<T>, store?: Store) => T;
 declare const setState: <T, New extends T>(token: StateToken<T>, value: New | ((oldValue: T) => New), store?: Store) => void;
 declare const isDefault: (token: ReadonlySelectorToken<unknown> | StateToken<unknown>, store?: Store) => boolean;
 
-export { AtomEffect, AtomFamily, AtomFamilyOptions, AtomOptions, AtomToken, Effectors, FamilyMetadata, LOG_LEVELS, Logger, Read, ReadonlySelectorFamily, ReadonlySelectorFamilyOptions, ReadonlySelectorOptions, ReadonlySelectorToken, ReadonlyTransactors, SelectorFamily, SelectorFamilyOptions, SelectorOptions, SelectorToken, Serializable, StateToken, StateUpdate, TimelineOptions, TimelineToken, Transaction, TransactionIO, TransactionOptions, TransactionToken, TransactionUpdateHandler, Transactors, UpdateHandler, Write, index as __INTERNAL__, atom, atomFamily, getState, isDefault, redo, runTransaction, selector, selectorFamily, setLogLevel, setState, subscribe, subscribeToTransaction, timeline, transaction, undo, useLogger, ƒn };
+export { AtomEffect, AtomFamily, AtomFamilyOptions, AtomOptions, AtomToken, Effectors, FamilyMetadata, LOG_LEVELS, Logger, Read, ReadonlySelectorFamily, ReadonlySelectorFamilyOptions, ReadonlySelectorOptions, ReadonlySelectorToken, ReadonlyTransactors, SelectorFamily, SelectorFamilyOptions, SelectorOptions, SelectorToken, Serializable, Silo, StateToken, StateUpdate, Store, TimelineOptions, TimelineToken, Transaction, TransactionIO, TransactionOptions, TransactionToken, TransactionUpdateHandler, Transactors, UpdateHandler, Write, index as __INTERNAL__, atom, atomFamily, getState, isDefault, redo, runTransaction, selector, selectorFamily, setLogLevel, setState, silo, subscribe, subscribeToTransaction, timeline, transaction, undo, useLogger };

package/dist/index.js

@@ -70,6 +70,7 @@ __export(src_exports, {
   selectorFamily: () => selectorFamily,
   setLogLevel: () => setLogLevel,
   setState: () => setState,
+  silo: () => silo,
   subscribe: () => subscribe,
   subscribeToTransaction: () => subscribeToTransaction,
   timeline: () => timeline,
@@ -79,6 +80,9 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
+// ../anvl/src/string/capitalize.ts
+var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
+
 // src/internal/index.ts
 var internal_exports = {};
 __export(internal_exports, {
@@ -152,9 +156,9 @@ function lookup(key, store) {
   return { key, type };
 }
 function withdraw(token, store) {
-  var _a, _b, _c;
+  var _a, _b, _c, _d;
   const core = target(store);
-  return (_c = (_b = (_a = import_hamt_plus.default.get(token.key, core.atoms)) != null ? _a : import_hamt_plus.default.get(token.key, core.selectors)) != null ? _b : import_hamt_plus.default.get(token.key, core.readonlySelectors)) != null ? _c : import_hamt_plus.default.get(token.key, core.transactions);
+  return (_d = (_c = (_b = (_a = import_hamt_plus.default.get(token.key, core.atoms)) != null ? _a : import_hamt_plus.default.get(token.key, core.selectors)) != null ? _b : import_hamt_plus.default.get(token.key, core.readonlySelectors)) != null ? _c : import_hamt_plus.default.get(token.key, core.transactions)) != null ? _d : null;
 }
 function deposit(state) {
   return __spreadValues({
@@ -246,7 +250,7 @@ var recordToEntries = (obj) => Object.entries(obj);
 var entriesToRecord = (entries) => Object.fromEntries(entries);
 
 // ../anvl/src/object/mapObject.ts
-var import_function = require("fp-ts/lib/function");
+var import_function = require("fp-ts/function");
 var mapObject = (obj, fn) => (0, import_function.pipe)(
   obj,
   recordToEntries,
@@ -350,13 +354,19 @@ var EMPTY_RELATION_DATA = {
   a: `from`,
   b: `to`
 };
-var isRelationData = (isContent, a = `from`, b = `to`) => (input) => hasExactProperties({
-  contents: isContent ? isRecord(import_string.isString, isContent) : hasExactProperties({}),
-  relations: isRecord(import_string.isString, isArray(import_string.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(import_string.isString, isContent) : hasExactProperties({}),
+    relations: isRecord(import_string.isString, isArray(import_string.isString)),
+    relationType: isRelationType,
+    a: isLiteral(a),
+    b: isLiteral(b)
+  })(input);
+};
 
 // ../anvl/src/join/get-related-ids.ts
 var getRelatedIds = (relationMap, id) => {
@@ -373,6 +383,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
 var import_function6 = require("fp-ts/function");
 
@@ -563,11 +588,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 {
@@ -578,20 +608,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);
@@ -615,13 +645,13 @@ 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)
     );
   }
@@ -807,18 +837,22 @@ var applyTransaction = (output, store) => {
   for (const { key, newValue } of atomUpdates) {
     const token = { key, type: `atom` };
     if (!import_hamt_plus4.default.has(token.key, store.valueMap)) {
-      const atom2 = import_hamt_plus4.default.get(token.key, store.transactionStatus.core.atoms);
-      store.atoms = import_hamt_plus4.default.set(atom2.key, atom2, store.atoms);
-      store.valueMap = import_hamt_plus4.default.set(atom2.key, atom2.default, store.valueMap);
-      (_c = store.config.logger) == null ? void 0 : _c.info(`\u{1F527}`, `add atom "${atom2.key}"`);
+      const newAtom = import_hamt_plus4.default.get(token.key, store.transactionStatus.core.atoms);
+      store.atoms = import_hamt_plus4.default.set(newAtom.key, newAtom, store.atoms);
+      store.valueMap = import_hamt_plus4.default.set(newAtom.key, newAtom.default, store.valueMap);
+      (_c = store.config.logger) == null ? void 0 : _c.info(`\u{1F527}`, `add atom "${newAtom.key}"`);
     }
-    const state = withdraw(token, store);
-    setState(state, newValue, store);
+    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,
@@ -834,6 +868,11 @@ var undoTransactionUpdate = (update, store) => {
   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);
   }
 };
@@ -843,6 +882,11 @@ var redoTransactionUpdate = (update, store) => {
   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);
   }
 };
@@ -1199,6 +1243,11 @@ var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
     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(
@@ -1223,6 +1272,11 @@ var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
   },
   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);
   }
 });
@@ -1330,7 +1384,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);
@@ -1395,6 +1449,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(
@@ -1506,6 +1565,11 @@ function timeline__INTERNAL(options, store = IMPLICIT.STORE) {
   };
   const subscribeToAtom = (token2) => {
     const state = withdraw(token2, store);
+    if (state === null) {
+      throw new Error(
+        `Cannot subscribe to atom "${token2.key}" because it has not been initialized in store "${store.config.name}"`
+      );
+    }
     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;
@@ -1523,6 +1587,11 @@ function timeline__INTERNAL(options, store = IMPLICIT.STORE) {
           { key: storeCurrentTransactionKey, type: `transaction` },
           store
         );
+        if (currentTransaction === null) {
+          throw new Error(
+            `Transaction "${storeCurrentTransactionKey}" not found in store "${store.config.name}". This is surprising, because we are in the application phase of "${storeCurrentTransactionKey}".`
+          );
+        }
         if (timelineData.transactionKey !== storeCurrentTransactionKey) {
           if (timelineData.transactionKey) {
             (_b2 = store.config.logger) == null ? void 0 : _b2.error(
@@ -1698,10 +1767,32 @@ function selectorFamily(options) {
   return selectorFamily__INTERNAL(options);
 }
 
+// src/silo.ts
+var silo = (name) => {
+  const store = createStore(name);
+  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)
+  };
+};
+
 // 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;
@@ -1724,6 +1815,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 = () => {
@@ -1749,11 +1845,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) => {
@@ -1766,6 +1875,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);
 };
@@ -1784,6 +1898,7 @@ var isDefault = (token, store = IMPLICIT.STORE) => token.type === `atom` ? isAto
   selectorFamily,
   setLogLevel,
   setState,
+  silo,
   subscribe,
   subscribeToTransaction,
   timeline,