atom.io 0.27.3 → 0.27.5

package/dist/{chunk-ETCFHO7J.js → chunk-6ABWLAGY.js}

@@ -2,6 +2,7 @@ import { Junction } from './chunk-IBTHB2PI.js';
 import { stringifyJson, parseJson, selectJson, selectJsonFamily } from 'atom.io/json';
 import { AtomIOLogger } from 'atom.io';
 import { getJoin, findRelations } from 'atom.io/data';
+import { subscribeToTimeline, subscribeToTransaction, subscribeToState, arbitrary as arbitrary$1 } from 'atom.io/internal';
 
 // internal/src/arbitrary.ts
 function arbitrary(random = Math.random) {
@@ -202,7 +203,7 @@ var readOrComputeValue = (state, target) => {
     target.logger.info(`\u{1F4D6}`, state.type, state.key, `reading cached value`);
     return readCachedValue(state, target);
   }
-  if (state.type !== `atom` && state.type !== `mutable_atom`) {
+  if (state.type === `selector` || state.type === `readonly_selector`) {
     target.logger.info(`\u{1F9EE}`, state.type, state.key, `computing value`);
     return state.get();
   }
@@ -437,26 +438,22 @@ var setAtomOrSelector = (state, value, store) => {
       break;
   }
 };
-
-// internal/src/families/throw-in-case-of-conflicting-family.ts
-function throwInCaseOfConflictingFamily(family, store) {
-  const existingFamily = store.families.get(family.key);
-  if (existingFamily) {
-    throw new Error(
-      `Tried to create ${family.type === `atom_family` ? `an` : `a`} ${prettyPrintTokenType(family)} with key "${family.key}", but "${family.key}" already exists in store "${store.config.name}" as ${existingFamily.type === `atom_family` ? `an` : `a`} ${prettyPrintTokenType(
-        existingFamily
-      )}`
-    );
-  }
-}
-
-// internal/src/families/create-regular-atom-family.ts
-function createRegularAtomFamily(options, store, internalRoles) {
+function createRegularAtomFamily(store, options, internalRoles) {
   const familyToken = {
     key: options.key,
     type: `atom_family`
   };
-  throwInCaseOfConflictingFamily(familyToken, store);
+  const existing = store.families.get(options.key);
+  if (existing) {
+    store.logger.error(
+      `\u2757`,
+      `atom_family`,
+      options.key,
+      `Overwriting an existing ${prettyPrintTokenType(
+        existing
+      )} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`
+    );
+  }
   const subject = new Subject();
   const familyFunction = (key) => {
     const subKey = stringifyJson(key);
@@ -471,42 +468,62 @@ function createRegularAtomFamily(options, store, internalRoles) {
     if (options.effects) {
       individualOptions.effects = options.effects(key);
     }
-    const token = createRegularAtom(individualOptions, family, target);
+    const token = createRegularAtom(target, individualOptions, family);
     subject.next({ type: `state_creation`, token });
     return token;
   };
   const atomFamily = Object.assign(familyFunction, familyToken, {
     subject,
-    install: (s) => createRegularAtomFamily(options, s),
+    install: (s) => createRegularAtomFamily(s, options),
     internalRoles
   });
   store.families.set(options.key, atomFamily);
+  store.defaults.set(options.key, options.default);
   return familyToken;
 }
 
 // internal/src/families/create-atom-family.ts
-function createAtomFamily(options, store) {
+function createAtomFamily(store, options) {
   const isMutable = `mutable` in options;
   if (isMutable) {
-    return createMutableAtomFamily(options, store);
+    return createMutableAtomFamily(store, options);
   }
-  return createRegularAtomFamily(options, store);
+  return createRegularAtomFamily(store, options);
 }
-
-// internal/src/get-state/get-from-store.ts
-function getFromStore(...params) {
+function getFromStore(store, ...params) {
   let token;
-  let store;
-  if (params.length === 2) {
+  if (params.length === 1) {
     token = params[0];
-    store = params[1];
   } else {
     const family = params[0];
     const key = params[1];
-    store = params[2];
-    const maybeToken = family.type === `molecule_family` ? seekInStore(family, key, store) : store.config.lifespan === `immortal` ? seekInStore(family, key, store) : findInStore(family, key, store);
+    const maybeToken = family.type === `molecule_family` ? seekInStore(store, family, key) : store.config.lifespan === `immortal` ? seekInStore(store, family, key) : findInStore(store, family, key);
     if (!maybeToken) {
-      throw new NotFoundError(family, key, store);
+      store.logger.error(
+        `\u2757`,
+        family.type,
+        family.key,
+        `tried to get member`,
+        stringifyJson(key),
+        `but it was not found in store`,
+        store.config.name
+      );
+      switch (family.type) {
+        case `atom_family`:
+        case `mutable_atom_family`:
+          return store.defaults.get(family.key);
+        case `selector_family`:
+        case `readonly_selector_family`: {
+          if (store.defaults.has(family.key)) {
+            return store.defaults.get(family.key);
+          }
+          const defaultValue = withdraw(family, store).default(key);
+          store.defaults.set(family.key, defaultValue);
+          return defaultValue;
+        }
+        case `molecule_family`:
+          throw new NotFoundError(family, key, store);
+      }
     }
     token = maybeToken;
   }
@@ -606,12 +623,12 @@ var registerSelector = (selectorKey, covered, store) => ({
       const [family, key] = params;
       switch (family.type) {
         case `molecule_family`:
-          return getFromStore(family, key, store);
+          return getFromStore(store, family, key);
         default:
           if (store.config.lifespan === `ephemeral`) {
-            dependency = findInStore(family, key, store);
+            dependency = findInStore(store, family, key);
           } else {
-            const maybeDependency = seekInStore(family, key, store);
+            const maybeDependency = seekInStore(store, family, key);
             if (maybeDependency) {
               dependency = maybeDependency;
             } else {
@@ -623,7 +640,7 @@ var registerSelector = (selectorKey, covered, store) => ({
       [dependency] = params;
     }
     if (dependency.type === `molecule`) {
-      return getFromStore(dependency, store);
+      return getFromStore(store, dependency);
     }
     const dependencyState = withdraw(dependency, store);
     const dependencyValue = readOrComputeValue(dependencyState, store);
@@ -657,7 +674,7 @@ var registerSelector = (selectorKey, covered, store) => ({
       const family = params[0];
       const key = params[1];
       value = params[2];
-      const maybeToken = store.config.lifespan === `ephemeral` ? findInStore(family, key, store) : seekInStore(family, key, store);
+      const maybeToken = store.config.lifespan === `ephemeral` ? findInStore(store, family, key) : seekInStore(store, family, key);
       if (!maybeToken) {
         throw new NotFoundError(family, key, store);
       }
@@ -667,13 +684,13 @@ var registerSelector = (selectorKey, covered, store) => ({
     const state = withdraw(token, target);
     setAtomOrSelector(state, value, target);
   },
-  find: (token, key) => findInStore(token, key, store),
-  seek: (token, key) => seekInStore(token, key, store),
-  json: (token) => getJsonToken(token, store)
+  find: (token, key) => findInStore(store, token, key),
+  seek: (token, key) => seekInStore(store, token, key),
+  json: (token) => getJsonToken(store, token)
 });
 
 // internal/src/selector/create-readonly-selector.ts
-var createReadonlySelector = (options, family, store) => {
+var createReadonlySelector = (store, options, family) => {
   const target = newest(store);
   const subject = new Subject();
   const covered = /* @__PURE__ */ new Set();
@@ -691,7 +708,7 @@ var createReadonlySelector = (options, family, store) => {
   const readonlySelector = {
     ...options,
     subject,
-    install: (s) => createReadonlySelector(options, family, s),
+    install: (s) => createReadonlySelector(s, options, family),
     get: getSelf,
     type: `readonly_selector`,
     ...family && { family }
@@ -716,22 +733,22 @@ var createReadonlySelector = (options, family, store) => {
 };
 
 // internal/src/selector/create-writable-selector.ts
-var createWritableSelector = (options, family, store) => {
+var createWritableSelector = (store, options, family) => {
   const target = newest(store);
   const subject = new Subject();
   const covered = /* @__PURE__ */ new Set();
-  const toolkit = registerSelector(options.key, covered, target);
-  const { find, get, seek, json } = toolkit;
+  const setterToolkit = registerSelector(options.key, covered, target);
+  const { find, get, seek, json } = setterToolkit;
   const getterToolkit = { find, get, seek, json };
-  const getSelf = (innerTarget = newest(store)) => {
-    const value = options.get(getterToolkit);
+  const getSelf = (getFn = options.get, innerTarget = newest(store)) => {
+    const value = getFn(getterToolkit);
     cacheValue(options.key, value, subject, innerTarget);
     covered.clear();
     return value;
   };
   const setSelf = (next) => {
     const innerTarget = newest(store);
-    const oldValue = getSelf(innerTarget);
+    const oldValue = getSelf(options.get, innerTarget);
     const newValue = become(next)(oldValue);
     store.logger.info(
       `\u{1F4DD}`,
@@ -748,12 +765,12 @@ var createWritableSelector = (options, family, store) => {
     if (isRootStore(innerTarget)) {
       subject.next({ newValue, oldValue });
     }
-    options.set(toolkit, newValue);
+    options.set(setterToolkit, newValue);
   };
   const mySelector = {
     ...options,
     subject,
-    install: (s) => createWritableSelector(options, family, s),
+    install: (s) => createWritableSelector(s, options, family),
     get: getSelf,
     set: setSelf,
     type: `selector`,
@@ -773,14 +790,14 @@ var createWritableSelector = (options, family, store) => {
 };
 
 // internal/src/selector/create-standalone-selector.ts
-function createStandaloneSelector(options, store) {
+function createStandaloneSelector(store, options) {
   const isWritable = `set` in options;
   if (isWritable) {
-    const state2 = createWritableSelector(options, void 0, store);
+    const state2 = createWritableSelector(store, options, void 0);
     store.on.selectorCreation.next(state2);
     return state2;
   }
-  const state = createReadonlySelector(options, void 0, store);
+  const state = createReadonlySelector(store, options, void 0);
   store.on.selectorCreation.next(state);
   return state;
 }
@@ -861,12 +878,22 @@ function disposeSelector(selectorToken, store) {
 }
 
 // internal/src/families/create-readonly-selector-family.ts
-function createReadonlySelectorFamily(options, store, internalRoles) {
+function createReadonlySelectorFamily(store, options, internalRoles) {
   const familyToken = {
     key: options.key,
     type: `readonly_selector_family`
   };
-  throwInCaseOfConflictingFamily(familyToken, store);
+  const existing = store.families.get(options.key);
+  if (existing) {
+    store.logger.error(
+      `\u2757`,
+      `readonly_selector_family`,
+      options.key,
+      `Overwriting an existing ${prettyPrintTokenType(
+        existing
+      )} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`
+    );
+  }
   const subject = new Subject();
   const familyFunction = (key) => {
     const subKey = stringifyJson(key);
@@ -874,30 +901,49 @@ function createReadonlySelectorFamily(options, store, internalRoles) {
     const fullKey = `${options.key}(${subKey})`;
     const target = newest(store);
     const token = createReadonlySelector(
+      target,
       {
         key: fullKey,
         get: options.get(key)
       },
-      family,
-      target
+      family
     );
     subject.next({ type: `state_creation`, token });
     return token;
   };
   const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
+    internalRoles,
     subject,
-    install: (s) => createReadonlySelectorFamily(options, s),
-    internalRoles
+    install: (s) => createReadonlySelectorFamily(s, options),
+    default: (key) => {
+      const getFn = options.get(key);
+      return getFn({
+        get: (...ps) => getFromStore(store, ...ps),
+        find: (token, k) => findInStore(store, token, k),
+        seek: (token, k) => seekInStore(store, token, k),
+        json: (token) => getJsonToken(store, token)
+      });
+    }
   });
   store.families.set(options.key, readonlySelectorFamily);
   return familyToken;
 }
-function createWritableSelectorFamily(options, store, internalRoles) {
+function createWritableSelectorFamily(store, options, internalRoles) {
   const familyToken = {
     key: options.key,
     type: `selector_family`
   };
-  throwInCaseOfConflictingFamily(familyToken, store);
+  const existing = store.families.get(options.key);
+  if (existing) {
+    store.logger.error(
+      `\u2757`,
+      `selector_family`,
+      options.key,
+      `Overwriting an existing ${prettyPrintTokenType(
+        existing
+      )} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`
+    );
+  }
   const subject = new Subject();
   const familyFunction = (key) => {
     const subKey = stringifyJson(key);
@@ -905,33 +951,42 @@ function createWritableSelectorFamily(options, store, internalRoles) {
     const fullKey = `${options.key}(${subKey})`;
     const target = newest(store);
     const token = createWritableSelector(
+      target,
       {
         key: fullKey,
         get: options.get(key),
         set: options.set(key)
       },
-      family,
-      target
+      family
     );
     subject.next({ type: `state_creation`, token });
     return token;
   };
   const selectorFamily = Object.assign(familyFunction, familyToken, {
+    internalRoles,
     subject,
-    install: (s) => createWritableSelectorFamily(options, s),
-    internalRoles
+    install: (s) => createWritableSelectorFamily(s, options),
+    default: (key) => {
+      const getFn = options.get(key);
+      return getFn({
+        get: (...ps) => getFromStore(store, ...ps),
+        find: (token, k) => findInStore(store, token, k),
+        seek: (token, k) => seekInStore(store, token, k),
+        json: (token) => getJsonToken(store, token)
+      });
+    }
   });
   store.families.set(options.key, selectorFamily);
   return familyToken;
 }
 
 // internal/src/families/create-selector-family.ts
-function createSelectorFamily(options, store) {
+function createSelectorFamily(store, options) {
   const isWritable = `set` in options;
   if (isWritable) {
-    return createWritableSelectorFamily(options, store);
+    return createWritableSelectorFamily(store, options);
   }
-  return createReadonlySelectorFamily(options, store);
+  return createReadonlySelectorFamily(store, options);
 }
 
 // internal/src/molecule/dispose-molecule.ts
@@ -974,7 +1029,7 @@ function disposeMolecule(token, store) {
       disposalEvent.family = token.family;
     }
     for (const state of molecule.tokens.values()) {
-      disposeFromStore(state, store);
+      disposeFromStore(store, state);
     }
     for (const child of molecule.below.values()) {
       if (child.family?.dependsOn === `all`) {
@@ -1004,7 +1059,7 @@ function disposeMolecule(token, store) {
 }
 
 // internal/src/families/init-family-member.ts
-function initFamilyMemberInStore(token, key, store) {
+function initFamilyMemberInStore(store, token, key) {
   const familyKey = token.key;
   const family = store.families.get(familyKey);
   if (family === void 0) {
@@ -1033,7 +1088,7 @@ function initFamilyMemberInStore(token, key, store) {
   }
   return state;
 }
-function seekInStore(token, key, store) {
+function seekInStore(store, token, key) {
   const subKey = stringifyJson(key);
   const fullKey = `${token.key}(${subKey})`;
   const target = newest(store);
@@ -1051,9 +1106,6 @@ function seekInStore(token, key, store) {
       break;
     case `molecule_family`:
       state = target.molecules.get(stringifyJson(key));
-      if (state) {
-        return deposit(state);
-      }
   }
   if (state) {
     return deposit(state);
@@ -1062,34 +1114,40 @@ function seekInStore(token, key, store) {
 }
 
 // internal/src/families/find-in-store.ts
-function findInStore(token, key, store) {
+function findInStore(store, token, key) {
   if (store.config.lifespan === `immortal`) {
     throw new Error(
       `Do not use \`find\` or \`findState\` in an immortal store. Prefer \`seek\` or \`seekState\`.`
     );
   }
-  let state = seekInStore(token, key, store);
+  let state = seekInStore(store, token, key);
   if (state) {
     return state;
   }
-  state = initFamilyMemberInStore(token, key, store);
+  state = initFamilyMemberInStore(store, token, key);
   return state;
 }
 
 // internal/src/families/dispose-from-store.ts
-function disposeFromStore(...params) {
+function disposeFromStore(store, ...params) {
   let token;
-  let store;
-  if (params.length === 2) {
+  if (params.length === 1) {
     token = params[0];
-    store = params[1];
   } else {
     const family = params[0];
     const key = params[1];
-    store = params[2];
-    const maybeToken = family.type === `molecule_family` ? seekInStore(family, key, store) : store.config.lifespan === `immortal` ? seekInStore(family, key, store) : findInStore(family, key, store);
+    const maybeToken = family.type === `molecule_family` ? seekInStore(store, family, key) : store.config.lifespan === `immortal` ? seekInStore(store, family, key) : findInStore(store, family, key);
     if (!maybeToken) {
-      throw new NotFoundError(family, key, store);
+      store.logger.error(
+        `\u2757`,
+        family.type,
+        family.key,
+        `tried to dispose of member`,
+        stringifyJson(key),
+        `but it was not found in store`,
+        store.config.name
+      );
+      return;
     }
     token = maybeToken;
   }
@@ -1109,22 +1167,30 @@ function disposeFromStore(...params) {
 }
 
 // internal/src/set-state/set-into-store.ts
-function setIntoStore(...params) {
+function setIntoStore(store, ...params) {
   let token;
   let value;
-  let store;
-  if (params.length === 3) {
+  if (params.length === 2) {
     token = params[0];
     value = params[1];
-    store = params[2];
   } else {
     const family = params[0];
     const key = params[1];
     value = params[2];
-    store = params[3];
-    const maybeToken = store.config.lifespan === `ephemeral` ? findInStore(family, key, store) : seekInStore(family, key, store);
+    const maybeToken = store.config.lifespan === `ephemeral` ? findInStore(store, family, key) : seekInStore(store, family, key);
     if (!maybeToken) {
-      throw new NotFoundError(family, key, store);
+      store.logger.error(
+        `\u2757`,
+        family.type,
+        family.key,
+        `tried to set member`,
+        stringifyJson(key),
+        `to`,
+        value,
+        `but it was not found in store`,
+        store.config.name
+      );
+      return;
     }
     token = maybeToken;
   }
@@ -1140,7 +1206,7 @@ function setIntoStore(...params) {
           token.key,
           `resuming deferred setState from T-${rejectionTime}`
         );
-        setIntoStore(token, value, store);
+        setIntoStore(store, token, value);
       }
     );
     return;
@@ -1158,11 +1224,11 @@ function ingestAtomUpdate(applying, atomUpdate, store) {
   if (atomUpdate.family) {
     Object.assign(token, { family: atomUpdate.family });
   }
-  setIntoStore(token, value, store);
+  setIntoStore(store, token, value);
 }
 
 // internal/src/molecule/create-molecule-family.ts
-function createMoleculeFamily(options, store) {
+function createMoleculeFamily(store, options) {
   const subject = new Subject();
   const token = {
     type: `molecule_family`,
@@ -1180,7 +1246,7 @@ function createMoleculeFamily(options, store) {
 
 // internal/src/molecule/grow-molecule-in-store.ts
 function growMoleculeInStore(molecule, family, store) {
-  const stateToken = initFamilyMemberInStore(family, molecule.key, store);
+  const stateToken = initFamilyMemberInStore(store, family, molecule.key);
   molecule.tokens.set(stateToken.key, stateToken);
   const isTransaction = isChildStore(store) && store.transactionMeta.phase === `building`;
   const moleculeInProgress = store.moleculeInProgress === molecule.key;
@@ -1253,16 +1319,16 @@ function makeMoleculeInStore(store, context, familyToken, key, ...params) {
     owner.below.set(molecule.stringKey, molecule);
   }
   const toolkit = {
-    get: (...ps) => getFromStore(...ps, newest(rootStore)),
+    get: (...ps) => getFromStore(newest(rootStore), ...ps),
     set: (...ps) => {
-      setIntoStore(...ps, newest(rootStore));
+      setIntoStore(newest(rootStore), ...ps);
     },
-    seek: (t, k) => seekInStore(t, k, newest(rootStore)),
-    json: (t) => getJsonToken(t, newest(rootStore)),
+    seek: (t, k) => seekInStore(newest(rootStore), t, k),
+    json: (t) => getJsonToken(newest(rootStore), t),
     run: (t, i = arbitrary()) => actUponStore(t, i, newest(store)),
     make: (ctx, f, k, ...args) => makeMoleculeInStore(newest(rootStore), ctx, f, k, ...args),
     dispose: (t) => {
-      disposeFromStore(t, newest(rootStore));
+      disposeFromStore(newest(rootStore), t);
     },
     env: () => getEnvironmentData(newest(rootStore)),
     bond: (token2, maybeRole) => {
@@ -1356,7 +1422,7 @@ function ingestCreationEvent(update, applying, store) {
       break;
     }
     case `oldValue`: {
-      disposeFromStore(update.token, store);
+      disposeFromStore(store, update.token);
       break;
     }
   }
@@ -1364,7 +1430,7 @@ function ingestCreationEvent(update, applying, store) {
 function ingestDisposalEvent(update, applying, store) {
   switch (applying) {
     case `newValue`: {
-      disposeFromStore(update.token, store);
+      disposeFromStore(store, update.token);
       break;
     }
     case `oldValue`: {
@@ -1386,7 +1452,7 @@ function createInStore(token, store) {
       if (store.config.lifespan === `immortal`) {
         throw new Error(`No molecule found for key "${token.family.subKey}"`);
       }
-      initFamilyMemberInStore(family, parseJson(token.family.subKey), store);
+      initFamilyMemberInStore(store, family, parseJson(token.family.subKey));
     }
   }
 }
@@ -1402,14 +1468,14 @@ function ingestMoleculeCreationEvent(update, applying, store) {
       );
       break;
     case `oldValue`:
-      disposeFromStore(update.token, store);
+      disposeFromStore(store, update.token);
       break;
   }
 }
 function ingestMoleculeDisposalEvent(update, applying, store) {
   switch (applying) {
     case `newValue`:
-      disposeFromStore(update.token, store);
+      disposeFromStore(store, update.token);
       break;
     case `oldValue`:
       {
@@ -1609,6 +1675,7 @@ var buildTransaction = (key, params, store, id) => {
     }),
     selectors: new LazyMap(parent.selectors),
     valueMap: new LazyMap(parent.valueMap),
+    defaults: parent.defaults,
     molecules: new LazyMap(parent.molecules),
     moleculeFamilies: new LazyMap(parent.moleculeFamilies),
     moleculeInProgress: parent.moleculeInProgress,
@@ -1627,17 +1694,17 @@ var buildTransaction = (key, params, store, id) => {
       output: void 0
     },
     toolkit: {
-      get: (...ps) => getFromStore(...ps, child),
+      get: (...ps) => getFromStore(child, ...ps),
       set: (...ps) => {
-        setIntoStore(...ps, child);
+        setIntoStore(child, ...ps);
       },
       run: (token, identifier = arbitrary()) => actUponStore(token, identifier, child),
-      find: (token, k) => findInStore(token, k, child),
-      seek: (token, k) => seekInStore(token, k, child),
-      json: (token) => getJsonToken(token, child),
+      find: (token, k) => findInStore(child, token, k),
+      seek: (token, k) => seekInStore(child, token, k),
+      json: (token) => getJsonToken(child, token),
       make: (context, family, k, ...args) => makeMoleculeInStore(child, context, family, k, ...args),
       dispose: (...ps) => {
-        disposeFromStore(...ps, child);
+        disposeFromStore(child, ...ps);
       },
       env: () => getEnvironmentData(child)
     }
@@ -1711,6 +1778,7 @@ var Store = class {
   parent = null;
   child = null;
   valueMap = /* @__PURE__ */ new Map();
+  defaults = /* @__PURE__ */ new Map();
   atoms = /* @__PURE__ */ new Map();
   selectors = /* @__PURE__ */ new Map();
   readonlySelectors = /* @__PURE__ */ new Map();
@@ -1810,7 +1878,7 @@ var Store = class {
         }
         atom.install(this);
         if (atom.type === `mutable_atom`) {
-          const originalJsonToken = getJsonToken(atom, store);
+          const originalJsonToken = getJsonToken(store, atom);
           const originalUpdateToken = getUpdateToken(atom);
           mutableHelpers.add(originalJsonToken.key);
           mutableHelpers.add(originalUpdateToken.key);
@@ -1903,6 +1971,19 @@ var recallState = (state, store) => {
   }
   return target.valueMap.get(state.key);
 };
+function subscribeInStore(store, token, handleUpdate, key = arbitrary$1()) {
+  switch (token.type) {
+    case `atom`:
+    case `mutable_atom`:
+    case `readonly_selector`:
+    case `selector`:
+      return subscribeToState(token, handleUpdate, key, store);
+    case `transaction`:
+      return subscribeToTransaction(token, handleUpdate, key, store);
+    case `timeline`:
+      return subscribeToTimeline(token, handleUpdate, key, store);
+  }
+}
 
 // internal/src/subscribe/subscribe-to-root-atoms.ts
 var subscribeToRootAtoms = (selector, store) => {
@@ -1949,7 +2030,7 @@ var subscribeToRootAtoms = (selector, store) => {
 };
 
 // internal/src/subscribe/subscribe-to-state.ts
-function subscribeToState(token, handleUpdate, key, store) {
+function subscribeToState2(token, handleUpdate, key, store) {
   function safelyHandleUpdate(update) {
     if (store.operation.open) {
       const unsubscribe2 = store.on.operationClose.subscribe(
@@ -1997,7 +2078,7 @@ function subscribeToState(token, handleUpdate, key, store) {
 }
 
 // internal/src/subscribe/subscribe-to-timeline.ts
-var subscribeToTimeline = (token, handleUpdate, key, store) => {
+var subscribeToTimeline2 = (token, handleUpdate, key, store) => {
   const tl = withdraw(token, store);
   store.logger.info(`\u{1F440}`, `timeline`, token.key, `Adding subscription "${key}"`);
   const unsubscribe = tl.subject.subscribe(key, handleUpdate);
@@ -2013,7 +2094,7 @@ var subscribeToTimeline = (token, handleUpdate, key, store) => {
 };
 
 // internal/src/subscribe/subscribe-to-transaction.ts
-var subscribeToTransaction = (token, handleUpdate, key, store) => {
+var subscribeToTransaction2 = (token, handleUpdate, key, store) => {
   const tx = withdraw(token, store);
   store.logger.info(
     `\u{1F440}`,
@@ -2045,12 +2126,12 @@ var Tracker = class {
       subKey: mutableState.family.subKey
     } : void 0;
     const latestUpdateState = createRegularAtom(
+      store,
       {
         key: latestUpdateStateKey,
         default: null
       },
-      familyMetaData,
-      store
+      familyMetaData
     );
     if (store.parent?.valueMap.has(latestUpdateStateKey)) {
       const parentValue = store.parent.valueMap.get(latestUpdateStateKey);
@@ -2062,14 +2143,14 @@ var Tracker = class {
   unsubscribeFromState;
   observeCore(mutableState, latestUpdateState, target) {
     const subscriptionKey = `tracker:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.key : `main`}:${mutableState.key}`;
-    const originalInnerValue = getFromStore(mutableState, target);
+    const originalInnerValue = getFromStore(target, mutableState);
     this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
       subscriptionKey,
       (update) => {
-        setIntoStore(latestUpdateState, update, target);
+        setIntoStore(target, latestUpdateState, update);
       }
     );
-    this.unsubscribeFromState = subscribeToState(
+    this.unsubscribeFromState = subscribeToState2(
       mutableState,
       (update) => {
         if (update.newValue !== update.oldValue) {
@@ -2077,7 +2158,7 @@ var Tracker = class {
           this.unsubscribeFromInnerValue = update.newValue.subscribe(
             subscriptionKey,
             (transceiverUpdate) => {
-              setIntoStore(latestUpdateState, transceiverUpdate, target);
+              setIntoStore(target, latestUpdateState, transceiverUpdate);
             }
           );
         }
@@ -2088,7 +2169,7 @@ var Tracker = class {
   }
   updateCore(mutableState, latestUpdateState, target) {
     const subscriptionKey = `tracker:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.key : `main`}:${mutableState.key}`;
-    subscribeToState(
+    subscribeToState2(
       latestUpdateState,
       ({ newValue, oldValue }) => {
         const timelineId = target.timelineTopics.getRelatedKey(
@@ -2097,22 +2178,18 @@ var Tracker = class {
         if (timelineId) {
           const timelineData = target.timelines.get(timelineId);
           if (timelineData?.timeTraveling) {
-            const unsubscribe2 = subscribeToTimeline(
+            const unsubscribe2 = subscribeToTimeline2(
               { key: timelineId, type: `timeline` },
               (update) => {
                 unsubscribe2();
-                setIntoStore(
-                  mutableState,
-                  (transceiver) => {
-                    if (update === `redo` && newValue) {
-                      transceiver.do(newValue);
-                    } else if (update === `undo` && oldValue) {
-                      transceiver.undo(oldValue);
-                    }
-                    return transceiver;
-                  },
-                  target
-                );
+                setIntoStore(target, mutableState, (transceiver) => {
+                  if (update === `redo` && newValue) {
+                    transceiver.do(newValue);
+                  } else if (update === `undo` && oldValue) {
+                    transceiver.undo(oldValue);
+                  }
+                  return transceiver;
+                });
               },
               subscriptionKey,
               target
@@ -2124,14 +2201,14 @@ var Tracker = class {
           subscriptionKey,
           () => {
             unsubscribe();
-            const mutable = getFromStore(mutableState, target);
+            const mutable = getFromStore(target, mutableState);
             const updateNumber = newValue === null ? -1 : mutable.getUpdateNumber(newValue);
             const eventOffset = updateNumber - mutable.cacheUpdateNumber;
             if (newValue && eventOffset === 1) {
               setIntoStore(
+                target,
                 mutableState,
-                (transceiver) => (transceiver.do(newValue), transceiver),
-                target
+                (transceiver) => (transceiver.do(newValue), transceiver)
               );
             } else {
               target.logger.info(
@@ -2167,7 +2244,7 @@ var Tracker = class {
 };
 
 // internal/src/mutable/create-mutable-atom.ts
-function createMutableAtom(options, family, store) {
+function createMutableAtom(store, options, family) {
   store.logger.info(
     `\u{1F528}`,
     `atom`,
@@ -2196,7 +2273,7 @@ function createMutableAtom(options, family, store) {
         options.key,
         `installing in store "${s.config.name}"`
       );
-      return createMutableAtom(options, family, s);
+      return createMutableAtom(s, options, family);
     },
     subject
   };
@@ -2214,9 +2291,9 @@ function createMutableAtom(options, family, store) {
     for (const effect of options.effects) {
       const cleanup = effect({
         setSelf: (next) => {
-          setIntoStore(token, next, store);
+          setIntoStore(store, token, next);
         },
-        onSet: (handle) => subscribeToState(token, handle, `effect[${effectIndex}]`, store)
+        onSet: (handle) => subscribeToState2(token, handle, `effect[${effectIndex}]`, store)
       });
       if (cleanup) {
         cleanupFunctions.push(cleanup);
@@ -2241,11 +2318,11 @@ var FamilyTracker = class {
   mutableAtoms;
   constructor(mutableAtoms, store) {
     const updateAtoms = createRegularAtomFamily(
+      store,
       {
         key: `*${mutableAtoms.key}`,
         default: null
       },
-      store,
       [`mutable`, `updates`]
     );
     this.latestUpdateAtoms = withdraw(updateAtoms, store);
@@ -2255,7 +2332,7 @@ var FamilyTracker = class {
       (event) => {
         if (event.token.family) {
           const key = parseJson(event.token.family.subKey);
-          seekInStore(this.latestUpdateAtoms, key, store);
+          seekInStore(store, this.latestUpdateAtoms, key);
           new Tracker(event.token, store);
         }
       }
@@ -2265,7 +2342,7 @@ var FamilyTracker = class {
       (event) => {
         if (event.token.family) {
           const key = parseJson(event.token.family.subKey);
-          const mutableAtomToken = seekInStore(this.mutableAtoms, key, store);
+          const mutableAtomToken = seekInStore(store, this.mutableAtoms, key);
           if (mutableAtomToken) {
             new Tracker(mutableAtomToken, store);
           }
@@ -2276,12 +2353,22 @@ var FamilyTracker = class {
 };
 
 // internal/src/mutable/create-mutable-atom-family.ts
-function createMutableAtomFamily(options, store, internalRoles) {
+function createMutableAtomFamily(store, options, internalRoles) {
   const familyToken = {
     key: options.key,
     type: `mutable_atom_family`
   };
-  throwInCaseOfConflictingFamily(familyToken, store);
+  const existing = store.families.get(options.key);
+  if (existing) {
+    store.logger.error(
+      `\u2757`,
+      `mutable_atom_family`,
+      options.key,
+      `Overwriting an existing ${prettyPrintTokenType(
+        existing
+      )} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`
+    );
+  }
   const subject = new Subject();
   const familyFunction = (key) => {
     const subKey = stringifyJson(key);
@@ -2298,13 +2385,13 @@ function createMutableAtomFamily(options, store, internalRoles) {
     if (options.effects) {
       individualOptions.effects = options.effects(key);
     }
-    const token = createMutableAtom(individualOptions, family, target);
+    const token = createMutableAtom(target, individualOptions, family);
     subject.next({ type: `state_creation`, token });
     return token;
   };
   const atomFamily = Object.assign(familyFunction, familyToken, {
     subject,
-    install: (s) => createMutableAtomFamily(options, s),
+    install: (s) => createMutableAtomFamily(s, options),
     toJson: options.toJson,
     fromJson: options.fromJson,
     internalRoles
@@ -2324,7 +2411,7 @@ var getJsonFamily = (mutableAtomFamily, store) => {
 };
 
 // internal/src/mutable/get-json-token.ts
-var getJsonToken = (mutableAtomToken, store) => {
+var getJsonToken = (store, mutableAtomToken) => {
   if (mutableAtomToken.family) {
     const target = newest(store);
     const jsonFamilyKey = `${mutableAtomToken.family.key}:JSON`;
@@ -2334,7 +2421,7 @@ var getJsonToken = (mutableAtomToken, store) => {
     };
     const family = withdraw(jsonFamilyToken, target);
     const subKey = JSON.parse(mutableAtomToken.family.subKey);
-    const jsonToken = findInStore(family, subKey, store);
+    const jsonToken = findInStore(store, family, subKey);
     return jsonToken;
   }
   const token = {
@@ -2453,7 +2540,7 @@ var markAtomAsNotDefault = (key, store) => {
 };
 
 // internal/src/atom/create-regular-atom.ts
-function createRegularAtom(options, family, store) {
+function createRegularAtom(store, options, family) {
   store.logger.info(
     `\u{1F528}`,
     `atom`,
@@ -2482,7 +2569,7 @@ function createRegularAtom(options, family, store) {
         options.key,
         `installing in store "${s.config.name}"`
       );
-      return createRegularAtom(options, family, s);
+      return createRegularAtom(s, options, family);
     },
     subject
   };
@@ -2503,9 +2590,9 @@ function createRegularAtom(options, family, store) {
     for (const effect of options.effects) {
       const cleanup = effect({
         setSelf: (next) => {
-          setIntoStore(token, next, store);
+          setIntoStore(store, token, next);
         },
-        onSet: (handle) => subscribeToState(token, handle, `effect[${effectIndex}]`, store)
+        onSet: (handle) => subscribeToState2(token, handle, `effect[${effectIndex}]`, store)
       });
       if (cleanup) {
         cleanupFunctions.push(cleanup);
@@ -2522,14 +2609,14 @@ function createRegularAtom(options, family, store) {
 }
 
 // internal/src/atom/create-standalone-atom.ts
-function createStandaloneAtom(options, store) {
+function createStandaloneAtom(store, options) {
   const isMutable = `mutable` in options;
   if (isMutable) {
-    const state2 = createMutableAtom(options, void 0, store);
+    const state2 = createMutableAtom(store, options, void 0);
     store.on.atomCreation.next(state2);
     return state2;
   }
-  const state = createRegularAtom(options, void 0, store);
+  const state = createRegularAtom(store, options, void 0);
   store.on.atomCreation.next(state);
   return state;
 }
@@ -3009,7 +3096,7 @@ function handleStateLifecycleEvent(event, tl, store) {
 }
 
 // internal/src/timeline/time-travel.ts
-var timeTravel = (action, token, store) => {
+var timeTravel = (store, action, token) => {
   store.logger.info(
     action === `redo` ? `\u23E9` : `\u23EA`,
     `timeline`,
@@ -3084,4 +3171,4 @@ var timeTravel = (action, token, store) => {
   );
 };
 
-export { FamilyTracker, Future, IMPLICIT, LazyMap, Molecule, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, createWritableSelectorFamily, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+export { FamilyTracker, Future, IMPLICIT, LazyMap, Molecule, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, createWritableSelectorFamily, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState2 as subscribeToState, subscribeToTimeline2 as subscribeToTimeline, subscribeToTransaction2 as subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };