atom.io 0.17.0 → 0.18.0

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;
 
@@ -307,6 +326,8 @@ 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;
@@ -245,34 +268,6 @@ var Future = class extends Promise {
   }
 };
 
-// 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 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);
@@ -299,10 +294,7 @@ function cacheValue(key, value, subject, target) {
   return value;
 }
 var readCachedValue = (token, target) => {
-  let value = target.valueMap.get(token.key);
-  if (token.type === `atom`) {
-    value = copyMutableIfWithinTransaction(value, token, target);
-  }
+  const value = target.valueMap.get(token.key);
   return value;
 };
 var evictCachedValue = (key, target) => {
@@ -549,6 +541,21 @@ var markDone = (key, store) => {
   store.operation.done.add(key);
 };
 
+// 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 targetValue;
+}
+
 // internal/src/set-state/emit-update.ts
 var emitUpdate = (state, update, store) => {
   store.logger.info(
@@ -640,7 +647,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);
@@ -657,19 +669,14 @@ var setAtom = (atom, next, target) => {
       stowUpdate(atom, update, 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
-        );
+      target.atoms.get(mutableKey);
+      let transceiver = target.valueMap.get(mutableKey);
+      if (atom.type === `mutable_atom` && isChildStore(target)) {
+        const { parent } = target;
+        const copiedValue = copyMutableIfNeeded(atom, parent, target);
+        transceiver = copiedValue;
       }
+      transceiver.do(update.newValue);
     }
   }
 };
@@ -1037,8 +1044,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 +1065,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}".`
@@ -1543,10 +1554,16 @@ function deleteAtom(atomToken, 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
   };
 }
@@ -1844,7 +1861,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 +2024,36 @@ 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);
+    console.log(`epoch is now`, newEpoch);
+  }
+}
+
 // internal/src/transaction/apply-transaction.ts
 var applyTransaction = (output, store) => {
   var _a;
@@ -2045,7 +2102,12 @@ var applyTransaction = (output, store) => {
   }
   ingestTransactionUpdate(`newValue`, child.transactionMeta.update, parent);
   if (isRootStore(parent)) {
-    parent.transactionMeta.epoch = child.transactionMeta.update.epoch;
+    console.log(child.transactionMeta.update);
+    setEpochNumberOfAction(
+      child.transactionMeta.update.key,
+      child.transactionMeta.update.epoch,
+      parent
+    );
     const myTransaction = withdraw(
       { key: child.transactionMeta.update.key, type: `transaction` },
       store
@@ -2062,6 +2124,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 +2164,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 +2178,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 +2226,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