@livestore/livestore 0.0.21 → 0.0.22

package/src/reactive.ts

@@ -24,9 +24,9 @@
 /* eslint-disable prefer-arrow/prefer-arrow-functions */
 
 import type { PrettifyFlat } from '@livestore/utils'
-import { pick, shouldNeverHappen } from '@livestore/utils'
+import { pick } from '@livestore/utils'
 import type * as otel from '@opentelemetry/api'
-import { isEqual, max, uniqueId } from 'lodash-es'
+import { isEqual, uniqueId } from 'lodash-es'
 
 import { BoundArray } from './bounded-collections.js'
 // import { getDurationMsFromSpan } from './otel.js'
@@ -34,32 +34,33 @@ import { BoundArray } from './bounded-collections.js'
 export const NOT_REFRESHED_YET = Symbol.for('NOT_REFRESHED_YET')
 export type NOT_REFRESHED_YET = typeof NOT_REFRESHED_YET
 
-export type GetAtom = <T>(atom: Atom<T, any>, otelContext?: otel.Context) => T
+export type GetAtom = <T>(atom: Atom<T, any, any>, otelContext?: otel.Context) => T
 
-export type Ref<T> = {
+export type Ref<T, TContext, TDebugRefreshReason extends Taggable> = {
   _tag: 'ref'
   id: string
   isDirty: false
   previousResult: T
-  height: 0
   computeResult: () => T
-  sub: Set<Atom<any, TODO>> // always empty
-  super: Set<Atom<any, TODO> | Effect>
+  sub: Set<Atom<any, TContext, TDebugRefreshReason>> // always empty
+  super: Set<Atom<any, TContext, TDebugRefreshReason> | Effect>
   label?: string
   /** Container for meta information (e.g. the LiveStore Store) */
   meta?: any
   equal: (a: T, b: T) => boolean
 }
 
-type BaseThunk<TResult, TContext> = {
+export type Thunk<TResult, TContext, TDebugRefreshReason extends Taggable> = {
   _tag: 'thunk'
   id: string
   isDirty: boolean
-  height: number
-  computeResult: (otelContext?: otel.Context) => TResult
+  computeResult: (
+    otelContext?: otel.Context,
+    debugRefreshReason?: RefreshReasonWithGenericReasons<TDebugRefreshReason>,
+  ) => TResult
   previousResult: TResult | NOT_REFRESHED_YET
-  sub: Set<Atom<any, TContext>>
-  super: Set<Atom<any, TContext> | Effect>
+  sub: Set<Atom<any, TContext, TDebugRefreshReason>>
+  super: Set<Atom<any, TContext, TDebugRefreshReason> | Effect>
   label?: string
   /** Container for meta information (e.g. the LiveStore Store) */
   meta?: any
@@ -69,34 +70,37 @@ type BaseThunk<TResult, TContext> = {
   __getResult: any
 }
 
-type UnevaluatedThunk<T, TContext> = BaseThunk<T, TContext>
-// & { result: NOT_REFRESHED_YET }
-export type Thunk<T, TContext> = BaseThunk<T, TContext>
-// & { result: T }
-
-export type Atom<T, TContext> = Ref<T> | Thunk<T, TContext>
+export type Atom<T, TContext, TDebugRefreshReason extends Taggable> =
+  | Ref<T, TContext, TDebugRefreshReason>
+  | Thunk<T, TContext, TDebugRefreshReason>
 
 export type Effect = {
   _tag: 'effect'
   id: string
   doEffect: (otelContext?: otel.Context) => void
-  sub: Set<Atom<any, TODO>>
+  sub: Set<Atom<any, TODO, TODO>>
+  label?: string
 }
 
 export type Taggable<T extends string = string> = { _tag: T }
 
+export type DebugThunkInfo<T extends string = string> = {
+  _tag: T
+  durationMs: number
+}
+
 export type ReactiveGraphOptions = {
   effectsWrapper?: (runEffects: () => void) => void
 }
 
-export type AtomDebugInfo<TDebugThunkInfo extends Taggable> = {
+export type AtomDebugInfo<TDebugThunkInfo extends DebugThunkInfo> = {
   atom: SerializedAtom
   resultChanged: boolean
-  durationMs: number
   debugInfo: TDebugThunkInfo
 }
 
-export type RefreshDebugInfo<TDebugRefreshReason extends Taggable, TDebugThunkInfo extends Taggable> = {
+// TODO possibly find a better name for "refresh"
+export type RefreshDebugInfo<TDebugRefreshReason extends Taggable, TDebugThunkInfo extends DebugThunkInfo> = {
   /** Currently only used for easier handling in React (e.g. as key) */
   id: string
   reason: TDebugRefreshReason
@@ -114,10 +118,6 @@ export type RefreshReasonWithGenericReasons<T extends Taggable> =
       _tag: 'makeThunk'
       label?: string
     }
-  | {
-      _tag: 'makeEffect'
-      label?: string
-    }
   | { _tag: 'unknown' }
 
 export const unknownRefreshReason = () => {
@@ -127,7 +127,7 @@ export const unknownRefreshReason = () => {
 
 export type SerializedAtom = Readonly<
   PrettifyFlat<
-    Pick<Atom<unknown, TODO>, '_tag' | 'height' | 'id' | 'label' | 'meta'> & {
+    Pick<Atom<unknown, unknown, any>, '_tag' | 'id' | 'label' | 'meta'> & {
       sub: string[]
       super: string[]
     }
@@ -146,16 +146,20 @@ type ReactiveGraphSnapshot = {
 const uniqueNodeId = () => uniqueId('node-')
 const uniqueRefreshInfoId = () => uniqueId('refresh-info-')
 
-const serializeAtom = (atom: Atom<any, TODO>): SerializedAtom => ({
-  ...pick(atom, ['_tag', 'height', 'id', 'label', 'meta']),
+const serializeAtom = (atom: Atom<any, unknown, any>): SerializedAtom => ({
+  ...pick(atom, ['_tag', 'id', 'label', 'meta']),
   sub: Array.from(atom.sub).map((a) => a.id),
   super: Array.from(atom.super).map((a) => a.id),
 })
 
 // const serializeEffect = (effect: Effect): SerializedEffect => pick(effect, ['_tag', 'id'])
 
-export class ReactiveGraph<TDebugRefreshReason extends Taggable, TDebugThunkInfo extends Taggable, TContext = {}> {
-  readonly atoms: Set<Atom<any, TContext>> = new Set()
+export class ReactiveGraph<
+  TDebugRefreshReason extends Taggable,
+  TDebugThunkInfo extends DebugThunkInfo,
+  TContext = {},
+> {
+  readonly atoms: Set<Atom<any, TContext, TDebugRefreshReason>> = new Set()
   effectsWrapper: (runEffects: () => void) => void
 
   context: TContext | undefined
@@ -164,17 +168,21 @@ export class ReactiveGraph<TDebugRefreshReason extends Taggable, TDebugThunkInfo
     RefreshDebugInfo<RefreshReasonWithGenericReasons<TDebugRefreshReason>, TDebugThunkInfo>
   > = new BoundArray(5000)
 
+  currentDebugRefresh: { refreshedAtoms: AtomDebugInfo<TDebugThunkInfo>[]; startMs: DOMHighResTimeStamp } | undefined
+
   constructor(options: ReactiveGraphOptions) {
     this.effectsWrapper = options?.effectsWrapper ?? ((runEffects: () => void) => runEffects())
   }
 
-  makeRef<T>(val: T, options?: { label?: string; meta?: unknown; equal?: (a: T, b: T) => boolean }): Ref<T> {
-    const ref: Ref<T> = {
+  makeRef<T>(
+    val: T,
+    options?: { label?: string; meta?: unknown; equal?: (a: T, b: T) => boolean },
+  ): Ref<T, TContext, TDebugRefreshReason> {
+    const ref: Ref<T, TContext, TDebugRefreshReason> = {
       _tag: 'ref',
       id: uniqueNodeId(),
       isDirty: false,
       previousResult: val,
-      height: 0,
       computeResult: () => ref.previousResult,
       sub: new Set(),
       super: new Set(),
@@ -189,9 +197,9 @@ export class ReactiveGraph<TDebugRefreshReason extends Taggable, TDebugThunkInfo
   }
 
   makeThunk<T>(
-    getResult_: (
+    getResult: (
       get: GetAtom,
-      addDebugInfo: (debugInfo: TDebugThunkInfo) => void,
+      setDebugInfo: (debugInfo: TDebugThunkInfo) => void,
       ctx: TContext,
       otelContext: otel.Context | undefined,
     ) => T,
@@ -201,67 +209,73 @@ export class ReactiveGraph<TDebugRefreshReason extends Taggable, TDebugThunkInfo
           meta?: any
           equal?: (a: T, b: T) => boolean
           /** Debug info for initializing the thunk (i.e. running it the first time) */
-          debugRefreshReason?: RefreshReasonWithGenericReasons<TDebugRefreshReason>
+          // debugRefreshReason?: RefreshReasonWithGenericReasons<TDebugRefreshReason>
         }
       | undefined,
-  ): Thunk<T, TContext> {
-    // const computeResult = (): T => {
-    //   const getAtom = (atom: Atom<T, any>): T => {
-    //     const __getResult = atom._tag === 'thunk' ? atom.__getResult.toString() : ''
-    //     if (atom.isDirty) {
-    //       console.log('atom is dirty', atom.id, atom.label ?? '', atom._tag, __getResult)
-    //       const result = atom.computeResult()
-    //       atom.isDirty = false
-    //       atom.previousResult = result
-    //       return result
-    //     } else {
-    //       console.log('atom is clean', atom.id, atom.label ?? '', atom._tag, __getResult)
-    //       return atom.previousResult as T
-    //     }
-    //   }
-
-    // let resultChanged = false
-    // const debugInfoForAtom = {
-    //   atom: serializeAtom(null as TODO),
-    //   resultChanged,
-    //   // debugInfo: unknownRefreshReason() as TDebugThunkInfo,
-    //   debugInfo: { _tag: 'unknown' } as TDebugThunkInfo,
-    //   durationMs: 0,
-    // } satisfies AtomDebugInfo<TDebugThunkInfo>
-
-    const addDebugInfo = (_debugInfo: TDebugThunkInfo) => {
-      // debugInfoForAtom.debugInfo = debugInfo
-    }
-
-    //       debugInfoForRefreshedAtoms.push(debugInfoForAtom)
-
-    // return getResult_(getAtom as GetAtom, addDebugInfo, this.context!)
-    // }
-
-    const thunk: UnevaluatedThunk<T, TContext> = {
+  ): Thunk<T, TContext, TDebugRefreshReason> {
+    const thunk: Thunk<T, TContext, TDebugRefreshReason> = {
       _tag: 'thunk',
       id: uniqueNodeId(),
       previousResult: NOT_REFRESHED_YET,
       isDirty: true,
-      height: 0,
-      computeResult: (otelContext) => {
+      computeResult: (otelContext, debugRefreshReason) => {
         if (thunk.isDirty) {
+          const neededCurrentRefresh = this.currentDebugRefresh === undefined
+          if (neededCurrentRefresh) {
+            this.currentDebugRefresh = { refreshedAtoms: [], startMs: performance.now() }
+          }
+
           // Reset previous subcomputations as we're about to re-add them as part of the `doEffect` call below
           thunk.sub = new Set()
 
-          const compute_ = (atom: Atom<T, unknown>, otelContext: otel.Context) => {
+          const getAtom = (atom: Atom<T, TContext, TDebugRefreshReason>, otelContext: otel.Context) => {
             this.addEdge(thunk, atom)
             return compute(atom, otelContext)
           }
-          const result = getResult_(
-            compute_ as GetAtom,
-            addDebugInfo,
-            this.context ?? shouldNeverHappen('No store context set yet'),
+
+          let debugInfo: TDebugThunkInfo | undefined = undefined
+          const setDebugInfo = (debugInfo_: TDebugThunkInfo) => {
+            debugInfo = debugInfo_
+          }
+
+          const result = getResult(
+            getAtom as GetAtom,
+            setDebugInfo,
+            this.context ?? throwContextNotSetError(),
             otelContext,
           )
+
+          const resultChanged = thunk.equal(thunk.previousResult as T, result) === false
+
+          const debugInfoForAtom = {
+            atom: serializeAtom(thunk),
+            resultChanged,
+            debugInfo: debugInfo ?? (unknownRefreshReason() as TDebugThunkInfo),
+          } satisfies AtomDebugInfo<TDebugThunkInfo>
+
+          this.currentDebugRefresh!.refreshedAtoms.push(debugInfoForAtom)
+
           thunk.isDirty = false
           thunk.previousResult = result
           thunk.recomputations++
+
+          if (neededCurrentRefresh) {
+            const refreshedAtoms = this.currentDebugRefresh!.refreshedAtoms
+            const durationMs = performance.now() - this.currentDebugRefresh!.startMs
+            this.currentDebugRefresh = undefined
+
+            const refreshDebugInfo = {
+              id: uniqueRefreshInfoId(),
+              reason: debugRefreshReason ?? { _tag: 'makeThunk', label: options?.label },
+              skippedRefresh: false,
+              refreshedAtoms,
+              durationMs,
+              completedTimestamp: Date.now(),
+              graphSnapshot: this.getSnapshot(),
+            }
+            this.debugRefreshInfos.push(refreshDebugInfo)
+          }
+
           return result
         } else {
           return thunk.previousResult as T
@@ -273,29 +287,15 @@ export class ReactiveGraph<TDebugRefreshReason extends Taggable, TDebugThunkInfo
       label: options?.label,
       meta: options?.meta,
       equal: options?.equal ?? isEqual,
-      __getResult: getResult_,
+      __getResult: getResult,
     }
 
     this.atoms.add(thunk)
-    // this.dirtyNodes.add(thunk)
-
-    const debugRefreshReason = options?.debugRefreshReason ?? { _tag: 'makeThunk', label: options?.label }
-
-    const refreshDebugInfo = {
-      id: uniqueRefreshInfoId(),
-      reason: debugRefreshReason,
-      skippedRefresh: true,
-      refreshedAtoms: [],
-      durationMs: 0,
-      completedTimestamp: Date.now(),
-      graphSnapshot: this.getSnapshot(),
-    }
-    this.debugRefreshInfos.push(refreshDebugInfo)
 
-    return thunk as unknown as Thunk<T, TContext>
+    return thunk
   }
 
-  destroy(node: Atom<any, TContext> | Effect) {
+  destroy(node: Atom<any, TContext, TDebugRefreshReason> | Effect) {
     // Recursively destroy any supercomputations
     if (node._tag === 'ref' || node._tag === 'thunk') {
       for (const superComp of node.super) {
@@ -315,50 +315,33 @@ export class ReactiveGraph<TDebugRefreshReason extends Taggable, TDebugThunkInfo
 
   makeEffect(
     doEffect: (get: GetAtom, otelContext?: otel.Context) => void,
-    options?:
-      | {
-          label?: string
-          debugRefreshReason?: RefreshReasonWithGenericReasons<TDebugRefreshReason>
-        }
-      | undefined,
+    options?: { label?: string } | undefined,
   ): Effect {
     const effect: Effect = {
       _tag: 'effect',
       id: uniqueNodeId(),
       doEffect: (otelContext) => {
+        // NOTE we're not tracking any debug refresh info for effects as they're tracked by the thunks they depend on
+
         // Reset previous subcomputations as we're about to re-add them as part of the `doEffect` call below
         effect.sub = new Set()
 
-        const getAtom = (atom: Atom<any, unknown>, otelContext: otel.Context) => {
+        const getAtom = (atom: Atom<any, TContext, TDebugRefreshReason>, otelContext: otel.Context) => {
           this.addEdge(effect, atom)
           return compute(atom, otelContext)
         }
+
         doEffect(getAtom as GetAtom, otelContext)
       },
       sub: new Set(),
+      label: options?.label,
     }
 
-    // this.effects.add(effect)
-    // this.dirtyNodes.add(effect)
-
-    const debugRefreshReason = options?.debugRefreshReason ?? { _tag: 'makeEffect', label: options?.label }
-
-    const refreshDebugInfo = {
-      id: uniqueRefreshInfoId(),
-      reason: debugRefreshReason ?? (unknownRefreshReason() as TDebugRefreshReason),
-      skippedRefresh: true,
-      refreshedAtoms: [],
-      durationMs: 0,
-      completedTimestamp: Date.now(),
-      graphSnapshot: this.getSnapshot(),
-    }
-    this.debugRefreshInfos.push(refreshDebugInfo)
-
     return effect
   }
 
   setRef<T>(
-    ref: Ref<T>,
+    ref: Ref<T, TContext, TDebugRefreshReason>,
     val: T,
     options?:
       | {
@@ -367,32 +350,16 @@ export class ReactiveGraph<TDebugRefreshReason extends Taggable, TDebugThunkInfo
         }
       | undefined,
   ) {
-    const { debugRefreshReason } = options ?? {}
     ref.previousResult = val
 
     const effectsToRefresh = new Set<Effect>()
     markSuperCompDirtyRec(ref, effectsToRefresh)
 
-    this.effectsWrapper(() => {
-      for (const effect of effectsToRefresh) {
-        effect.doEffect(options?.otelContext)
-      }
-    })
-
-    const refreshDebugInfo: RefreshDebugInfo<TDebugRefreshReason, TDebugThunkInfo> = {
-      id: uniqueRefreshInfoId(),
-      reason: debugRefreshReason ?? (unknownRefreshReason() as TDebugRefreshReason),
-      skippedRefresh: true,
-      refreshedAtoms: [],
-      durationMs: 0,
-      completedTimestamp: Date.now(),
-      graphSnapshot: this.getSnapshot(),
-    }
-    this.debugRefreshInfos.push(refreshDebugInfo)
+    this.runEffects(effectsToRefresh, options)
   }
 
   setRefs<T>(
-    refs: [Ref<T>, T][],
+    refs: [Ref<T, TContext, TDebugRefreshReason>, T][],
     options?:
       | {
           debugRefreshReason?: TDebugRefreshReason
@@ -400,7 +367,6 @@ export class ReactiveGraph<TDebugRefreshReason extends Taggable, TDebugThunkInfo
         }
       | undefined,
   ) {
-    const debugRefreshReason = options?.debugRefreshReason
     const effectsToRefresh = new Set<Effect>()
     for (const [ref, val] of refs) {
       ref.previousResult = val
@@ -408,213 +374,56 @@ export class ReactiveGraph<TDebugRefreshReason extends Taggable, TDebugThunkInfo
       markSuperCompDirtyRec(ref, effectsToRefresh)
     }
 
+    this.runEffects(effectsToRefresh, options)
+  }
+
+  private runEffects = (
+    effectsToRefresh: Set<Effect>,
+    options?:
+      | {
+          debugRefreshReason?: TDebugRefreshReason
+          otelContext?: otel.Context
+        }
+      | undefined,
+  ) => {
     this.effectsWrapper(() => {
+      this.currentDebugRefresh = { refreshedAtoms: [], startMs: performance.now() }
+
       for (const effect of effectsToRefresh) {
         effect.doEffect(options?.otelContext)
       }
-    })
 
-    const refreshDebugInfo: RefreshDebugInfo<TDebugRefreshReason, TDebugThunkInfo> = {
-      id: uniqueRefreshInfoId(),
-      reason: debugRefreshReason ?? (unknownRefreshReason() as TDebugRefreshReason),
-      skippedRefresh: true,
-      refreshedAtoms: [],
-      durationMs: 0,
-      completedTimestamp: Date.now(),
-      graphSnapshot: this.getSnapshot(),
-    }
-    this.debugRefreshInfos.push(refreshDebugInfo)
-  }
-
-  // get<T>(atom: Atom<T, TContext>, context: Atom<any, TContext> | Effect): T {
-  //   // Autotracking: if we're getting the value of an atom,
-  //   // that means it's a subcomputation for the currently refreshing atom.
-  //   this.addEdge(context, atom)
-
-  //   const dependencyMightBeStale = context._tag !== 'effect' && context.height <= atom.height
-  //   const dependencyNotRefreshedYet = atom.result === NOT_REFRESHED_YET
-
-  //   if (dependencyMightBeStale || dependencyNotRefreshedYet) {
-  //     throw new DependencyNotReadyError(
-  //       `${this.label(context)} referenced dependency ${this.label(atom)} which isn't ready`,
-  //     )
-  //   }
-
-  //   return atom.result
-  // }
-
-  /**
-   * Update the graph to be consistent with the current values of the root atoms.
-   * Generally we run this after a ref is updated.
-   * At the end of the refresh, we run any effects that were scheduled.
-   *
-   * @param roots Root atoms to start the refresh from
-   */
-  // refresh(
-  //   options?:
-  //     | {
-  //         otelHint?: string
-  //         debugRefreshReason?: RefreshReasonWithGenericReasons<TDebugRefreshReason>
-  //       }
-  //     | undefined,
-  //   otelContext: otel.Context = otel.context.active(),
-  // ): void {
-  //   const otelHint = options?.otelHint ?? ''
-  //   const debugRefreshReason = options?.debugRefreshReason
-
-  //   const roots = [...this.dirtyNodes]
-
-  //   const debugInfoForRefreshedAtoms: AtomDebugInfo<TDebugThunkInfo>[] = []
-
-  //   // if (otelHint.includes('tableName')) {
-  //   //   console.log('refresh', otelHint, { shouldTrace })
-  //   // }
-
-  //   this.otelTracer.startActiveSpan(`LiveStore.refresh:${otelHint}`, {}, otelContext, (span) => {
-  //     const atomsToRefresh = roots.filter(isAtom)
-  //     const effectsToRun = new Set(roots.filter(isEffect))
-
-  //     span.setAttribute('livestore.hint', otelHint)
-  //     span.setAttribute('livestore.rootsCount', roots.length)
-  //     // span.setAttribute('sstack', new Error().stack!)
-
-  //     // Sort in topological order, starting with minimum height
-  //     while (atomsToRefresh.length > 0) {
-  //       atomsToRefresh.sort((a, b) => a.height - b.height)
-  //       const atomToRefresh = atomsToRefresh.shift()!
-
-  //       // Recompute the value
-  //       let resultChanged = false
-  //       const debugInfoForAtom = {
-  //         atom: serializeAtom(atomToRefresh),
-  //         resultChanged,
-  //         // debugInfo: unknownRefreshReason() as TDebugThunkInfo,
-  //         debugInfo: { _tag: 'unknown' } as TDebugThunkInfo,
-  //         durationMs: 0,
-  //       } satisfies AtomDebugInfo<TDebugThunkInfo>
-  //       try {
-  //         atomToRefresh.sub = new Set()
-  //         const beforeTimestamp = performance.now()
-  //         const newResult = atomToRefresh.getResult(
-  //           (atom) => this.get(atom, atomToRefresh),
-  //           (debugInfo) => {
-  //             debugInfoForAtom.debugInfo = debugInfo
-  //           },
-  //           this.context ?? shouldNeverHappen(`No context provided yet for ReactiveGraph`),
-  //         )
-  //         const afterTimestamp = performance.now()
-  //         debugInfoForAtom.durationMs = afterTimestamp - beforeTimestamp
-
-  //         // Determine if the result changed to do early cutoff and avoid further unnecessary updates.
-  //         // Refs never depend on anything, so if a ref is being refreshed it definitely changed.
-  //         // For thunks, we use a deep equality check.
-  //         resultChanged =
-  //           atomToRefresh._tag === 'ref' ||
-  //           (atomToRefresh._tag === 'thunk' && !atomToRefresh.equal(atomToRefresh.result, newResult))
-
-  //         if (resultChanged) {
-  //           atomToRefresh.result = newResult
-  //         }
-
-  //         this.dirtyNodes.delete(atomToRefresh)
-  //       } catch (e) {
-  //         if (e instanceof DependencyNotReadyError) {
-  //           // If we hit a dependency that wasn't ready yet,
-  //           // abort this recomputation and try again later.
-  //           if (!atomsToRefresh.includes(atomToRefresh)) {
-  //             atomsToRefresh.push(atomToRefresh)
-  //           }
-  //         } else {
-  //           throw e
-  //         }
-  //       }
-
-  //       debugInfoForRefreshedAtoms.push(debugInfoForAtom)
-
-  //       if (!resultChanged) {
-  //         continue
-  //       }
-
-  //       // Schedule supercomputations
-  //       for (const superComp of atomToRefresh.super) {
-  //         switch (superComp._tag) {
-  //           case 'ref':
-  //           case 'thunk': {
-  //             if (!atomsToRefresh.includes(superComp)) {
-  //               atomsToRefresh.push(superComp)
-  //             }
-  //             break
-  //           }
-  //           case 'effect': {
-  //             effectsToRun.add(superComp)
-  //             break
-  //           }
-  //         }
-  //       }
-  //     }
-
-  //     this.effectsWrapper(() => {
-  //       for (const effect of effectsToRun) {
-  //         effect.doEffect((atom: Atom<any, TContext>) => this.get(atom, effect))
-  //         this.dirtyNodes.delete(effect)
-  //       }
-  //     })
-
-  //     span.end()
-
-  //     const spanDurationMs = getDurationMsFromSpan(span)
-
-  //     const refreshDebugInfo: RefreshDebugInfo<
-  //       RefreshReasonWithGenericReasons<TDebugRefreshReason>,
-  //       TDebugThunkInfo
-  //     > = {
-  //       id: uniqueRefreshInfoId(),
-  //       reason: debugRefreshReason ?? unknownRefreshReason(),
-  //       refreshedAtoms: debugInfoForRefreshedAtoms,
-  //       skippedRefresh: false,
-  //       durationMs: spanDurationMs,
-  //       completedTimestamp: Date.now(),
-  //       graphSnapshot: this.getSnapshot(),
-  //     }
-
-  //     this.debugRefreshInfos.push(refreshDebugInfo)
-  //   })
-  // }
-
-  label(atom: Atom<any, TContext> | Effect) {
-    if (atom._tag === 'effect') {
-      return `unknown effect`
-    } else {
-      return atom.label ?? `unknown ${atom._tag}`
-    }
+      const refreshedAtoms = this.currentDebugRefresh.refreshedAtoms
+      const durationMs = performance.now() - this.currentDebugRefresh.startMs
+      this.currentDebugRefresh = undefined
+
+      const refreshDebugInfo: RefreshDebugInfo<TDebugRefreshReason, TDebugThunkInfo> = {
+        id: uniqueRefreshInfoId(),
+        reason: options?.debugRefreshReason ?? (unknownRefreshReason() as TDebugRefreshReason),
+        skippedRefresh: false,
+        refreshedAtoms,
+        durationMs,
+        completedTimestamp: Date.now(),
+        graphSnapshot: this.getSnapshot(),
+      }
+      this.debugRefreshInfos.push(refreshDebugInfo)
+    })
   }
 
-  addEdge(superComp: Atom<any, TContext> | Effect, subComp: Atom<any, TContext>) {
+  addEdge(
+    superComp: Atom<any, TContext, TDebugRefreshReason> | Effect,
+    subComp: Atom<any, TContext, TDebugRefreshReason>,
+  ) {
     superComp.sub.add(subComp)
     subComp.super.add(superComp)
-    this.updateAtomHeight(superComp)
   }
 
-  removeEdge(superComp: Atom<any, TContext> | Effect, subComp: Atom<any, TContext>) {
+  removeEdge(
+    superComp: Atom<any, TContext, TDebugRefreshReason> | Effect,
+    subComp: Atom<any, TContext, TDebugRefreshReason>,
+  ) {
     superComp.sub.delete(subComp)
     subComp.super.delete(superComp)
-    this.updateAtomHeight(superComp)
-  }
-
-  updateAtomHeight(atom: Atom<any, TContext> | Effect) {
-    switch (atom._tag) {
-      case 'ref': {
-        atom.height = 0
-        break
-      }
-      case 'thunk': {
-        atom.height = (max([...atom.sub].map((atom) => atom.height)) || 0) + 1
-        break
-      }
-      case 'effect': {
-        break
-      }
-    }
   }
 
   private getSnapshot = (): ReactiveGraphSnapshot => ({
@@ -622,17 +431,13 @@ export class ReactiveGraph<TDebugRefreshReason extends Taggable, TDebugThunkInfo
     // effects: Array.from(this.effects).map(serializeEffect),
     // dirtyNodes: Array.from(this.dirtyNodes).map((a) => a.id),
   })
-
-  get atomsCount() {
-    return this.atoms.size
-  }
 }
 
 // const isAtom = <T, TContext>(a: Atom<T, TContext> | Effect): a is Atom<T, TContext> =>
 //   a._tag === 'ref' || a._tag === 'thunk'
 // const isEffect = <T, TContext>(a: Atom<T, TContext> | Effect): a is Effect => a._tag === 'effect'
 
-const compute = <T>(atom: Atom<T, any>, otelContext: otel.Context): T => {
+const compute = <T>(atom: Atom<T, unknown, any>, otelContext: otel.Context): T => {
   // const __getResult = atom._tag === 'thunk' ? atom.__getResult.toString() : ''
   if (atom.isDirty) {
     // console.log('atom is dirty', atom.id, atom.label ?? '', atom._tag, __getResult)
@@ -646,7 +451,7 @@ const compute = <T>(atom: Atom<T, any>, otelContext: otel.Context): T => {
   }
 }
 
-const markSuperCompDirtyRec = <T>(atom: Atom<T, any>, effectsToRefresh: Set<Effect>) => {
+const markSuperCompDirtyRec = <T>(atom: Atom<T, unknown, any>, effectsToRefresh: Set<Effect>) => {
   for (const superComp of atom.super) {
     if (superComp._tag === 'thunk' || superComp._tag === 'ref') {
       superComp.isDirty = true
@@ -656,3 +461,7 @@ const markSuperCompDirtyRec = <T>(atom: Atom<T, any>, effectsToRefresh: Set<Effe
     }
   }
 }
+
+const throwContextNotSetError = (): never => {
+  throw new Error(`LiveStore Error: \`context\` not set on ReactiveGraph`)
+}