atom.io 0.17.0 → 0.18.1

package/internal/dist/index.d.ts

@@ -1,64 +1,5 @@
-import { ƒn as _n, TransactionUpdate, TransactionOptions, TransactionToken, TransactorsWithRunAndEnv, RegularAtomToken, MutableAtomToken, WritableSelectorToken, ReadonlySelectorToken, WritableToken, ReadableToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, TimelineUpdate, TimelineOptions, TimelineToken, AtomToken, WritableSelectorFamily, MutableAtomFamily, RegularAtomFamily, ReadonlySelectorFamily, AtomIOLogger, Logger, SelectorToken, MutableAtomOptions, MutableAtomFamilyOptions, AtomFamily, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, MutableAtomFamilyToken, RegularAtomFamilyToken, WritableSelectorFamilyToken, ReadonlySelectorFamilyToken, WritableFamilyToken, ReadableFamilyToken, KeyedStateUpdate, ReadonlySelectorOptions, WritableSelectorOptions, Transactors, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
+import { ƒn as _n, TransactionToken, TransactionUpdate, TransactionOptions, TransactorsWithRunAndEnv, RegularAtomToken, MutableAtomToken, WritableSelectorToken, ReadonlySelectorToken, WritableToken, ReadableToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, TimelineUpdate, TimelineOptions, TimelineToken, AtomToken, WritableSelectorFamily, MutableAtomFamily, RegularAtomFamily, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomFamily, SelectorFamily, SelectorToken, RegularAtomFamilyToken, MutableAtomFamilyToken, AtomFamilyToken, ReadonlySelectorFamilyToken, WritableSelectorFamilyToken, SelectorFamilyToken, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, WritableFamilyToken, ReadableFamilyToken, KeyedStateUpdate, ReadonlySelectorOptions, WritableSelectorOptions, Transactors, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
 import { Json, JsonInterface } from 'atom.io/json';
-import { Store as Store$1 } from 'atom.io/internal';
-
-declare const abortTransaction: (store: Store) => void;
-
-declare const applyTransaction: <ƒ extends _n>(output: ReturnType<ƒ>, store: Store) => void;
-
-interface RootStore extends Store {
-    transactionMeta: TransactionEpoch;
-    parent: null;
-    child: ChildStore | null;
-}
-interface ChildStore extends Store {
-    transactionMeta: TransactionProgress<_n>;
-    parent: ChildStore | RootStore;
-    child: ChildStore | null;
-}
-
-declare const buildTransaction: (key: string, params: any[], store: Store, id?: string) => ChildStore;
-
-declare class Subject<T> {
-    Subscriber: (value: T) => void;
-    subscribers: Map<string, this[`Subscriber`]>;
-    subscribe(key: string, subscriber: this[`Subscriber`]): () => void;
-    private unsubscribe;
-    next(value: T): void;
-}
-declare class StatefulSubject<T> extends Subject<T> {
-    state: T;
-    constructor(initialState: T);
-    next(value: T): void;
-}
-
-type Transaction<ƒ extends _n> = {
-    key: string;
-    type: `transaction`;
-    install: (store: Store) => void;
-    subject: Subject<TransactionUpdate<ƒ>>;
-    run: (parameters: Parameters<ƒ>, id?: string) => ReturnType<ƒ>;
-};
-declare function createTransaction<ƒ extends _n>(options: TransactionOptions<ƒ>, store: Store): TransactionToken<ƒ>;
-
-declare const TRANSACTION_PHASES: readonly ["idle", "building", "applying"];
-type TransactionPhase = (typeof TRANSACTION_PHASES)[number];
-type TransactionProgress<ƒ extends _n> = {
-    phase: `applying` | `building`;
-    update: TransactionUpdate<ƒ>;
-    transactors: TransactorsWithRunAndEnv;
-};
-type TransactionEpoch = {
-    epoch: number;
-};
-
-declare function deposit<T>(state: RegularAtom<T>): RegularAtomToken<T>;
-declare function deposit<T extends Transceiver<any>>(state: MutableAtom<T, any>): MutableAtomToken<T, any>;
-declare function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T>;
-declare function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>;
-declare function deposit<T>(state: WritableState<T>): WritableToken<T>;
-declare function deposit<T>(state: Transaction<T extends _n ? T : never>): TransactionToken<T>;
-declare function deposit<T>(state: ReadableState<T>): ReadableToken<T>;
 
 type primitive = boolean | number | string | null;
 
@@ -134,6 +75,78 @@ declare class Junction<const ASide extends string, const BSide extends string, c
     has(a: string, b?: string): boolean;
 }
 
+declare const abortTransaction: (store: Store) => void;
+
+declare function actUponStore<ƒ extends _n>(token: TransactionToken<ƒ>, id: string, store: Store): (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+
+declare const applyTransaction: <ƒ extends _n>(output: ReturnType<ƒ>, store: Store) => void;
+
+declare function assignTransactionToContinuity(continuityKey: string, transactionKey: string, store: Store): void;
+
+interface RootStore extends Store {
+    transactionMeta: TransactionEpoch;
+    parent: null;
+    child: ChildStore | null;
+}
+interface ChildStore extends Store {
+    transactionMeta: TransactionProgress<_n>;
+    parent: ChildStore | RootStore;
+    child: ChildStore | null;
+}
+declare function isRootStore(store: Store): store is RootStore;
+declare function isChildStore(store: Store): store is ChildStore;
+
+declare const buildTransaction: (key: string, params: any[], store: Store, id: string) => ChildStore;
+
+declare class Subject<T> {
+    Subscriber: (value: T) => void;
+    subscribers: Map<string, this[`Subscriber`]>;
+    subscribe(key: string, subscriber: this[`Subscriber`]): () => void;
+    private unsubscribe;
+    next(value: T): void;
+}
+declare class StatefulSubject<T> extends Subject<T> {
+    state: T;
+    constructor(initialState: T);
+    next(value: T): void;
+}
+
+type Transaction<ƒ extends _n> = {
+    key: string;
+    type: `transaction`;
+    install: (store: Store) => void;
+    subject: Subject<TransactionUpdate<ƒ>>;
+    run: (parameters: Parameters<ƒ>, id?: string) => ReturnType<ƒ>;
+};
+declare function createTransaction<ƒ extends _n>(options: TransactionOptions<ƒ>, store: Store): TransactionToken<ƒ>;
+
+declare function getContinuityKey(transactionKey: string, store: Store): string | undefined;
+declare function getEpochNumberOfContinuity(continuityKey: string, store: Store): number | undefined;
+declare function getEpochNumberOfAction(transactionKey: string, store: Store): number | undefined;
+
+declare function setEpochNumberOfContinuity(continuityKey: string, newEpoch: number, store: Store): void;
+declare function setEpochNumberOfAction(transactionKey: string, newEpoch: number, store: Store): void;
+
+declare const TRANSACTION_PHASES: readonly ["idle", "building", "applying"];
+type TransactionPhase = (typeof TRANSACTION_PHASES)[number];
+type TransactionProgress<ƒ extends _n> = {
+    phase: `applying` | `building`;
+    update: TransactionUpdate<ƒ>;
+    transactors: TransactorsWithRunAndEnv;
+};
+type TransactionEpoch = {
+    epoch: Map<string, number>;
+    actionContinuities: Junction<`continuity`, `action`>;
+};
+
+declare function deposit<T>(state: RegularAtom<T>): RegularAtomToken<T>;
+declare function deposit<T extends Transceiver<any>>(state: MutableAtom<T, any>): MutableAtomToken<T, any>;
+declare function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T>;
+declare function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>;
+declare function deposit<T>(state: WritableState<T>): WritableToken<T>;
+declare function deposit<T>(state: Transaction<T extends _n ? T : never>): TransactionToken<T>;
+declare function deposit<T>(state: ReadableState<T>): ReadableToken<T>;
+
 interface Lineage {
     parent: typeof this | null;
     child: typeof this | null;
@@ -229,7 +242,7 @@ declare const IMPLICIT: {
 };
 declare const clearStore: (store: Store) => void;
 
-type Withdrawable = ReadableState<any> | Timeline<any> | Transaction<any>;
+type Withdrawable = Atom<any> | AtomFamily<any, any> | MutableAtom<any, any> | MutableAtomFamily<any, any, any> | ReadableState<any> | ReadableState<any> | ReadonlySelector<any> | ReadonlySelectorFamily<any, any> | RegularAtom<any> | RegularAtomFamily<any, any> | Selector<any> | SelectorFamily<any, any> | Timeline<any> | Transaction<any> | WritableSelector<any> | WritableSelectorFamily<any, any> | WritableState<any>;
 declare function withdraw<T>(token: RegularAtomToken<T>, store: Store): RegularAtom<T> | undefined;
 declare function withdraw<T extends Transceiver<any>>(token: MutableAtomToken<T, any>, store: Store): MutableAtom<T, any> | undefined;
 declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T> | undefined;
@@ -238,6 +251,12 @@ declare function withdraw<T>(token: ReadonlySelectorToken<T>, store: Store): Rea
 declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T> | undefined;
 declare function withdraw<T>(token: WritableToken<T>, store: Store): WritableState<T> | undefined;
 declare function withdraw<T>(token: ReadableToken<T>, store: Store): ReadableState<T> | undefined;
+declare function withdraw<T, K extends Json.Serializable>(token: RegularAtomFamilyToken<T, K>, store: Store): RegularAtomFamily<T, K> | undefined;
+declare function withdraw<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(token: MutableAtomFamilyToken<T, J, K>, store: Store): MutableAtomFamily<T, J, K> | undefined;
+declare function withdraw<T, K extends Json.Serializable>(token: AtomFamilyToken<T>, store: Store): AtomFamily<T, any> | undefined;
+declare function withdraw<T, K extends Json.Serializable>(token: ReadonlySelectorFamilyToken<T, K>, store: Store): ReadonlySelectorFamily<T, any> | undefined;
+declare function withdraw<T, K extends Json.Serializable>(token: WritableSelectorFamilyToken<T, K>, store: Store): WritableSelectorFamily<T, any> | undefined;
+declare function withdraw<T, K extends Json.Serializable>(token: SelectorFamilyToken<T, K>, store: Store): SelectorFamily<T, any> | undefined;
 declare function withdraw<T>(token: TransactionToken<T>, store: Store): Transaction<T extends _n ? T : never> | undefined;
 declare function withdraw<T>(token: TimelineToken<T>, store: Store): Timeline<T extends TimelineManageable ? T : never> | undefined;
 
@@ -301,12 +320,14 @@ declare function createStandaloneAtom<T extends Transceiver<any>, J extends Json
 
 declare function createRegularAtom<T>(options: MutableAtomOptions<any, any> | RegularAtomOptions<T>, family: FamilyMetadata | undefined, store: Store): RegularAtomToken<T>;
 
-declare function deleteAtom(atomToken: RegularAtomToken<unknown>, store: Store): void;
+declare function deleteAtom(atomToken: AtomToken<unknown>, store: Store): void;
 
 declare const isAtomDefault: (key: string, store: Store) => boolean;
 declare const markAtomAsDefault: (key: string, store: Store) => void;
 declare const markAtomAsNotDefault: (key: string, store: Store) => void;
 
+declare function arbitrary(random?: () => number): string;
+
 /**
  * A Promise that can be canceled.
  * @internal
@@ -339,13 +360,16 @@ declare function createSelectorFamily<T, K extends Json.Serializable>(options: R
 
 declare function findInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J>;
 declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T>;
+declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T>;
 declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key, store: Store): WritableSelectorToken<T>;
 declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key, store: Store): ReadonlySelectorToken<T>;
+declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T>;
 declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T>;
 declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T>;
 
 type EnvironmentData = {
-    runtime: `browser` | `node` | `unknown`;
+    window: typeof window | undefined;
+    global: typeof global | undefined;
     store: Store;
 };
 declare function getEnvironmentData(store: Store): EnvironmentData;
@@ -423,11 +447,11 @@ declare const subscribeToRootAtoms: <T>(selector: Selector<T>, store: Store) =>
 
 declare function subscribeToState<T>(token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key: string, store: Store): () => void;
 
-declare const subscribeToTimeline: <ManagedAtom extends TimelineManageable>(token: TimelineToken<ManagedAtom>, handleUpdate: (update: TimelineUpdate<any> | `redo` | `undo`) => void, key: string, store: Store$1) => (() => void);
+declare const subscribeToTimeline: <ManagedAtom extends TimelineManageable>(token: TimelineToken<ManagedAtom>, handleUpdate: (update: TimelineUpdate<any> | `redo` | `undo`) => void, key: string, store: Store) => (() => void);
 
-declare const subscribeToTransaction: <ƒ extends _n>(token: TransactionToken<ƒ>, handleUpdate: TransactionUpdateHandler<ƒ>, key: string, store: Store$1) => (() => void);
+declare const subscribeToTransaction: <ƒ extends _n>(token: TransactionToken<ƒ>, handleUpdate: TransactionUpdateHandler<ƒ>, key: string, store: Store) => (() => void);
 
-type BaseStateData = {
+type AtomIOState = {
     key: string;
     family?: FamilyMetadata;
     install: (store: Store) => void;
@@ -436,23 +460,23 @@ type BaseStateData = {
         oldValue: any;
     }>;
 };
-type RegularAtom<T> = BaseStateData & {
+type RegularAtom<T> = AtomIOState & {
     type: `atom`;
     default: T | (() => T);
     cleanup?: () => void;
 };
-type MutableAtom<T extends Transceiver<any>, J extends Json.Serializable> = BaseStateData & JsonInterface<T, J> & {
+type MutableAtom<T extends Transceiver<any>, J extends Json.Serializable> = AtomIOState & JsonInterface<T, J> & {
     type: `mutable_atom`;
     default: T | (() => T);
     cleanup?: () => void;
 };
 type Atom<T> = RegularAtom<T> | (T extends Transceiver<any> ? MutableAtom<T, any> : never);
-type WritableSelector<T> = BaseStateData & {
+type WritableSelector<T> = AtomIOState & {
     type: `selector`;
     get: () => T;
     set: (newValue: T | ((oldValue: T) => T)) => void;
 };
-type ReadonlySelector<T> = BaseStateData & {
+type ReadonlySelector<T> = AtomIOState & {
     type: `readonly_selector`;
     get: () => T;
 };
@@ -460,4 +484,4 @@ type Selector<T> = ReadonlySelector<T> | WritableSelector<T>;
 type WritableState<T> = Atom<T> | WritableSelector<T>;
 type ReadableState<T> = Atom<T> | Selector<T>;
 
-export { type Atom, type AtomKey, type BaseStateData, type EnvironmentData, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, type MutableAtom, NotFoundError, type OperationProgress, type ReadableState, type ReadonlySelector, type ReadonlySelectorKey, type RegularAtom, type Selector, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineSelectorUpdate, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableSelector, type WritableState, 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, findInStore, getEnvironmentData, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isDone, isMutable, isReadonlySelectorKey, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
+export { type Atom, type AtomIOState, type AtomKey, type ChildStore, type EnvironmentData, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, type MutableAtom, NotFoundError, type OperationProgress, type ReadableState, type ReadonlySelector, type ReadonlySelectorKey, type RegularAtom, type RootStore, type Selector, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineSelectorUpdate, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableSelector, type WritableState, abortTransaction, actUponStore, addAtomToTimeline, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deleteAtom, deleteSelector, deposit, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };

package/internal/dist/index.js

@@ -1,9 +1,7 @@
 import { Junction } from '../../dist/chunk-NYTGCPHB.js';
-import { isChildStore, isRootStore } from '../../dist/chunk-H4Q5FTPZ.js';
 import { __spreadValues, __spreadProps } from '../../dist/chunk-PZLG2HP3.js';
 import { stringifyJson, selectJson, parseJson, selectJsonFamily } from 'atom.io/json';
-import { AtomIOLogger, runTransaction } from 'atom.io';
-import { withdraw as withdraw$1 } from 'atom.io/internal';
+import { AtomIOLogger } from 'atom.io';
 
 // internal/src/lineage.ts
 function newest(scion) {
@@ -56,6 +54,14 @@ var StatefulSubject = class extends Subject {
   }
 };
 
+// internal/src/transaction/is-root-store.ts
+function isRootStore(store) {
+  return `epoch` in store.transactionMeta;
+}
+function isChildStore(store) {
+  return `phase` in store.transactionMeta;
+}
+
 // internal/src/store/store.ts
 var Store = class {
   constructor(name, store = null) {
@@ -99,7 +105,11 @@ var Store = class {
     };
     this.operation = { open: false };
     this.transactionMeta = {
-      epoch: -1
+      epoch: /* @__PURE__ */ new Map(),
+      actionContinuities: new Junction({
+        between: [`continuity`, `action`],
+        cardinality: `1:n`
+      })
     };
     this.config = {
       name: `IMPLICIT_STORE`
@@ -124,7 +134,14 @@ var Store = class {
     if (store !== null) {
       this.valueMap = new Map(store == null ? void 0 : store.valueMap);
       this.operation = __spreadValues({}, store == null ? void 0 : store.operation);
-      this.transactionMeta = __spreadValues({}, store == null ? void 0 : store.transactionMeta);
+      if (isRootStore(store)) {
+        this.transactionMeta = {
+          epoch: new Map(store == null ? void 0 : store.transactionMeta.epoch),
+          actionContinuities: new Junction(
+            store == null ? void 0 : store.transactionMeta.actionContinuities.toJSON()
+          )
+        };
+      }
       this.config = __spreadProps(__spreadValues({}, store == null ? void 0 : store.config), {
         name
       });
@@ -191,6 +208,12 @@ function withdraw(token, store) {
       case `readonly_selector`:
         withdrawn = target.readonlySelectors.get(token.key);
         break;
+      case `atom_family`:
+      case `mutable_atom_family`:
+      case `selector_family`:
+      case `readonly_selector_family`:
+        withdrawn = target.families.get(token.key);
+        break;
       case `timeline`:
         withdrawn = target.timelines.get(token.key);
         break;
@@ -250,6 +273,9 @@ function copyMutableIfNeeded(atom, origin, target) {
   const originValue = origin.valueMap.get(atom.key);
   const targetValue = target.valueMap.get(atom.key);
   if (originValue === targetValue) {
+    if (originValue === void 0) {
+      return typeof atom.default === `function` ? atom.default() : atom.default;
+    }
     origin.logger.info(`\u{1F4C3}`, `atom`, `${atom.key}`, `copying`);
     const jsonValue = atom.toJson(originValue);
     const copiedValue = atom.fromJson(jsonValue);
@@ -260,19 +286,6 @@ function copyMutableIfNeeded(atom, origin, target) {
   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 (atom.type === `mutable_atom`) {
-      const copiedValue = copyMutableIfNeeded(atom, parent, target);
-      return copiedValue;
-    }
-  }
-  return oldValue;
-}
-
 // internal/src/caching.ts
 function cacheValue(key, value, subject, target) {
   const currentValue = target.valueMap.get(key);
@@ -300,8 +313,10 @@ function cacheValue(key, value, subject, target) {
 }
 var readCachedValue = (token, target) => {
   let value = target.valueMap.get(token.key);
-  if (token.type === `atom`) {
-    value = copyMutableIfWithinTransaction(value, token, target);
+  if (token.type === `mutable_atom` && isChildStore(target)) {
+    const { parent } = target;
+    const copiedValue = copyMutableIfNeeded(token, parent, target);
+    value = copiedValue;
   }
   return value;
 };
@@ -551,17 +566,31 @@ var markDone = (key, store) => {
 
 // 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
-  );
+  switch (state.type) {
+    case `mutable_atom`:
+      store.logger.info(
+        `\u{1F4E2}`,
+        state.type,
+        state.key,
+        `is now (`,
+        update.newValue,
+        `) subscribers:`,
+        state.subject.subscribers
+      );
+      break;
+    default:
+      store.logger.info(
+        `\u{1F4E2}`,
+        state.type,
+        state.key,
+        `went (`,
+        update.oldValue,
+        `->`,
+        update.newValue,
+        `) subscribers:`,
+        state.subject.subscribers
+      );
+  }
   state.subject.next(update);
 };
 
@@ -640,7 +669,12 @@ 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);
+  let newValue = oldValue;
+  if (atom.type === `mutable_atom` && isChildStore(target)) {
+    const { parent } = target;
+    const copiedValue = copyMutableIfNeeded(atom, parent, target);
+    newValue = copiedValue;
+  }
   newValue = become(next)(newValue);
   target.logger.info(`\u{1F4DD}`, `atom`, atom.key, `set to`, newValue);
   newValue = cacheValue(atom.key, newValue, atom.subject, target);
@@ -658,18 +692,15 @@ var setAtom = (atom, next, target) => {
     } else if (atom.key.startsWith(`*`)) {
       const mutableKey = atom.key.slice(1);
       const mutableAtom = target.atoms.get(mutableKey);
-      let mutable = target.valueMap.get(mutableKey);
-      mutable = copyMutableIfWithinTransaction(mutable, mutableAtom, target);
-      const output = mutable.do(update.newValue);
-      if (output !== null) {
-        target.logger.warn(
-          `\u274C`,
-          `mutable_atom`,
-          mutableKey,
-          `could not be updated.`,
-          typeof output === `number` ? `Expected update number ${mutable.cacheUpdateNumber + 1}, but got ${output}` : output
-        );
+      let transceiver = target.valueMap.get(mutableKey);
+      if (mutableAtom.type === `mutable_atom` && isChildStore(target)) {
+        const { parent } = target;
+        const copiedValue = copyMutableIfNeeded(mutableAtom, parent, target);
+        transceiver = copiedValue;
       }
+      const accepted = transceiver.do(update.newValue) === null;
+      if (accepted)
+        evictDownStream(mutableAtom, target);
     }
   }
 };
@@ -1037,8 +1068,10 @@ function subscribeToState(token, handleUpdate, key, store) {
   };
   return unsubscribe;
 }
+
+// internal/src/subscribe/subscribe-to-timeline.ts
 var subscribeToTimeline = (token, handleUpdate, key, store) => {
-  const tl = withdraw$1(token, store);
+  const tl = withdraw(token, store);
   if (tl === void 0) {
     throw new Error(
       `Cannot subscribe to timeline "${token.key}": timeline not found in store "${store.config.name}".`
@@ -1056,8 +1089,10 @@ var subscribeToTimeline = (token, handleUpdate, key, store) => {
     unsubscribe();
   };
 };
+
+// internal/src/subscribe/subscribe-to-transaction.ts
 var subscribeToTransaction = (token, handleUpdate, key, store) => {
-  const tx = withdraw$1(token, store);
+  const tx = withdraw(token, store);
   if (tx === void 0) {
     throw new Error(
       `Cannot subscribe to transaction "${token.key}": transaction not found in store "${store.config.name}".`
@@ -1540,13 +1575,23 @@ function deleteAtom(atomToken, store) {
   target.selectorAtoms.delete(key);
   target.atomsThatAreDefault.delete(key);
   target.timelineAtoms.delete(key);
+  if (atomToken.type === `mutable_atom`) {
+    const updateToken = getUpdateToken(atomToken);
+    deleteAtom(updateToken, store);
+  }
   store.logger.info(`\u{1F525}`, `atom`, `${key}`, `deleted`);
 }
 
+// internal/src/arbitrary.ts
+function arbitrary(random = Math.random) {
+  return random().toString(36).slice(2);
+}
+
 // internal/src/get-environment-data.ts
 function getEnvironmentData(store) {
   return {
-    runtime: typeof window === `undefined` ? typeof global === `object` ? `node` : `unknown` : `browser`,
+    window: typeof window === `undefined` ? void 0 : window,
+    global: typeof global === `undefined` ? void 0 : global,
     store
   };
 }
@@ -1565,7 +1610,11 @@ function getFromStore(token, store) {
 function ingestAtomUpdate(applying, atomUpdate, store) {
   const { key, newValue, oldValue } = atomUpdate;
   const value = applying === `newValue` ? newValue : oldValue;
-  setIntoStore({ key, type: `atom` }, value, store);
+  const token = { key, type: `atom` };
+  if (atomUpdate.family) {
+    Object.assign(token, { family: atomUpdate.family });
+  }
+  setIntoStore(token, value, store);
 }
 
 // internal/src/ingest-updates/ingest-selector-update.ts
@@ -1844,7 +1893,17 @@ function createTimeline(options, store, data) {
   for (const tokenOrFamily of options.atoms) {
     let atomKey = tokenOrFamily.key;
     if (tokenOrFamily.type === `atom_family` || tokenOrFamily.type === `mutable_atom_family`) {
-      const family = tokenOrFamily;
+      const familyToken = tokenOrFamily;
+      const family = withdraw(familyToken, store);
+      if (family === void 0) {
+        store.logger.error(
+          `\u274C`,
+          `timeline`,
+          options.key,
+          `Failed to add family "${familyToken.key}" because it does not exist in the store`
+        );
+        continue;
+      }
       const familyKey = family.key;
       target.timelineAtoms.set({ atomKey: familyKey, timelineKey });
       family.subject.subscribe(`timeline:${options.key}`, (token2) => {
@@ -1997,6 +2056,35 @@ var abortTransaction = (store) => {
   target.parent.child = null;
 };
 
+// internal/src/transaction/act-upon-store.ts
+function actUponStore(token, id, store) {
+  return (...parameters) => {
+    const tx = withdraw(token, store);
+    if (tx) {
+      return tx.run(parameters, id);
+    }
+    throw new NotFoundError(token, store);
+  };
+}
+
+// internal/src/transaction/set-epoch-number.ts
+function setEpochNumberOfContinuity(continuityKey, newEpoch, store) {
+  const isRoot = isRootStore(store);
+  if (isRoot && continuityKey) {
+    store.transactionMeta.epoch.set(continuityKey, newEpoch);
+  }
+}
+function setEpochNumberOfAction(transactionKey, newEpoch, store) {
+  const isRoot = isRootStore(store);
+  if (!isRoot) {
+    return;
+  }
+  const continuityKey = store.transactionMeta.actionContinuities.getRelatedKey(transactionKey);
+  if (continuityKey !== void 0) {
+    store.transactionMeta.epoch.set(continuityKey, newEpoch);
+  }
+}
+
 // internal/src/transaction/apply-transaction.ts
 var applyTransaction = (output, store) => {
   var _a;
@@ -2045,7 +2133,11 @@ var applyTransaction = (output, store) => {
   }
   ingestTransactionUpdate(`newValue`, child.transactionMeta.update, parent);
   if (isRootStore(parent)) {
-    parent.transactionMeta.epoch = child.transactionMeta.update.epoch;
+    setEpochNumberOfAction(
+      child.transactionMeta.update.key,
+      child.transactionMeta.update.epoch,
+      parent
+    );
     const myTransaction = withdraw(
       { key: child.transactionMeta.update.key, type: `transaction` },
       store
@@ -2062,6 +2154,21 @@ var applyTransaction = (output, store) => {
   }
   parent.on.transactionApplying.next(null);
 };
+
+// internal/src/transaction/assign-transaction-to-continuity.ts
+function assignTransactionToContinuity(continuityKey, transactionKey, store) {
+  const isRoot = isRootStore(store);
+  if (!isRoot) {
+    return;
+  }
+  const { epoch, actionContinuities } = store.transactionMeta;
+  actionContinuities.set(continuityKey, transactionKey);
+  if (!epoch.has(continuityKey)) {
+    epoch.set(continuityKey, -1);
+  }
+}
+
+// internal/src/transaction/build-transaction.ts
 var buildTransaction = (key, params, store, id) => {
   const parent = newest(store);
   const childBase = {
@@ -2087,12 +2194,13 @@ var buildTransaction = (key, params, store, id) => {
     selectors: new LazyMap(parent.selectors),
     valueMap: new LazyMap(parent.valueMap)
   };
+  const epoch = getEpochNumberOfAction(key, store);
   const transactionMeta = {
     phase: `building`,
     update: {
       key,
-      id: id != null ? id : Math.random().toString(36).slice(2),
-      epoch: isRootStore(parent) ? parent.transactionMeta.epoch + 1 : NaN,
+      id,
+      epoch: epoch === void 0 ? NaN : epoch + 1,
       updates: [],
       params,
       output: void 0
@@ -2100,7 +2208,7 @@ var buildTransaction = (key, params, store, id) => {
     transactors: {
       get: (token) => getFromStore(token, child),
       set: (token, value) => setIntoStore(token, value, child),
-      run: (token, id2) => runTransaction(token, id2, child),
+      run: (token, id2 = arbitrary()) => actUponStore(token, id2, child),
       find: (token, key2) => findInStore(token, key2, child),
       env: () => getEnvironmentData(child)
     }
@@ -2148,9 +2256,27 @@ function createTransaction(options, store) {
   return token;
 }
 
+// internal/src/transaction/get-epoch-number.ts
+function getContinuityKey(transactionKey, store) {
+  const isRoot = isRootStore(store);
+  const continuity = isRoot ? store.transactionMeta.actionContinuities.getRelatedKey(transactionKey) : void 0;
+  return continuity;
+}
+function getEpochNumberOfContinuity(continuityKey, store) {
+  const isRoot = isRootStore(store);
+  const epoch = isRoot && continuityKey ? store.transactionMeta.epoch.get(continuityKey) : void 0;
+  return epoch;
+}
+function getEpochNumberOfAction(transactionKey, store) {
+  const isRoot = isRootStore(store);
+  const continuity = isRoot ? store.transactionMeta.actionContinuities.getRelatedKey(transactionKey) : void 0;
+  const epoch = isRoot && continuity !== void 0 ? store.transactionMeta.epoch.get(continuity) : void 0;
+  return epoch;
+}
+
 // 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, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deleteAtom, deleteSelector, deposit, evictCachedValue, findInStore, getEnvironmentData, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isDone, isMutable, isReadonlySelectorKey, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
+export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, addAtomToTimeline, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deleteAtom, deleteSelector, deposit, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map