atom.io 0.3.1 → 0.4.0

package/src/internal/meta/meta-state.ts

@@ -0,0 +1,135 @@
+import type { AtomToken, ReadonlySelectorToken, SelectorToken } from "../.."
+import { selector, atom } from "../.."
+import type { Store } from "../store"
+import { IMPLICIT } from "../store"
+
+export type StateTokenIndex<
+  Token extends
+    | AtomToken<unknown>
+    | ReadonlySelectorToken<unknown>
+    | SelectorToken<unknown>
+> = Record<
+  string,
+  | Token
+  | {
+      key: string
+      familyMembers: Record<string, Token>
+    }
+>
+
+export type AtomTokenIndex = StateTokenIndex<AtomToken<unknown>>
+export type SelectorTokenIndex = StateTokenIndex<
+  ReadonlySelectorToken<unknown> | SelectorToken<unknown>
+>
+
+export const attachMetaAtoms = (
+  store: Store = IMPLICIT.STORE
+): ReadonlySelectorToken<AtomTokenIndex> => {
+  const atomTokenIndexState__INTERNAL = atom<AtomTokenIndex>({
+    key: `👁‍🗨_atom_token_index__INTERNAL`,
+    default: () =>
+      [...store.atoms].reduce<AtomTokenIndex>((acc, [key]) => {
+        acc[key] = { key, type: `atom` }
+        return acc
+      }, {}),
+    effects: [
+      ({ setSelf }) => {
+        store.subject.atomCreation.subscribe((atomToken) => {
+          if (store.operation.open) {
+            return
+          }
+          setSelf((state) => {
+            const { key, family } = atomToken
+            if (family) {
+              const { key: familyKey, subKey } = family
+              const current = state[familyKey]
+              if (current === undefined || `familyMembers` in current) {
+                const familyKeyState = current || {
+                  key: familyKey,
+                  familyMembers: {},
+                }
+                return {
+                  ...state,
+                  [familyKey]: {
+                    ...familyKeyState,
+                    familyMembers: {
+                      ...familyKeyState.familyMembers,
+                      [subKey]: atomToken,
+                    },
+                  },
+                }
+              }
+            }
+            return {
+              ...state,
+              [key]: atomToken,
+            }
+          })
+        })
+      },
+    ],
+  })
+  return selector({
+    key: `👁‍🗨_atom_token_index`,
+    get: ({ get }) => get(atomTokenIndexState__INTERNAL),
+  })
+}
+
+export const attachMetaSelectors = (
+  store: Store = IMPLICIT.STORE
+): ReadonlySelectorToken<SelectorTokenIndex> => {
+  const readonlySelectorTokenIndexState__INTERNAL = atom<SelectorTokenIndex>({
+    key: `👁‍🗨_selector_token_index__INTERNAL`,
+    default: () =>
+      Object.assign(
+        [...store.readonlySelectors].reduce<SelectorTokenIndex>((acc, [key]) => {
+          acc[key] = { key, type: `readonly_selector` }
+          return acc
+        }, {}),
+        [...store.selectors].reduce<SelectorTokenIndex>((acc, [key]) => {
+          acc[key] = { key, type: `selector` }
+          return acc
+        }, {})
+      ),
+    effects: [
+      ({ setSelf }) => {
+        store.subject.selectorCreation.subscribe((selectorToken) => {
+          if (store.operation.open) {
+            return
+          }
+          setSelf((state) => {
+            const { key, family } = selectorToken
+            if (family) {
+              const { key: familyKey, subKey } = family
+              const current = state[familyKey]
+              if (current === undefined || `familyMembers` in current) {
+                const familyKeyState = current || {
+                  key: familyKey,
+                  familyMembers: {},
+                }
+                return {
+                  ...state,
+                  [familyKey]: {
+                    ...familyKeyState,
+                    familyMembers: {
+                      ...familyKeyState.familyMembers,
+                      [subKey]: selectorToken,
+                    },
+                  },
+                }
+              }
+            }
+            return {
+              ...state,
+              [key]: selectorToken,
+            }
+          })
+        })
+      },
+    ],
+  })
+  return selector({
+    key: `👁‍🗨_selector_token_index`,
+    get: ({ get }) => get(readonlySelectorTokenIndexState__INTERNAL),
+  })
+}

package/src/internal/meta/meta-timelines.ts

@@ -0,0 +1 @@
+export {}

package/src/internal/meta/meta-transactions.ts

@@ -0,0 +1 @@
+export {}

package/src/internal/operation.ts

@@ -22,7 +22,6 @@ export type OperationProgress =
 export const openOperation = (token: StateToken<any>, store: Store): void => {
   const core = target(store)
   if (core.operation.open) {
-    console.warn(core.operation.open)
     store.config.logger?.error(
       `❌ failed to setState to "${token.key}" during a setState for "${core.operation.token.key}"`
     )

package/src/internal/selector-internal.ts

@@ -18,7 +18,7 @@ import type {
   AtomToken,
   FamilyMetadata,
   ReadonlySelectorOptions,
-  ReadonlyValueToken,
+  ReadonlySelectorToken,
   SelectorOptions,
   SelectorToken,
   StateToken,
@@ -46,7 +46,7 @@ export const lookupSelectorSources = (
   store: Store
 ): (
   | AtomToken<unknown>
-  | ReadonlyValueToken<unknown>
+  | ReadonlySelectorToken<unknown>
   | SelectorToken<unknown>
 )[] =>
   target(store)
@@ -56,7 +56,7 @@ export const lookupSelectorSources = (
 
 export const traceSelectorAtoms = (
   selectorKey: string,
-  dependency: ReadonlyValueToken<unknown> | StateToken<unknown>,
+  dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>,
   store: Store
 ): AtomToken<unknown>[] => {
   const roots: AtomToken<unknown>[] = []
@@ -97,12 +97,15 @@ export const traceAllSelectorAtoms = (
 
 export const updateSelectorAtoms = (
   selectorKey: string,
-  dependency: ReadonlyValueToken<unknown> | StateToken<unknown>,
+  dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>,
   store: Store
 ): void => {
   const core = target(store)
   if (dependency.type === `atom`) {
-    core.selectorAtoms = core.selectorAtoms.set(selectorKey, dependency.key)
+    core.selectorAtoms = core.selectorAtoms.set({
+      selectorKey,
+      atomKey: dependency.key,
+    })
     store.config.logger?.info(
       `   || adding root for "${selectorKey}": ${dependency.key}`
     )
@@ -114,7 +117,10 @@ export const updateSelectorAtoms = (
     roots.map((r) => r.key)
   )
   for (const root of roots) {
-    core.selectorAtoms = core.selectorAtoms.set(selectorKey, root.key)
+    core.selectorAtoms = core.selectorAtoms.set({
+      selectorKey,
+      atomKey: root.key,
+    })
   }
 }
 
@@ -142,9 +148,12 @@ export const registerSelector = (
         dependencyValue,
         `)`
       )
-      core.selectorGraph = core.selectorGraph.set(selectorKey, dependency.key, {
-        source: dependency.key,
-      })
+      core.selectorGraph = core.selectorGraph.set(
+        { from: dependency.key, to: selectorKey },
+        {
+          source: dependency.key,
+        }
+      )
     }
     updateSelectorAtoms(selectorKey, dependency, store)
     return dependencyValue
@@ -164,12 +173,12 @@ export function selector__INTERNAL<T>(
   options: ReadonlySelectorOptions<T>,
   family?: FamilyMetadata,
   store?: Store
-): ReadonlyValueToken<T>
+): ReadonlySelectorToken<T>
 export function selector__INTERNAL<T>(
   options: ReadonlySelectorOptions<T> | SelectorOptions<T>,
   family?: FamilyMetadata,
   store: Store = IMPLICIT.STORE
-): ReadonlyValueToken<T> | SelectorToken<T> {
+): ReadonlySelectorToken<T> | SelectorToken<T> {
   const core = target(store)
   if (HAMT.has(options.key, core.selectors)) {
     store.config.logger?.error(
@@ -200,7 +209,13 @@ export function selector__INTERNAL<T>(
     )
     const initialValue = getSelf()
     store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
-    return { ...readonlySelector, type: `readonly_selector` }
+    const token: ReadonlySelectorToken<T> = {
+      key: options.key,
+      type: `readonly_selector`,
+      family,
+    }
+    store.subject.selectorCreation.next(token)
+    return token
   }
   const setSelf = (next: T | ((oldValue: T) => T)): void => {
     store.config.logger?.info(`   <- "${options.key}" became`, next)
@@ -224,5 +239,11 @@ export function selector__INTERNAL<T>(
   core.selectors = HAMT.set(options.key, mySelector, core.selectors)
   const initialValue = getSelf()
   store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
-  return { ...mySelector, type: `selector` }
+  const token: SelectorToken<T> = {
+    key: options.key,
+    type: `selector`,
+    family,
+  }
+  store.subject.selectorCreation.next(token)
+  return token
 }

package/src/internal/store.ts

@@ -1,5 +1,6 @@
 import type { Hamt } from "hamt_plus"
 import HAMT from "hamt_plus"
+import * as Rx from "rxjs"
 
 import { doNothing } from "~/packages/anvl/src/function"
 import { Join } from "~/packages/anvl/src/join"
@@ -13,7 +14,16 @@ import type {
   Timeline,
   TimelineData,
 } from "."
-import type { Logger, Transaction, ƒn } from ".."
+import type {
+  AtomToken,
+  Logger,
+  ReadonlySelectorToken,
+  SelectorToken,
+  TimelineToken,
+  Transaction,
+  TransactionToken,
+  ƒn,
+} from ".."
 
 export type StoreCore = Pick<
   Store,
@@ -34,15 +44,24 @@ export interface Store {
   atoms: Hamt<Atom<any>, string>
   atomsThatAreDefault: Set<string>
   readonlySelectors: Hamt<ReadonlySelector<any>, string>
-  selectorAtoms: Join
+  selectorAtoms: Join<null, `selectorKey`, `atomKey`>
   selectorGraph: Join<{ source: string }>
   selectors: Hamt<Selector<any>, string>
   timelines: Hamt<Timeline, string>
-  timelineAtoms: Join
+  timelineAtoms: Join<null, `timelineKey`, `atomKey`>
   timelineStore: Hamt<TimelineData, string>
   transactions: Hamt<Transaction<any>, string>
   valueMap: Hamt<any, string>
 
+  subject: {
+    atomCreation: Rx.Subject<AtomToken<unknown>>
+    selectorCreation: Rx.Subject<
+      ReadonlySelectorToken<unknown> | SelectorToken<unknown>
+    >
+    transactionCreation: Rx.Subject<TransactionToken<unknown>>
+    timelineCreation: Rx.Subject<TimelineToken>
+  }
+
   operation: OperationProgress
   transactionStatus: TransactionStatus<ƒn>
   config: {
@@ -57,15 +76,26 @@ export const createStore = (name: string): Store =>
     atoms: HAMT.make<Atom<any>, string>(),
     atomsThatAreDefault: new Set(),
     readonlySelectors: HAMT.make<ReadonlySelector<any>, string>(),
-    selectorAtoms: new Join({ relationType: `n:n` }),
+    selectorAtoms: new Join({ relationType: `n:n` })
+      .from(`selectorKey`)
+      .to(`atomKey`),
     selectorGraph: new Join({ relationType: `n:n` }),
     selectors: HAMT.make<Selector<any>, string>(),
     timelines: HAMT.make<Timeline, string>(),
-    timelineAtoms: new Join({ relationType: `1:n` }),
+    timelineAtoms: new Join({ relationType: `1:n` })
+      .from(`timelineKey`)
+      .to(`atomKey`),
     timelineStore: HAMT.make<TimelineData, string>(),
     transactions: HAMT.make<Transaction<any>, string>(),
     valueMap: HAMT.make<any, string>(),
 
+    subject: {
+      atomCreation: new Rx.Subject(),
+      selectorCreation: new Rx.Subject(),
+      transactionCreation: new Rx.Subject(),
+      timelineCreation: new Rx.Subject(),
+    },
+
     operation: {
       open: false,
     },

package/src/internal/time-travel-internal.ts

@@ -0,0 +1,89 @@
+import type { Store } from "."
+import { IMPLICIT } from "."
+import { setState } from ".."
+import type { TimelineToken } from ".."
+
+export const redo__INTERNAL = (
+  token: TimelineToken,
+  store: Store = IMPLICIT.STORE
+): void => {
+  store.config.logger?.info(`⏩ redo "${token.key}"`)
+  const timelineData = store.timelineStore.get(token.key)
+  if (!timelineData) {
+    store.config.logger?.error(
+      `Failed to redo on timeline "${token.key}". This timeline has not been initialized.`
+    )
+    return
+  }
+  if (timelineData.at === timelineData.history.length) {
+    store.config.logger?.warn(
+      `Failed to redo at the end of timeline "${token.key}". There is nothing to redo.`
+    )
+    return
+  }
+  timelineData.timeTraveling = true
+  const update = timelineData.history[timelineData.at]
+  switch (update.type) {
+    case `atom_update`: {
+      const { key, newValue } = update
+      setState({ key, type: `atom` }, newValue)
+      break
+    }
+    case `selector_update`:
+    case `transaction_update`: {
+      for (const atomUpdate of update.atomUpdates) {
+        const { key, newValue } = atomUpdate
+        setState({ key, type: `atom` }, newValue)
+      }
+      break
+    }
+  }
+  ++timelineData.at
+  timelineData.timeTraveling = false
+  store.config.logger?.info(
+    `⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
+  )
+}
+
+export const undo__INTERNAL = (
+  token: TimelineToken,
+  store: Store = IMPLICIT.STORE
+): void => {
+  store.config.logger?.info(`⏪ undo "${token.key}"`)
+  const timelineData = store.timelineStore.get(token.key)
+  if (!timelineData) {
+    store.config.logger?.error(
+      `Failed to undo on timeline "${token.key}". This timeline has not been initialized.`
+    )
+    return
+  }
+  if (timelineData.at === 0) {
+    store.config.logger?.warn(
+      `Failed to undo at the beginning of timeline "${token.key}". There is nothing to undo.`
+    )
+    return
+  }
+  timelineData.timeTraveling = true
+
+  --timelineData.at
+  const update = timelineData.history[timelineData.at]
+  switch (update.type) {
+    case `atom_update`: {
+      const { key, oldValue } = update
+      setState({ key, type: `atom` }, oldValue)
+      break
+    }
+    case `selector_update`:
+    case `transaction_update`: {
+      for (const atomUpdate of update.atomUpdates) {
+        const { key, oldValue } = atomUpdate
+        setState({ key, type: `atom` }, oldValue)
+      }
+      break
+    }
+  }
+  timelineData.timeTraveling = false
+  store.config.logger?.info(
+    `⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
+  )
+}

package/src/internal/timeline-internal.ts

@@ -1,10 +1,7 @@
-/* eslint-disable max-lines */
-
 import HAMT from "hamt_plus"
 
 import type { KeyedStateUpdate, TransactionUpdate, Store } from "."
 import { target, IMPLICIT, withdraw } from "."
-import { setState } from ".."
 import type { AtomToken, TimelineOptions, TimelineToken, ƒn } from ".."
 
 export type Timeline = {
@@ -34,19 +31,20 @@ export type TimelineData = {
     | TimelineSelectorUpdate
     | TimelineTransactionUpdate
   )[]
+  selectorTime: number | null
+  transactionKey: string | null
 }
 
 export function timeline__INTERNAL(
   options: TimelineOptions,
   store: Store = IMPLICIT.STORE
 ): TimelineToken {
-  let incompleteSelectorTime: number | null = null
-  // let selectorAtomUpdates: TimelineAtomUpdate[] = []
-  let incompleteTransactionKey: string | null = null
   const timelineData: TimelineData = {
     at: 0,
     timeTraveling: false,
     history: [],
+    selectorTime: null,
+    transactionKey: null,
   }
 
   const subscribeToAtom = (token: AtomToken<any>) => {
@@ -71,8 +69,10 @@ export function timeline__INTERNAL(
         `->`,
         update.newValue,
         storeCurrentTransactionKey
-          ? `) in "${storeCurrentTransactionKey}"`
-          : `) independently`
+          ? `) in transaction "${storeCurrentTransactionKey}"`
+          : storeCurrentSelectorKey
+          ? `) in selector "${storeCurrentSelectorKey}"`
+          : `)`
       )
 
       if (
@@ -83,13 +83,13 @@ export function timeline__INTERNAL(
           { key: storeCurrentTransactionKey, type: `transaction` },
           store
         )
-        if (incompleteTransactionKey !== storeCurrentTransactionKey) {
-          if (incompleteTransactionKey) {
+        if (timelineData.transactionKey !== storeCurrentTransactionKey) {
+          if (timelineData.transactionKey) {
             store.config.logger?.error(
-              `Timeline "${options.key}" was unable to resolve transaction "${incompleteTransactionKey}. This is probably a bug.`
+              `Timeline "${options.key}" was unable to resolve transaction "${timelineData.transactionKey}. This is probably a bug.`
             )
           }
-          incompleteTransactionKey = storeCurrentTransactionKey
+          timelineData.transactionKey = storeCurrentTransactionKey
           const subscription = currentTransaction.subject.subscribe((update) => {
             if (timelineData.timeTraveling === false) {
               if (timelineData.at !== timelineData.history.length) {
@@ -105,7 +105,7 @@ export function timeline__INTERNAL(
             }
             timelineData.at = timelineData.history.length
             subscription.unsubscribe()
-            incompleteTransactionKey = null
+            timelineData.transactionKey = null
             store.config.logger?.info(
               `⌛ timeline "${options.key}" got a transaction_update "${update.key}"`
             )
@@ -113,7 +113,7 @@ export function timeline__INTERNAL(
         }
       } else if (storeCurrentSelectorKey) {
         if (timelineData.timeTraveling === false) {
-          if (storeCurrentSelectorTime !== incompleteSelectorTime) {
+          if (storeCurrentSelectorTime !== timelineData.selectorTime) {
             const newSelectorUpdate: TimelineSelectorUpdate = {
               type: `selector_update`,
               key: storeCurrentSelectorKey,
@@ -134,7 +134,7 @@ export function timeline__INTERNAL(
               newSelectorUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
             )
             timelineData.at = timelineData.history.length
-            incompleteSelectorTime = storeCurrentSelectorTime
+            timelineData.selectorTime = storeCurrentSelectorTime
           } else {
             const latestUpdate = timelineData.history.at(-1)
             if (latestUpdate?.type === `selector_update`) {
@@ -152,7 +152,7 @@ export function timeline__INTERNAL(
         }
       } else {
         if (timelineData.timeTraveling === false) {
-          incompleteSelectorTime = null
+          timelineData.selectorTime = null
           if (timelineData.at !== timelineData.history.length) {
             timelineData.history.splice(timelineData.at)
           }
@@ -197,97 +197,17 @@ export function timeline__INTERNAL(
       }
       subscribeToAtom(token)
     }
-    core.timelineAtoms = core.timelineAtoms.set(tokenOrFamily.key, options.key)
+    core.timelineAtoms = core.timelineAtoms.set({
+      atomKey: tokenOrFamily.key,
+      timelineKey: options.key,
+    })
   }
 
   store.timelineStore = HAMT.set(options.key, timelineData, store.timelineStore)
-  return {
+  const token: TimelineToken = {
     key: options.key,
     type: `timeline`,
   }
-}
-
-export const redo__INTERNAL = (
-  token: TimelineToken,
-  store: Store = IMPLICIT.STORE
-): void => {
-  store.config.logger?.info(`⏩ redo "${token.key}"`)
-  const timelineData = store.timelineStore.get(token.key)
-  if (!timelineData) {
-    store.config.logger?.error(
-      `Failed to redo on timeline "${token.key}". This timeline has not been initialized.`
-    )
-    return
-  }
-  if (timelineData.at === timelineData.history.length) {
-    store.config.logger?.warn(
-      `Failed to redo at the end of timeline "${token.key}". There is nothing to redo.`
-    )
-    return
-  }
-  timelineData.timeTraveling = true
-  const update = timelineData.history[timelineData.at]
-  switch (update.type) {
-    case `atom_update`: {
-      const { key, newValue } = update
-      setState({ key, type: `atom` }, newValue)
-      break
-    }
-    case `selector_update`:
-    case `transaction_update`: {
-      for (const atomUpdate of update.atomUpdates) {
-        const { key, newValue } = atomUpdate
-        setState({ key, type: `atom` }, newValue)
-      }
-      break
-    }
-  }
-  ++timelineData.at
-  timelineData.timeTraveling = false
-  store.config.logger?.info(
-    `⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
-  )
-}
-
-export const undo__INTERNAL = (
-  token: TimelineToken,
-  store: Store = IMPLICIT.STORE
-): void => {
-  store.config.logger?.info(`⏪ undo "${token.key}"`)
-  const timelineData = store.timelineStore.get(token.key)
-  if (!timelineData) {
-    store.config.logger?.error(
-      `Failed to undo on timeline "${token.key}". This timeline has not been initialized.`
-    )
-    return
-  }
-  if (timelineData.at === 0) {
-    store.config.logger?.warn(
-      `Failed to undo at the beginning of timeline "${token.key}". There is nothing to undo.`
-    )
-    return
-  }
-  timelineData.timeTraveling = true
-
-  --timelineData.at
-  const update = timelineData.history[timelineData.at]
-  switch (update.type) {
-    case `atom_update`: {
-      const { key, oldValue } = update
-      setState({ key, type: `atom` }, oldValue)
-      break
-    }
-    case `selector_update`:
-    case `transaction_update`: {
-      for (const atomUpdate of update.atomUpdates) {
-        const { key, oldValue } = atomUpdate
-        setState({ key, type: `atom` }, oldValue)
-      }
-      break
-    }
-  }
-  timelineData.timeTraveling = false
-  store.config.logger?.info(
-    `⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
-  )
+  store.subject.timelineCreation.next(token)
+  return token
 }

package/src/internal/transaction-internal.ts

@@ -2,7 +2,7 @@ import HAMT from "hamt_plus"
 import * as Rx from "rxjs"
 
 import type { Store, StoreCore } from "."
-import { deposit, withdraw, IMPLICIT } from "."
+import { cacheValue, deposit, withdraw, IMPLICIT } from "."
 import { getState, setState } from ".."
 import type {
   AtomToken,
@@ -75,14 +75,22 @@ export const applyTransaction = <ƒ extends ƒn>(
     return
   }
   store.config.logger?.info(
-    ` ▶️ apply transaction "${store.transactionStatus.key}" (init)`
+    `🛃 apply transaction "${store.transactionStatus.key}"`
   )
   store.transactionStatus.phase = `applying`
   store.transactionStatus.output = output
   const { atomUpdates } = store.transactionStatus
-  for (const { key, oldValue, newValue } of atomUpdates) {
+
+  for (const { key, newValue } of atomUpdates) {
     const token: AtomToken<unknown> = { key, type: `atom` }
+    if (!HAMT.has(token.key, store.valueMap)) {
+      const atom = HAMT.get(token.key, store.transactionStatus.core.atoms)
+      store.atoms = HAMT.set(atom.key, atom, store.atoms)
+      store.valueMap = HAMT.set(atom.key, atom.default, store.valueMap)
+      store.config.logger?.info(`🔧`, `add atom "${atom.key}"`)
+    }
     const state = withdraw(token, store)
+
     setState(state, newValue, store)
   }
   const myTransaction = withdraw<ƒ>(
@@ -103,7 +111,7 @@ export const undoTransactionUpdate = <ƒ extends ƒn>(
   store: Store
 ): void => {
   store.config.logger?.info(` ⏮ undo transaction "${update.key}" (undo)`)
-  for (const { key, oldValue, newValue } of update.atomUpdates) {
+  for (const { key, oldValue } of update.atomUpdates) {
     const token: AtomToken<unknown> = { key, type: `atom` }
     const state = withdraw(token, store)
     setState(state, oldValue, store)
@@ -114,7 +122,7 @@ export const redoTransactionUpdate = <ƒ extends ƒn>(
   store: Store
 ): void => {
   store.config.logger?.info(` ⏭ redo transaction "${update.key}" (redo)`)
-  for (const { key, oldValue, newValue } of update.atomUpdates) {
+  for (const { key, newValue } of update.atomUpdates) {
     const token: AtomToken<unknown> = { key, type: `atom` }
     const state = withdraw(token, store)
     setState(state, newValue, store)
@@ -166,6 +174,7 @@ export function transaction__INTERNAL<ƒ extends ƒn>(
     core.transactions
   )
   const token = deposit(newTransaction)
+  store.subject.transactionCreation.next(token)
   return token
 }