@livestore/livestore 0.4.0-dev.2 → 0.4.0-dev.20

package/src/live-queries/base-class.ts

@@ -166,10 +166,13 @@ export abstract class LiveStoreQueryBase<TResult> implements LiveQuery<TResult>
 
   // subscribe = (
   //   onNewValue: (value: TResult) => void,
-  //   onUnsubsubscribe?: () => void,
-  //   options?: { label?: string; otelContext?: otel.Context } | undefined,
+  //   options?: {
+  //     label?: string
+  //     otelContext?: otel.Context
+  //     onUnsubsubscribe?: () => void
+  //   },
   // ): (() => void) =>
-  //   this.reactivityGraph.context?.store.subscribe(this, onNewValue, onUnsubsubscribe, options) ??
+  //   this.reactivityGraph.context?.store.subscribe(this, onNewValue, options) ??
   //   RG.throwContextNotSetError(this.reactivityGraph)
 }
 

package/src/live-queries/client-document-get-query.ts

@@ -3,7 +3,7 @@ import { SessionIdSymbol } from '@livestore/common'
 import { State } from '@livestore/common/schema'
 import { shouldNeverHappen } from '@livestore/utils'
 import type * as otel from '@opentelemetry/api'
-
+import { StoreInternalsSymbol } from '../store/store-types.ts'
 import type { ReactivityGraphContext } from './base-class.ts'
 
 export const rowQueryLabel = (
@@ -30,11 +30,11 @@ export const makeExecBeforeFirstRun =
       )
     }
 
-    const otelContext = otelContext_ ?? store.otel.queriesSpanContext
+    const otelContext = otelContext_ ?? store[StoreInternalsSymbol].otel.queriesSpanContext
 
     const idVal = id === SessionIdSymbol ? store.sessionId : id!
     const rowExists =
