atom.io 0.15.3 → 0.15.5

package/internal/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { FamilyMetadata as FamilyMetadata$1, SelectorOptions, SelectorToken, ReadonlySelectorOptions, ReadonlySelectorToken, Transactors, StateToken, ƒn as _n, TransactionUpdate, TransactionOptions, TransactionToken, TransactorsWithRun, AtomToken, MutableAtomOptions, MutableAtomToken, MutableAtomFamilyOptions, MutableAtomFamily, SelectorFamily, AtomFamily, StateUpdate, TimelineUpdate, TimelineOptions, TimelineToken, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomOptions, AtomFamilyOptions, ReadonlySelectorFamilyOptions, SelectorFamilyOptions, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
+import { FamilyMetadata as FamilyMetadata$1, SelectorOptions, SelectorToken, ReadonlySelectorOptions, ReadonlySelectorToken, Transactors, WritableToken, ƒn as _n, TransactionUpdate, TransactionOptions, TransactionToken, TransactorsWithRunAndEnv, AtomToken, ReadableToken, MutableAtomOptions, MutableAtomToken, MutableAtomFamilyOptions, MutableAtomFamily, SelectorFamily, AtomFamily, TimelineManageable, StateUpdate, TokenType, TimelineUpdate, TimelineOptions, TimelineToken, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomOptions, AtomFamilyOptions, ReadonlySelectorFamilyOptions, SelectorFamilyOptions, KeyedStateUpdate, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
 import { Json } from 'atom.io/json';
 import { Store as Store$1 } from 'atom.io/internal';
 
@@ -73,20 +73,20 @@ declare const registerSelector: (selectorKey: string, store: Store) => Transacto
 declare const traceSelectorAtoms: (selectorKey: string, directDependencyKey: StateKey<unknown>, store: Store) => AtomKey<unknown>[];
 declare const traceAllSelectorAtoms: (selectorKey: string, store: Store) => AtomKey<unknown>[];
 
-declare const updateSelectorAtoms: (selectorKey: string, dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>, store: Store) => void;
+declare const updateSelectorAtoms: (selectorKey: string, dependency: ReadonlySelectorToken<unknown> | WritableToken<unknown>, store: Store) => void;
 
 declare const abortTransaction: (store: Store) => void;
 
 declare const applyTransaction: <ƒ extends _n>(output: ReturnType<ƒ>, store: Store) => void;
 
-declare const buildTransaction: (key: string, params: any[], store: Store) => void;
+declare const buildTransaction: (key: string, params: any[], store: Store, id?: string) => void;
 
 type Transaction<ƒ extends _n> = {
     key: string;
     type: `transaction`;
     install: (store: Store) => void;
     subject: Subject<TransactionUpdate<ƒ>>;
-    run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+    run: (parameters: Parameters<ƒ>, id?: string) => ReturnType<ƒ>;
 };
 declare function createTransaction<ƒ extends _n>(options: TransactionOptions<ƒ>, store: Store): TransactionToken<ƒ>;
 
@@ -96,15 +96,15 @@ type TransactionMeta<ƒ extends _n> = {
     phase: `applying` | `building`;
     time: number;
     update: TransactionUpdate<ƒ>;
-    transactors: TransactorsWithRun;
+    transactors: TransactorsWithRunAndEnv;
 };
 
 declare function deposit<T>(state: Atom<T>): AtomToken<T>;
 declare function deposit<T>(state: Selector<T>): SelectorToken<T>;
-declare function deposit<T>(state: Atom<T> | Selector<T>): StateToken<T>;
+declare function deposit<T>(state: Atom<T> | Selector<T>): WritableToken<T>;
 declare function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>;
 declare function deposit<T>(state: Transaction<T extends _n ? T : never>): TransactionToken<T>;
-declare function deposit<T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>): ReadonlySelectorToken<T> | StateToken<T>;
+declare function deposit<T>(state: StateNode<T>): ReadableToken<T>;
 
 type primitive = boolean | number | string | null;
 
@@ -246,47 +246,47 @@ type OperationProgress = {
     done: Set<string>;
     prev: Map<string, any>;
     time: number;
-    token: StateToken<any>;
+    token: WritableToken<any>;
 };
-declare const openOperation: (token: StateToken<any>, store: Store) => `rejection` | undefined;
+declare const openOperation: (token: WritableToken<any>, store: Store) => `rejection` | undefined;
 declare const closeOperation: (store: Store) => void;
 declare const isDone: (key: string, store: Store) => boolean;
 declare const markDone: (key: string, store: Store) => void;
 
-type TimelineAtomUpdate = StateUpdate<unknown> & {
+type TimelineAtomUpdate<ManagedAtom extends TimelineManageable> = StateUpdate<TokenType<ManagedAtom>> & {
     key: string;
     type: `atom_update`;
     timestamp: number;
     family?: FamilyMetadata$1;
 };
-type TimelineSelectorUpdate = {
+type TimelineSelectorUpdate<ManagedAtom extends TimelineManageable> = {
     key: string;
     type: `selector_update`;
     timestamp: number;
-    atomUpdates: Omit<TimelineAtomUpdate, `timestamp`>[];
+    atomUpdates: Omit<TimelineAtomUpdate<ManagedAtom>, `timestamp`>[];
 };
 type TimelineTransactionUpdate = TransactionUpdate<_n> & {
     key: string;
     type: `transaction_update`;
     timestamp: number;
 };
-type Timeline = {
+type Timeline<ManagedAtom extends TimelineManageable> = {
     type: `timeline`;
     key: string;
     at: number;
-    shouldCapture?: (update: TimelineUpdate, timeline: Timeline) => boolean;
+    shouldCapture?: (update: TimelineUpdate<TimelineManageable>, timeline: Timeline<ManagedAtom>) => boolean;
     timeTraveling: `into_future` | `into_past` | null;
-    history: TimelineUpdate[];
+    history: TimelineUpdate<ManagedAtom>[];
     selectorTime: number | null;
     transactionKey: string | null;
     install: (store: Store) => void;
-    subject: Subject<TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate | `redo` | `undo`>;
+    subject: Subject<TimelineAtomUpdate<ManagedAtom> | TimelineSelectorUpdate<ManagedAtom> | TimelineTransactionUpdate | `redo` | `undo`>;
 };
-declare function createTimeline(options: TimelineOptions, store: Store, data?: Timeline): TimelineToken;
+declare function createTimeline<ManagedAtom extends TimelineManageable>(options: TimelineOptions<ManagedAtom>, store: Store, data?: Timeline<ManagedAtom>): TimelineToken<ManagedAtom>;
 
-declare const addAtomToTimeline: (atomToken: AtomToken<any>, tl: Timeline, store: Store) => void;
+declare const addAtomToTimeline: (atomToken: AtomToken<any>, tl: Timeline<any>, store: Store) => void;
 
-declare const timeTravel: (direction: `backward` | `forward`, token: TimelineToken, store: Store) => void;
+declare const timeTravel: (action: `redo` | `undo`, token: TimelineToken<any>, store: Store) => void;
 
 declare class Store implements Lineage {
     parent: Store | null;
@@ -297,7 +297,7 @@ declare class Store implements Lineage {
     readonlySelectors: Map<string, ReadonlySelector<any>>;
     trackers: Map<string, Tracker<Transceiver<any>>>;
     families: Map<string, AtomFamily<any, any> | ReadonlySelectorFamily<any, any> | SelectorFamily<any, any>>;
-    timelines: Map<string, Timeline>;
+    timelines: Map<string, Timeline<any>>;
     transactions: Map<string, Transaction<_n>>;
     atomsThatAreDefault: Set<string>;
     timelineAtoms: Junction<"timelineKey", "atomKey", null>;
@@ -305,13 +305,13 @@ declare class Store implements Lineage {
     selectorGraph: Junction<"upstreamSelectorKey", "downstreamSelectorKey", {
         source: string;
     }>;
-    subject: {
+    on: {
         atomCreation: Subject<AtomToken<unknown>>;
         selectorCreation: Subject<ReadonlySelectorToken<unknown> | SelectorToken<unknown>>;
         transactionCreation: Subject<TransactionToken<_n>>;
-        timelineCreation: Subject<TimelineToken>;
+        timelineCreation: Subject<TimelineToken<unknown>>;
         transactionApplying: StatefulSubject<TransactionMeta<_n> | null>;
-        operationStatus: Subject<OperationProgress>;
+        operationClose: Subject<OperationProgress>;
     };
     operation: OperationProgress;
     transactionMeta: TransactionMeta<_n> | null;
@@ -330,17 +330,17 @@ declare const clearStore: (store: Store) => void;
 
 declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T> | undefined;
 declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T> | undefined;
-declare function withdraw<T>(token: StateToken<T>, store: Store): Atom<T> | Selector<T> | undefined;
+declare function withdraw<T>(token: WritableToken<T>, store: Store): Atom<T> | Selector<T> | undefined;
 declare function withdraw<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T> | undefined;
 declare function withdraw<T>(token: TransactionToken<T>, store: Store): Transaction<T extends _n ? T : never> | undefined;
-declare function withdraw<T>(token: ReadonlySelectorToken<T> | StateToken<T>, store: Store): Atom<T> | ReadonlySelector<T> | Selector<T> | undefined;
-declare function withdraw<T>(token: TimelineToken, store: Store): Timeline | undefined;
+declare function withdraw<T>(token: ReadableToken<T>, store: Store): StateNode<T> | undefined;
+declare function withdraw<T>(token: TimelineToken<T>, store: Store): Timeline<T extends TimelineManageable ? T : never> | undefined;
 
 declare function withdrawNewFamilyMember<T>(token: AtomToken<T>, store: Store): Atom<T> | undefined;
 declare function withdrawNewFamilyMember<T>(token: SelectorToken<T>, store: Store): Selector<T> | undefined;
 declare function withdrawNewFamilyMember<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T> | undefined;
-declare function withdrawNewFamilyMember<T>(token: StateToken<T>, store: Store): Atom<T> | Selector<T> | undefined;
-declare function withdrawNewFamilyMember<T>(token: ReadonlySelectorToken<T> | StateToken<T>, store: Store): Atom<T> | ReadonlySelector<T> | Selector<T> | undefined;
+declare function withdrawNewFamilyMember<T>(token: WritableToken<T>, store: Store): Atom<T> | Selector<T> | undefined;
+declare function withdrawNewFamilyMember<T>(token: ReadableToken<T>, store: Store): StateNode<T> | undefined;
 
 declare function createAtom<T>(options: AtomOptions<T> | MutableAtomOptions<any, any>, family: FamilyMetadata$1 | undefined, store: Store): AtomToken<T>;
 
@@ -396,6 +396,18 @@ declare function createReadonlySelectorFamily<T, K extends Json.Serializable>(op
 declare function createSelectorFamily<T, K extends Json.Serializable>(options: SelectorFamilyOptions<T, K>, store: Store): SelectorFamily<T, K>;
 declare function createSelectorFamily<T, K extends Json.Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamily<T, K>;
 
+type EnvironmentData = {
+    runtime: `browser` | `node` | `unknown`;
+    store: Store;
+};
+declare function getEnvironmentData(store: Store): EnvironmentData;
+
+declare function ingestAtomUpdate(applying: `newValue` | `oldValue`, atomUpdate: KeyedStateUpdate<any>, store: Store): void;
+
+declare function ingestSelectorUpdate(applying: `newValue` | `oldValue`, selectorUpdate: TimelineSelectorUpdate<any>, store: Store): void;
+
+declare function ingestTransactionUpdate(applying: `newValue` | `oldValue`, transactionUpdate: TransactionUpdate<any>, store: Store): void;
+
 declare class LazyMap<K, V> extends Map<K, V> {
     protected readonly source: Map<K, V>;
     deleted: Set<K>;
@@ -408,7 +420,7 @@ declare class LazyMap<K, V> extends Map<K, V> {
 }
 
 declare class NotFoundError extends Error {
-    constructor(token: ReadonlySelectorToken<any> | StateToken<any>, store: Store);
+    constructor(token: ReadableToken<any>, store: Store);
 }
 
 declare const readOrComputeValue: <T>(state: StateNode<T>, target: Store) => T;
@@ -420,12 +432,12 @@ declare const setAtomOrSelector: <T>(state: Atom<T> | Selector<T>, value: T | ((
 
 declare const subscribeToRootAtoms: <T>(state: ReadonlySelector<T> | Selector<T>, store: Store) => (() => void)[] | null;
 
-declare function subscribeToState<T>(token: ReadonlySelectorToken<T> | StateToken<T>, handleUpdate: UpdateHandler<T>, key: string, store: Store): () => void;
+declare function subscribeToState<T>(token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key: string, store: Store): () => void;
 
-declare const subscribeToTimeline: (token: TimelineToken, handleUpdate: (update: TimelineUpdate | `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$1) => (() => void);
 
 declare const subscribeToTransaction: <ƒ extends _n>(token: TransactionToken<ƒ>, handleUpdate: TransactionUpdateHandler<ƒ>, key: string, store: Store$1) => (() => void);
 
 type StateNode<T> = Atom<T> | ReadonlySelector<T> | Selector<T>;
 
-export { type Atom, type AtomKey, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, type MutableAtom, NotFoundError, type OperationProgress, type ReadonlySelector, type ReadonlySelectorKey, type Selector, type SelectorKey, type Signal, type StateKey, type StateNode, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineSelectorUpdate, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionMeta, type TransactionPhase, type Transceiver, type TransceiverMode, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelector, createSelectorFamily, createTimeline, createTransaction, deleteAtom, deleteSelector, deposit, eldest, evictCachedValue, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, isAtomDefault, isAtomKey, isDone, isReadonlySelectorKey, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
+export { type Atom, type AtomKey, type EnvironmentData, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, type MutableAtom, NotFoundError, type OperationProgress, type ReadonlySelector, type ReadonlySelectorKey, type Selector, type SelectorKey, type Signal, type StateKey, type StateNode, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineSelectorUpdate, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionMeta, type TransactionPhase, type Transceiver, type TransceiverMode, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelector, createSelectorFamily, createTimeline, createTransaction, deleteAtom, deleteSelector, deposit, eldest, evictCachedValue, getEnvironmentData, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isDone, isReadonlySelectorKey, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };

package/internal/dist/index.js

@@ -1,8 +1,7 @@
-import { getState as getState$1, setState as setState$1, runTransaction } from '../../dist/chunk-K22LR3V6.js';
 import { Junction } from '../../dist/chunk-NYTGCPHB.js';
 import { __spreadValues, __spreadProps } from '../../dist/chunk-PZLG2HP3.js';
 import { selectJson, stringifyJson, parseJson, selectJsonFamily } from 'atom.io/json';
-import { AtomIOLogger, getState, setState } from 'atom.io';
+import { AtomIOLogger, findInStore, getState, setState, runTransaction } from 'atom.io';
 import { withdraw as withdraw$1 } from 'atom.io/internal';
 
 // internal/src/lineage.ts
@@ -187,7 +186,7 @@ var closeOperation = (store) => {
     );
   }
   store.operation = { open: false };
-  store.subject.operationStatus.next(store.operation);
+  store.on.operationClose.next(store.operation);
 };
 var isDone = (key, store) => {
   if (!store.operation.open) {
@@ -413,13 +412,13 @@ var Store = class {
         makeContentKey: (...keys) => keys.sort().join(`:`)
       }
     );
-    this.subject = {
+    this.on = {
       atomCreation: new Subject(),
       selectorCreation: new Subject(),
       transactionCreation: new Subject(),
       timelineCreation: new Subject(),
       transactionApplying: new StatefulSubject(null),
-      operationStatus: new Subject()
+      operationClose: new Subject()
     };
     this.operation = { open: false };
     this.transactionMeta = null;
@@ -654,24 +653,27 @@ var registerSelector = (selectorKey, store) => ({
     updateSelectorAtoms(selectorKey, dependency, store);
     return dependencyValue;
   },
-  set: (stateToken, newValue) => {
-    const state = withdraw(stateToken, store);
+  set: (WritableToken, newValue) => {
+    const state = withdraw(WritableToken, store);
     if (state === void 0) {
       throw new Error(
-        `State "${stateToken.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
+        `State "${WritableToken.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
       );
     }
     setAtomOrSelector(state, newValue, store);
-  }
+  },
+  find: (token, key) => findInStore(token, key, store)
 });
 
 // internal/src/selector/create-read-write-selector.ts
 var createReadWriteSelector = (options, family, store) => {
   const target = newest(store);
   const subject = new Subject();
-  const { get, set } = registerSelector(options.key, store);
+  const transactors = registerSelector(options.key, store);
+  const { find, get } = transactors;
+  const readonlyTransactors = { find, get };
   const getSelf = () => {
-    const value = options.get({ get });
+    const value = options.get(readonlyTransactors);
     cacheValue(options.key, value, subject, newest(store));
     return value;
   };
@@ -693,7 +695,7 @@ var createReadWriteSelector = (options, family, store) => {
     if (target.transactionMeta === null) {
       subject.next({ newValue, oldValue });
     }
-    options.set({ get, set }, newValue);
+    options.set(transactors, newValue);
   };
   const mySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
     subject,
@@ -712,7 +714,7 @@ var createReadWriteSelector = (options, family, store) => {
   if (family) {
     token.family = family;
   }
-  store.subject.selectorCreation.next(token);
+  store.on.selectorCreation.next(token);
   return token;
 };
 
@@ -720,9 +722,9 @@ var createReadWriteSelector = (options, family, store) => {
 var createReadonlySelector = (options, family, store) => {
   const target = newest(store);
   const subject = new Subject();
-  const { get } = registerSelector(options.key, store);
+  const { get, find } = registerSelector(options.key, store);
   const getSelf = () => {
-    const value = options.get({ get });
+    const value = options.get({ get, find });
     cacheValue(options.key, value, subject, store);
     return value;
   };
@@ -748,7 +750,7 @@ var createReadonlySelector = (options, family, store) => {
   if (family) {
     token.family = family;
   }
-  store.subject.selectorCreation.next(token);
+  store.on.selectorCreation.next(token);
   return token;
 };
 
@@ -959,7 +961,7 @@ var Tracker = class {
       `tracker:${store.config.name}:${target.transactionMeta === null ? `main` : target.transactionMeta.update.key}`,
       (update) => {
         if (target.operation.open) {
-          const unsubscribe = target.subject.operationStatus.subscribe(
+          const unsubscribe = target.on.operationClose.subscribe(
             mutableState.key,
             () => {
               unsubscribe();
@@ -982,7 +984,7 @@ var Tracker = class {
             `tracker:${store.config.name}:${target2.transactionMeta === null ? `main` : target2.transactionMeta.update.key}`,
             (update2) => {
               if (target2.operation.open) {
-                const unsubscribe = target2.subject.operationStatus.subscribe(
+                const unsubscribe = target2.on.operationClose.subscribe(
                   mutableState.key,
                   () => {
                     unsubscribe();
@@ -1034,7 +1036,7 @@ var Tracker = class {
             return;
           }
         }
-        const unsubscribe = store.subject.operationStatus.subscribe(
+        const unsubscribe = store.on.operationClose.subscribe(
           latestUpdateState.key,
           () => {
             unsubscribe();
@@ -1392,7 +1394,7 @@ function createRegularAtom(options, family, store) {
       }
     };
   }
-  store.subject.atomCreation.next(token);
+  store.on.atomCreation.next(token);
   return token;
 }
 
@@ -1405,7 +1407,7 @@ function createAtom(options, family, store) {
 }
 
 // internal/src/atom/delete-atom.ts
-function deleteAtom2(atomToken, store) {
+function deleteAtom(atomToken, store) {
   var _a, _b;
   const target = newest(store);
   const { key } = atomToken;
@@ -1436,6 +1438,39 @@ function deleteAtom2(atomToken, store) {
   store.logger.info(`\u{1F525}`, `atom`, `${key}`, `deleted`);
 }
 
+// internal/src/get-environment-data.ts
+function getEnvironmentData(store) {
+  return {
+    runtime: typeof window === `undefined` ? typeof global === `object` ? `node` : `unknown` : `browser`,
+    store
+  };
+}
+function ingestAtomUpdate(applying, atomUpdate, store) {
+  const { key, newValue, oldValue } = atomUpdate;
+  const value = applying === `newValue` ? newValue : oldValue;
+  setState({ key, type: `atom` }, value, store);
+}
+
+// internal/src/ingest-updates/ingest-selector-update.ts
+function ingestSelectorUpdate(applying, selectorUpdate, store) {
+  const updates = applying === `newValue` ? selectorUpdate.atomUpdates : [...selectorUpdate.atomUpdates].reverse();
+  for (const atomUpdate of updates) {
+    ingestAtomUpdate(applying, atomUpdate, store);
+  }
+}
+
+// internal/src/ingest-updates/ingest-transaction-update.ts
+function ingestTransactionUpdate(applying, transactionUpdate, store) {
+  const updates = applying === `newValue` ? transactionUpdate.updates : [...transactionUpdate.updates].reverse();
+  for (const updateFromTransaction of updates) {
+    if (`newValue` in updateFromTransaction) {
+      ingestAtomUpdate(applying, updateFromTransaction, store);
+    } else {
+      ingestTransactionUpdate(applying, updateFromTransaction, store);
+    }
+  }
+}
+
 // internal/src/lazy-map.ts
 var LazyMap = class extends Map {
   constructor(source) {
@@ -1505,8 +1540,8 @@ var addAtomToTimeline = (atomToken, tl, store) => {
     const target = newest(store);
     const currentSelectorKey = store.operation.open && store.operation.token.type === `selector` ? store.operation.token.key : null;
     const currentSelectorTime = store.operation.open && store.operation.token.type === `selector` ? store.operation.time : null;
-    const currentTransactionKey = (_a = target.subject.transactionApplying.state) == null ? void 0 : _a.update.key;
-    const currentTransactionTime = (_b = target.subject.transactionApplying.state) == null ? void 0 : _b.time;
+    const currentTransactionKey = (_a = target.on.transactionApplying.state) == null ? void 0 : _a.update.key;
+    const currentTransactionTime = (_b = target.on.transactionApplying.state) == null ? void 0 : _b.time;
     store.logger.info(
       `\u23F3`,
       `timeline`,
@@ -1786,13 +1821,14 @@ function createTimeline(options, store, data) {
     key: timelineKey,
     type: `timeline`
   };
-  store.subject.timelineCreation.next(token);
+  store.on.timelineCreation.next(token);
   return token;
 }
-var timeTravel = (direction, token, store) => {
-  const action = direction === `forward` ? `redo` : `undo`;
+
+// internal/src/timeline/time-travel.ts
+var timeTravel = (action, token, store) => {
   store.logger.info(
-    direction === `forward` ? `\u23E9` : `\u23EA`,
+    action === `redo` ? `\u23E9` : `\u23EA`,
     `timeline`,
     token.key,
     action
@@ -1807,53 +1843,36 @@ var timeTravel = (direction, token, store) => {
     );
     return;
   }
-  if (direction === `forward` && timelineData.at === timelineData.history.length || direction === `backward` && timelineData.at === 0) {
+  if (action === `redo` && timelineData.at === timelineData.history.length || action === `undo` && timelineData.at === 0) {
     store.logger.warn(
       `\u{1F481}`,
       `timeline`,
       token.key,
-      `Failed to ${action} at the ${direction === `forward` ? `end` : `beginning`} of timeline "${token.key}". There is nothing to ${action}.`
+      `Failed to ${action} at the ${action === `redo` ? `end` : `beginning`} of timeline "${token.key}". There is nothing to ${action}.`
     );
     return;
   }
-  timelineData.timeTraveling = direction === `forward` ? `into_future` : `into_past`;
-  if (direction === `backward`) {
+  timelineData.timeTraveling = action === `redo` ? `into_future` : `into_past`;
+  if (action === `undo`) {
     --timelineData.at;
   }
   const update = timelineData.history[timelineData.at];
-  const updateValues = (atomUpdate) => {
-    const { key, newValue, oldValue } = atomUpdate;
-    const value = direction === `forward` ? newValue : oldValue;
-    setState({ key, type: `atom` }, value, store);
-  };
-  const updateValuesFromTransactionUpdate = (transactionUpdate) => {
-    const updates = direction === `forward` ? transactionUpdate.updates : [...transactionUpdate.updates].reverse();
-    for (const updateFromTransaction of updates) {
-      if (`newValue` in updateFromTransaction) {
-        updateValues(updateFromTransaction);
-      } else {
-        updateValuesFromTransactionUpdate(updateFromTransaction);
-      }
-    }
-  };
+  const applying = action === `redo` ? `newValue` : `oldValue`;
   switch (update.type) {
     case `atom_update`: {
-      updateValues(update);
+      ingestAtomUpdate(applying, update, store);
       break;
     }
     case `selector_update`: {
-      const updates = direction === `forward` ? update.atomUpdates : [...update.atomUpdates].reverse();
-      for (const atomUpdate of updates) {
-        updateValues(atomUpdate);
-      }
+      ingestSelectorUpdate(applying, update, store);
       break;
     }
     case `transaction_update`: {
-      updateValuesFromTransactionUpdate(update);
+      ingestTransactionUpdate(applying, update, store);
       break;
     }
   }
-  if (direction === `forward`) {
+  if (action === `redo`) {
     ++timelineData.at;
   }
   timelineData.subject.next(action);
@@ -1886,44 +1905,8 @@ var abortTransaction = (store) => {
   );
   target.parent.child = null;
 };
-function ingestAtomUpdate(update, parent, child) {
-  var _a, _b, _c;
-  const { key, newValue } = update;
-  const token = { key, type: `atom` };
-  if (!parent.valueMap.has(token.key)) {
-    if (token.family) {
-      const family = parent.families.get(token.family.key);
-      if (family) {
-        family(token.family.subKey);
-      }
-    } else {
-      const newAtom = child.atoms.get(token.key);
-      if (!newAtom) {
-        throw new Error(
-          `Absurd Error: Atom "${token.key}" not found while copying updates from transaction "${(_a = child.transactionMeta) == null ? void 0 : _a.update.key}" to store "${parent.config.name}"`
-        );
-      }
-      parent.atoms.set(newAtom.key, newAtom);
-      parent.valueMap.set(newAtom.key, newAtom.default);
-      parent.logger.info(
-        `\u{1F528}`,
-        `transaction`,
-        (_c = (_b = child.transactionMeta) == null ? void 0 : _b.update.key) != null ? _c : `???`,
-        `Adding atom "${newAtom.key}"`
-      );
-    }
-  }
-  setState(token, newValue, parent);
-}
-function ingestTransactionUpdate(transactionUpdate, parent, child) {
-  for (const update of transactionUpdate.updates) {
-    if (`newValue` in update) {
-      ingestAtomUpdate(update, parent, child);
-    } else {
-      ingestTransactionUpdate(update, parent, child);
-    }
-  }
-}
+
+// internal/src/transaction/apply-transaction.ts
 var applyTransaction = (output, store) => {
   var _a;
   const child = newest(store);
@@ -1940,7 +1923,7 @@ var applyTransaction = (output, store) => {
   child.transactionMeta.phase = `applying`;
   child.transactionMeta.update.output = output;
   parent.child = null;
-  parent.subject.transactionApplying.next(child.transactionMeta);
+  parent.on.transactionApplying.next(child.transactionMeta);
   const { updates } = child.transactionMeta.update;
   store.logger.info(
     `\u{1F6C4}`,
@@ -1969,7 +1952,7 @@ var applyTransaction = (output, store) => {
       );
     }
   }
-  ingestTransactionUpdate(child.transactionMeta.update, parent, child);
+  ingestTransactionUpdate(`newValue`, child.transactionMeta.update, parent);
   if (parent.transactionMeta === null) {
     const myTransaction = withdraw(
       { key: child.transactionMeta.update.key, type: `transaction` },
@@ -1985,16 +1968,14 @@ var applyTransaction = (output, store) => {
   } else {
     parent.transactionMeta.update.updates.push(child.transactionMeta.update);
   }
-  parent.subject.transactionApplying.next(null);
+  parent.on.transactionApplying.next(null);
 };
-
-// internal/src/transaction/build-transaction.ts
-var buildTransaction = (key, params, store) => {
+var buildTransaction = (key, params, store, id) => {
   const parent = newest(store);
   const child = {
     parent,
     child: null,
-    subject: parent.subject,
+    on: parent.on,
     loggers: parent.loggers,
     logger: parent.logger,
     config: parent.config,
@@ -2020,14 +2001,17 @@ var buildTransaction = (key, params, store) => {
     time: Date.now(),
     update: {
       key,
+      id: id != null ? id : Math.random().toString(36).slice(2),
       updates: [],
       params,
       output: void 0
     },
     transactors: {
-      get: (token) => getState$1(token, child),
-      set: (token, value) => setState$1(token, value, child),
-      run: (token) => runTransaction(token, child)
+      get: (token) => getState(token, child),
+      set: (token, value) => setState(token, value, child),
+      run: (token) => runTransaction(token, child),
+      find: (token, key2) => findInStore(token, key2, child),
+      env: () => getEnvironmentData(child)
     }
   };
   parent.child = child;
@@ -2045,8 +2029,8 @@ function createTransaction(options, store) {
   const newTransaction = {
     key: options.key,
     type: `transaction`,
-    run: (...params) => {
-      buildTransaction(options.key, params, store);
+    run: (params, id) => {
+      buildTransaction(options.key, params, store, id);
       try {
         const target2 = newest(store);
         const { transactors } = target2.transactionMeta;
@@ -2065,13 +2049,13 @@ function createTransaction(options, store) {
   const target = newest(store);
   target.transactions.set(newTransaction.key, newTransaction);
   const token = deposit(newTransaction);
-  store.subject.transactionCreation.next(token);
+  store.on.transactionCreation.next(token);
   return token;
 }
 
 // internal/src/transaction/index.ts
 var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
 
-export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelector, createSelectorFamily, createTimeline, createTransaction, deleteAtom2 as deleteAtom, deleteSelector, deposit, eldest, evictCachedValue, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, isAtomDefault, isAtomKey, isDone, isReadonlySelectorKey, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
+export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelector, createSelectorFamily, createTimeline, createTransaction, deleteAtom, deleteSelector, deposit, eldest, evictCachedValue, getEnvironmentData, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isDone, isReadonlySelectorKey, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map