atom.io 0.27.4 → 0.27.5

package/dist/{chunk-JRENM6KL.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) {
@@ -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,13 +468,13 @@ 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);
@@ -486,24 +483,21 @@ function createRegularAtomFamily(options, store, internalRoles) {
 }
 
 // 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);
 }
-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) {
       store.logger.error(
         `\u2757`,
@@ -629,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 {
@@ -646,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);
@@ -680,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);
       }
@@ -690,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();
@@ -714,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 }
@@ -739,7 +733,7 @@ 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();
@@ -776,7 +770,7 @@ var createWritableSelector = (options, family, store) => {
   const mySelector = {
     ...options,
     subject,
-    install: (s) => createWritableSelector(options, family, s),
+    install: (s) => createWritableSelector(s, options, family),
     get: getSelf,
     set: setSelf,
     type: `selector`,
@@ -796,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;
 }
@@ -884,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);
@@ -897,12 +901,12 @@ 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;
@@ -910,26 +914,36 @@ function createReadonlySelectorFamily(options, store, internalRoles) {
   const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
     internalRoles,
     subject,
-    install: (s) => createReadonlySelectorFamily(options, s),
+    install: (s) => createReadonlySelectorFamily(s, options),
     default: (key) => {
       const getFn = options.get(key);
       return getFn({
-        get: (token) => getFromStore(token, store),
-        find: (token, k) => findInStore(token, k, store),
-        seek: (token, k) => seekInStore(token, k, store),
-        json: (token) => getJsonToken(token, store)
+        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);
@@ -937,13 +951,13 @@ 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;
@@ -951,15 +965,14 @@ function createWritableSelectorFamily(options, store, internalRoles) {
   const selectorFamily = Object.assign(familyFunction, familyToken, {
     internalRoles,
     subject,
-    install: (s) => createWritableSelectorFamily(options, s),
+    install: (s) => createWritableSelectorFamily(s, options),
     default: (key) => {
       const getFn = options.get(key);
       return getFn({
-        get: (...params) => getFromStore(...params, store),
-        // TODO: make store zero-arg
-        find: (token, k) => findInStore(token, k, store),
-        seek: (token, k) => seekInStore(token, k, store),
-        json: (token) => getJsonToken(token, store)
+        get: (...ps) => getFromStore(store, ...ps),
+        find: (token, k) => findInStore(store, token, k),
+        seek: (token, k) => seekInStore(store, token, k),
+        json: (token) => getJsonToken(store, token)
       });
     }
   });
@@ -968,12 +981,12 @@ function createWritableSelectorFamily(options, store, internalRoles) {
 }
 
 // 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
@@ -1016,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`) {
@@ -1046,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) {
@@ -1075,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);
@@ -1101,32 +1114,29 @@ 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) {
       store.logger.error(
         `\u2757`,
@@ -1157,20 +1167,17 @@ 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) {
       store.logger.error(
         `\u2757`,
@@ -1199,7 +1206,7 @@ function setIntoStore(...params) {
           token.key,
           `resuming deferred setState from T-${rejectionTime}`
         );
-        setIntoStore(token, value, store);
+        setIntoStore(store, token, value);
       }
     );
     return;
@@ -1217,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`,
@@ -1239,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;
@@ -1312,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) => {
@@ -1415,7 +1422,7 @@ function ingestCreationEvent(update, applying, store) {
       break;
     }
     case `oldValue`: {
-      disposeFromStore(update.token, store);
+      disposeFromStore(store, update.token);
       break;
     }
   }
@@ -1423,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`: {
@@ -1445,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));
     }
   }
 }
@@ -1461,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`:
       {
@@ -1687,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)
     }
@@ -1871,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);
@@ -1964,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) => {
@@ -2010,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(
@@ -2058,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);
@@ -2074,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}`,
@@ -2106,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);
@@ -2123,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) {
@@ -2138,7 +2158,7 @@ var Tracker = class {
           this.unsubscribeFromInnerValue = update.newValue.subscribe(
             subscriptionKey,
             (transceiverUpdate) => {
-              setIntoStore(latestUpdateState, transceiverUpdate, target);
+              setIntoStore(target, latestUpdateState, transceiverUpdate);
             }
           );
         }
@@ -2149,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(
@@ -2158,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
@@ -2185,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(
@@ -2228,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`,
@@ -2257,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
   };
@@ -2275,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);
@@ -2302,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);
@@ -2316,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);
         }
       }
@@ -2326,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);
           }
@@ -2337,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);
@@ -2359,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
@@ -2385,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`;
@@ -2395,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 = {
@@ -2514,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`,
@@ -2543,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
   };
@@ -2564,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);
@@ -2583,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;
 }
@@ -3070,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`,
@@ -3145,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 };