-      store.sqliteDbWrapper.cachedSelect(
+      store[StoreInternalsSymbol].sqliteDbWrapper.cachedSelect(
         `SELECT 1 FROM '${table.sqliteDef.name}' WHERE id = ?`,
         [idVal] as any as PreparedBindValues,
         { otelContext },

package/src/live-queries/db-query.test.ts

@@ -2,11 +2,12 @@ import { Effect, ReadonlyRecord, Schema } from '@livestore/utils/effect'
 import { Vitest } from '@livestore/utils-dev/node-vitest'
 import * as otel from '@opentelemetry/api'
 import { BasicTracerProvider, InMemorySpanExporter, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base'
-import { expect } from 'vitest'
+import { assert, expect } from 'vitest'
 
 import * as RG from '../reactive.ts'
-import { events, makeTodoMvc, tables } from '../utils/tests/fixture.ts'
-import { getSimplifiedRootSpan } from '../utils/tests/otel.ts'
+import { StoreInternalsSymbol } from '../store/store-types.ts'
+import { events, makeTodoMvc, type Todo, tables } from '../utils/tests/fixture.ts'
+import { getAllSimplifiedRootSpans, getSimplifiedRootSpan } from '../utils/tests/otel.ts'
 import { computed } from './computed.ts'
 import { queryDb } from './db-query.ts'
 
@@ -83,7 +84,8 @@ Vitest.describe('otel', () => {
       Effect.tap(({ exporter, provider }) =>
         Effect.promise(async () => {
           await provider.forceFlush()
-          expect(getSimplifiedRootSpan(exporter, mapAttributes)).toMatchSnapshot()
+          expect(getSimplifiedRootSpan(exporter, 'createStore', mapAttributes)).toMatchSnapshot()
+          expect(getAllSimplifiedRootSpans(exporter, 'LiveStore:commit', mapAttributes)).toMatchSnapshot()
           await provider.shutdown()
         }),
       ),
@@ -105,7 +107,7 @@ Vitest.describe('otel', () => {
         { label: 'all todos' },
       )
 
-      expect(store.reactivityGraph.getSnapshot({ includeResults: true })).toMatchSnapshot()
+      expect(store[StoreInternalsSymbol].reactivityGraph.getSnapshot({ includeResults: true })).toMatchSnapshot()
 
       expect(store.query(query$)).toMatchInlineSnapshot(`
       {
@@ -115,11 +117,11 @@ Vitest.describe('otel', () => {
       }
     `)
 
-      expect(store.reactivityGraph.getSnapshot({ includeResults: true })).toMatchSnapshot()
+      expect(store[StoreInternalsSymbol].reactivityGraph.getSnapshot({ includeResults: true })).toMatchSnapshot()
 
       store.commit(events.todoCreated({ id: 't1', text: 'buy milk', completed: false }))
 
-      expect(store.reactivityGraph.getSnapshot({ includeResults: true })).toMatchSnapshot()
+      expect(store[StoreInternalsSymbol].reactivityGraph.getSnapshot({ includeResults: true })).toMatchSnapshot()
 
       expect(store.query(query$)).toMatchInlineSnapshot(`
       {
@@ -129,7 +131,7 @@ Vitest.describe('otel', () => {
       }
     `)
 
-      expect(store.reactivityGraph.getSnapshot({ includeResults: true })).toMatchSnapshot()
+      expect(store[StoreInternalsSymbol].reactivityGraph.getSnapshot({ includeResults: true })).toMatchSnapshot()
 
       span.end()
 
@@ -139,7 +141,8 @@ Vitest.describe('otel', () => {
       Effect.tap(({ exporter, provider }) =>
         Effect.promise(async () => {
           await provider.forceFlush()
-          expect(getSimplifiedRootSpan(exporter, mapAttributes)).toMatchSnapshot()
+          expect(getSimplifiedRootSpan(exporter, 'createStore', mapAttributes)).toMatchSnapshot()
+          expect(getAllSimplifiedRootSpans(exporter, 'LiveStore:commit', mapAttributes)).toMatchSnapshot()
           await provider.shutdown()
         }),
       ),
@@ -183,7 +186,8 @@ Vitest.describe('otel', () => {
       Effect.tap(({ exporter, provider }) =>
         Effect.promise(async () => {
           await provider.forceFlush()
-          expect(getSimplifiedRootSpan(exporter, mapAttributes)).toMatchSnapshot()
+          expect(getSimplifiedRootSpan(exporter, 'createStore', mapAttributes)).toMatchSnapshot()
+          expect(getAllSimplifiedRootSpans(exporter, 'LiveStore:commit', mapAttributes)).toMatchSnapshot()
           await provider.shutdown()
         }),
       ),
@@ -201,10 +205,8 @@ Vitest.describe('otel', () => {
         .where({ completed: false })
         .first({ behaviour: 'fallback', fallback: () => defaultTodo })
 
-      const unsubscribe = store.subscribe(queryBuilder, {
-        onUpdate: (result) => {
-          callbackResults.push(result)
-        },
+      const unsubscribe = store.subscribe(queryBuilder, (result) => {
+        callbackResults.push(result)
       })
 
       expect(callbackResults).toHaveLength(1)
@@ -228,7 +230,55 @@ Vitest.describe('otel', () => {
       Effect.tap(({ exporter, provider }) =>
         Effect.promise(async () => {
           await provider.forceFlush()
-          expect(getSimplifiedRootSpan(exporter, mapAttributes)).toMatchSnapshot()
+          expect(getSimplifiedRootSpan(exporter, 'createStore', mapAttributes)).toMatchSnapshot()
+          expect(getAllSimplifiedRootSpans(exporter, 'LiveStore:commit', mapAttributes)).toMatchSnapshot()
+          await provider.shutdown()
+        }),
+      ),
+    ),
+  )
+
+  Vitest.scopedLive('QueryBuilder subscription - skipInitialRun', () =>
+    Effect.gen(function* () {
+      const { store, exporter, span, provider } = yield* makeQuery
+
+      const callbackResults: Todo[] = []
+      const defaultTodo: Todo = { id: '', text: '', completed: false }
+
+      const queryBuilder = tables.todos
+        .where({ completed: false })
+        .first({ behaviour: 'fallback', fallback: () => defaultTodo })
+
+      const unsubscribe = store.subscribe(
+        queryBuilder,
+        (result) => {
+          callbackResults.push(result)
+        },
+        { skipInitialRun: true },
+      )
+
+      expect(callbackResults).toHaveLength(0)
+
+      store.commit(events.todoCreated({ id: 't-skip', text: 'skip initial', completed: false }))
+
+      expect(callbackResults).toHaveLength(1)
+      expect(callbackResults[0]).toMatchObject({
+        id: 't-skip',
+        text: 'skip initial',
+        completed: false,
+      })
+
+      unsubscribe()
+      span.end()
+
+      return { exporter, provider }
+    }).pipe(
+      Effect.scoped,
+      Effect.tap(({ exporter, provider }) =>
+        Effect.promise(async () => {
+          await provider.forceFlush()
+          expect(getSimplifiedRootSpan(exporter, 'createStore', mapAttributes)).toMatchSnapshot()
+          expect(getAllSimplifiedRootSpans(exporter, 'LiveStore:commit', mapAttributes)).toMatchSnapshot()
           await provider.shutdown()
         }),
       ),
@@ -247,16 +297,12 @@ Vitest.describe('otel', () => {
         .where({ completed: false })
         .first({ behaviour: 'fallback', fallback: () => defaultTodo })
 
-      const unsubscribe1 = store.subscribe(queryBuilder, {
-        onUpdate: (result) => {
-          callbackResults1.push(result)
-        },
+      const unsubscribe1 = store.subscribe(queryBuilder, (result) => {
+        callbackResults1.push(result)
       })
 
-      const unsubscribe2 = store.subscribe(queryBuilder, {
-        onUpdate: (result) => {
-          callbackResults2.push(result)
-        },
+      const unsubscribe2 = store.subscribe(queryBuilder, (result) => {
+        callbackResults2.push(result)
       })
 
       expect(callbackResults1).toHaveLength(1)
@@ -283,7 +329,105 @@ Vitest.describe('otel', () => {
       Effect.tap(({ exporter, provider }) =>
         Effect.promise(async () => {
           await provider.forceFlush()
-          expect(getSimplifiedRootSpan(exporter, mapAttributes)).toMatchSnapshot()
+          expect(getSimplifiedRootSpan(exporter, 'createStore', mapAttributes)).toMatchSnapshot()
+          expect(getAllSimplifiedRootSpans(exporter, 'LiveStore:commit', mapAttributes)).toMatchSnapshot()
+          await provider.shutdown()
+        }),
+      ),
+    ),
+  )
+
+  Vitest.scopedLive('QueryBuilder subscription - async iterator', () =>
+    Effect.gen(function* () {
+      const { store, exporter, span, provider } = yield* makeQuery
+
+      const defaultTodo: Todo = { id: '', text: '', completed: false }
+
+      const queryBuilder = tables.todos
+        .where({ completed: false })
+        .first({ behaviour: 'fallback', fallback: () => defaultTodo })
+
+      yield* Effect.promise(async () => {
+        const iterator = store.subscribe(queryBuilder)[Symbol.asyncIterator]()
+
+        const initial = await iterator.next()
+        expect(initial.done).toBe(false)
+        expect(initial.value).toMatchObject(defaultTodo)
+
+        store.commit(events.todoCreated({ id: 't-async', text: 'write tests', completed: false }))
+
+        const update = await iterator.next()
+        expect(update.done).toBe(false)
+        expect(update.value).toMatchObject({
+          id: 't-async',
+          text: 'write tests',
+          completed: false,
+        })
+
+        const doneResult = await iterator.return?.()
+        assert(doneResult)
+        expect(doneResult.done).toBe(true)
+      })
+
+      span.end()
+
+      return { exporter, provider }
+    }).pipe(
+      Effect.scoped,
+      Effect.tap(({ exporter, provider }) =>
+        Effect.promise(async () => {
+          await provider.forceFlush()
+          expect(getSimplifiedRootSpan(exporter, 'createStore', mapAttributes)).toMatchSnapshot()
+          expect(getAllSimplifiedRootSpans(exporter, 'LiveStore:commit', mapAttributes)).toMatchSnapshot()
+          await provider.shutdown()
+        }),
+      ),
+    ),
+  )
+
+  Vitest.scopedLive('QueryBuilder subscription - async iterator with skipInitialRun', () =>
+    Effect.gen(function* () {
+      const { store, exporter, span, provider } = yield* makeQuery
+
+      const defaultTodo: Todo = { id: '', text: '', completed: false }
+
+      const queryBuilder = tables.todos
+        .where({ completed: false })
+        .first({ behaviour: 'fallback', fallback: () => defaultTodo })
+
+      yield* Effect.promise(async () => {
+        const iterator = store.subscribe(queryBuilder, { skipInitialRun: true })[Symbol.asyncIterator]()
+
+        const pending = Symbol('pending')
+        const nextPromise = iterator.next()
+        const raceResult = await Promise.race([nextPromise, Promise.resolve(pending)])
+        expect(raceResult).toBe(pending)
+
+        store.commit(events.todoCreated({ id: 't-async-skip', text: 'write tests later', completed: false }))
+
+        const update = await nextPromise
+        expect(update.done).toBe(false)
+        expect(update.value).toMatchObject({
+          id: 't-async-skip',
+          text: 'write tests later',
+          completed: false,
+        })
+
+        const doneResult = await iterator.return?.()
+        assert(doneResult)
+        expect(doneResult.done).toBe(true)
+      })
+
+      span.end()
+
+      return { exporter, provider }
+    }).pipe(
+      Effect.scoped,
+      Effect.tap(({ exporter, provider }) =>
+        Effect.promise(async () => {
+          await provider.forceFlush()
+          expect(getSimplifiedRootSpan(exporter, 'createStore', mapAttributes)).toMatchSnapshot()
+          expect(getAllSimplifiedRootSpans(exporter, 'LiveStore:commit', mapAttributes)).toMatchSnapshot()
           await provider.shutdown()
         }),
       ),
@@ -296,10 +440,8 @@ Vitest.describe('otel', () => {
 
       const callbackResults: any[] = []
 
-      const unsubscribe = store.subscribe(tables.todos, {
-        onUpdate: (result) => {
-          callbackResults.push(result)
-        },
+      const unsubscribe = store.subscribe(tables.todos, (result) => {
+        callbackResults.push(result)
       })
 
       expect(callbackResults).toHaveLength(1)
@@ -324,7 +466,8 @@ Vitest.describe('otel', () => {
       Effect.tap(({ exporter, provider }) =>
         Effect.promise(async () => {
           await provider.forceFlush()
-          expect(getSimplifiedRootSpan(exporter, mapAttributes)).toMatchSnapshot()
+          expect(getSimplifiedRootSpan(exporter, 'createStore', mapAttributes)).toMatchSnapshot()
+          expect(getAllSimplifiedRootSpans(exporter, 'LiveStore:commit', mapAttributes)).toMatchSnapshot()
           await provider.shutdown()
         }),
       ),

package/src/live-queries/db-query.ts

@@ -7,15 +7,16 @@ import {
   QueryBuilderAstSymbol,
   replaceSessionIdSymbol,
   SessionIdSymbol,
-  UnexpectedError,
+  UnknownError,
 } from '@livestore/common'
-import { deepEqual, shouldNeverHappen } from '@livestore/utils'
+import { deepEqual, omitUndefineds, shouldNeverHappen } from '@livestore/utils'
 import { Equal, Hash, Predicate, Schema, TreeFormatter } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 
 import type { Thunk } from '../reactive.ts'
 import { isThunk, NOT_REFRESHED_YET } from '../reactive.ts'
 import type { RefreshReason } from '../store/store-types.ts'
+import { StoreInternalsSymbol } from '../store/store-types.ts'
 import { isValidFunctionString } from '../utils/function-string.ts'
 import type { DepKey, GetAtomResult, LiveQueryDef, ReactivityGraph, ReactivityGraphContext } from './base-class.ts'
 import { depsToString, LiveStoreQueryBase, makeGetAtomResult, withRCMap } from './base-class.ts'
@@ -124,9 +125,8 @@ export const queryDb: {
         reactivityGraph: ctx.reactivityGraph.deref()!,
         queryInput,
         label,
-        map: options?.map,
-        otelContext,
         def,
+        ...omitUndefineds({ map: options?.map, otelContext }),
       })
     }),
     label,
@@ -254,7 +254,7 @@ export class LiveStoreDbQuery<TResultSchema, TResult = TResultSchema> extends Li
               : undefined,
         }
       } catch (cause) {
-        throw new UnexpectedError({ cause, note: `Error building query for ${qb.toString()}`, payload: { qb } })
+        throw new UnknownError({ cause, note: `Error building query for ${qb.toString()}`, payload: { qb } })
       }
     }
 
@@ -365,23 +365,25 @@ export class LiveStoreDbQuery<TResultSchema, TResult = TResultSchema> extends Li
             const bindValues = queryInputResult.bindValues
 
             if (queriedTablesRef.current === undefined) {
-              queriedTablesRef.current = store.sqliteDbWrapper.getTablesUsed(sqlString)
+              queriedTablesRef.current = store[StoreInternalsSymbol].sqliteDbWrapper.getTablesUsed(sqlString)
             }
 
             if (bindValues !== undefined) {
-              replaceSessionIdSymbol(bindValues, store.clientSession.sessionId)
+              replaceSessionIdSymbol(bindValues, store.sessionId)
             }
 
             // Establish a reactive dependency on the tables used in the query
             for (const tableName of queriedTablesRef.current) {
-              const tableRef = store.tableRefs[tableName] ?? shouldNeverHappen(`No table ref found for ${tableName}`)
+              const tableRef =
+                store[StoreInternalsSymbol].tableRefs[tableName] ??
+                shouldNeverHappen(`No table ref found for ${tableName}`)
               get(tableRef, otelContext, debugRefreshReason)
             }
 
             span.setAttribute('sql.query', sqlString)
             span.updateName(`db:${sqlString.slice(0, 50)}`)
 
-            const rawDbResults = store.sqliteDbWrapper.cachedSelect<any>(
+            const rawDbResults = store[StoreInternalsSymbol].sqliteDbWrapper.cachedSelect<any>(
               sqlString,
               bindValues ? prepareBindValues(bindValues, sqlString) : undefined,
               {
@@ -429,7 +431,11 @@ Result:`,
             return result
           },
         ),
-      { label: `${label}:results`, meta: { liveStoreThunkType: 'db.result' }, equal: resultsEqual },
+      {
+        label: `${label}:results`,
+        meta: { liveStoreThunkType: 'db.result' },
+        ...omitUndefineds({ equal: resultsEqual }),
+      },
     )
 
     this.results$ = results$

package/src/mod.ts

@@ -4,6 +4,7 @@ export {
   type BootStatus,
   type DebugInfo,
   IntentionalShutdownCause,
+  liveStoreVersion,
   type MutableDebugInfo,
   type PreparedBindValues,
   prepareBindValues,
@@ -14,6 +15,7 @@ export {
   SessionIdSymbol,
   type SqliteDb,
   StoreInterrupted,
+  type SyncState,
   sql,
 } from '@livestore/common'
 export * from '@livestore/common/schema'
@@ -33,14 +35,29 @@ export {
   signal,
 } from './live-queries/mod.ts'
 export { emptyDebugInfo, SqliteDbWrapper } from './SqliteDbWrapper.ts'
-export { type CreateStoreOptions, createStore, createStorePromise } from './store/create-store.ts'
+export {
+  type CreateStoreOptions,
+  type CreateStoreOptionsPromise,
+  createStore,
+  createStorePromise,
+} from './store/create-store.ts'
 export { Store } from './store/store.ts'
-export type { OtelOptions, QueryDebugInfo, RefreshReason, Unsubscribe } from './store/store-types.ts'
 export {
+  isLiveQueryDef,
+  isLiveQueryInstance,
+  isQueryable,
   type LiveStoreContext,
   type LiveStoreContextRunning,
   makeShutdownDeferred,
+  type OtelOptions,
+  type Queryable,
+  type QueryDebugInfo,
+  type RefreshReason,
   type ShutdownDeferred,
+  type StoreInternals,
+  StoreInternalsSymbol,
+  type SubscribeOptions,
+  type Unsubscribe,
 } from './store/store-types.ts'
 export { exposeDebugUtils } from './utils/dev.ts'
 export * from './utils/stack-info.ts'

package/src/reactive.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-
+import type { DebugRefreshReasonBase, DebugThunkInfo } from './reactive.ts'
 import { ReactiveGraph } from './reactive.ts'
 
 describe('a trivial graph', () => {
@@ -424,3 +424,152 @@ describe('error handling', () => {
     )
   })
 })
+
+// Bug: When an effect calls setRef during execution, it triggers nested runEffects calls.
+// The nested call would overwrite and clear the shared currentDebugRefresh state,
+// causing a TypeError when the outer runEffects tried to access currentDebugRefresh.refreshedAtoms.
+// Fix: Use local variables to capture debug state instead of relying on shared mutable state.
+describe('bug fix: currentDebugRefresh race condition', () => {
+  it('keeps the debug refresh context when nested effect runs are triggered', () => {
+    type TestRefreshReason = DebugRefreshReasonBase | { _tag: 'outer' } | { _tag: 'nested' }
+
+    const graph = new ReactiveGraph<TestRefreshReason, DebugThunkInfo>()
+    graph.context = {}
+
+    const triggerRef = graph.makeRef(0, { label: 'trigger' })
+    const responseRef = graph.makeRef(0, { label: 'response' })
+
+    const triggerThunk = graph.makeThunk((get) => get(triggerRef), { label: 'triggerThunk' })
+    const laterThunk = graph.makeThunk((get) => get(triggerRef) + 1, { label: 'laterThunk' })
+    const responseThunk = graph.makeThunk((get) => get(responseRef), { label: 'responseThunk' })
+
+    const nestedEffect = graph.makeEffect((get) => {
+      get(responseThunk)
+    })
+
+    let observedLater: number | undefined
+    const outerEffect = graph.makeEffect((get) => {
+      const current = get(triggerThunk)
+
+      if (current !== 0) {
+        graph.setRef(responseRef, current, {
+          debugRefreshReason: { _tag: 'nested' },
+        })
+      }
+
+      observedLater = get(laterThunk)
+    })
+
+    nestedEffect.doEffect()
+    outerEffect.doEffect()
+    graph.debugRefreshInfos.clear()
+
+    graph.setRef(triggerRef, 1, { debugRefreshReason: { _tag: 'outer' } })
+
+    expect(observedLater).toBe(2)
+
+    const refreshInfos = Array.from(graph.debugRefreshInfos)
+    const outerRefresh = refreshInfos.find((info) => info.reason._tag === 'outer')
+    expect(outerRefresh).toBeDefined()
+    const refreshedLabels = outerRefresh!.refreshedAtoms.map((atomInfo) => atomInfo.atom.label)
+    expect(refreshedLabels).toContain('triggerThunk')
+    expect(refreshedLabels).toContain('laterThunk')
+
+    const makeThunkRefreshes = refreshInfos.filter((info) => info.reason._tag === 'makeThunk')
+    expect(makeThunkRefreshes).toHaveLength(0)
+  })
+
+  it('handles nested runEffects from effect calling setRef', () => {
+    const graph = new ReactiveGraph()
+    graph.context = {}
+
+    const a = graph.makeRef(1)
+    const b = graph.makeRef(2)
+
+    // Effect that calls setRef, triggering nested runEffects
+    graph
+      .makeEffect((get) => {
+        get(a)
+        graph.setRef(b, 3)
+      })
+      .doEffect()
+
+    // Effect observing b
+    graph.makeEffect((get) => get(b)).doEffect()
+
+    // Previously crashed with: Cannot read properties of undefined (reading 'refreshedAtoms')
+    // Now handles nested runEffects correctly
+    expect(() => graph.setRef(a, 2)).not.toThrow()
+  })
+
+  it('handles thunk calling setRef directly', () => {
+    const graph = new ReactiveGraph()
+    graph.context = {}
+
+    const a = graph.makeRef(1)
+    const b = graph.makeRef(2)
+
+    // Effect observing b so setRef(b) triggers runEffects
+    graph.makeEffect((get) => get(b)).doEffect()
+
+    // Thunk that calls setRef during its computation
+    const thunk = graph.makeThunk((get) => {
+      const val = get(a)
+      graph.setRef(b, val * 2) // This triggers nested runEffects
+      return val + get(b)
+    })
+
+    // With our fix, this handles nested currentDebugRefresh correctly
+    expect(() => thunk.computeResult()).not.toThrow()
+    expect(thunk.computeResult()).toBe(3) // 1 + 2 (b was already set to 2)
+  })
+
+  it('handles nested thunk computations', () => {
+    const graph = new ReactiveGraph()
+    graph.context = {}
+
+    const a = graph.makeRef(1)
+
+    // Outer thunk that creates and computes inner thunk
+    const outerThunk = graph.makeThunk((get) => {
+      const val = get(a)
+
+      // Create and compute inner thunk during outer computation
+      const innerThunk = graph.makeThunk((innerGet) => innerGet(a) * 2)
+
+      // Nested thunk computation - previously could corrupt currentDebugRefresh
+      return val + innerThunk.computeResult()
+    })
+
+    // With our fix, nested thunk computations work correctly
+    expect(() => outerThunk.computeResult()).not.toThrow()
+    expect(outerThunk.computeResult()).toBe(3) // 1 + (1 * 2)
+  })
+})
+
+// Bug: Nodes could have undefined or deleted super/sub properties in certain edge cases,
+// causing crashes with "Cannot read properties of undefined" errors.
+// Fix: Added validation checks in destroyNode to handle corrupted nodes gracefully.
+// Note: Full addEdge protection was removed, so some scenarios still crash with native errors.
+describe('bug fix: node corruption protection', () => {
+  it('handles node destruction during effect execution', () => {
+    const graph = new ReactiveGraph()
+    graph.context = {}
+
+    const a = graph.makeRef(1)
+    const thunk1 = graph.makeThunk((get) => get(a) * 2)
+    const thunk2 = graph.makeThunk((get) => get(thunk1))
+
+    let firstRun = true
+    const effect = graph.makeEffect((get) => {
+      if (firstRun) {
+        firstRun = false
+        graph.destroyNode(thunk1) // Destroy dependency mid-execution
+      }
+      get(thunk2)
+    })
+
+    // Should detect the destroyed node
+    expect(() => effect.doEffect()).toThrow('LiveStore Error: Attempted to compute destroyed')
+  })
+})