atom.io 0.15.6 → 0.16.0

package/internal/dist/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-var json = require('atom.io/json');
 var atom_io = require('atom.io');
+var json = require('atom.io/json');
 var internal = require('atom.io/internal');
 
 var __defProp = Object.defineProperty;
@@ -31,213 +31,277 @@ 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/future.ts
-var Future = class extends Promise {
-  constructor(executor) {
-    super((resolve, reject) => {
-      const pass = (value) => this.isCanceled ? reject(`canceled`) : resolve(value);
-      const fail = (reason) => this.isCanceled ? reject(`canceled`) : reject(reason);
-      if (typeof executor === `function`) {
-        executor(pass, fail);
-      } else {
-        executor.then(pass, fail);
+// ../rel8/junction/src/junction.ts
+var Junction = class {
+  constructor(data, config) {
+    this.relations = /* @__PURE__ */ new Map();
+    this.contents = /* @__PURE__ */ new Map();
+    this.makeContentKey = (a, b) => `${a}:${b}`;
+    var _a, _b, _c, _d;
+    this.a = data.between[0];
+    this.b = data.between[1];
+    this.cardinality = data.cardinality;
+    if (!(config == null ? void 0 : config.externalStore)) {
+      this.relations = new Map((_a = data.relations) == null ? void 0 : _a.map(([a, b]) => [a, new Set(b)]));
+      this.contents = new Map(data.contents);
+    }
+    this.isContent = (_b = config == null ? void 0 : config.isContent) != null ? _b : null;
+    if (config == null ? void 0 : config.makeContentKey) {
+      this.makeContentKey = config.makeContentKey;
+    }
+    if (config == null ? void 0 : config.externalStore) {
+      const externalStore = config.externalStore;
+      this.has = (a, b) => externalStore.has(a, b);
+      this.addRelation = (a, b) => {
+        externalStore.addRelation(a, b);
+      };
+      this.deleteRelation = (a, b) => {
+        externalStore.deleteRelation(a, b);
+      };
+      this.replaceRelationsSafely = (a, bs) => {
+        externalStore.replaceRelationsSafely(a, bs);
+      };
+      this.replaceRelationsUnsafely = (a, bs) => {
+        externalStore.replaceRelationsUnsafely(a, bs);
+      };
+      this.getRelatedKeys = (key) => externalStore.getRelatedKeys(key);
+      if (externalStore.getContent) {
+        this.getContentInternal = (contentKey) => {
+          return externalStore.getContent(contentKey);
+        };
+        this.setContent = (contentKey, content) => {
+          externalStore.setContent(contentKey, content);
+        };
+        this.deleteContent = (contentKey) => {
+          externalStore.deleteContent(contentKey);
+        };
       }
-    });
-    this.isCanceled = false;
+      for (const [x, ys] of (_c = data.relations) != null ? _c : []) {
+        for (const y of ys)
+          this.addRelation(x, y);
+      }
+      for (const [contentKey, content] of (_d = data.contents) != null ? _d : []) {
+        this.setContent(contentKey, content);
+      }
+    }
   }
-  cancel() {
-    this.isCanceled = true;
+  getRelatedKeys(key) {
+    return this.relations.get(key);
   }
-};
-
-// internal/src/set-state/copy-mutable-if-needed.ts
-function copyMutableIfNeeded(atom, transform, 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);
-    target.valueMap.set(atom.key, copiedValue);
-    new Tracker(atom, origin);
-    return copiedValue;
+  addRelation(a, b) {
+    let aRelations = this.relations.get(a);
+    let bRelations = this.relations.get(b);
+    if (aRelations) {
+      aRelations.add(b);
+    } else {
+      aRelations = /* @__PURE__ */ new Set([b]);
+      this.relations.set(a, aRelations);
+    }
+    if (bRelations) {
+      bRelations.add(a);
+    } else {
+      bRelations = /* @__PURE__ */ new Set([a]);
+      this.relations.set(b, bRelations);
+    }
   }
-  return targetValue;
-}
-
-// internal/src/set-state/copy-mutable-in-transaction.ts
-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;
+  deleteRelation(a, b) {
+    const aRelations = this.relations.get(a);
+    if (aRelations) {
+      aRelations.delete(b);
+      if (aRelations.size === 0) {
+        this.relations.delete(a);
+      }
+      const bRelations = this.relations.get(b);
+      if (bRelations) {
+        bRelations.delete(a);
+        if (bRelations.size === 0) {
+          this.relations.delete(b);
         }
       }
     }
-    if (`toJson` in atom && `fromJson` in atom) {
-      const copiedValue = copyMutableIfNeeded(atom, 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) {
-  const currentValue = target.valueMap.get(key);
-  if (currentValue instanceof Future) {
-    currentValue.cancel();
+  replaceRelationsUnsafely(a, bs) {
+    this.relations.set(a, new Set(bs));
+    for (const b of bs) {
+      const bRelations = /* @__PURE__ */ new Set([a]);
+      this.relations.set(b, bRelations);
+    }
   }
-  if (value instanceof Promise) {
-    const future = new Future(value);
-    target.valueMap.set(key, future);
-    future.then((resolved) => {
-      if (future.isCanceled) {
-        return;
+  replaceRelationsSafely(a, bs) {
+    const aRelationsPrev = this.relations.get(a);
+    if (aRelationsPrev) {
+      for (const b of aRelationsPrev) {
+        const bRelations = this.relations.get(b);
+        if (bRelations) {
+          if (bRelations.size === 1) {
+            this.relations.delete(b);
+          } else {
+            bRelations.delete(a);
+          }
+          this.contents.delete(this.makeContentKey(a, b));
+        }
       }
-      cacheValue(key, resolved, subject, target);
-      subject.next({ newValue: resolved, oldValue: future });
-    }).catch((thrown) => {
-      if (thrown !== `canceled`) {
-        target.logger.error(`\u{1F4A5}`, `state`, key, `rejected:`, thrown);
+    }
+    this.relations.set(a, new Set(bs));
+    for (const b of bs) {
+      let bRelations = this.relations.get(b);
+      if (bRelations) {
+        bRelations.add(a);
+      } else {
+        bRelations = /* @__PURE__ */ new Set([a]);
+        this.relations.set(b, bRelations);
       }
-    });
-    return future;
+    }
   }
-  target.valueMap.set(key, value);
-  return value;
-}
-var readCachedValue = (token, target) => {
-  let value = target.valueMap.get(token.key);
-  if (token.type === `atom`) {
-    value = copyMutableIfWithinTransaction(value, token, target);
+  getContentInternal(contentKey) {
+    return this.contents.get(contentKey);
   }
-  return value;
-};
-var evictCachedValue = (key, target) => {
-  const currentValue = target.valueMap.get(key);
-  if (currentValue instanceof Future) {
-    currentValue.cancel();
+  setContent(contentKey, content) {
+    this.contents.set(contentKey, content);
   }
-  if (target.operation.open) {
-    target.operation.prev.set(key, currentValue);
+  deleteContent(contentKey) {
+    this.contents.delete(contentKey);
   }
-  target.valueMap.delete(key);
-  target.logger.info(`\u{1F5D1}`, `state`, key, `evicted`);
-};
-
-// internal/src/read-or-compute-value.ts
-var readOrComputeValue = (state, target) => {
-  if (target.valueMap.has(state.key)) {
-    target.logger.info(`\u{1F4D6}`, state.type, state.key, `reading cached value`);
-    return readCachedValue(state, target);
+  toJSON() {
+    return {
+      between: [this.a, this.b],
+      cardinality: this.cardinality,
+      relations: [...this.relations.entries()].map(([a, b]) => [a, [...b]]),
+      contents: [...this.contents.entries()]
+    };
   }
-  if (state.type !== `atom`) {
-    target.logger.info(`\u{1F9EE}`, state.type, state.key, `computing value`);
-    return state.get();
+  set(a, ...rest) {
+    var _a;
+    const b = typeof rest[0] === `string` ? rest[0] : a[this.b];
+    const content = ((_a = rest[1]) != null ? _a : typeof rest[0] === `string`) ? void 0 : rest[0];
+    a = typeof a === `string` ? a : a[this.a];
+    switch (this.cardinality) {
+      case `1:1`: {
+        const bPrev = this.getRelatedKey(a);
+        if (bPrev && bPrev !== b)
+          this.delete(bPrev, a);
+      }
+      case `1:n`: {
+        const aPrev = this.getRelatedKey(b);
+        if (aPrev && aPrev !== a)
+          this.delete(aPrev, b);
+      }
+    }
+    if (content) {
+      const contentKey = this.makeContentKey(a, b);
+      this.setContent(contentKey, content);
+    }
+    this.addRelation(a, b);
+    return this;
   }
-  const fallback = state.default instanceof Function ? state.default() : state.default;
-  target.logger.info(
-    `\u{1F481}`,
-    `atom`,
-    state.key,
-    `could not find cached value; using default`,
-    fallback
-  );
-  return state.default instanceof Function ? state.default() : state.default;
-};
-
-// internal/src/operation.ts
-var openOperation = (token, store) => {
-  if (store.operation.open) {
-    store.logger.error(
-      `\u274C`,
-      token.type,
-      token.key,
-      `failed to setState during a setState for "${store.operation.token.key}"`
-    );
-    return `rejection`;
+  delete(x, b) {
+    b = typeof b === `string` ? b : x[this.b];
+    const a = typeof x === `string` ? x : x[this.a];
+    if (a === void 0 && typeof b === `string`) {
+      const bRelations = this.getRelatedKeys(b);
+      if (bRelations) {
+        for (const a2 of bRelations) {
+          this.delete(a2, b);
+        }
+      }
+    }
+    if (typeof a === `string` && b === void 0) {
+      const aRelations = this.getRelatedKeys(a);
+      if (aRelations) {
+        for (const b2 of aRelations) {
+          this.delete(a, b2);
+        }
+      }
+    }
+    if (typeof a === `string` && typeof b === `string`) {
+      this.deleteRelation(a, b);
+      const contentKey = this.makeContentKey(a, b);
+      this.deleteContent(contentKey);
+    }
+    return this;
   }
-  store.operation = {
-    open: true,
-    done: /* @__PURE__ */ new Set(),
-    prev: /* @__PURE__ */ new Map(),
-    time: Date.now(),
-    token
-  };
-  store.logger.info(
-    `\u2B55`,
-    token.type,
-    token.key,
-    `operation start in store "${store.config.name}"${store.transactionMeta === null ? `` : ` ${store.transactionMeta.phase} "${store.transactionMeta.update.key}"`}`
-  );
-};
-var closeOperation = (store) => {
-  if (store.operation.open) {
-    store.logger.info(
-      `\u{1F534}`,
-      store.operation.token.type,
-      store.operation.token.key,
-      `operation done in store "${store.config.name}"`
-    );
+  getRelatedKey(key) {
+    const relations = this.getRelatedKeys(key);
+    if (relations) {
+      if (relations.size > 1) {
+        console.warn(
+          `${relations.size} related keys were found for key "${key}": (${[
+            ...relations
+          ].map((k) => `"${k}"`).join(`, `)}). Only one related key was expected.`
+        );
+      }
+      for (const relation of relations) {
+        return relation;
+      }
+    }
   }
-  store.operation = { open: false };
-  store.on.operationClose.next(store.operation);
-};
-var isDone = (key, store) => {
-  if (!store.operation.open) {
-    store.logger.warn(
-      `\u{1F41E}`,
-      `unknown`,
-      key,
-      `isDone called outside of an operation. This is probably a bug.`
-    );
-    return true;
+  replaceRelations(a, relations, config) {
+    const hasContent = !Array.isArray(relations);
+    const bs = hasContent ? Object.keys(relations) : relations;
+    if (config == null ? void 0 : config.reckless) {
+      this.replaceRelationsUnsafely(a, bs);
+    } else {
+      this.replaceRelationsSafely(a, bs);
+    }
+    if (hasContent) {
+      for (const b of bs) {
+        const contentKey = this.makeContentKey(a, b);
+        const content = relations[b];
+        this.setContent(contentKey, content);
+      }
+    }
+    return this;
   }
-  return store.operation.done.has(key);
-};
-var markDone = (key, store) => {
-  if (!store.operation.open) {
-    store.logger.warn(
-      `\u{1F41E}`,
-      `unknown`,
-      key,
-      `markDone called outside of an operation. This is probably a bug.`
-    );
-    return;
+  getContent(a, b) {
+    const contentKey = this.makeContentKey(a, b);
+    return this.getContentInternal(contentKey);
+  }
+  getRelationEntries(input) {
+    const a = input[this.a];
+    const b = input[this.b];
+    if (a !== void 0 && b === void 0) {
+      const aRelations = this.getRelatedKeys(a);
+      if (aRelations) {
+        return [...aRelations].map((b2) => {
+          var _a;
+          return [b2, (_a = this.getContent(a, b2)) != null ? _a : null];
+        });
+      }
+    }
+    if (a === void 0 && b !== void 0) {
+      const bRelations = this.getRelatedKeys(b);
+      if (bRelations) {
+        return [...bRelations].map((a2) => {
+          var _a;
+          return [a2, (_a = this.getContent(a2, b)) != null ? _a : null];
+        });
+      }
+    }
+    return [];
+  }
+  has(a, b) {
+    var _a;
+    if (b) {
+      const setA = this.getRelatedKeys(a);
+      return (_a = setA == null ? void 0 : setA.has(b)) != null ? _a : false;
+    }
+    return this.relations.has(a);
   }
-  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() {
@@ -269,565 +333,476 @@ var StatefulSubject = class extends Subject {
   }
 };
 
-// internal/src/set-state/emit-update.ts
-var emitUpdate = (state, update, store) => {
-  store.logger.info(
-    `\u{1F4E2}`,
-    state.type,
-    state.key,
-    `went (`,
-    update.oldValue,
-    `->`,
-    update.newValue,
-    `) subscribers:`,
-    state.subject.subscribers
-  );
-  state.subject.next(update);
-};
-
-// internal/src/set-state/evict-downstream.ts
-var evictDownStream = (atom, store) => {
-  const downstreamKeys = store.selectorAtoms.getRelatedKeys(atom.key);
-  store.logger.info(
-    `\u{1F9F9}`,
-    atom.type,
-    atom.key,
-    downstreamKeys ? `evicting ${downstreamKeys.size} states downstream:` : `no downstream states`,
-    downstreamKeys != null ? downstreamKeys : `to evict`
-  );
-  if (downstreamKeys) {
-    if (store.operation.open) {
-      store.logger.info(
-        `\u{1F9F9}`,
-        atom.type,
-        atom.key,
-        `[ ${[...store.operation.done].join(`, `)} ] already done`
-      );
-    }
-    for (const key of downstreamKeys) {
-      if (isDone(key, store)) {
-        continue;
+// 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(`:`)
       }
-      evictCachedValue(key, store);
-      markDone(key, store);
-    }
-  }
-};
-
-// internal/src/set-state/stow-update.ts
-function shouldUpdateBeStowed(key, update) {
-  if (isTransceiver(update.newValue)) {
-    return false;
-  }
-  if (key.includes(`\u{1F441}\u200D\u{1F5E8}`)) {
-    return false;
-  }
-  return true;
-}
-var stowUpdate = (state, update, store) => {
-  const { key } = state;
-  const target = newest(store);
-  if (target.transactionMeta === null || target.transactionMeta.phase !== `building`) {
-    store.logger.error(
-      `\u{1F41E}`,
-      `atom`,
-      key,
-      `stowUpdate called outside of a transaction. This is probably a bug.`
     );
-    return;
-  }
-  const shouldStow = shouldUpdateBeStowed(key, update);
-  if (!shouldStow) {
-    return;
-  }
-  const atomUpdate = __spreadValues({ key }, update);
-  if (state.family) {
-    atomUpdate.family = state.family;
-  }
-  target.transactionMeta.update.updates.push(atomUpdate);
-  store.logger.info(
-    `\u{1F4C1}`,
-    `atom`,
-    key,
-    `stowed (`,
-    update.oldValue,
-    `->`,
-    update.newValue,
-    `)`
-  );
+    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 atom_io.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/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);
+// 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;
   }
-  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/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/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/future.ts
+var Future = class extends Promise {
+  constructor(executor) {
+    super((resolve, reject) => {
+      const pass = (value) => this.isCanceled ? reject(`canceled`) : resolve(value);
+      const fail = (reason) => this.isCanceled ? reject(`canceled`) : reject(reason);
+      if (typeof executor === `function`) {
+        executor(pass, fail);
+      } else {
+        executor.then(pass, fail);
+      }
+    });
+    this.isCanceled = false;
+  }
+  cancel() {
+    this.isCanceled = true;
   }
 };
 
-// internal/src/store/deposit.ts
-function deposit(state) {
-  const token = {
-    key: state.key,
-    type: state.type
-  };
-  if (`family` in state) {
-    token.family = state.family;
+// internal/src/set-state/copy-mutable-if-needed.ts
+function copyMutableIfNeeded(atom, origin, target) {
+  const originValue = origin.valueMap.get(atom.key);
+  const targetValue = target.valueMap.get(atom.key);
+  if (originValue === targetValue) {
+    origin.logger.info(`\u{1F4C3}`, `atom`, `${atom.key}`, `copying`);
+    const jsonValue = atom.toJson(originValue);
+    const copiedValue = atom.fromJson(jsonValue);
+    target.valueMap.set(atom.key, copiedValue);
+    new Tracker(atom, origin);
+    return copiedValue;
   }
-  return token;
+  return targetValue;
 }
 
-// ../rel8/junction/src/junction.ts
-var Junction = class {
-  constructor(data, config) {
-    this.relations = /* @__PURE__ */ new Map();
-    this.contents = /* @__PURE__ */ new Map();
-    this.makeContentKey = (a, b) => `${a}:${b}`;
-    var _a, _b, _c, _d;
-    this.a = data.between[0];
-    this.b = data.between[1];
-    this.cardinality = data.cardinality;
-    if (!(config == null ? void 0 : config.externalStore)) {
-      this.relations = new Map((_a = data.relations) == null ? void 0 : _a.map(([a, b]) => [a, new Set(b)]));
-      this.contents = new Map(data.contents);
-    }
-    this.isContent = (_b = config == null ? void 0 : config.isContent) != null ? _b : null;
-    if (config == null ? void 0 : config.makeContentKey) {
-      this.makeContentKey = config.makeContentKey;
-    }
-    if (config == null ? void 0 : config.externalStore) {
-      const externalStore = config.externalStore;
-      this.has = (a, b) => externalStore.has(a, b);
-      this.addRelation = (a, b) => {
-        externalStore.addRelation(a, b);
-      };
-      this.deleteRelation = (a, b) => {
-        externalStore.deleteRelation(a, b);
-      };
-      this.replaceRelationsSafely = (a, bs) => {
-        externalStore.replaceRelationsSafely(a, bs);
-      };
-      this.replaceRelationsUnsafely = (a, bs) => {
-        externalStore.replaceRelationsUnsafely(a, bs);
-      };
-      this.getRelatedKeys = (key) => externalStore.getRelatedKeys(key);
-      if (externalStore.getContent) {
-        this.getContentInternal = (contentKey) => {
-          return externalStore.getContent(contentKey);
-        };
-        this.setContent = (contentKey, content) => {
-          externalStore.setContent(contentKey, content);
-        };
-        this.deleteContent = (contentKey) => {
-          externalStore.deleteContent(contentKey);
-        };
-      }
-      for (const [x, ys] of (_c = data.relations) != null ? _c : []) {
-        for (const y of ys)
-          this.addRelation(x, y);
-      }
-      for (const [contentKey, content] of (_d = data.contents) != null ? _d : []) {
-        this.setContent(contentKey, content);
-      }
+// internal/src/set-state/copy-mutable-in-transaction.ts
+function copyMutableIfWithinTransaction(oldValue, atom, store) {
+  const target = newest(store);
+  const parent = target.parent;
+  if (parent !== null) {
+    if (atom.type === `mutable_atom`) {
+      const copiedValue = copyMutableIfNeeded(atom, parent, target);
+      return copiedValue;
     }
   }
-  getRelatedKeys(key) {
-    return this.relations.get(key);
-  }
-  addRelation(a, b) {
-    let aRelations = this.relations.get(a);
-    let bRelations = this.relations.get(b);
-    if (aRelations) {
-      aRelations.add(b);
-    } else {
-      aRelations = /* @__PURE__ */ new Set([b]);
-      this.relations.set(a, aRelations);
-    }
-    if (bRelations) {
-      bRelations.add(a);
-    } else {
-      bRelations = /* @__PURE__ */ new Set([a]);
-      this.relations.set(b, bRelations);
-    }
+  return oldValue;
+}
+
+// internal/src/caching.ts
+function cacheValue(key, value, subject, target) {
+  const currentValue = target.valueMap.get(key);
+  if (currentValue instanceof Future) {
+    currentValue.cancel();
   }
-  deleteRelation(a, b) {
-    const aRelations = this.relations.get(a);
-    if (aRelations) {
-      aRelations.delete(b);
-      if (aRelations.size === 0) {
-        this.relations.delete(a);
+  if (value instanceof Promise) {
+    const future = new Future(value);
+    target.valueMap.set(key, future);
+    future.then((resolved) => {
+      if (future.isCanceled) {
+        return;
       }
-      const bRelations = this.relations.get(b);
-      if (bRelations) {
-        bRelations.delete(a);
-        if (bRelations.size === 0) {
-          this.relations.delete(b);
-        }
+      cacheValue(key, resolved, subject, target);
+      subject.next({ newValue: resolved, oldValue: future });
+    }).catch((thrown) => {
+      if (thrown !== `canceled`) {
+        target.logger.error(`\u{1F4A5}`, `state`, key, `rejected:`, thrown);
       }
-    }
+    });
+    return future;
   }
-  replaceRelationsUnsafely(a, bs) {
-    this.relations.set(a, new Set(bs));
-    for (const b of bs) {
-      const bRelations = /* @__PURE__ */ new Set([a]);
-      this.relations.set(b, bRelations);
-    }
+  target.valueMap.set(key, value);
+  return value;
+}
+var readCachedValue = (token, target) => {
+  let value = target.valueMap.get(token.key);
+  if (token.type === `atom`) {
+    value = copyMutableIfWithinTransaction(value, token, target);
   }
-  replaceRelationsSafely(a, bs) {
-    const aRelationsPrev = this.relations.get(a);
-    if (aRelationsPrev) {
-      for (const b of aRelationsPrev) {
-        const bRelations = this.relations.get(b);
-        if (bRelations) {
-          if (bRelations.size === 1) {
-            this.relations.delete(b);
-          } else {
-            bRelations.delete(a);
-          }
-          this.contents.delete(this.makeContentKey(a, b));
-        }
-      }
-    }
-    this.relations.set(a, new Set(bs));
-    for (const b of bs) {
-      let bRelations = this.relations.get(b);
-      if (bRelations) {
-        bRelations.add(a);
-      } else {
-        bRelations = /* @__PURE__ */ new Set([a]);
-        this.relations.set(b, bRelations);
-      }
-    }
+  return value;
+};
+var evictCachedValue = (key, target) => {
+  const currentValue = target.valueMap.get(key);
+  if (currentValue instanceof Future) {
+    currentValue.cancel();
   }
-  getContentInternal(contentKey) {
-    return this.contents.get(contentKey);
+  if (target.operation.open) {
+    target.operation.prev.set(key, currentValue);
   }
-  setContent(contentKey, content) {
-    this.contents.set(contentKey, content);
+  target.valueMap.delete(key);
+  target.logger.info(`\u{1F5D1}`, `state`, key, `evicted`);
+};
+
+// internal/src/read-or-compute-value.ts
+var readOrComputeValue = (state, target) => {
+  if (target.valueMap.has(state.key)) {
+    target.logger.info(`\u{1F4D6}`, state.type, state.key, `reading cached value`);
+    return readCachedValue(state, target);
   }
-  deleteContent(contentKey) {
-    this.contents.delete(contentKey);
+  if (state.type !== `atom` && state.type !== `mutable_atom`) {
+    target.logger.info(`\u{1F9EE}`, state.type, state.key, `computing value`);
+    return state.get();
   }
-  toJSON() {
-    return {
-      between: [this.a, this.b],
-      cardinality: this.cardinality,
-      relations: [...this.relations.entries()].map(([a, b]) => [a, [...b]]),
-      contents: [...this.contents.entries()]
-    };
+  const fallback = state.default instanceof Function ? state.default() : state.default;
+  target.logger.info(
+    `\u{1F481}`,
+    `atom`,
+    state.key,
+    `could not find cached value; using default`,
+    fallback
+  );
+  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) {
+    store.logger.error(
+      `\u274C`,
+      token.type,
+      token.key,
+      `failed to setState during a setState for "${store.operation.token.key}"`
+    );
+    return `rejection`;
   }
-  set(a, ...rest) {
-    var _a;
-    const b = typeof rest[0] === `string` ? rest[0] : a[this.b];
-    const content = ((_a = rest[1]) != null ? _a : typeof rest[0] === `string`) ? void 0 : rest[0];
-    a = typeof a === `string` ? a : a[this.a];
-    switch (this.cardinality) {
-      case `1:1`: {
-        const bPrev = this.getRelatedKey(a);
-        if (bPrev && bPrev !== b)
-          this.delete(bPrev, a);
-      }
-      case `1:n`: {
-        const aPrev = this.getRelatedKey(b);
-        if (aPrev && aPrev !== a)
-          this.delete(aPrev, b);
-      }
-    }
-    if (content) {
-      const contentKey = this.makeContentKey(a, b);
-      this.setContent(contentKey, content);
-    }
-    this.addRelation(a, b);
-    return this;
+  store.operation = {
+    open: true,
+    done: /* @__PURE__ */ new Set(),
+    prev: /* @__PURE__ */ new Map(),
+    time: Date.now(),
+    token
+  };
+  store.logger.info(
+    `\u2B55`,
+    token.type,
+    token.key,
+    `operation start in store "${store.config.name}"${store.transactionMeta === null ? `` : ` ${store.transactionMeta.phase} "${store.transactionMeta.update.key}"`}`
+  );
+};
+var closeOperation = (store) => {
+  if (store.operation.open) {
+    store.logger.info(
+      `\u{1F534}`,
+      store.operation.token.type,
+      store.operation.token.key,
+      `operation done in store "${store.config.name}"`
+    );
   }
-  delete(x, b) {
-    b = typeof b === `string` ? b : x[this.b];
-    const a = typeof x === `string` ? x : x[this.a];
-    if (a === void 0 && typeof b === `string`) {
-      const bRelations = this.getRelatedKeys(b);
-      if (bRelations) {
-        for (const a2 of bRelations) {
-          this.delete(a2, b);
-        }
-      }
-    }
-    if (typeof a === `string` && b === void 0) {
-      const aRelations = this.getRelatedKeys(a);
-      if (aRelations) {
-        for (const b2 of aRelations) {
-          this.delete(a, b2);
-        }
-      }
-    }
-    if (typeof a === `string` && typeof b === `string`) {
-      this.deleteRelation(a, b);
-      const contentKey = this.makeContentKey(a, b);
-      this.deleteContent(contentKey);
-    }
-    return this;
+  store.operation = { open: false };
+  store.on.operationClose.next(store.operation);
+};
+var isDone = (key, store) => {
+  if (!store.operation.open) {
+    store.logger.warn(
+      `\u{1F41E}`,
+      `unknown`,
+      key,
+      `isDone called outside of an operation. This is probably a bug.`
+    );
+    return true;
   }
-  getRelatedKey(key) {
-    const relations = this.getRelatedKeys(key);
-    if (relations) {
-      if (relations.size > 1) {
-        console.warn(
-          `${relations.size} related keys were found for key "${key}": (${[
-            ...relations
-          ].map((k) => `"${k}"`).join(`, `)}). Only one related key was expected.`
-        );
-      }
-      for (const relation of relations) {
-        return relation;
-      }
-    }
+  return store.operation.done.has(key);
+};
+var markDone = (key, store) => {
+  if (!store.operation.open) {
+    store.logger.warn(
+      `\u{1F41E}`,
+      `unknown`,
+      key,
+      `markDone called outside of an operation. This is probably a bug.`
+    );
+    return;
   }
-  replaceRelations(a, relations, config) {
-    const hasContent = !Array.isArray(relations);
-    const bs = hasContent ? Object.keys(relations) : relations;
-    if (config == null ? void 0 : config.reckless) {
-      this.replaceRelationsUnsafely(a, bs);
-    } else {
-      this.replaceRelationsSafely(a, bs);
-    }
-    if (hasContent) {
-      for (const b of bs) {
-        const contentKey = this.makeContentKey(a, b);
-        const content = relations[b];
-        this.setContent(contentKey, content);
-      }
-    }
-    return this;
-  }
-  getContent(a, b) {
-    const contentKey = this.makeContentKey(a, b);
-    return this.getContentInternal(contentKey);
-  }
-  getRelationEntries(input) {
-    const a = input[this.a];
-    const b = input[this.b];
-    if (a !== void 0 && b === void 0) {
-      const aRelations = this.getRelatedKeys(a);
-      if (aRelations) {
-        return [...aRelations].map((b2) => {
-          var _a;
-          return [b2, (_a = this.getContent(a, b2)) != null ? _a : null];
-        });
-      }
+  store.operation.done.add(key);
+};
+
+// internal/src/set-state/emit-update.ts
+var emitUpdate = (state, update, store) => {
+  store.logger.info(
+    `\u{1F4E2}`,
+    state.type,
+    state.key,
+    `went (`,
+    update.oldValue,
+    `->`,
+    update.newValue,
+    `) subscribers:`,
+    state.subject.subscribers
+  );
+  state.subject.next(update);
+};
+
+// internal/src/set-state/evict-downstream.ts
+var evictDownStream = (atom, store) => {
+  const downstreamKeys = store.selectorAtoms.getRelatedKeys(atom.key);
+  store.logger.info(
+    `\u{1F9F9}`,
+    atom.type,
+    atom.key,
+    downstreamKeys ? `evicting ${downstreamKeys.size} states downstream:` : `no downstream states`,
+    downstreamKeys != null ? downstreamKeys : `to evict`
+  );
+  if (downstreamKeys) {
+    if (store.operation.open) {
+      store.logger.info(
+        `\u{1F9F9}`,
+        atom.type,
+        atom.key,
+        `[ ${[...store.operation.done].join(`, `)} ] already done`
+      );
     }
-    if (a === void 0 && b !== void 0) {
-      const bRelations = this.getRelatedKeys(b);
-      if (bRelations) {
-        return [...bRelations].map((a2) => {
-          var _a;
-          return [a2, (_a = this.getContent(a2, b)) != null ? _a : null];
-        });
+    for (const key of downstreamKeys) {
+      if (isDone(key, store)) {
+        continue;
       }
+      evictCachedValue(key, store);
+      markDone(key, store);
     }
-    return [];
-  }
-  has(a, b) {
-    var _a;
-    if (b) {
-      const setA = this.getRelatedKeys(a);
-      return (_a = setA == null ? void 0 : setA.has(b)) != null ? _a : false;
-    }
-    return this.relations.has(a);
   }
 };
 
-// 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(`:`)
-      }
+// internal/src/set-state/stow-update.ts
+function shouldUpdateBeStowed(key, update) {
+  if (isTransceiver(update.newValue)) {
+    return false;
+  }
+  if (key.includes(`\u{1F441}\u200D\u{1F5E8}`)) {
+    return false;
+  }
+  return true;
+}
+var stowUpdate = (state, update, store) => {
+  const { key } = state;
+  const target = newest(store);
+  if (target.transactionMeta === null || target.transactionMeta.phase !== `building`) {
+    store.logger.error(
+      `\u{1F41E}`,
+      `atom`,
+      key,
+      `stowUpdate called outside of a transaction. This is probably a bug.`
     );
-    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 atom_io.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);
-      }
-    }
+    return;
   }
-};
-var IMPLICIT = {
-  STORE_INTERNAL: void 0,
-  get STORE() {
-    var _a;
-    return (_a = this.STORE_INTERNAL) != null ? _a : this.STORE_INTERNAL = new Store(`IMPLICIT_STORE`);
+  const shouldStow = shouldUpdateBeStowed(key, update);
+  if (!shouldStow) {
+    return;
   }
-};
-var clearStore = (store) => {
-  const { config } = store;
-  Object.assign(store, new Store(config.name));
-  store.config = config;
+  const atomUpdate = __spreadValues({ key }, update);
+  if (state.family) {
+    atomUpdate.family = state.family;
+  }
+  target.transactionMeta.update.updates.push(atomUpdate);
+  store.logger.info(
+    `\u{1F4C1}`,
+    `atom`,
+    key,
+    `stowed (`,
+    update.oldValue,
+    `->`,
+    update.newValue,
+    `)`
+  );
 };
 
-// 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;
+// 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);
     }
-    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);
@@ -867,7 +842,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)
@@ -877,7 +853,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
@@ -948,8 +924,44 @@ var registerSelector = (selectorKey, store) => ({
   find: (token, key) => atom_io.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, 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) => 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);
@@ -982,7 +994,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`
@@ -1001,59 +1013,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
@@ -1095,44 +1061,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;
 };
 
@@ -1147,7 +1115,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}`,
@@ -1358,27 +1326,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 = json.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) => atom_io.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);
+  json.selectJson(token, options, store);
+  store.on.atomCreation.next(token);
+  return token;
 }
 function createRegularAtomFamily(options, store) {
   const subject = new Subject();
@@ -1399,16 +1407,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;
@@ -1420,9 +1419,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;
@@ -1430,7 +1426,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);
@@ -1447,7 +1444,7 @@ function createReadonlySelectorFamily(options, store) {
       if (existing) {
         return deposit(existing);
       }
-      return createSelector(
+      return createReadonlySelector(
         {
           key: fullKey,
           get: options.get(key)
@@ -1466,23 +1463,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 = json.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),
@@ -1498,13 +1490,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) {
@@ -1541,29 +1542,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 = json.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
+    }
   );
-  json.selectJsonFamily(coreFamily, options);
-  new FamilyTracker(coreFamily, store);
-  return coreFamily;
+  const target = newest(store);
+  target.families.set(options.key, atomFamily);
+  json.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`,
@@ -1586,13 +1621,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) {
@@ -1624,7 +1656,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`,
@@ -1643,7 +1675,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
   });
@@ -1681,12 +1713,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
@@ -1807,9 +1840,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;
@@ -1818,6 +1850,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);
@@ -2002,14 +2035,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;
@@ -2032,27 +2057,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);
         }
       }
@@ -2095,9 +2108,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 = {
@@ -2357,27 +2379,27 @@ exports.buildTransaction = buildTransaction;
 exports.cacheValue = cacheValue;
 exports.clearStore = clearStore;
 exports.closeOperation = closeOperation;
-exports.createAtom = createAtom;
 exports.createAtomFamily = createAtomFamily;
 exports.createMutableAtom = createMutableAtom;
 exports.createMutableAtomFamily = createMutableAtomFamily;
+exports.createReadonlySelector = createReadonlySelector;
 exports.createReadonlySelectorFamily = createReadonlySelectorFamily;
 exports.createRegularAtom = createRegularAtom;
 exports.createRegularAtomFamily = createRegularAtomFamily;
-exports.createSelector = createSelector;
 exports.createSelectorFamily = createSelectorFamily;
+exports.createStandaloneAtom = createStandaloneAtom;
+exports.createStandaloneSelector = createStandaloneSelector;
 exports.createTimeline = createTimeline;
 exports.createTransaction = createTransaction;
+exports.createWritableSelector = createWritableSelector;
 exports.deleteAtom = deleteAtom;
 exports.deleteSelector = deleteSelector;
 exports.deposit = deposit;
-exports.eldest = eldest;
 exports.evictCachedValue = evictCachedValue;
 exports.getEnvironmentData = getEnvironmentData;
 exports.getJsonFamily = getJsonFamily;
 exports.getJsonToken = getJsonToken;
 exports.getSelectorDependencyKeys = getSelectorDependencyKeys;
-exports.getUpdateFamily = getUpdateFamily;
 exports.getUpdateToken = getUpdateToken;
 exports.ingestAtomUpdate = ingestAtomUpdate;
 exports.ingestSelectorUpdate = ingestSelectorUpdate;
@@ -2385,6 +2407,7 @@ exports.ingestTransactionUpdate = ingestTransactionUpdate;
 exports.isAtomDefault = isAtomDefault;
 exports.isAtomKey = isAtomKey;
 exports.isDone = isDone;
+exports.isMutable = isMutable;
 exports.isReadonlySelectorKey = isReadonlySelectorKey;
 exports.isSelectorKey = isSelectorKey;
 exports.isStateKey = isStateKey;