atom.io 0.10.1 → 0.10.3

package/internal/dist/index.js

@@ -314,27 +314,20 @@ var Store = class {
       name: `IMPLICIT_STORE`
     };
     this.loggers = [
-      new atom_io.AtomIOLogger(
-        __spreadValues({}, console),
-        `warn`,
-        (message) => !message.includes(`\u{1F441}\u200D\u{1F5E8}`)
-      )
+      new atom_io.AtomIOLogger(`warn`, (_, __, key) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`))
     ];
     this.logger = {
       error: (...messages) => {
-        for (const logger of this.loggers) {
+        for (const logger of this.loggers)
           logger.error(...messages);
-        }
       },
       info: (...messages) => {
-        for (const logger of this.loggers) {
+        for (const logger of this.loggers)
           logger.info(...messages);
-        }
       },
       warn: (...messages) => {
-        for (const logger of this.loggers) {
+        for (const logger of this.loggers)
           logger.warn(...messages);
-        }
       }
     };
     if (store !== null) {
@@ -379,17 +372,28 @@ var clearStore = (store = IMPLICIT.STORE) => {
 var abortTransaction = (store) => {
   if (store.transactionStatus.phase === `idle`) {
     store.logger.warn(
-      `\u{1F41E} abortTransaction called outside of a transaction. This is probably a bug.`
+      `\u{1F41E}`,
+      `transaction`,
+      `???`,
+      `abortTransaction called outside of a transaction. This is probably a bug in AtomIO.`
     );
     return;
   }
+  store.logger.info(
+    `\u{1FA82}`,
+    `transaction`,
+    store.transactionStatus.key,
+    `Aborting transaction`
+  );
   store.transactionStatus = { phase: `idle` };
-  store.logger.info(`\u{1FA82}`, `transaction fail`);
 };
 var applyTransaction = (output, store) => {
   if (store.transactionStatus.phase !== `building`) {
     store.logger.warn(
-      `\u{1F41E} applyTransaction called outside of a transaction. This is probably a bug.`
+      `\u{1F41E}`,
+      `transaction`,
+      `???`,
+      `applyTransaction called outside of a transaction. This is probably a bug in AtomIO.`
     );
     return;
   }
@@ -397,9 +401,12 @@ var applyTransaction = (output, store) => {
   store.transactionStatus.output = output;
   const { atomUpdates } = store.transactionStatus;
   store.logger.info(
-    `\u{1F6C3} applying transaction "${store.transactionStatus.key}" with ${atomUpdates.length} updates.`
+    `\u{1F6C4}`,
+    `transaction`,
+    store.transactionStatus.key,
+    `Applying transaction with ${atomUpdates.length} updates:`,
+    atomUpdates
   );
-  store.logger.info(`\u{1F6C3} the updates are:`, atomUpdates);
   for (const { key, newValue } of atomUpdates) {
     const token = { key, type: `atom` };
     if (!store.valueMap.has(token.key)) {
@@ -417,7 +424,12 @@ var applyTransaction = (output, store) => {
         }
         store.atoms.set(newAtom.key, newAtom);
         store.valueMap.set(newAtom.key, newAtom.default);
-        store.logger.info(`\u{1F527} add atom "${newAtom.key}"`);
+        store.logger.info(
+          `\u{1F528}`,
+          `transaction`,
+          store.transactionStatus.key,
+          `Adding atom "${newAtom.key}"`
+        );
       }
     }
     atom_io.setState(token, newValue, store);
@@ -437,8 +449,13 @@ var applyTransaction = (output, store) => {
     output,
     params: store.transactionStatus.params
   });
+  store.logger.info(
+    `\u{1F6EC}`,
+    `transaction`,
+    store.transactionStatus.key,
+    `Finished applying transaction.`
+  );
   store.transactionStatus = { phase: `idle` };
-  store.logger.info(`\u{1F6EC} transaction "${myTransaction.key}" applied`);
 };
 
 // src/transaction/build-transaction.ts
@@ -469,7 +486,11 @@ var buildTransaction = (key, params, store) => {
     output: void 0
   };
   store.logger.info(
-    `\u{1F6EB} transaction "${key}" building in store "${store.config.name}"`
+    `\u{1F6EB}`,
+    `transaction`,
+    key,
+    `Building transaction with params:`,
+    params
   );
 };
 
@@ -492,10 +513,7 @@ function transaction__INTERNAL(options, store = IMPLICIT.STORE) {
         return output;
       } catch (thrown) {
         abortTransaction(store);
-        store.logger.error(
-          `\u2757 Transaction "${options.key}" failed in store "${store.config.name}":`,
-          thrown
-        );
+        store.logger.warn(`\u{1F4A5}`, `transaction`, options.key, `caught:`, thrown);
         throw thrown;
       }
     },
@@ -510,7 +528,7 @@ function transaction__INTERNAL(options, store = IMPLICIT.STORE) {
 }
 var target = (store = IMPLICIT.STORE) => store.transactionStatus.phase === `building` ? store.transactionStatus.core : store;
 var redoTransactionUpdate = (update, store) => {
-  store.logger.info(` \u23ED redo transaction "${update.key}" (redo)`);
+  store.logger.info(`\u23ED\uFE0F`, `transaction`, update.key, `Redo`);
   for (const { key, newValue } of update.atomUpdates) {
     const token = { key, type: `atom` };
     const state = withdraw(token, store);
@@ -523,7 +541,13 @@ var redoTransactionUpdate = (update, store) => {
   }
 };
 var undoTransactionUpdate = (update, store) => {
-  store.logger.info(` \u23EE undo transaction "${update.key}" (undo)`);
+  store.logger.info(
+    `\u23EE\uFE0F`,
+    `transaction`,
+    update.key,
+    `Undoing transaction update`,
+    update
+  );
   for (const { key, oldValue } of update.atomUpdates) {
     const token = { key, type: `atom` };
     const state = withdraw(token, store);
@@ -554,11 +578,16 @@ var addAtomToTimeline = (atomToken, tl, store = IMPLICIT.STORE) => {
     const currentTransactionKey = store.transactionStatus.phase === `applying` ? store.transactionStatus.key : null;
     const currentTransactionTime = store.transactionStatus.phase === `applying` ? store.transactionStatus.time : null;
     store.logger.info(
-      `\u23F3 timeline "${tl.key}" saw atom "${atomToken.key}" go (`,
+      `\u23F3`,
+      `timeline`,
+      tl.key,
+      `atom`,
+      atomToken.key,
+      `went`,
       update.oldValue,
       `->`,
       update.newValue,
-      currentTransactionKey ? `) in transaction "${currentTransactionKey}"` : currentSelectorKey ? `) in selector "${currentSelectorKey}"` : `)`
+      currentTransactionKey ? `in transaction "${currentTransactionKey}"` : currentSelectorKey ? `in selector "${currentSelectorKey}"` : ``
     );
     if (tl.timeTraveling === null) {
       if (tl.selectorTime && tl.selectorTime !== currentSelectorTime) {
@@ -582,7 +611,10 @@ var addAtomToTimeline = (atomToken, tl, store = IMPLICIT.STORE) => {
         if (tl.transactionKey !== currentTransactionKey) {
           if (tl.transactionKey) {
             store.logger.error(
-              `\u{1F41E} Timeline "${tl.key}" was unable to resolve transaction "${tl.transactionKey}. This is probably a bug.`
+              `\u{1F41E}`,
+              `timeline`,
+              tl.key,
+              `unable to resolve transaction "${tl.transactionKey}. This is probably a bug in AtomIO.`
             );
           }
           tl.transactionKey = currentTransactionKey;
@@ -622,7 +654,10 @@ var addAtomToTimeline = (atomToken, tl, store = IMPLICIT.STORE) => {
               }
               tl.transactionKey = null;
               store.logger.info(
-                `\u231B timeline "${tl.key}" got a transaction_update "${update2.key}"`
+                `\u231B`,
+                `timeline`,
+                tl.key,
+                `got a transaction_update "${update2.key}"`
               );
             }
           );
@@ -645,7 +680,10 @@ var addAtomToTimeline = (atomToken, tl, store = IMPLICIT.STORE) => {
           }
           tl.history.push(latestUpdate);
           store.logger.info(
-            `\u231B timeline "${tl.key}" got a selector_update "${currentSelectorKey}" with`,
+            `\u231B`,
+            `timeline`,
+            tl.key,
+            `got a selector_update "${currentSelectorKey}" with`,
             latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
           );
           tl.at = tl.history.length;
@@ -657,7 +695,10 @@ var addAtomToTimeline = (atomToken, tl, store = IMPLICIT.STORE) => {
               type: `atom_update`
             }, update));
             store.logger.info(
-              `\u231B timeline "${tl.key}" set selector_update "${currentSelectorKey}" to`,
+              `\u231B`,
+              `timeline`,
+              tl.key,
+              `set selector_update "${currentSelectorKey}" to`,
               latestUpdate == null ? void 0 : latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
             );
           }
@@ -689,7 +730,10 @@ var addAtomToTimeline = (atomToken, tl, store = IMPLICIT.STORE) => {
         }
         const willCapture = (_d = (_c = tl.shouldCapture) == null ? void 0 : _c.call(tl, atomUpdate, tl)) != null ? _d : true;
         store.logger.info(
-          `\u231B timeline "${tl.key}" got an atom_update to "${atom.key}"`
+          `\u231B`,
+          `timeline`,
+          tl.key,
+          `got an atom_update to "${atom.key}"`
         );
         if (willCapture) {
           tl.history.push(atomUpdate);
@@ -701,17 +745,23 @@ var addAtomToTimeline = (atomToken, tl, store = IMPLICIT.STORE) => {
   });
 };
 var redo__INTERNAL = (token, store = IMPLICIT.STORE) => {
-  store.logger.info(`\u23E9 redo "${token.key}"`);
+  store.logger.info(`\u23E9`, `timeline`, token.key, `redo`);
   const timelineData = store.timelines.get(token.key);
   if (!timelineData) {
     store.logger.error(
-      `\u{1F41E} Failed to redo on timeline "${token.key}". This timeline has not been initialized.`
+      `\u{1F41E}`,
+      `timeline`,
+      token.key,
+      `Failed to redo. This timeline has not been initialized.`
     );
     return;
   }
   if (timelineData.at === timelineData.history.length) {
     store.logger.warn(
-      `\u261D\uFE0F Failed to redo at the end of timeline "${token.key}". There is nothing to redo.`
+      `\u{1F481}`,
+      `timeline`,
+      token.key,
+      `Failed to redo at the end of timeline "${token.key}". There is nothing to redo.`
     );
     return;
   }
@@ -736,21 +786,30 @@ var redo__INTERNAL = (token, store = IMPLICIT.STORE) => {
   timelineData.subject.next(`redo`);
   timelineData.timeTraveling = null;
   store.logger.info(
-    `\u23F9\uFE0F "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
+    `\u23F9\uFE0F`,
+    `timeline`,
+    token.key,
+    `"${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
   );
 };
 var undo__INTERNAL = (token, store = IMPLICIT.STORE) => {
-  store.logger.info(`\u23EA undo "${token.key}"`);
+  store.logger.info(`\u23EA`, `timeline`, token.key, `undo`);
   const timelineData = store.timelines.get(token.key);
   if (!timelineData) {
     store.logger.error(
-      `\u{1F41E} Failed to undo on timeline "${token.key}". This timeline has not been initialized.`
+      `\u{1F41E}`,
+      `timeline`,
+      token.key,
+      `Failed to undo. This timeline has not been initialized.`
     );
     return;
   }
   if (timelineData.at === 0) {
     store.logger.warn(
-      `\u261D\uFE0F Failed to undo at the beginning of timeline "${token.key}". There is nothing to undo.`
+      `\u{1F481}`,
+      `timeline`,
+      token.key,
+      `Failed to undo at the beginning of timeline "${token.key}". There is nothing to undo.`
     );
     return;
   }
@@ -775,7 +834,10 @@ var undo__INTERNAL = (token, store = IMPLICIT.STORE) => {
   timelineData.subject.next(`undo`);
   timelineData.timeTraveling = null;
   store.logger.info(
-    `\u23F9\uFE0F "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
+    `\u23F9\uFE0F`,
+    `timeline`,
+    token.key,
+    `"${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
   );
 };
 
@@ -802,7 +864,10 @@ function timeline__INTERNAL(options, store = IMPLICIT.STORE, data = null) {
     const timelineKey = core.timelineAtoms.getRelatedKey(tokenOrFamily.key);
     if (timelineKey) {
       store.logger.error(
-        `\u274C Failed to add atom "${tokenOrFamily.key}" to timeline "${options.key}" because it belongs to timeline "${timelineKey}"`
+        `\u274C`,
+        `timeline`,
+        options.key,
+        `Failed to add atom "${tokenOrFamily.key}" because it already belongs to timeline "${timelineKey}"`
       );
       continue;
     }
@@ -824,7 +889,10 @@ function timeline__INTERNAL(options, store = IMPLICIT.STORE, data = null) {
         );
         if (familyTimelineKey) {
           store.logger.error(
-            `\u274C Failed to add atom "${token2.key}" to timeline "${options.key}" because its family "${token2.family.key}" belongs to timeline "${familyTimelineKey}"`
+            `\u274C`,
+            `timeline`,
+            options.key,
+            `Failed to add atom "${token2.key}" because its family "${token2.family.key}" already belongs to timeline "${familyTimelineKey}"`
           );
           continue;
         }
@@ -857,7 +925,12 @@ function withdraw(token, store) {
     core = store.transactionStatus.core;
     state = (_h = (_g = (_f = (_e = core.atoms.get(token.key)) != null ? _e : core.selectors.get(token.key)) != null ? _f : core.readonlySelectors.get(token.key)) != null ? _g : core.transactions.get(token.key)) != null ? _h : core.timelines.get(token.key);
     if (state) {
-      store.logger.info(`\u{1F6E0}\uFE0F add ${token.type} "${token.key}"`);
+      store.logger.info(
+        `\u{1F6E0}\uFE0F`,
+        token.type,
+        token.key,
+        `add ${token.type} "${token.key}"`
+      );
       switch (state.type) {
         case `atom`: {
           store.atoms.set(token.key, state);
@@ -896,7 +969,10 @@ function withdraw(token, store) {
 // src/store/withdraw-new-family-member.ts
 function withdrawNewFamilyMember(token, store) {
   store.logger.info(
-    `\u{1F46A} creating new family member "${token.key}" in store "${store.config.name}"`
+    `\u{1F46A}`,
+    token.type,
+    token.key,
+    `creating new family member in store "${store.config.name}"`
   );
   if (token.family) {
     const core = target(store);
@@ -926,9 +1002,9 @@ var cacheValue = (key, value, subject, store = IMPLICIT.STORE) => {
       }
       cacheValue(key, value2, subject, store);
       subject.next({ newValue: value2, oldValue: value2 });
-    }).catch((error) => {
-      if (error !== `canceled`) {
-        store.logger.error(`\u{1F645}\u200D\u2642\uFE0F Promised value for "${key}" rejected:`, error);
+    }).catch((thrown) => {
+      if (thrown !== `canceled`) {
+        store.logger.error(`\u{1F4A5}`, `state`, key, `rejected:`, thrown);
       }
     });
   } else {
@@ -947,7 +1023,7 @@ var evictCachedValue = (key, store = IMPLICIT.STORE) => {
     core.operation.prev.set(key, currentValue);
   }
   core.valueMap.delete(key);
-  store.logger.info(`\u{1F5D1} evicted "${key}"`);
+  store.logger.info(`\u{1F5D1}`, `state`, key, `evicted`);
 };
 var Tracker = class {
   constructor(mutableState, store = IMPLICIT.STORE) {
@@ -1068,7 +1144,10 @@ var Tracker = class {
 // src/mutable/create-mutable-atom.ts
 function createMutableAtom(options, store = IMPLICIT.STORE) {
   store.logger.info(
-    `\u{1F527} creating mutable atom "${options.key}" in store "${store.config.name}"`
+    `\u{1F527}`,
+    `atom`,
+    options.key,
+    `creating in store "${store.config.name}"`
   );
   const coreState = createAtom(options, void 0, store);
   new Tracker(coreState, store);
@@ -1076,10 +1155,6 @@ function createMutableAtom(options, store = IMPLICIT.STORE) {
   atom_io.subscribe(
     jsonState,
     () => {
-      store.logger.info(
-        `\u{1F50D} tracker-initializer:${store == null ? void 0 : store.config.name}:${store.transactionStatus.phase === `idle` ? `main` : store.transactionStatus.key}`,
-        `Initializing tracker for ${coreState.key}`
-      );
       const trackerHasBeenInitialized = target(store).trackers.has(coreState.key);
       if (!trackerHasBeenInitialized) {
         new Tracker(coreState, store);
@@ -1139,16 +1214,14 @@ var getSelectorDependencyKeys = (key, store) => {
 // src/get-state-internal.ts
 var getState__INTERNAL = (state, store = IMPLICIT.STORE) => {
   if (isValueCached(state.key, store)) {
-    store.logger.info(`\u{1F4D6} reading "${state.key}"`);
+    store.logger.info(`\u{1F4D6}`, state.type, state.key, `reading cached value`);
     return readCachedValue(state.key, store);
   }
   if (state.type !== `atom`) {
-    store.logger.info(`\u{1F9EE} calculating "${state.key}"`);
+    store.logger.info(`\u{1F9EE}`, state.type, state.key, `calculating value`);
     return state.get();
   }
-  store.logger.error(
-    `\u{1F41E} Attempted to get atom "${state.key}", which was never initialized in store "${store.config.name}".`
-  );
+  store.logger.error(`\u{1F41E}`, `atom`, state.key, `could not find cached value`);
   return state.default;
 };
 
@@ -1162,7 +1235,10 @@ var openOperation = (token, store) => {
   const core = target(store);
   if (core.operation.open) {
     store.logger.error(
-      `\u274C failed to setState to "${token.key}" during a setState for "${core.operation.token.key}"`
+      `\u274C`,
+      token.type,
+      token.key,
+      `failed to setState during a setState for "${core.operation.token.key}"`
     );
     return `rejection`;
   }
@@ -1174,19 +1250,32 @@ var openOperation = (token, store) => {
     token
   };
   store.logger.info(
-    `\u2B55 operation start from "${token.key}" in store "${store.config.name}"${store.transactionStatus.phase === `idle` ? `` : ` ${store.transactionStatus.phase} "${store.transactionStatus.key}"`}`
+    `\u2B55`,
+    token.type,
+    token.key,
+    `operation start in store "${store.config.name}"${store.transactionStatus.phase === `idle` ? `` : ` ${store.transactionStatus.phase} "${store.transactionStatus.key}"`}`
   );
 };
 var closeOperation = (store) => {
   const core = target(store);
+  if (core.operation.open) {
+    store.logger.info(
+      `\u{1F534}`,
+      core.operation.token.type,
+      core.operation.token.key,
+      `operation done in store "${store.config.name}"`
+    );
+  }
   core.operation = { open: false };
-  store.logger.info(`\u{1F534} operation done`);
   store.subject.operationStatus.next(core.operation);
 };
 var isDone = (key, store = IMPLICIT.STORE) => {
   const core = target(store);
   if (!core.operation.open) {
     store.logger.warn(
+      `\u{1F41E}`,
+      `unknown`,
+      key,
       `isDone called outside of an operation. This is probably a bug.`
     );
     return true;
@@ -1197,7 +1286,10 @@ var markDone = (key, store = IMPLICIT.STORE) => {
   const core = target(store);
   if (!core.operation.open) {
     store.logger.warn(
-      `\u{1F41E} markDone called outside of an operation. This is probably a bug.`
+      `\u{1F41E}`,
+      `unknown`,
+      key,
+      `markDone called outside of an operation. This is probably a bug.`
     );
     return;
   }
@@ -1209,7 +1301,7 @@ function copyMutableIfNeeded(atom, transform, origin, target2) {
   const originValue = origin.valueMap.get(atom.key);
   const targetValue = target2.valueMap.get(atom.key);
   if (originValue === targetValue) {
-    origin.logger.info(`\u{1F4C3} copying`, `${atom.key}`);
+    origin.logger.info(`\u{1F4C3}`, `atom`, `${atom.key}`, `copying`);
     const copiedValue = transform.fromJson(transform.toJson(originValue));
     target2.valueMap.set(atom.key, copiedValue);
     new Tracker(atom, origin);
@@ -1222,9 +1314,6 @@ function copyMutableIfNeeded(atom, transform, origin, target2) {
 function copyMutableIfWithinTransaction(atom, store) {
   if (store.transactionStatus.phase === `building` || store.transactionStatus.phase === `applying`) {
     if (`toJson` in atom && `fromJson` in atom) {
-      store.logger.info(
-        `\u{1F4C4} copyMutableIfWithinTransaction: ${atom.key} is mutable`
-      );
       const copiedValue = copyMutableIfNeeded(
         atom,
         atom,
@@ -1260,43 +1349,46 @@ function copyMutableFamilyMemberWithinTransaction(atom, family, origin, target2)
 
 // src/set-state/emit-update.ts
 var emitUpdate = (state, update, store) => {
-  const { key } = state;
   const { logger } = store;
   logger.info(
-    `\u{1F4E2} ${state.type} "${key}" went (`,
+    `\u{1F4E2}`,
+    state.type,
+    state.key,
+    `went (`,
     update.oldValue,
     `->`,
     update.newValue,
-    `)`
+    `) subscribers:`,
+    state.subject.subscribers
   );
-  logger.info(`\u{1F4E2} notifying subscribers:`, state.subject.subscribers);
   state.subject.next(update);
 };
 
 // src/set-state/evict-downstream.ts
-var evictDownStream = (state, store = IMPLICIT.STORE) => {
+var evictDownStream = (atom, store = IMPLICIT.STORE) => {
   var _a;
   const core = target(store);
-  const downstreamKeys = core.selectorAtoms.getRelatedKeys(state.key);
+  const downstreamKeys = core.selectorAtoms.getRelatedKeys(atom.key);
   store.logger.info(
-    `\u{1F9F9} evicting ${downstreamKeys == null ? void 0 : downstreamKeys.size} states downstream from ${state.type} "${state.key}":`,
+    `\u{1F9F9}`,
+    atom.type,
+    atom.key,
+    `evicting ${(_a = downstreamKeys == null ? void 0 : downstreamKeys.size) != null ? _a : 0} states downstream:`,
     downstreamKeys
   );
-  if (core.operation.open) {
-    store.logger.info(`\u{1F9F9}`, [...core.operation.done], `already done`);
-  }
-  if (downstreamKeys) {
+  if (downstreamKeys !== void 0) {
+    if (core.operation.open) {
+      store.logger.info(
+        `\u{1F9F9}`,
+        atom.type,
+        atom.key,
+        `[ ${[...core.operation.done].join(`, `)} ] already done`
+      );
+    }
     for (const key of downstreamKeys) {
       if (isDone(key, store)) {
         continue;
       }
-      const state2 = (_a = core.selectors.get(key)) != null ? _a : core.readonlySelectors.get(key);
-      if (!state2) {
-        store.logger.error(
-          `\u{1F41E} "${key}" was not found in selectors or readonlySelectors`
-        );
-        return;
-      }
       evictCachedValue(key, store);
       markDone(key, store);
     }
@@ -1316,8 +1408,11 @@ function shouldUpdateBeStowed(key, update) {
 var stowUpdate = (state, update, store) => {
   const { key } = state;
   if (store.transactionStatus.phase !== `building`) {
-    store.logger.warn(
-      `\u{1F41E} stowUpdate called outside of a transaction. This is probably a bug.`
+    store.logger.error(
+      `\u{1F41E}`,
+      `atom`,
+      key,
+      `stowUpdate called outside of a transaction. This is probably a bug.`
     );
     return;
   }
@@ -1331,7 +1426,10 @@ var stowUpdate = (state, update, store) => {
   }
   store.transactionStatus.atomUpdates.push(atomUpdate);
   store.logger.info(
-    `\u{1F4C1} ${key} stowed (`,
+    `\u{1F4C1}`,
+    `atom`,
+    key,
+    `stowed (`,
     update.oldValue,
     `->`,
     update.newValue,
@@ -1344,7 +1442,7 @@ var setAtom = (atom, next, store = IMPLICIT.STORE) => {
   const oldValue = getState__INTERNAL(atom, store);
   let newValue = copyMutableIfWithinTransaction(atom, store);
   newValue = become(next)(newValue);
-  store.logger.info(`\u{1F4DD} setting atom "${atom.key}" to`, newValue);
+  store.logger.info(`\u{1F4DD}`, `atom`, atom.key, `set to`, newValue);
   cacheValue(atom.key, newValue, atom.subject, store);
   if (isAtomDefault(atom.key, store)) {
     markAtomAsNotDefault(atom.key, store);
@@ -1410,13 +1508,18 @@ var updateSelectorAtoms = (selectorKey, dependency, store) => {
       atomKey: dependency.key
     });
     store.logger.info(
-      `\u{1F50D} selector "${selectorKey}" discovers root atom "${dependency.key}"`
+      `\u{1F50D}`,
+      `selector`,
+      selectorKey,
+      `discovers root atom "${dependency.key}"`
     );
   } else {
     const rootKeys = traceSelectorAtoms(selectorKey, dependency.key, store);
     store.logger.info(
-      `\u{1F50D} selector "${selectorKey}" discovers root atoms:`,
-      rootKeys.map((r) => r)
+      `\u{1F50D}`,
+      `selector`,
+      selectorKey,
+      `discovers root atoms: [ ${rootKeys.map((key) => `"${key}"`).join(`, `)} ]`
     );
     for (const atomKey of rootKeys) {
       core.selectorAtoms = core.selectorAtoms.set({
@@ -1440,7 +1543,12 @@ var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
     }
     const dependencyValue = getState__INTERNAL(dependencyState, store);
     store.logger.info(
-      `\u{1F50C} selector "${selectorKey}" registers dependency ( "${dependency.key}" = ${dependencyValue} )`
+      `\u{1F50C}`,
+      `selector`,
+      selectorKey,
+      `registers dependency ( "${dependency.key}" =`,
+      dependencyValue,
+      `)`
     );
     if (!alreadyRegistered) {
       core.selectorGraph = core.selectorGraph.set(
@@ -1479,7 +1587,16 @@ var createReadWriteSelector = (options, family, store, core) => {
   const setSelf = (next) => {
     const oldValue = getSelf();
     const newValue = become(next)(oldValue);
-    store.logger.info(`\u{1F4DD} set "${options.key}" (`, oldValue, `->`, newValue, `)`);
+    store.logger.info(
+      `\u{1F4DD}`,
+      `selector`,
+      options.key,
+      `set (`,
+      oldValue,
+      `->`,
+      newValue,
+      `)`
+    );
     cacheValue(options.key, newValue, subject, store);
     markDone(options.key, store);
     if (store.transactionStatus.phase === `idle`) {
@@ -1496,7 +1613,7 @@ var createReadWriteSelector = (options, family, store, core) => {
   }), family && { family });
   core.selectors.set(options.key, mySelector);
   const initialValue = getSelf();
-  store.logger.info(`\u2728 "${options.key}" =`, initialValue);
+  store.logger.info(`\u2728`, mySelector.type, mySelector.key, `=`, initialValue);
   const token = {
     key: options.key,
     type: `selector`
@@ -1525,7 +1642,13 @@ var createReadonlySelector = (options, family, store, core) => {
   }), family && { family });
   core.readonlySelectors.set(options.key, readonlySelector);
   const initialValue = getSelf();
-  store.logger.info(`\u2728 "${options.key}" =`, initialValue);
+  store.logger.info(
+    `\u2728`,
+    readonlySelector.type,
+    readonlySelector.key,
+    `=`,
+    initialValue
+  );
   const token = {
     key: options.key,
     type: `readonly_selector`
@@ -1544,9 +1667,10 @@ function createSelector(options, family, store = IMPLICIT.STORE) {
   const existingReadonly = core.readonlySelectors.get(options.key);
   if (existingWritable || existingReadonly) {
     store.logger.error(
-      `\u2753 Tried to create ${existingReadonly ? `readonly selector` : `selector`}`,
-      `"${options.key}", but it already exists in the store.`,
-      `(Ignore if you are in development using hot module replacement.)`
+      `\u274C`,
+      existingReadonly ? `readonly_selector` : `selector`,
+      options.key,
+      `Tried to create selector, but it already exists in the store. (Ignore if you are in development using hot module replacement.)`
     );
   }
   if (`set` in options) {
@@ -1728,14 +1852,19 @@ var isSelectorDefault = (key, store = IMPLICIT.STORE) => {
 function createAtom(options, family, store = IMPLICIT.STORE) {
   var _a;
   store.logger.info(
-    `\u{1F528} creating atom "${options.key}" in store "${store.config.name}"`
+    `\u{1F528}`,
+    `atom`,
+    options.key,
+    `creating in store "${store.config.name}"`
   );
   const core = target(store);
   const existing = core.atoms.get(options.key);
   if (existing) {
     store.logger.error(
-      `\u2753 Tried to create atom "${options.key}",`,
-      `but it already exists in the store.`,
+      `\u274C`,
+      `atom`,
+      options.key,
+      `Tried to create atom, but it already exists in the store.`,
       `(Ignore if you are in development using hot module replacement.)`
     );
     return deposit(existing);
@@ -1745,7 +1874,10 @@ function createAtom(options, family, store = IMPLICIT.STORE) {
     type: `atom`,
     install: (store2) => {
       store2.logger.info(
-        `\u{1F6E0}\uFE0F  installing atom "${options.key}" in store "${store2.config.name}"`
+        `\u{1F6E0}\uFE0F`,
+        `atom`,
+        options.key,
+        `installing in store "${store2.config.name}"`
       );
       return `mutable` in options ? createMutableAtom(options, store2) : createAtom(options, void 0, store2);
     },
@@ -1775,7 +1907,7 @@ function deleteAtom(atomToken, store = IMPLICIT.STORE) {
   core.selectorAtoms.delete(key);
   core.atomsThatAreDefault.delete(key);
   core.timelineAtoms.delete(key);
-  store.logger.info(`\u{1F525} Atom "${key}" deleted`);
+  store.logger.info(`\u{1F525}`, `atom`, `${key}`, `deleted`);
 }
 
 // src/subscribe/recall-state.ts
@@ -1783,7 +1915,10 @@ var recallState = (state, store = IMPLICIT.STORE) => {
   const core = target(store);
   if (!core.operation.open) {
     store.logger.warn(
-      `\u{1F41E}recall called outside of an operation. This is probably a bug.`
+      `\u{1F41E}`,
+      state.type,
+      state.key,
+      `recall called outside of an operation. This is probably a bug.`
     );
     return core.valueMap.get(state.key);
   }
@@ -1803,20 +1938,26 @@ var subscribeToRootAtoms = (state, store) => {
       `${state.type}:${state.key}`,
       (atomChange) => {
         store.logger.info(
-          `\u{1F4E2} selector "${state.key}" saw root "${atomKey}" go (`,
+          `\u{1F4E2}`,
+          state.type,
+          state.key,
+          `root`,
+          atomKey,
+          `went`,
           atomChange.oldValue,
           `->`,
-          atomChange.newValue,
-          `)`
+          atomChange.newValue
         );
         const oldValue = recallState(state, store);
         const newValue = getState__INTERNAL(state, store);
         store.logger.info(
-          `\u2728 "${state.key}" went (`,
+          `\u2728`,
+          state.type,
+          state.key,
+          `went`,
           oldValue,
           `->`,
-          newValue,
-          `)`
+          newValue
         );
         state.subject.next({ newValue, oldValue });
       }