atom.io 0.15.6 → 0.16.1

package/internal/dist/index.js

@@ -1,7 +1,7 @@
 import { Junction } from '../../dist/chunk-NYTGCPHB.js';
 import { __spreadValues, __spreadProps } from '../../dist/chunk-PZLG2HP3.js';
-import { selectJson, stringifyJson, parseJson, selectJsonFamily } from 'atom.io/json';
 import { AtomIOLogger, findInStore, getState, setState, runTransaction } from 'atom.io';
+import { selectJson, stringifyJson, parseJson, selectJsonFamily } from 'atom.io/json';
 import { withdraw as withdraw$1 } from 'atom.io/internal';
 
 // internal/src/lineage.ts
@@ -11,11 +11,214 @@ function newest(scion) {
   }
   return scion;
 }
-function eldest(scion) {
-  while (scion.parent !== null) {
-    scion = scion.parent;
+
+// internal/src/store/deposit.ts
+function deposit(state) {
+  const token = {
+    key: state.key,
+    type: state.type
+  };
+  if (`family` in state) {
+    token.family = state.family;
   }
-  return scion;
+  return token;
+}
+
+// internal/src/subject.ts
+var Subject = class {
+  constructor() {
+    this.subscribers = /* @__PURE__ */ new Map();
+  }
+  subscribe(key, subscriber) {
+    this.subscribers.set(key, subscriber);
+    const unsubscribe = () => this.unsubscribe(key);
+    return unsubscribe;
+  }
+  unsubscribe(key) {
+    this.subscribers.delete(key);
+  }
+  next(value) {
+    const subscribers = this.subscribers.values();
+    for (const subscriber of subscribers) {
+      subscriber(value);
+    }
+  }
+};
+var StatefulSubject = class extends Subject {
+  constructor(initialState) {
+    super();
+    this.state = initialState;
+  }
+  next(value) {
+    this.state = value;
+    super.next(value);
+  }
+};
+
+// internal/src/store/store.ts
+var Store = class {
+  constructor(name, store = null) {
+    this.parent = null;
+    this.child = null;
+    this.valueMap = /* @__PURE__ */ new Map();
+    this.atoms = /* @__PURE__ */ new Map();
+    this.selectors = /* @__PURE__ */ new Map();
+    this.readonlySelectors = /* @__PURE__ */ new Map();
+    this.trackers = /* @__PURE__ */ new Map();
+    this.families = /* @__PURE__ */ new Map();
+    this.timelines = /* @__PURE__ */ new Map();
+    this.transactions = /* @__PURE__ */ new Map();
+    this.atomsThatAreDefault = /* @__PURE__ */ new Set();
+    this.timelineAtoms = new Junction({
+      between: [`timelineKey`, `atomKey`],
+      cardinality: `1:n`
+    });
+    this.selectorAtoms = new Junction({
+      between: [`selectorKey`, `atomKey`],
+      cardinality: `n:n`
+    });
+    this.selectorGraph = new Junction(
+      {
+        between: [`upstreamSelectorKey`, `downstreamSelectorKey`],
+        cardinality: `n:n`
+      },
+      {
+        makeContentKey: (...keys) => keys.sort().join(`:`)
+      }
+    );
+    this.on = {
+      atomCreation: new Subject(),
+      selectorCreation: new Subject(),
+      transactionCreation: new Subject(),
+      timelineCreation: new Subject(),
+      transactionApplying: new StatefulSubject(null),
+      operationClose: new Subject()
+    };
+    this.operation = { open: false };
+    this.transactionMeta = null;
+    this.config = {
+      name: `IMPLICIT_STORE`
+    };
+    this.loggers = [
+      new AtomIOLogger(`warn`, (_, __, key) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`))
+    ];
+    this.logger = {
+      error: (...messages) => {
+        for (const logger of this.loggers)
+          logger.error(...messages);
+      },
+      info: (...messages) => {
+        for (const logger of this.loggers)
+          logger.info(...messages);
+      },
+      warn: (...messages) => {
+        for (const logger of this.loggers)
+          logger.warn(...messages);
+      }
+    };
+    if (store !== null) {
+      this.valueMap = new Map(store == null ? void 0 : store.valueMap);
+      this.operation = __spreadValues({}, store == null ? void 0 : store.operation);
+      this.transactionMeta = null;
+      this.config = __spreadProps(__spreadValues({}, store == null ? void 0 : store.config), {
+        name
+      });
+      for (const [, family] of store.families) {
+        family.install(this);
+      }
+      const mutableHelpers = /* @__PURE__ */ new Set();
+      for (const [, atom] of store.atoms) {
+        if (mutableHelpers.has(atom.key)) {
+          continue;
+        }
+        atom.install(this);
+        if (atom.type === `mutable_atom`) {
+          const originalJsonToken = getJsonToken(atom);
+          const originalUpdateToken = getUpdateToken(atom);
+          mutableHelpers.add(originalJsonToken.key);
+          mutableHelpers.add(originalUpdateToken.key);
+        }
+      }
+      for (const [, selector] of store.readonlySelectors) {
+        selector.install(this);
+      }
+      for (const [, selector] of store.selectors) {
+        if (mutableHelpers.has(selector.key)) {
+          continue;
+        }
+        selector.install(this);
+      }
+      for (const [, tx] of store.transactions) {
+        tx.install(this);
+      }
+      for (const [, timeline] of store.timelines) {
+        timeline.install(this);
+      }
+    }
+  }
+};
+var IMPLICIT = {
+  STORE_INTERNAL: void 0,
+  get STORE() {
+    var _a;
+    return (_a = this.STORE_INTERNAL) != null ? _a : this.STORE_INTERNAL = new Store(`IMPLICIT_STORE`);
+  }
+};
+var clearStore = (store) => {
+  const { config } = store;
+  Object.assign(store, new Store(config.name));
+  store.config = config;
+};
+
+// internal/src/store/withdraw.ts
+function withdraw(token, store) {
+  let withdrawn;
+  let target = store;
+  while (target !== null) {
+    switch (token.type) {
+      case `atom`:
+      case `mutable_atom`:
+        withdrawn = target.atoms.get(token.key);
+        break;
+      case `selector`:
+        withdrawn = target.selectors.get(token.key);
+        break;
+      case `readonly_selector`:
+        withdrawn = target.readonlySelectors.get(token.key);
+        break;
+      case `timeline`:
+        withdrawn = target.timelines.get(token.key);
+        break;
+      case `transaction`:
+        withdrawn = target.transactions.get(token.key);
+        break;
+    }
+    if (withdrawn) {
+      return withdrawn;
+    }
+    target = target.child;
+  }
+}
+
+// internal/src/store/withdraw-new-family-member.ts
+function withdrawNewFamilyMember(token, store) {
+  if (token.family) {
+    store.logger.info(
+      `\u{1F46A}`,
+      token.type,
+      token.key,
+      `creating new family member in store "${store.config.name}"`
+    );
+    const target = newest(store);
+    const family = target.families.get(token.family.key);
+    if (family) {
+      const jsonSubKey = JSON.parse(token.family.subKey);
+      family(jsonSubKey);
+      const state = withdraw(token, store);
+      return state;
+    }
+  }
+  return void 0;
 }
 
 // internal/src/future.ts
@@ -38,13 +241,13 @@ var Future = class extends Promise {
 };
 
 // internal/src/set-state/copy-mutable-if-needed.ts
-function copyMutableIfNeeded(atom, transform, origin, target) {
+function copyMutableIfNeeded(atom, origin, target) {
   const originValue = origin.valueMap.get(atom.key);
   const targetValue = target.valueMap.get(atom.key);
   if (originValue === targetValue) {
     origin.logger.info(`\u{1F4C3}`, `atom`, `${atom.key}`, `copying`);
-    const jsonValue = transform.toJson(originValue);
-    const copiedValue = transform.fromJson(jsonValue);
+    const jsonValue = atom.toJson(originValue);
+    const copiedValue = atom.fromJson(jsonValue);
     target.valueMap.set(atom.key, copiedValue);
     new Tracker(atom, origin);
     return copiedValue;
@@ -57,34 +260,13 @@ function copyMutableIfWithinTransaction(oldValue, atom, store) {
   const target = newest(store);
   const parent = target.parent;
   if (parent !== null) {
-    if (`family` in atom) {
-      const family = parent.families.get(atom.family.key);
-      if (family && family.type === `atom_family`) {
-        const result = copyMutableFamilyMemberWithinTransaction(
-          atom,
-          family,
-          parent,
-          target
-        );
-        if (result) {
-          return result;
-        }
-      }
-    }
-    if (`toJson` in atom && `fromJson` in atom) {
-      const copiedValue = copyMutableIfNeeded(atom, atom, parent, target);
+    if (atom.type === `mutable_atom`) {
+      const copiedValue = copyMutableIfNeeded(atom, parent, target);
       return copiedValue;
     }
   }
   return oldValue;
 }
-function copyMutableFamilyMemberWithinTransaction(atom, family, origin, target) {
-  if (`toJson` in family && `fromJson` in family) {
-    const copyCreated = copyMutableIfNeeded(atom, family, origin, target);
-    return copyCreated;
-  }
-  return null;
-}
 
 // internal/src/caching.ts
 function cacheValue(key, value, subject, target) {
@@ -136,7 +318,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`) {
+  if (state.type !== `atom` && state.type !== `mutable_atom`) {
     target.logger.info(`\u{1F9EE}`, state.type, state.key, `computing value`);
     return state.get();
   }
@@ -151,6 +333,11 @@ var readOrComputeValue = (state, target) => {
   return state.default instanceof Function ? state.default() : state.default;
 };
 
+// internal/src/set-state/become.ts
+var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
+  originalThing instanceof Function ? originalThing() : originalThing
+) : nextVersionOfThing;
+
 // internal/src/operation.ts
 var openOperation = (token, store) => {
   if (store.operation.open) {
@@ -213,42 +400,6 @@ var markDone = (key, store) => {
   store.operation.done.add(key);
 };
 
-// internal/src/set-state/become.ts
-var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
-  originalThing instanceof Function ? originalThing() : originalThing
-) : nextVersionOfThing;
-
-// internal/src/subject.ts
-var Subject = class {
-  constructor() {
-    this.subscribers = /* @__PURE__ */ new Map();
-  }
-  subscribe(key, subscriber) {
-    this.subscribers.set(key, subscriber);
-    const unsubscribe = () => this.unsubscribe(key);
-    return unsubscribe;
-  }
-  unsubscribe(key) {
-    this.subscribers.delete(key);
-  }
-  next(value) {
-    const subscribers = this.subscribers.values();
-    for (const subscriber of subscribers) {
-      subscriber(value);
-    }
-  }
-};
-var StatefulSubject = class extends Subject {
-  constructor(initialState) {
-    super();
-    this.state = initialState;
-  }
-  next(value) {
-    this.state = value;
-    super.next(value);
-  }
-};
-
 // internal/src/set-state/emit-update.ts
 var emitUpdate = (state, update, store) => {
   store.logger.info(
@@ -338,216 +489,42 @@ var stowUpdate = (state, update, store) => {
 };
 
 // internal/src/set-state/set-atom.ts
-var setAtom = (atom, next, target) => {
-  const oldValue = readOrComputeValue(atom, target);
-  let newValue = copyMutableIfWithinTransaction(oldValue, atom, target);
-  newValue = become(next)(newValue);
-  target.logger.info(`\u{1F4DD}`, `atom`, atom.key, `set to`, newValue);
-  newValue = cacheValue(atom.key, newValue, atom.subject, target);
-  if (isAtomDefault(atom.key, target)) {
-    markAtomAsNotDefault(atom.key, target);
-  }
-  markDone(atom.key, target);
-  evictDownStream(atom, target);
-  const update = { oldValue, newValue };
-  if (target.transactionMeta === null) {
-    emitUpdate(atom, update, target);
-  } else if (target.on.transactionApplying && target.parent) {
-    stowUpdate(atom, update, target);
-    if (atom.key.startsWith(`*`)) {
-      const mutableKey = atom.key.slice(1);
-      const mutable = target.valueMap.get(mutableKey);
-      mutable.do(update.newValue);
-    }
-  }
-};
-
-// internal/src/set-state/set-atom-or-selector.ts
-var setAtomOrSelector = (state, value, store) => {
-  switch (state.type) {
-    case `atom`:
-      setAtom(state, value, store);
-      break;
-    case `selector`:
-      state.set(value);
-      break;
-  }
-};
-
-// internal/src/store/deposit.ts
-function deposit(state) {
-  const token = {
-    key: state.key,
-    type: state.type
-  };
-  if (`family` in state) {
-    token.family = state.family;
-  }
-  return token;
-}
-var Store = class {
-  constructor(name, store = null) {
-    this.parent = null;
-    this.child = null;
-    this.valueMap = /* @__PURE__ */ new Map();
-    this.atoms = /* @__PURE__ */ new Map();
-    this.selectors = /* @__PURE__ */ new Map();
-    this.readonlySelectors = /* @__PURE__ */ new Map();
-    this.trackers = /* @__PURE__ */ new Map();
-    this.families = /* @__PURE__ */ new Map();
-    this.timelines = /* @__PURE__ */ new Map();
-    this.transactions = /* @__PURE__ */ new Map();
-    this.atomsThatAreDefault = /* @__PURE__ */ new Set();
-    this.timelineAtoms = new Junction({
-      between: [`timelineKey`, `atomKey`],
-      cardinality: `1:n`
-    });
-    this.selectorAtoms = new Junction({
-      between: [`selectorKey`, `atomKey`],
-      cardinality: `n:n`
-    });
-    this.selectorGraph = new Junction(
-      {
-        between: [`upstreamSelectorKey`, `downstreamSelectorKey`],
-        cardinality: `n:n`
-      },
-      {
-        makeContentKey: (...keys) => keys.sort().join(`:`)
-      }
-    );
-    this.on = {
-      atomCreation: new Subject(),
-      selectorCreation: new Subject(),
-      transactionCreation: new Subject(),
-      timelineCreation: new Subject(),
-      transactionApplying: new StatefulSubject(null),
-      operationClose: new Subject()
-    };
-    this.operation = { open: false };
-    this.transactionMeta = null;
-    this.config = {
-      name: `IMPLICIT_STORE`
-    };
-    this.loggers = [
-      new AtomIOLogger(`warn`, (_, __, key) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`))
-    ];
-    this.logger = {
-      error: (...messages) => {
-        for (const logger of this.loggers)
-          logger.error(...messages);
-      },
-      info: (...messages) => {
-        for (const logger of this.loggers)
-          logger.info(...messages);
-      },
-      warn: (...messages) => {
-        for (const logger of this.loggers)
-          logger.warn(...messages);
-      }
-    };
-    if (store !== null) {
-      this.valueMap = new Map(store == null ? void 0 : store.valueMap);
-      this.operation = __spreadValues({}, store == null ? void 0 : store.operation);
-      this.transactionMeta = (store == null ? void 0 : store.transactionMeta) ? __spreadValues({}, store == null ? void 0 : store.transactionMeta) : null;
-      this.config = __spreadProps(__spreadValues({}, store == null ? void 0 : store.config), {
-        name
-      });
-      for (const [, family] of store.families) {
-        family.install(this);
-      }
-      const mutableHelpers = /* @__PURE__ */ new Set();
-      for (const [, atom] of store.atoms) {
-        if (mutableHelpers.has(atom.key)) {
-          continue;
-        }
-        atom.install(this);
-        if (`mutable` in atom) {
-          const originalJsonToken = getJsonToken(atom);
-          const originalUpdateToken = getUpdateToken(atom);
-          mutableHelpers.add(originalJsonToken.key);
-          mutableHelpers.add(originalUpdateToken.key);
-        }
-      }
-      for (const [, selector] of store.readonlySelectors) {
-        selector.install(this);
-      }
-      for (const [, selector] of store.selectors) {
-        if (mutableHelpers.has(selector.key)) {
-          continue;
-        }
-        selector.install(this);
-      }
-      for (const [, tx] of store.transactions) {
-        tx.install(this);
-      }
-      for (const [, timeline] of store.timelines) {
-        timeline.install(this);
-      }
-    }
-  }
-};
-var IMPLICIT = {
-  STORE_INTERNAL: void 0,
-  get STORE() {
-    var _a;
-    return (_a = this.STORE_INTERNAL) != null ? _a : this.STORE_INTERNAL = new Store(`IMPLICIT_STORE`);
-  }
-};
-var clearStore = (store) => {
-  const { config } = store;
-  Object.assign(store, new Store(config.name));
-  store.config = config;
-};
-
-// internal/src/store/withdraw.ts
-function withdraw(token, store) {
-  let withdrawn;
-  let target = store;
-  while (target !== null) {
-    switch (token.type) {
-      case `atom`:
-        withdrawn = target.atoms.get(token.key);
-        break;
-      case `selector`:
-        withdrawn = target.selectors.get(token.key);
-        break;
-      case `readonly_selector`:
-        withdrawn = target.readonlySelectors.get(token.key);
-        break;
-      case `timeline`:
-        withdrawn = target.timelines.get(token.key);
-        break;
-      case `transaction`:
-        withdrawn = target.transactions.get(token.key);
-        break;
-    }
-    if (withdrawn) {
-      return withdrawn;
+var setAtom = (atom, next, target) => {
+  const oldValue = readOrComputeValue(atom, target);
+  let newValue = copyMutableIfWithinTransaction(oldValue, atom, target);
+  newValue = become(next)(newValue);
+  target.logger.info(`\u{1F4DD}`, `atom`, atom.key, `set to`, newValue);
+  newValue = cacheValue(atom.key, newValue, atom.subject, target);
+  if (isAtomDefault(atom.key, target)) {
+    markAtomAsNotDefault(atom.key, target);
+  }
+  markDone(atom.key, target);
+  evictDownStream(atom, target);
+  const update = { oldValue, newValue };
+  if (target.transactionMeta === null) {
+    emitUpdate(atom, update, target);
+  } else if (target.on.transactionApplying && target.parent) {
+    stowUpdate(atom, update, target);
+    if (atom.key.startsWith(`*`)) {
+      const mutableKey = atom.key.slice(1);
+      const mutable = target.valueMap.get(mutableKey);
+      mutable.do(update.newValue);
     }
-    target = target.child;
   }
-}
+};
 
-// internal/src/store/withdraw-new-family-member.ts
-function withdrawNewFamilyMember(token, store) {
-  if (token.family) {
-    store.logger.info(
-      `\u{1F46A}`,
-      token.type,
-      token.key,
-      `creating new family member in store "${store.config.name}"`
-    );
-    const target = newest(store);
-    const family = target.families.get(token.family.key);
-    if (family) {
-      const jsonSubKey = JSON.parse(token.family.subKey);
-      family(jsonSubKey);
-      const state = withdraw(token, store);
-      return state;
-    }
+// internal/src/set-state/set-atom-or-selector.ts
+var setAtomOrSelector = (state, value, store) => {
+  switch (state.type) {
+    case `atom`:
+    case `mutable_atom`:
+      setAtom(state, value, store);
+      break;
+    case `selector`:
+      state.set(value);
+      break;
   }
-  return void 0;
-}
+};
 
 // internal/src/keys.ts
 var isAtomKey = (key, store) => newest(store).atoms.has(key);
@@ -587,7 +564,8 @@ var traceSelectorAtoms = (selectorKey, directDependencyKey, store) => {
   }
   return rootKeys;
 };
-var traceAllSelectorAtoms = (selectorKey, store) => {
+var traceAllSelectorAtoms = (selector, store) => {
+  const selectorKey = selector.key;
   const directDependencyKeys = getSelectorDependencyKeys(selectorKey, store);
   return directDependencyKeys.flatMap(
     (depKey) => isAtomKey(depKey, store) ? depKey : traceSelectorAtoms(selectorKey, depKey, store)
@@ -597,7 +575,7 @@ var traceAllSelectorAtoms = (selectorKey, store) => {
 // internal/src/selector/update-selector-atoms.ts
 var updateSelectorAtoms = (selectorKey, dependency, store) => {
   const target = newest(store);
-  if (dependency.type === `atom`) {
+  if (dependency.type === `atom` || dependency.type === `mutable_atom`) {
     target.selectorAtoms.set({
       selectorKey,
       atomKey: dependency.key
@@ -668,11 +646,47 @@ var registerSelector = (selectorKey, store) => ({
   find: (token, key) => findInStore(token, key, store)
 });
 
-// internal/src/selector/create-read-write-selector.ts
-var createReadWriteSelector = (options, family, store) => {
+// internal/src/selector/create-readonly-selector.ts
+var createReadonlySelector = (options, family, store) => {
+  const target = newest(store);
+  const subject = new Subject();
+  const { get, find } = registerSelector(options.key, target);
+  const getSelf = () => {
+    const value = options.get({ get, find });
+    cacheValue(options.key, value, subject, newest(store));
+    return value;
+  };
+  const readonlySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
+    subject,
+    install: (s) => createReadonlySelector(options, family, s),
+    get: getSelf,
+    type: `readonly_selector`
+  }), family && { family });
+  target.readonlySelectors.set(options.key, readonlySelector);
+  const initialValue = getSelf();
+  store.logger.info(
+    `\u2728`,
+    readonlySelector.type,
+    readonlySelector.key,
+    `=`,
+    initialValue
+  );
+  const token = {
+    key: options.key,
+    type: `readonly_selector`
+  };
+  if (family) {
+    token.family = family;
+  }
+  store.on.selectorCreation.next(token);
+  return token;
+};
+
+// internal/src/selector/create-writable-selector.ts
+var createWritableSelector = (options, family, store) => {
   const target = newest(store);
   const subject = new Subject();
-  const transactors = registerSelector(options.key, store);
+  const transactors = registerSelector(options.key, target);
   const { find, get } = transactors;
   const readonlyTransactors = { find, get };
   const getSelf = () => {
@@ -702,7 +716,7 @@ var createReadWriteSelector = (options, family, store) => {
   };
   const mySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
     subject,
-    install: (s) => createSelector(options, family, s),
+    install: (s) => createWritableSelector(options, family, s),
     get: getSelf,
     set: setSelf,
     type: `selector`
@@ -721,59 +735,13 @@ var createReadWriteSelector = (options, family, store) => {
   return token;
 };
 
-// internal/src/selector/create-readonly-selector.ts
-var createReadonlySelector = (options, family, store) => {
-  const target = newest(store);
-  const subject = new Subject();
-  const { get, find } = registerSelector(options.key, store);
-  const getSelf = () => {
-    const value = options.get({ get, find });
-    cacheValue(options.key, value, subject, store);
-    return value;
-  };
-  const readonlySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
-    subject,
-    install: (s) => createSelector(options, family, s),
-    get: getSelf,
-    type: `readonly_selector`
-  }), family && { family });
-  target.readonlySelectors.set(options.key, readonlySelector);
-  const initialValue = getSelf();
-  store.logger.info(
-    `\u2728`,
-    readonlySelector.type,
-    readonlySelector.key,
-    `=`,
-    initialValue
-  );
-  const token = {
-    key: options.key,
-    type: `readonly_selector`
-  };
-  if (family) {
-    token.family = family;
-  }
-  store.on.selectorCreation.next(token);
-  return token;
-};
-
-// internal/src/selector/create-selector.ts
-function createSelector(options, family, store) {
-  const target = newest(store);
-  const existingWritable = target.selectors.get(options.key);
-  const existingReadonly = target.readonlySelectors.get(options.key);
-  if (existingWritable || existingReadonly) {
-    store.logger.error(
-      `\u274C`,
-      existingReadonly ? `readonly_selector` : `selector`,
-      options.key,
-      `Tried to create selector, but it already exists in the store.`
-    );
+// internal/src/selector/create-standalone-selector.ts
+function createStandaloneSelector(options, store) {
+  const isWritable = `set` in options;
+  if (isWritable) {
+    return createWritableSelector(options, void 0, store);
   }
-  if (`set` in options) {
-    return createReadWriteSelector(options, family, store);
-  }
-  return createReadonlySelector(options, family, store);
+  return createReadonlySelector(options, void 0, store);
 }
 
 // internal/src/selector/delete-selector.ts
@@ -815,44 +783,46 @@ var recallState = (state, store) => {
 };
 
 // internal/src/subscribe/subscribe-to-root-atoms.ts
-var subscribeToRootAtoms = (state, store) => {
+var subscribeToRootAtoms = (selector, store) => {
   const target = newest(store);
-  const dependencySubscriptions = `default` in state ? null : traceAllSelectorAtoms(state.key, store).map((atomKey) => {
-    const atom = target.atoms.get(atomKey);
-    if (atom === void 0) {
-      throw new Error(
-        `Atom "${atomKey}", a dependency of selector "${state.key}", not found in store "${store.config.name}".`
-      );
-    }
-    return atom.subject.subscribe(
-      `${state.type}:${state.key}`,
-      (atomChange) => {
-        store.logger.info(
-          `\u{1F4E2}`,
-          state.type,
-          state.key,
-          `root`,
-          atomKey,
-          `went`,
-          atomChange.oldValue,
-          `->`,
-          atomChange.newValue
-        );
-        const oldValue = recallState(state, target);
-        const newValue = readOrComputeValue(state, target);
-        store.logger.info(
-          `\u2728`,
-          state.type,
-          state.key,
-          `went`,
-          oldValue,
-          `->`,
-          newValue
+  const dependencySubscriptions = traceAllSelectorAtoms(selector, store).map(
+    (atomKey) => {
+      const atom = target.atoms.get(atomKey);
+      if (atom === void 0) {
+        throw new Error(
+          `Atom "${atomKey}", a dependency of selector "${selector.key}", not found in store "${store.config.name}".`
         );
-        state.subject.next({ newValue, oldValue });
       }
-    );
-  });
+      return atom.subject.subscribe(
+        `${selector.type}:${selector.key}`,
+        (atomChange) => {
+          store.logger.info(
+            `\u{1F4E2}`,
+            selector.type,
+            selector.key,
+            `root`,
+            atomKey,
+            `went`,
+            atomChange.oldValue,
+            `->`,
+            atomChange.newValue
+          );
+          const oldValue = recallState(selector, target);
+          const newValue = readOrComputeValue(selector, target);
+          store.logger.info(
+            `\u2728`,
+            selector.type,
+            selector.key,
+            `went`,
+            oldValue,
+            `->`,
+            newValue
+          );
+          selector.subject.next({ newValue, oldValue });
+        }
+      );
+    }
+  );
   return dependencySubscriptions;
 };
 
@@ -867,7 +837,7 @@ function subscribeToState(token, handleUpdate, key, store) {
   }
   const unsubFunction = state.subject.subscribe(key, handleUpdate);
   store.logger.info(`\u{1F440}`, state.type, state.key, `Adding subscription "${key}"`);
-  const dependencyUnsubFunctions = state.type !== `atom` ? subscribeToRootAtoms(state, store) : null;
+  const dependencyUnsubFunctions = state.type !== `atom` && state.type !== `mutable_atom` ? subscribeToRootAtoms(state, store) : null;
   const unsubscribe = dependencyUnsubFunctions === null ? () => {
     store.logger.info(
       `\u{1F648}`,
@@ -1078,27 +1048,67 @@ var Tracker = class {
 // internal/src/mutable/create-mutable-atom.ts
 function createMutableAtom(options, family, store) {
   store.logger.info(
-    `\u{1F527}`,
+    `\u{1F528}`,
     `atom`,
     options.key,
     `creating in store "${store.config.name}"`
   );
-  const coreState = createRegularAtom(options, family, store);
-  new Tracker(coreState, store);
-  const jsonState = selectJson(coreState, options, store);
   const target = newest(store);
-  subscribeToState(
-    jsonState,
-    () => {
-      const trackerHasBeenInitialized = newest(store).trackers.has(coreState.key);
-      if (!trackerHasBeenInitialized) {
-        new Tracker(coreState, store);
-      }
+  const existing = target.atoms.get(options.key);
+  if (existing && existing.type === `mutable_atom`) {
+    store.logger.error(
+      `\u274C`,
+      `atom`,
+      options.key,
+      `Tried to create atom, but it already exists in the store.`
+    );
+    return deposit(existing);
+  }
+  const subject = new Subject();
+  const newAtom = __spreadProps(__spreadValues({}, options), {
+    type: `mutable_atom`,
+    install: (store2) => {
+      store2.logger.info(
+        `\u{1F6E0}\uFE0F`,
+        `atom`,
+        options.key,
+        `installing in store "${store2.config.name}"`
+      );
+      return createMutableAtom(options, family, store2);
     },
-    `tracker-initializer:${store == null ? void 0 : store.config.name}:${target.transactionMeta === null ? `main` : `${target.transactionMeta.update.key}`}`,
-    store
-  );
-  return coreState;
+    subject
+  });
+  if (family) {
+    newAtom.family = family;
+  }
+  const initialValue = options.default();
+  target.atoms.set(newAtom.key, newAtom);
+  markAtomAsDefault(options.key, store);
+  cacheValue(options.key, initialValue, subject, target);
+  const token = deposit(newAtom);
+  if (options.effects) {
+    let effectIndex = 0;
+    const cleanupFunctions = [];
+    for (const effect of options.effects) {
+      const cleanup = effect({
+        setSelf: (next) => setState(token, next, store),
+        onSet: (handle) => subscribeToState(token, handle, `effect[${effectIndex}]`, store)
+      });
+      if (cleanup) {
+        cleanupFunctions.push(cleanup);
+      }
+      ++effectIndex;
+    }
+    newAtom.cleanup = () => {
+      for (const cleanup of cleanupFunctions) {
+        cleanup();
+      }
+    };
+  }
+  new Tracker(token, store);
+  selectJson(token, options, store);
+  store.on.atomCreation.next(token);
+  return token;
 }
 function createRegularAtomFamily(options, store) {
   const subject = new Subject();
@@ -1119,16 +1129,7 @@ function createRegularAtomFamily(options, store) {
         if (options.effects) {
           individualOptions.effects = options.effects(key);
         }
-        if (`mutable` in options) {
-          const mutableOptions = __spreadProps(__spreadValues({}, individualOptions), {
-            mutable: true,
-            toJson: options.toJson,
-            fromJson: options.fromJson
-          });
-          token = createMutableAtom(mutableOptions, family, store);
-        } else {
-          token = createRegularAtom(individualOptions, family, store);
-        }
+        token = createRegularAtom(individualOptions, family, store);
         subject.next(token);
       }
       return token;
@@ -1140,9 +1141,6 @@ function createRegularAtomFamily(options, store) {
       install: (store2) => createRegularAtomFamily(options, store2)
     }
   );
-  if (`mutable` in options && typeof options.mutable === `boolean`) {
-    Object.assign(atomFamily, { mutable: options.mutable });
-  }
   const target = newest(store);
   target.families.set(options.key, atomFamily);
   return atomFamily;
@@ -1150,7 +1148,8 @@ function createRegularAtomFamily(options, store) {
 
 // internal/src/families/create-atom-family.ts
 function createAtomFamily(options, store) {
-  if (`mutable` in options) {
+  const isMutable2 = `mutable` in options;
+  if (isMutable2) {
     return createMutableAtomFamily(options, store);
   }
   return createRegularAtomFamily(options, store);
@@ -1167,7 +1166,7 @@ function createReadonlySelectorFamily(options, store) {
       if (existing) {
         return deposit(existing);
       }
-      return createSelector(
+      return createReadonlySelector(
         {
           key: fullKey,
           get: options.get(key)
@@ -1186,23 +1185,18 @@ function createReadonlySelectorFamily(options, store) {
   store.families.set(options.key, readonlySelectorFamily);
   return readonlySelectorFamily;
 }
-function createSelectorFamily(options, store) {
-  const isReadonly = !(`set` in options);
-  if (isReadonly) {
-    return createReadonlySelectorFamily(options, store);
-  }
-  const target = newest(store);
+function createWritableSelectorFamily(options, store) {
   const subject = new Subject();
   const selectorFamily = Object.assign(
     (key) => {
       const subKey = stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
-      const existing = target.selectors.get(fullKey);
+      const existing = store.selectors.get(fullKey);
       if (existing) {
         return deposit(existing);
       }
-      const token = createSelector(
+      const token = createWritableSelector(
         {
           key: fullKey,
           get: options.get(key),
@@ -1218,13 +1212,22 @@ function createSelectorFamily(options, store) {
       key: options.key,
       type: `selector_family`,
       subject,
-      install: (store2) => createSelectorFamily(options, store2)
+      install: (store2) => createWritableSelectorFamily(options, store2)
     }
   );
-  target.families.set(options.key, selectorFamily);
+  store.families.set(options.key, selectorFamily);
   return selectorFamily;
 }
 
+// internal/src/families/create-selector-family.ts
+function createSelectorFamily(options, store) {
+  const isWritable = `set` in options;
+  if (isWritable) {
+    return createWritableSelectorFamily(options, store);
+  }
+  return createReadonlySelectorFamily(options, store);
+}
+
 // internal/src/mutable/tracker-family.ts
 var FamilyTracker = class {
   constructor(findMutableState, store) {
@@ -1261,29 +1264,63 @@ var FamilyTracker = class {
 
 // internal/src/mutable/create-mutable-atom-family.ts
 function createMutableAtomFamily(options, store) {
-  const coreFamily = Object.assign(
-    createRegularAtomFamily(options, store),
-    options
+  const subject = new Subject();
+  const atomFamily = Object.assign(
+    (key) => {
+      const subKey = stringifyJson(key);
+      const family = { key: options.key, subKey };
+      const fullKey = `${options.key}(${subKey})`;
+      const existing = withdraw({ key: fullKey, type: `mutable_atom` }, store);
+      let token;
+      if (existing) {
+        token = deposit(existing);
+      } else {
+        const individualOptions = {
+          key: fullKey,
+          default: () => options.default(key),
+          toJson: options.toJson,
+          fromJson: options.fromJson,
+          mutable: true
+        };
+        if (options.effects) {
+          individualOptions.effects = options.effects(key);
+        }
+        token = createMutableAtom(individualOptions, family, store);
+        subject.next(token);
+      }
+      return token;
+    },
+    {
+      key: options.key,
+      type: `mutable_atom_family`,
+      subject,
+      install: (store2) => createMutableAtomFamily(options, store2),
+      toJson: options.toJson,
+      fromJson: options.fromJson
+    }
   );
-  selectJsonFamily(coreFamily, options);
-  new FamilyTracker(coreFamily, store);
-  return coreFamily;
+  const target = newest(store);
+  target.families.set(options.key, atomFamily);
+  selectJsonFamily(atomFamily, options, store);
+  new FamilyTracker(atomFamily, store);
+  return atomFamily;
 }
 
 // internal/src/mutable/get-json-family.ts
 var getJsonFamily = (mutableAtomFamily, store) => {
   const target = newest(store);
   const key = `${mutableAtomFamily.key}:JSON`;
-  const jsonFamily = target.families.get(
-    key
-  );
+  const jsonFamily = target.families.get(key);
   return jsonFamily;
 };
 
 // internal/src/mutable/get-json-token.ts
 var getJsonToken = (mutableAtomToken) => {
   const key = mutableAtomToken.family ? `${mutableAtomToken.family.key}:JSON(${mutableAtomToken.family.subKey})` : `${mutableAtomToken.key}:JSON`;
-  const jsonToken = { type: `selector`, key };
+  const jsonToken = {
+    type: `selector`,
+    key
+  };
   if (mutableAtomToken.family) {
     jsonToken.family = {
       key: `${mutableAtomToken.family.key}:JSON`,
@@ -1306,13 +1343,10 @@ var getUpdateToken = (mutableAtomToken) => {
   return updateToken;
 };
 
-// internal/src/mutable/get-update-family.ts
-var getUpdateFamily = (mutableAtomFamily, store) => {
-  const target = newest(store);
-  const key = `*${mutableAtomFamily.key}`;
-  const updateFamily = target.families.get(key);
-  return updateFamily;
-};
+// internal/src/mutable/is-mutable.ts
+function isMutable(atomOrTokenOrFamily) {
+  return atomOrTokenOrFamily.type === `mutable_atom` || atomOrTokenOrFamily.type === `mutable_atom_family`;
+}
 
 // internal/src/mutable/transceiver.ts
 function isTransceiver(value) {
@@ -1344,7 +1378,7 @@ function createRegularAtom(options, family, store) {
   );
   const target = newest(store);
   const existing = target.atoms.get(options.key);
-  if (existing) {
+  if (existing && existing.type === `atom`) {
     store.logger.error(
       `\u274C`,
       `atom`,
@@ -1363,7 +1397,7 @@ function createRegularAtom(options, family, store) {
         options.key,
         `installing in store "${store2.config.name}"`
       );
-      return `mutable` in options ? createMutableAtom(options, family, store2) : createRegularAtom(options, family, store2);
+      return createRegularAtom(options, family, store2);
     },
     subject
   });
@@ -1401,12 +1435,13 @@ function createRegularAtom(options, family, store) {
   return token;
 }
 
-// internal/src/atom/create-atom.ts
-function createAtom(options, family, store) {
-  if (`mutable` in options) {
-    return createMutableAtom(options, family, store);
+// internal/src/atom/create-standalone-atom.ts
+function createStandaloneAtom(options, store) {
+  const isMutable2 = `mutable` in options;
+  if (isMutable2) {
+    return createMutableAtom(options, void 0, store);
   }
-  return createRegularAtom(options, family, store);
+  return createRegularAtom(options, void 0, store);
 }
 
 // internal/src/atom/delete-atom.ts
@@ -1527,9 +1562,8 @@ var NotFoundError = class extends Error {
 // internal/src/timeline/add-atom-to-timeline.ts
 var addAtomToTimeline = (atomToken, tl, store) => {
   let maybeAtom = withdraw(atomToken, store);
-  if (maybeAtom == null ? void 0 : maybeAtom.mutable) {
-    console.log(`adding transceiver to timeline`, atomToken.key);
-    const updateToken = getUpdateToken(atomToken);
+  if ((maybeAtom == null ? void 0 : maybeAtom.type) === `mutable_atom`) {
+    const updateToken = getUpdateToken(maybeAtom);
     maybeAtom = withdraw(updateToken, store);
   }
   const atom = maybeAtom;
@@ -1538,6 +1572,7 @@ var addAtomToTimeline = (atomToken, tl, store) => {
       `Cannot subscribe to atom "${atomToken.key}" because it has not been initialized in store "${store.config.name}"`
     );
   }
+  store.timelineAtoms.set({ atomKey: atom.key, timelineKey: tl.key });
   atom.subject.subscribe(`timeline`, (update) => {
     var _a, _b, _c, _d, _e, _f;
     const target = newest(store);
@@ -1722,14 +1757,6 @@ var addAtomToTimeline = (atomToken, tl, store) => {
   });
 };
 
-// internal/src/mutable/is-mutable.ts
-function isMutable(atomOrTokenOrFamily) {
-  if (`mutable` in atomOrTokenOrFamily) {
-    return atomOrTokenOrFamily.mutable;
-  }
-  return false;
-}
-
 // internal/src/timeline/create-timeline.ts
 function createTimeline(options, store, data) {
   var _a, _b;
@@ -1752,27 +1779,15 @@ function createTimeline(options, store, data) {
   const target = newest(store);
   for (const tokenOrFamily of options.atoms) {
     let atomKey = tokenOrFamily.key;
-    const existingTimelineKey = target.timelineAtoms.getRelatedKey(atomKey);
-    if (existingTimelineKey) {
-      store.logger.error(
-        `\u274C`,
-        `timeline`,
-        options.key,
-        `Failed to add atom "${atomKey}" because it already belongs to timeline "${existingTimelineKey}"`
-      );
-      continue;
-    }
-    if (tokenOrFamily.type === `atom_family`) {
-      let family = tokenOrFamily;
-      if (isMutable(family)) {
-        family = getUpdateFamily(family, store);
-        atomKey = family.key;
-      }
+    if (tokenOrFamily.type === `atom_family` || tokenOrFamily.type === `mutable_atom_family`) {
+      const family = tokenOrFamily;
+      const familyKey = family.key;
+      target.timelineAtoms.set({ atomKey: familyKey, timelineKey });
       family.subject.subscribe(`timeline:${options.key}`, (token2) => {
         addAtomToTimeline(token2, tl, store);
       });
       for (const atom of target.atoms.values()) {
-        if (((_b = atom.family) == null ? void 0 : _b.key) === family.key) {
+        if (((_b = atom.family) == null ? void 0 : _b.key) === familyKey) {
           addAtomToTimeline(atom, tl, store);
         }
       }
@@ -1815,9 +1830,18 @@ function createTimeline(options, store, data) {
           continue;
         }
       }
+      const existingTimelineKey = target.timelineAtoms.getRelatedKey(atomKey);
+      if (existingTimelineKey) {
+        store.logger.error(
+          `\u274C`,
+          `timeline`,
+          options.key,
+          `Failed to add atom "${atomKey}" because it already belongs to timeline "${existingTimelineKey}"`
+        );
+        continue;
+      }
       addAtomToTimeline(atom, tl, store);
     }
-    target.timelineAtoms.set({ atomKey, timelineKey });
   }
   store.timelines.set(options.key, tl);
   const token = {
@@ -2059,6 +2083,6 @@ function createTransaction(options, store) {
 // internal/src/transaction/index.ts
 var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
 
-export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelector, createSelectorFamily, createTimeline, createTransaction, deleteAtom, deleteSelector, deposit, eldest, evictCachedValue, getEnvironmentData, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isDone, isReadonlySelectorKey, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
+export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deleteAtom, deleteSelector, deposit, evictCachedValue, getEnvironmentData, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isDone, isMutable, isReadonlySelectorKey, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map