atom.io 0.18.1 → 0.18.3

package/internal/dist/index.js

@@ -1,5 +1,5 @@
-import { Junction } from '../../dist/chunk-NYTGCPHB.js';
-import { __spreadValues, __spreadProps } from '../../dist/chunk-PZLG2HP3.js';
+import { Junction } from '../../dist/chunk-WX2NCOZR.js';
+import { __spreadValues, __spreadProps } from '../../dist/chunk-U2IICNHQ.js';
 import { stringifyJson, selectJson, parseJson, selectJsonFamily } from 'atom.io/json';
 import { AtomIOLogger } from 'atom.io';
 
@@ -226,27 +226,37 @@ function withdraw(token, store) {
     }
     target = target.child;
   }
+  throw new NotFoundError(token, store);
 }
 
 // internal/src/store/withdraw-new-family-member.ts
-function withdrawNewFamilyMember(token, store) {
-  if (token.family) {
-    store.logger.info(
-      `\u{1F46A}`,
-      token.type,
-      token.key,
-      `creating new family member in store "${store.config.name}"`
-    );
-    const target = newest(store);
-    const family = target.families.get(token.family.key);
-    if (family) {
-      const jsonSubKey = JSON.parse(token.family.subKey);
-      family(jsonSubKey);
-      const state = withdraw(token, store);
-      return state;
+function withdrawOrCreate(token, store) {
+  try {
+    const state = withdraw(token, store);
+    return state;
+  } catch (notFoundError) {
+    if (token.family) {
+      store.logger.info(
+        `\u{1F46A}`,
+        token.type,
+        token.key,
+        `creating new family member in store "${store.config.name}"`
+      );
+      const target = newest(store);
+      const family = target.families.get(token.family.key);
+      if (family) {
+        const jsonSubKey = JSON.parse(token.family.subKey);
+        family(jsonSubKey);
+        const state = withdraw(token, store);
+        return state;
+      }
+      throw new NotFoundError(
+        { key: token.family.key, type: `${token.type}_family` },
+        store
+      );
     }
+    throw notFoundError;
   }
-  return void 0;
 }
 
 // internal/src/future.ts
@@ -359,10 +369,11 @@ function createRegularAtomFamily(options, store) {
       const subKey = stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
-      const existing = withdraw({ key: fullKey, type: `atom` }, store);
+      const target2 = newest(store);
+      const atomAlreadyCreated = target2.atoms.has(fullKey);
       let token;
-      if (existing) {
-        token = deposit(existing);
+      if (atomAlreadyCreated) {
+        token = { type: `atom`, key: fullKey, family };
       } else {
         const individualOptions = {
           key: fullKey,
@@ -720,15 +731,11 @@ var setAtomOrSelector = (state, value, store) => {
 
 // internal/src/set-state/set-into-store.ts
 function setIntoStore(token, value, store) {
-  var _a;
   const rejection = openOperation(token, store);
   if (rejection) {
     return;
   }
-  const state = (_a = withdraw(token, store)) != null ? _a : withdrawNewFamilyMember(token, store);
-  if (state === void 0) {
-    throw new NotFoundError(token, store);
-  }
+  const state = withdrawOrCreate(token, store);
   setAtomOrSelector(state, value, store);
   closeOperation(store);
 }
@@ -813,14 +820,8 @@ var updateSelectorAtoms = (selectorKey, dependency, store) => {
 // internal/src/selector/register-selector.ts
 var registerSelector = (selectorKey, store) => ({
   get: (dependency) => {
-    var _a;
     const target = newest(store);
-    const dependencyState = (_a = withdraw(dependency, store)) != null ? _a : withdrawNewFamilyMember(dependency, store);
-    if (dependencyState === void 0) {
-      throw new Error(
-        `State "${dependency.key}" not found in store "${store.config.name}".`
-      );
-    }
+    const dependencyState = withdrawOrCreate(dependency, store);
     const dependencyValue = readOrComputeValue(dependencyState, store);
     store.logger.info(
       `\u{1F50C}`,
@@ -843,12 +844,7 @@ var registerSelector = (selectorKey, store) => ({
     return dependencyValue;
   },
   set: (WritableToken, newValue) => {
-    const state = withdraw(WritableToken, store);
-    if (state === void 0) {
-      throw new Error(
-        `State "${WritableToken.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
-      );
-    }
+    const state = withdrawOrCreate(WritableToken, store);
     setAtomOrSelector(state, newValue, store);
   },
   find: (token, key) => findInStore(token, key, store)
@@ -1036,8 +1032,7 @@ var subscribeToRootAtoms = (selector, store) => {
 
 // internal/src/subscribe/subscribe-to-state.ts
 function subscribeToState(token, handleUpdate, key, store) {
-  var _a;
-  const state = (_a = withdraw(token, store)) != null ? _a : withdrawNewFamilyMember(token, store);
+  const state = withdrawOrCreate(token, store);
   if (state === void 0) {
     throw new Error(
       `State "${token.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
@@ -1072,11 +1067,6 @@ function subscribeToState(token, handleUpdate, key, store) {
 // internal/src/subscribe/subscribe-to-timeline.ts
 var subscribeToTimeline = (token, handleUpdate, key, store) => {
   const tl = withdraw(token, store);
-  if (tl === void 0) {
-    throw new Error(
-      `Cannot subscribe to timeline "${token.key}": timeline not found in store "${store.config.name}".`
-    );
-  }
   store.logger.info(`\u{1F440}`, `timeline`, token.key, `Adding subscription "${key}"`);
   const unsubscribe = tl.subject.subscribe(key, handleUpdate);
   return () => {
@@ -1093,11 +1083,6 @@ var subscribeToTimeline = (token, handleUpdate, key, store) => {
 // internal/src/subscribe/subscribe-to-transaction.ts
 var subscribeToTransaction = (token, handleUpdate, key, store) => {
   const tx = withdraw(token, store);
-  if (tx === void 0) {
-    throw new Error(
-      `Cannot subscribe to transaction "${token.key}": transaction not found in store "${store.config.name}".`
-    );
-  }
   store.logger.info(
     `\u{1F440}`,
     `transaction`,
@@ -1372,10 +1357,11 @@ function createMutableAtomFamily(options, store) {
       const subKey = stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
-      const existing = withdraw({ key: fullKey, type: `mutable_atom` }, store);
+      const target2 = newest(store);
+      const atomAlreadyCreated = target2.atoms.has(fullKey);
       let token;
-      if (existing) {
-        token = deposit(existing);
+      if (atomAlreadyCreated) {
+        token = { type: `mutable_atom`, key: fullKey, family };
       } else {
         const individualOptions = {
           key: fullKey,
@@ -1598,11 +1584,7 @@ function getEnvironmentData(store) {
 
 // internal/src/get-state/get-from-store.ts
 function getFromStore(token, store) {
-  var _a;
-  const state = (_a = withdraw(token, store)) != null ? _a : withdrawNewFamilyMember(token, store);
-  if (state === void 0) {
-    throw new NotFoundError(token, store);
-  }
+  const state = withdrawOrCreate(token, store);
   return readOrComputeValue(state, store);
 }
 
@@ -1674,16 +1656,11 @@ var LazyMap = class extends Map {
 // internal/src/timeline/add-atom-to-timeline.ts
 var addAtomToTimeline = (atomToken, tl, store) => {
   let maybeAtom = withdraw(atomToken, store);
-  if ((maybeAtom == null ? void 0 : maybeAtom.type) === `mutable_atom`) {
+  if (maybeAtom.type === `mutable_atom`) {
     const updateToken = getUpdateToken(maybeAtom);
     maybeAtom = withdraw(updateToken, store);
   }
   const atom = maybeAtom;
-  if (atom === void 0) {
-    throw new Error(
-      `Cannot subscribe to atom "${atomToken.key}" because it has not been initialized in store "${store.config.name}"`
-    );
-  }
   store.timelineAtoms.set({ atomKey: atom.key, timelineKey: tl.key });
   atom.subject.subscribe(`timeline`, (update) => {
     var _a, _b, _c, _d, _e, _f;
@@ -1715,15 +1692,11 @@ var addAtomToTimeline = (atomToken, tl, store) => {
         }
       }
       if (currentTransactionKey) {
-        const currentTransaction = withdraw(
-          { key: currentTransactionKey, type: `transaction` },
-          store
-        );
-        if (currentTransaction === void 0) {
-          throw new Error(
-            `Transaction "${currentTransactionKey}" not found in store "${store.config.name}". This is surprising, because we are in the application phase of "${currentTransactionKey}".`
-          );
-        }
+        const txToken = {
+          key: currentTransactionKey,
+          type: `transaction`
+        };
+        const currentTransaction = withdraw(txToken, store);
         if (tl.transactionKey !== currentTransactionKey) {
           if (tl.transactionKey) {
             store.logger.error(
@@ -1895,15 +1868,6 @@ function createTimeline(options, store, data) {
     if (tokenOrFamily.type === `atom_family` || tokenOrFamily.type === `mutable_atom_family`) {
       const familyToken = tokenOrFamily;
       const family = withdraw(familyToken, store);
-      if (family === void 0) {
-        store.logger.error(
-          `\u274C`,
-          `timeline`,
-          options.key,
-          `Failed to add family "${familyToken.key}" because it does not exist in the store`
-        );
-        continue;
-      }
       const familyKey = family.key;
       target.timelineAtoms.set({ atomKey: familyKey, timelineKey });
       family.subject.subscribe(`timeline:${options.key}`, (token2) => {
@@ -1916,26 +1880,8 @@ function createTimeline(options, store, data) {
       }
     } else {
       let atom = withdraw(tokenOrFamily, store);
-      if (atom === void 0) {
-        store.logger.error(
-          `\u274C`,
-          `timeline`,
-          options.key,
-          `Failed to add atom "${atomKey}" because it does not exist in the store`
-        );
-        continue;
-      }
       if (isMutable(atom)) {
         const updateAtom = withdraw(getUpdateToken(atom), store);
-        if (updateAtom === void 0) {
-          store.logger.error(
-            `\u274C`,
-            `timeline`,
-            options.key,
-            `Failed to add update atom "${atomKey}" because it does not exist in the store`
-          );
-          continue;
-        }
         atom = updateAtom;
         atomKey = atom.key;
       }
@@ -2277,6 +2223,4 @@ function getEpochNumberOfAction(transactionKey, store) {
 // internal/src/transaction/index.ts
 var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
 
-export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, addAtomToTimeline, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deleteAtom, deleteSelector, deposit, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.js.map
+export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, addAtomToTimeline, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deleteAtom, deleteSelector, deposit, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawOrCreate };

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

@@ -10,7 +10,6 @@ import { stringifyJson } from "atom.io/json"
 
 import { createRegularAtom } from "../atom"
 import { newest } from "../lineage"
-import { deposit, withdraw } from "../store"
 import type { Store } from "../store"
 import { Subject } from "../subject"
 
@@ -24,10 +23,11 @@ export function createRegularAtomFamily<T, K extends Json.Serializable>(
 			const subKey = stringifyJson(key)
 			const family: FamilyMetadata = { key: options.key, subKey }
 			const fullKey = `${options.key}(${subKey})`
-			const existing = withdraw({ key: fullKey, type: `atom` }, store)
+			const target = newest(store)
+			const atomAlreadyCreated = target.atoms.has(fullKey)
 			let token: RegularAtomToken<any>
-			if (existing) {
-				token = deposit(existing)
+			if (atomAlreadyCreated) {
+				token = { type: `atom`, key: fullKey, family }
 			} else {
 				const individualOptions: RegularAtomOptions<any> = {
 					key: fullKey,

package/internal/src/get-state/get-from-store.ts

@@ -2,13 +2,10 @@ import type { ReadableToken } from "atom.io"
 
 import { NotFoundError } from "../not-found-error"
 import type { Store } from "../store"
-import { withdraw, withdrawNewFamilyMember } from "../store"
+import { withdraw, withdrawOrCreate } from "../store"
 import { readOrComputeValue } from "./read-or-compute-value"
 
 export function getFromStore<T>(token: ReadableToken<T>, store: Store): T {
-	const state = withdraw(token, store) ?? withdrawNewFamilyMember(token, store)
-	if (state === undefined) {
-		throw new NotFoundError(token, store)
-	}
+	const state = withdrawOrCreate(token, store)
 	return readOrComputeValue(state, store)
 }

package/internal/src/mutable/create-mutable-atom-family.ts

@@ -11,7 +11,6 @@ import { stringifyJson } from "atom.io/json"
 
 import { newest } from "../lineage"
 import { createMutableAtom } from "../mutable"
-import { deposit, withdraw } from "../store"
 import type { Store } from "../store"
 import { Subject } from "../subject"
 import { FamilyTracker } from "./tracker-family"
@@ -31,10 +30,11 @@ export function createMutableAtomFamily<
 			const subKey = stringifyJson(key)
 			const family: FamilyMetadata = { key: options.key, subKey }
 			const fullKey = `${options.key}(${subKey})`
-			const existing = withdraw({ key: fullKey, type: `mutable_atom` }, store)
+			const target = newest(store)
+			const atomAlreadyCreated = target.atoms.has(fullKey)
 			let token: MutableAtomToken<T, J>
-			if (existing) {
-				token = deposit(existing)
+			if (atomAlreadyCreated) {
+				token = { type: `mutable_atom`, key: fullKey, family }
 			} else {
 				const individualOptions: MutableAtomOptions<T, J> = {
 					key: fullKey,

package/internal/src/selector/register-selector.ts

@@ -5,7 +5,7 @@ import { readOrComputeValue } from "../get-state/read-or-compute-value"
 import { newest } from "../lineage"
 import { setAtomOrSelector } from "../set-state"
 import type { Store } from "../store"
-import { withdraw, withdrawNewFamilyMember } from "../store"
+import { withdrawOrCreate } from "../store"
 import { updateSelectorAtoms } from "./update-selector-atoms"
 
 export const registerSelector = (
@@ -15,13 +15,7 @@ export const registerSelector = (
 	get: (dependency) => {
 		const target = newest(store)
 
-		const dependencyState =
-			withdraw(dependency, store) ?? withdrawNewFamilyMember(dependency, store)
-		if (dependencyState === undefined) {
-			throw new Error(
-				`State "${dependency.key}" not found in store "${store.config.name}".`,
-			)
-		}
+		const dependencyState = withdrawOrCreate(dependency, store)
 		const dependencyValue = readOrComputeValue(dependencyState, store)
 
 		store.logger.info(
@@ -46,12 +40,7 @@ export const registerSelector = (
 		return dependencyValue
 	},
 	set: (WritableToken, newValue) => {
-		const state = withdraw(WritableToken, store)
-		if (state === undefined) {
-			throw new Error(
-				`State "${WritableToken.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`,
-			)
-		}
+		const state = withdrawOrCreate(WritableToken, store)
 		setAtomOrSelector(state, newValue, store)
 	},
 	find: ((token, key) => findInStore(token, key, store)) as typeof findState,

package/internal/src/set-state/set-into-store.ts

@@ -3,7 +3,7 @@ import type { WritableToken } from "atom.io"
 import { NotFoundError } from "../not-found-error"
 import { closeOperation, openOperation } from "../operation"
 import type { Store } from "../store"
-import { withdraw, withdrawNewFamilyMember } from "../store"
+import { withdrawOrCreate } from "../store"
 import { setAtomOrSelector } from "./set-atom-or-selector"
 
 export function setIntoStore<T, New extends T>(
@@ -15,10 +15,7 @@ export function setIntoStore<T, New extends T>(
 	if (rejection) {
 		return
 	}
-	const state = withdraw(token, store) ?? withdrawNewFamilyMember(token, store)
-	if (state === undefined) {
-		throw new NotFoundError(token, store)
-	}
+	const state = withdrawOrCreate(token, store)
 	setAtomOrSelector(state, value, store)
 	closeOperation(store)
 }

package/internal/src/store/withdraw-new-family-member.ts

@@ -5,6 +5,7 @@ import type {
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
+
 import type {
 	Atom,
 	ReadableState,
@@ -13,47 +14,56 @@ import type {
 	WritableSelector,
 	WritableState,
 } from ".."
-import { newest, withdraw } from ".."
+import { NotFoundError, newest, withdraw } from ".."
 
-export function withdrawNewFamilyMember<T>(
+export function withdrawOrCreate<T>(
 	token: RegularAtomToken<T>,
 	store: Store,
-): Atom<T> | undefined
-export function withdrawNewFamilyMember<T>(
+): Atom<T>
+export function withdrawOrCreate<T>(
 	token: WritableSelectorToken<T>,
 	store: Store,
-): WritableSelector<T> | undefined
-export function withdrawNewFamilyMember<T>(
+): WritableSelector<T>
+export function withdrawOrCreate<T>(
 	token: ReadonlySelectorToken<T>,
 	store: Store,
-): ReadonlySelector<T> | undefined
-export function withdrawNewFamilyMember<T>(
+): ReadonlySelector<T>
+export function withdrawOrCreate<T>(
 	token: WritableToken<T>,
 	store: Store,
-): WritableState<T> | undefined
-export function withdrawNewFamilyMember<T>(
+): WritableState<T>
+export function withdrawOrCreate<T>(
 	token: ReadableToken<T>,
 	store: Store,
-): ReadableState<T> | undefined
-export function withdrawNewFamilyMember<T>(
+): ReadableState<T>
+export function withdrawOrCreate<T>(
 	token: ReadableToken<T>,
 	store: Store,
-): ReadableState<T> | undefined {
-	if (token.family) {
-		store.logger.info(
-			`👪`,
-			token.type,
-			token.key,
-			`creating new family member in store "${store.config.name}"`,
-		)
-		const target = newest(store)
-		const family = target.families.get(token.family.key)
-		if (family) {
-			const jsonSubKey = JSON.parse(token.family.subKey)
-			family(jsonSubKey)
-			const state = withdraw(token, store)
-			return state
+): ReadableState<T> {
+	try {
+		const state = withdraw(token, store)
+		return state
+	} catch (notFoundError) {
+		if (token.family) {
+			store.logger.info(
+				`👪`,
+				token.type,
+				token.key,
+				`creating new family member in store "${store.config.name}"`,
+			)
+			const target = newest(store)
+			const family = target.families.get(token.family.key)
+			if (family) {
+				const jsonSubKey = JSON.parse(token.family.subKey)
+				family(jsonSubKey)
+				const state = withdraw(token, store)
+				return state
+			}
+			throw new NotFoundError(
+				{ key: token.family.key, type: `${token.type}_family` },
+				store,
+			)
 		}
+		throw notFoundError
 	}
-	return undefined
 }

package/internal/src/store/withdraw.ts

@@ -37,6 +37,8 @@ import type {
 	WritableSelector,
 	WritableState,
 } from ".."
+import { NotFoundError } from ".."
+
 import type { Timeline } from "../timeline"
 import type { Transaction } from "../transaction"
 import type { Store } from "./store"
@@ -63,40 +65,34 @@ export type Withdrawable =
 export function withdraw<T>(
 	token: RegularAtomToken<T>,
 	store: Store,
-): RegularAtom<T> | undefined
+): RegularAtom<T>
 export function withdraw<T extends Transceiver<any>>(
 	token: MutableAtomToken<T, any>,
 	store: Store,
-): MutableAtom<T, any> | undefined
-export function withdraw<T>(
-	token: AtomToken<T>,
-	store: Store,
-): Atom<T> | undefined
+): MutableAtom<T, any>
+export function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T>
 export function withdraw<T>(
 	token: WritableSelectorToken<T>,
 	store: Store,
-): WritableSelector<T> | undefined
+): WritableSelector<T>
 export function withdraw<T>(
 	token: ReadonlySelectorToken<T>,
 	store: Store,
-): ReadonlySelector<T> | undefined
-export function withdraw<T>(
-	token: SelectorToken<T>,
-	store: Store,
-): Selector<T> | undefined
+): ReadonlySelector<T>
+export function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T>
 export function withdraw<T>(
 	token: WritableToken<T>,
 	store: Store,
-): WritableState<T> | undefined
+): WritableState<T>
 export function withdraw<T>(
 	token: ReadableToken<T>,
 	store: Store,
-): ReadableState<T> | undefined
+): ReadableState<T>
 
 export function withdraw<T, K extends Json.Serializable>(
 	token: RegularAtomFamilyToken<T, K>,
 	store: Store,
-): RegularAtomFamily<T, K> | undefined
+): RegularAtomFamily<T, K>
 export function withdraw<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
@@ -104,32 +100,32 @@ export function withdraw<
 >(
 	token: MutableAtomFamilyToken<T, J, K>,
 	store: Store,
-): MutableAtomFamily<T, J, K> | undefined
+): MutableAtomFamily<T, J, K>
 export function withdraw<T, K extends Json.Serializable>(
 	token: AtomFamilyToken<T>,
 	store: Store,
-): AtomFamily<T, any> | undefined
+): AtomFamily<T, any>
 export function withdraw<T, K extends Json.Serializable>(
 	token: ReadonlySelectorFamilyToken<T, K>,
 	store: Store,
-): ReadonlySelectorFamily<T, any> | undefined
+): ReadonlySelectorFamily<T, any>
 export function withdraw<T, K extends Json.Serializable>(
 	token: WritableSelectorFamilyToken<T, K>,
 	store: Store,
-): WritableSelectorFamily<T, any> | undefined
+): WritableSelectorFamily<T, any>
 export function withdraw<T, K extends Json.Serializable>(
 	token: SelectorFamilyToken<T, K>,
 	store: Store,
-): SelectorFamily<T, any> | undefined
+): SelectorFamily<T, any>
 
 export function withdraw<T>(
 	token: TransactionToken<T>,
 	store: Store,
-): Transaction<T extends ƒn ? T : never> | undefined
+): Transaction<T extends ƒn ? T : never>
 export function withdraw<T>(
 	token: TimelineToken<T>,
 	store: Store,
-): Timeline<T extends TimelineManageable ? T : never> | undefined
+): Timeline<T extends TimelineManageable ? T : never>
 export function withdraw<T>(
 	token:
 		| RegularAtomFamilyToken<T, any>
@@ -142,7 +138,7 @@ export function withdraw<T>(
 				? MutableAtomFamilyToken<T, any, any> | MutableAtomToken<T, any>
 				: never),
 	store: Store,
-): Withdrawable | undefined {
+): Withdrawable {
 	let withdrawn: Withdrawable | undefined
 	let target: Store | null = store
 	while (target !== null) {
@@ -175,4 +171,5 @@ export function withdraw<T>(
 		}
 		target = target.child
 	}
+	throw new NotFoundError(token, store)
 }

package/internal/src/subscribe/subscribe-to-state.ts

@@ -1,6 +1,6 @@
 import type { ReadableToken, UpdateHandler } from "atom.io"
 import type { Store } from "../store"
-import { withdraw, withdrawNewFamilyMember } from "../store"
+import { withdrawOrCreate } from "../store"
 import { subscribeToRootAtoms } from "./subscribe-to-root-atoms"
 
 export function subscribeToState<T>(
@@ -9,8 +9,7 @@ export function subscribeToState<T>(
 	key: string,
 	store: Store,
 ): () => void {
-	const state =
-		withdraw<T>(token, store) ?? withdrawNewFamilyMember(token, store)
+	const state = withdrawOrCreate(token, store)
 	if (state === undefined) {
 		throw new Error(
 			`State "${token.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`,

package/internal/src/subscribe/subscribe-to-timeline.ts

@@ -9,11 +9,6 @@ export const subscribeToTimeline = <ManagedAtom extends TimelineManageable>(
 	store: Store,
 ): (() => void) => {
 	const tl = withdraw(token, store)
-	if (tl === undefined) {
-		throw new Error(
-			`Cannot subscribe to timeline "${token.key}": timeline not found in store "${store.config.name}".`,
-		)
-	}
 	store.logger.info(`👀`, `timeline`, token.key, `Adding subscription "${key}"`)
 	const unsubscribe = tl.subject.subscribe(key, handleUpdate)
 	return () => {

package/internal/src/subscribe/subscribe-to-transaction.ts

@@ -9,11 +9,6 @@ export const subscribeToTransaction = <ƒ extends ƒn>(
 	store: Store,
 ): (() => void) => {
 	const tx = withdraw(token, store)
-	if (tx === undefined) {
-		throw new Error(
-			`Cannot subscribe to transaction "${token.key}": transaction not found in store "${store.config.name}".`,
-		)
-	}
 	store.logger.info(
 		`👀`,
 		`transaction`,