atom.io 0.18.0 → 0.18.2

package/internal/dist/index.d.ts

@@ -243,28 +243,28 @@ declare const IMPLICIT: {
 declare const clearStore: (store: Store) => void;
 
 type Withdrawable = Atom<any> | AtomFamily<any, any> | MutableAtom<any, any> | MutableAtomFamily<any, any, any> | ReadableState<any> | ReadableState<any> | ReadonlySelector<any> | ReadonlySelectorFamily<any, any> | RegularAtom<any> | RegularAtomFamily<any, any> | Selector<any> | SelectorFamily<any, any> | Timeline<any> | Transaction<any> | WritableSelector<any> | WritableSelectorFamily<any, any> | WritableState<any>;
-declare function withdraw<T>(token: RegularAtomToken<T>, store: Store): RegularAtom<T> | undefined;
-declare function withdraw<T extends Transceiver<any>>(token: MutableAtomToken<T, any>, store: Store): MutableAtom<T, any> | undefined;
-declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T> | undefined;
-declare function withdraw<T>(token: WritableSelectorToken<T>, store: Store): WritableSelector<T> | undefined;
-declare function withdraw<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T> | undefined;
-declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T> | undefined;
-declare function withdraw<T>(token: WritableToken<T>, store: Store): WritableState<T> | undefined;
-declare function withdraw<T>(token: ReadableToken<T>, store: Store): ReadableState<T> | undefined;
-declare function withdraw<T, K extends Json.Serializable>(token: RegularAtomFamilyToken<T, K>, store: Store): RegularAtomFamily<T, K> | undefined;
-declare function withdraw<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(token: MutableAtomFamilyToken<T, J, K>, store: Store): MutableAtomFamily<T, J, K> | undefined;
-declare function withdraw<T, K extends Json.Serializable>(token: AtomFamilyToken<T>, store: Store): AtomFamily<T, any> | undefined;
-declare function withdraw<T, K extends Json.Serializable>(token: ReadonlySelectorFamilyToken<T, K>, store: Store): ReadonlySelectorFamily<T, any> | undefined;
-declare function withdraw<T, K extends Json.Serializable>(token: WritableSelectorFamilyToken<T, K>, store: Store): WritableSelectorFamily<T, any> | undefined;
-declare function withdraw<T, K extends Json.Serializable>(token: SelectorFamilyToken<T, K>, store: Store): SelectorFamily<T, any> | undefined;
-declare function withdraw<T>(token: TransactionToken<T>, store: Store): Transaction<T extends _n ? T : never> | undefined;
-declare function withdraw<T>(token: TimelineToken<T>, store: Store): Timeline<T extends TimelineManageable ? T : never> | undefined;
-
-declare function withdrawNewFamilyMember<T>(token: RegularAtomToken<T>, store: Store): Atom<T> | undefined;
-declare function withdrawNewFamilyMember<T>(token: WritableSelectorToken<T>, store: Store): WritableSelector<T> | undefined;
-declare function withdrawNewFamilyMember<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T> | undefined;
-declare function withdrawNewFamilyMember<T>(token: WritableToken<T>, store: Store): WritableState<T> | undefined;
-declare function withdrawNewFamilyMember<T>(token: ReadableToken<T>, store: Store): ReadableState<T> | undefined;
+declare function withdraw<T>(token: RegularAtomToken<T>, store: Store): RegularAtom<T>;
+declare function withdraw<T extends Transceiver<any>>(token: MutableAtomToken<T, any>, store: Store): MutableAtom<T, any>;
+declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T>;
+declare function withdraw<T>(token: WritableSelectorToken<T>, store: Store): WritableSelector<T>;
+declare function withdraw<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T>;
+declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T>;
+declare function withdraw<T>(token: WritableToken<T>, store: Store): WritableState<T>;
+declare function withdraw<T>(token: ReadableToken<T>, store: Store): ReadableState<T>;
+declare function withdraw<T, K extends Json.Serializable>(token: RegularAtomFamilyToken<T, K>, store: Store): RegularAtomFamily<T, K>;
+declare function withdraw<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(token: MutableAtomFamilyToken<T, J, K>, store: Store): MutableAtomFamily<T, J, K>;
+declare function withdraw<T, K extends Json.Serializable>(token: AtomFamilyToken<T>, store: Store): AtomFamily<T, any>;
+declare function withdraw<T, K extends Json.Serializable>(token: ReadonlySelectorFamilyToken<T, K>, store: Store): ReadonlySelectorFamily<T, any>;
+declare function withdraw<T, K extends Json.Serializable>(token: WritableSelectorFamilyToken<T, K>, store: Store): WritableSelectorFamily<T, any>;
+declare function withdraw<T, K extends Json.Serializable>(token: SelectorFamilyToken<T, K>, store: Store): SelectorFamily<T, any>;
+declare function withdraw<T>(token: TransactionToken<T>, store: Store): Transaction<T extends _n ? T : never>;
+declare function withdraw<T>(token: TimelineToken<T>, store: Store): Timeline<T extends TimelineManageable ? T : never>;
+
+declare function withdrawOrCreate<T>(token: RegularAtomToken<T>, store: Store): Atom<T>;
+declare function withdrawOrCreate<T>(token: WritableSelectorToken<T>, store: Store): WritableSelector<T>;
+declare function withdrawOrCreate<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T>;
+declare function withdrawOrCreate<T>(token: WritableToken<T>, store: Store): WritableState<T>;
+declare function withdrawOrCreate<T>(token: ReadableToken<T>, store: Store): ReadableState<T>;
 
 interface Transceiver<Signal extends Json.Serializable> {
     do: (update: Signal) => number | `OUT_OF_RANGE` | null;
@@ -320,7 +320,7 @@ declare function createStandaloneAtom<T extends Transceiver<any>, J extends Json
 
 declare function createRegularAtom<T>(options: MutableAtomOptions<any, any> | RegularAtomOptions<T>, family: FamilyMetadata | undefined, store: Store): RegularAtomToken<T>;
 
-declare function deleteAtom(atomToken: RegularAtomToken<unknown>, store: Store): void;
+declare function deleteAtom(atomToken: AtomToken<unknown>, store: Store): void;
 
 declare const isAtomDefault: (key: string, store: Store) => boolean;
 declare const markAtomAsDefault: (key: string, store: Store) => void;
@@ -484,4 +484,4 @@ type Selector<T> = ReadonlySelector<T> | WritableSelector<T>;
 type WritableState<T> = Atom<T> | WritableSelector<T>;
 type ReadableState<T> = Atom<T> | Selector<T>;
 
-export { type Atom, type AtomIOState, type AtomKey, type ChildStore, type EnvironmentData, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, type MutableAtom, NotFoundError, type OperationProgress, type ReadableState, type ReadonlySelector, type ReadonlySelectorKey, type RegularAtom, type RootStore, type Selector, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineSelectorUpdate, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableSelector, type WritableState, 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 };
+export { type Atom, type AtomIOState, type AtomKey, type ChildStore, type EnvironmentData, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, type MutableAtom, NotFoundError, type OperationProgress, type ReadableState, type ReadonlySelector, type ReadonlySelectorKey, type RegularAtom, type RootStore, type Selector, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineSelectorUpdate, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableSelector, type WritableState, 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/dist/index.js

@@ -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
@@ -268,6 +278,24 @@ var Future = class extends Promise {
   }
 };
 
+// internal/src/set-state/copy-mutable-if-needed.ts
+function copyMutableIfNeeded(atom, origin, target) {
+  const originValue = origin.valueMap.get(atom.key);
+  const targetValue = target.valueMap.get(atom.key);
+  if (originValue === targetValue) {
+    if (originValue === void 0) {
+      return typeof atom.default === `function` ? atom.default() : atom.default;
+    }
+    origin.logger.info(`\u{1F4C3}`, `atom`, `${atom.key}`, `copying`);
+    const jsonValue = atom.toJson(originValue);
+    const copiedValue = atom.fromJson(jsonValue);
+    target.valueMap.set(atom.key, copiedValue);
+    new Tracker(atom, origin);
+    return copiedValue;
+  }
+  return targetValue;
+}
+
 // internal/src/caching.ts
 function cacheValue(key, value, subject, target) {
   const currentValue = target.valueMap.get(key);
@@ -294,7 +322,12 @@ function cacheValue(key, value, subject, target) {
   return value;
 }
 var readCachedValue = (token, target) => {
-  const value = target.valueMap.get(token.key);
+  let value = target.valueMap.get(token.key);
+  if (token.type === `mutable_atom` && isChildStore(target)) {
+    const { parent } = target;
+    const copiedValue = copyMutableIfNeeded(token, parent, target);
+    value = copiedValue;
+  }
   return value;
 };
 var evictCachedValue = (key, target) => {
@@ -336,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,
@@ -541,34 +575,33 @@ var markDone = (key, store) => {
   store.operation.done.add(key);
 };
 
-// internal/src/set-state/copy-mutable-if-needed.ts
-function copyMutableIfNeeded(atom, origin, target) {
-  const originValue = origin.valueMap.get(atom.key);
-  const targetValue = target.valueMap.get(atom.key);
-  if (originValue === targetValue) {
-    origin.logger.info(`\u{1F4C3}`, `atom`, `${atom.key}`, `copying`);
-    const jsonValue = atom.toJson(originValue);
-    const copiedValue = atom.fromJson(jsonValue);
-    target.valueMap.set(atom.key, copiedValue);
-    new Tracker(atom, origin);
-    return copiedValue;
-  }
-  return targetValue;
-}
-
 // internal/src/set-state/emit-update.ts
 var emitUpdate = (state, update, store) => {
-  store.logger.info(
-    `\u{1F4E2}`,
-    state.type,
-    state.key,
-    `went (`,
-    update.oldValue,
-    `->`,
-    update.newValue,
-    `) subscribers:`,
-    state.subject.subscribers
-  );
+  switch (state.type) {
+    case `mutable_atom`:
+      store.logger.info(
+        `\u{1F4E2}`,
+        state.type,
+        state.key,
+        `is now (`,
+        update.newValue,
+        `) subscribers:`,
+        state.subject.subscribers
+      );
+      break;
+    default:
+      store.logger.info(
+        `\u{1F4E2}`,
+        state.type,
+        state.key,
+        `went (`,
+        update.oldValue,
+        `->`,
+        update.newValue,
+        `) subscribers:`,
+        state.subject.subscribers
+      );
+  }
   state.subject.next(update);
 };
 
@@ -669,14 +702,16 @@ var setAtom = (atom, next, target) => {
       stowUpdate(atom, update, target);
     } else if (atom.key.startsWith(`*`)) {
       const mutableKey = atom.key.slice(1);
-      target.atoms.get(mutableKey);
+      const mutableAtom = target.atoms.get(mutableKey);
       let transceiver = target.valueMap.get(mutableKey);
-      if (atom.type === `mutable_atom` && isChildStore(target)) {
+      if (mutableAtom.type === `mutable_atom` && isChildStore(target)) {
         const { parent } = target;
-        const copiedValue = copyMutableIfNeeded(atom, parent, target);
+        const copiedValue = copyMutableIfNeeded(mutableAtom, parent, target);
         transceiver = copiedValue;
       }
-      transceiver.do(update.newValue);
+      const accepted = transceiver.do(update.newValue) === null;
+      if (accepted)
+        evictDownStream(mutableAtom, target);
     }
   }
 };
@@ -696,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);
 }
@@ -789,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}`,
@@ -819,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)
@@ -1012,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?`
@@ -1048,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 () => {
@@ -1069,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`,
@@ -1348,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,
@@ -1551,6 +1561,10 @@ function deleteAtom(atomToken, store) {
   target.selectorAtoms.delete(key);
   target.atomsThatAreDefault.delete(key);
   target.timelineAtoms.delete(key);
+  if (atomToken.type === `mutable_atom`) {
+    const updateToken = getUpdateToken(atomToken);
+    deleteAtom(updateToken, store);
+  }
   store.logger.info(`\u{1F525}`, `atom`, `${key}`, `deleted`);
 }
 
@@ -1570,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);
 }
 
@@ -1582,7 +1592,11 @@ function getFromStore(token, store) {
 function ingestAtomUpdate(applying, atomUpdate, store) {
   const { key, newValue, oldValue } = atomUpdate;
   const value = applying === `newValue` ? newValue : oldValue;
-  setIntoStore({ key, type: `atom` }, value, store);
+  const token = { key, type: `atom` };
+  if (atomUpdate.family) {
+    Object.assign(token, { family: atomUpdate.family });
+  }
+  setIntoStore(token, value, store);
 }
 
 // internal/src/ingest-updates/ingest-selector-update.ts
@@ -1642,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;
@@ -1683,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(
@@ -1863,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) => {
@@ -1884,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;
       }
@@ -2050,7 +2028,6 @@ function setEpochNumberOfAction(transactionKey, newEpoch, store) {
   const continuityKey = store.transactionMeta.actionContinuities.getRelatedKey(transactionKey);
   if (continuityKey !== void 0) {
     store.transactionMeta.epoch.set(continuityKey, newEpoch);
-    console.log(`epoch is now`, newEpoch);
   }
 }
 
@@ -2102,7 +2079,6 @@ var applyTransaction = (output, store) => {
   }
   ingestTransactionUpdate(`newValue`, child.transactionMeta.update, parent);
   if (isRootStore(parent)) {
-    console.log(child.transactionMeta.update);
     setEpochNumberOfAction(
       child.transactionMeta.update.key,
       child.transactionMeta.update.epoch,
@@ -2247,6 +2223,6 @@ 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 };
+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 };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map