@livestore/livestore 0.3.0-dev.5 → 0.3.0-dev.51

package/src/live-queries/{db.ts → db-query.ts}

@@ -1,26 +1,27 @@
-import type { Bindable, QueryBuilder, QueryInfo } from '@livestore/common'
+import type { Bindable, QueryBuilder } from '@livestore/common'
 import {
+  getDurationMsFromSpan,
   getResultSchema,
   isQueryBuilder,
   prepareBindValues,
   QueryBuilderAstSymbol,
   replaceSessionIdSymbol,
+  SessionIdSymbol,
   UnexpectedError,
 } from '@livestore/common'
 import { deepEqual, shouldNeverHappen } from '@livestore/utils'
 import { Predicate, Schema, TreeFormatter } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 
-import { globalReactivityGraph } from '../global-state.js'
 import type { Thunk } from '../reactive.js'
 import { isThunk, NOT_REFRESHED_YET } from '../reactive.js'
-import { makeExecBeforeFirstRun, rowQueryLabel } from '../row-query-utils.js'
 import type { RefreshReason } from '../store/store-types.js'
-import { getDurationMsFromSpan } from '../utils/otel.js'
-import type { GetAtomResult, LiveQuery, QueryContext, ReactivityGraph } from './base-class.js'
-import { LiveStoreQueryBase, makeGetAtomResult } from './base-class.js'
+import { isValidFunctionString } from '../utils/function-string.js'
+import type { DepKey, GetAtomResult, LiveQueryDef, ReactivityGraph, ReactivityGraphContext } from './base-class.js'
+import { depsToString, LiveStoreQueryBase, makeGetAtomResult, withRCMap } from './base-class.js'
+import { makeExecBeforeFirstRun, rowQueryLabel } from './client-document-get-query.js'
 
-export type QueryInputRaw<TDecoded, TEncoded, TQueryInfo extends QueryInfo> = {
+export type QueryInputRaw<TDecoded, TEncoded> = {
   query: string
   schema: Schema.Schema<TDecoded, TEncoded>
   bindValues?: Bindable
@@ -30,104 +31,180 @@ export type QueryInputRaw<TDecoded, TEncoded, TQueryInfo extends QueryInfo> = {
    * NOTE In the future we want to do this automatically at build time
    */
   queriedTables?: Set<string>
-  queryInfo?: TQueryInfo
-  execBeforeFirstRun?: (ctx: QueryContext) => void
+  execBeforeFirstRun?: (ctx: ReactivityGraphContext) => void
 }
 
-export type QueryInput<TDecoded, TEncoded, TQueryInfo extends QueryInfo> =
-  | QueryInputRaw<TDecoded, TEncoded, TQueryInfo>
-  | QueryBuilder<TDecoded, any, any, TQueryInfo>
+export const isQueryInputRaw = (value: unknown): value is QueryInputRaw<any, any> =>
+  Predicate.hasProperty(value, 'query') && Predicate.hasProperty(value, 'schema')
+
+export type QueryInput<TDecoded, TEncoded> = QueryInputRaw<TDecoded, TEncoded> | QueryBuilder<TDecoded, any, any>
 
 /**
- * NOTE `query` is only supposed to read data. Don't use it to insert/update/delete data but use mutations instead.
+ * NOTE `queryDb` is only supposed to read data. Don't use it to insert/update/delete data but use events instead.
+ *
+ * When using contextual data when constructing the query, please make sure to include it in the `deps` option.
+ *
+ * @example
+ * ```ts
+ * const todos$ = queryDb(tables.todos.where({ complete: true }))
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Group-by raw SQL query
+ * const colorCounts$ = queryDb({
+ *   query: sql`SELECT color, COUNT(*) as count FROM todos WHERE complete = ? GROUP BY color`,
+ *   schema: Schema.Array(Schema.Struct({
+ *     color: Schema.String,
+ *     count: Schema.Number,
+ *   })),
+ *   bindValues: [1],
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Using contextual data when constructing the query
+ * const makeFilteredQuery = (filter: string) =>
+ *   queryDb(tables.todos.where({ title: { op: 'like', value: filter } }), { deps: [filter] })
+ *
+ * const filteredTodos$ = makeFilteredQuery('buy coffee')
+ * ```
  */
 export const queryDb: {
-  <TResultSchema, TResult = TResultSchema, TQueryInfo extends QueryInfo = QueryInfo.None>(
-    queryInput:
-      | QueryInputRaw<TResultSchema, ReadonlyArray<any>, TQueryInfo>
-      | QueryBuilder<TResultSchema, any, any, TQueryInfo>,
+  <TResultSchema, TResult = TResultSchema>(
+    queryInput: QueryInputRaw<TResultSchema, ReadonlyArray<any>> | QueryBuilder<TResultSchema, any, any>,
     options?: {
       map?: (rows: TResultSchema) => TResult
       /**
        * Used for debugging / devtools
        */
       label?: string
-      reactivityGraph?: ReactivityGraph
-      otelContext?: otel.Context
+      deps?: DepKey
     },
-  ): LiveQuery<TResult, TQueryInfo>
+  ): LiveQueryDef<TResult>
   // NOTE in this "thunk case", we can't directly derive label/queryInfo from the queryInput,
   // so the caller needs to provide them explicitly otherwise queryInfo will be set to `None`,
   // and label will be set during the query execution
-  <TResultSchema, TResult = TResultSchema, TQueryInfo extends QueryInfo = QueryInfo.None>(
+  <TResultSchema, TResult = TResultSchema>(
     queryInput:
-      | ((get: GetAtomResult) => QueryInputRaw<TResultSchema, ReadonlyArray<any>, TQueryInfo>)
-      | ((get: GetAtomResult) => QueryBuilder<TResultSchema, any, any, TQueryInfo>),
+      | ((get: GetAtomResult) => QueryInputRaw<TResultSchema, ReadonlyArray<any>>)
+      | ((get: GetAtomResult) => QueryBuilder<TResultSchema, any, any>),
     options?: {
       map?: (rows: TResultSchema) => TResult
       /**
        * Used for debugging / devtools
        */
       label?: string
-      reactivityGraph?: ReactivityGraph
-      queryInfo?: TQueryInfo
-      otelContext?: otel.Context
+      deps?: DepKey
     },
-  ): LiveQuery<TResult, TQueryInfo>
-} = (queryInput, options) =>
-  new LiveStoreDbQuery({
-    queryInput,
-    label: options?.label,
-    reactivityGraph: options?.reactivityGraph,
-    map: options?.map,
-    queryInfo: Predicate.hasProperty(options, 'queryInfo') ? (options.queryInfo as QueryInfo) : undefined,
-    otelContext: options?.otelContext,
-  })
+  ): LiveQueryDef<TResult>
+} = (queryInput, options) => {
+  const { queryString, extraDeps } = getQueryStringAndExtraDeps(queryInput)
+
+  const hash = [queryString, options?.deps ? depsToString(options.deps) : undefined, depsToString(extraDeps)]
+    .filter(Boolean)
+    .join('-')
+
+  if (isValidFunctionString(hash)._tag === 'invalid') {
+    throw new Error(`On Expo/React Native, db queries must provide a \`deps\` option`)
+  }
+
+  if (hash.trim() === '') {
+    return shouldNeverHappen(`Invalid query hash for query: ${queryInput}`)
+  }
+
+  const label = options?.label ?? queryString
+
+  const def: LiveQueryDef<any> = {
+    _tag: 'def',
+    make: withRCMap(hash, (ctx, otelContext) => {
+      // TODO onDestroy
+      return new LiveStoreDbQuery({
+        reactivityGraph: ctx.reactivityGraph.deref()!,
+        queryInput,
+        label,
+        map: options?.map,
+        otelContext,
+        def,
+      })
+    }),
+    label,
+    hash,
+  }
+
+  return def
+}
+
+const bindValuesToDepKey = (bindValues: Bindable | undefined): DepKey => {
+  if (bindValues === undefined) {
+    return []
+  }
+
+  return Object.entries(bindValues)
+    .map(([key, value]: [string, any]) => `${key}:${value === SessionIdSymbol ? 'SessionIdSymbol' : value}`)
+    .join(',')
+}
+
+const getQueryStringAndExtraDeps = (
+  queryInput: QueryInput<any, any> | ((get: GetAtomResult) => QueryInput<any, any>),
+): { queryString: string; extraDeps: DepKey } => {
+  if (isQueryBuilder(queryInput)) {
+    const { query, bindValues } = queryInput.asSql()
+    return { queryString: query, extraDeps: bindValuesToDepKey(bindValues) }
+  }
+
+  if (isQueryInputRaw(queryInput)) {
+    return { queryString: queryInput.query, extraDeps: bindValuesToDepKey(queryInput.bindValues) }
+  }
+
+  if (typeof queryInput === 'function') {
+    return { queryString: queryInput.toString(), extraDeps: [] }
+  }
+
+  return shouldNeverHappen(`Invalid query input: ${queryInput}`)
+}
 
 /* An object encapsulating a reactive SQL query */
-export class LiveStoreDbQuery<
-  TResultSchema,
-  TResult = TResultSchema,
-  TQueryInfo extends QueryInfo = QueryInfo.None,
-> extends LiveStoreQueryBase<TResult, TQueryInfo> {
-  _tag: 'db' = 'db'
+export class LiveStoreDbQuery<TResultSchema, TResult = TResultSchema> extends LiveStoreQueryBase<TResult> {
+  _tag = 'db' as const
 
   /** A reactive thunk representing the query text */
-  queryInput$: Thunk<QueryInput<TResultSchema, ReadonlyArray<any>, TQueryInfo>, QueryContext, RefreshReason> | undefined
+  queryInput$: Thunk<QueryInputRaw<any, any>, ReactivityGraphContext, RefreshReason> | undefined
 
   /** A reactive thunk representing the query results */
-  results$: Thunk<TResult, QueryContext, RefreshReason>
+  results$: Thunk<TResult, ReactivityGraphContext, RefreshReason>
 
   label: string
 
-  queryInfo: TQueryInfo
-
-  protected reactivityGraph
+  readonly reactivityGraph
 
   private mapResult: (rows: TResultSchema) => TResult
+  def: LiveQueryDef<TResult>
 
   constructor({
     queryInput,
     label: inputLabel,
     reactivityGraph,
     map,
-    queryInfo: inputQueryInfo,
     otelContext,
+    def,
   }: {
     label?: string
     queryInput:
-      | QueryInput<TResultSchema, ReadonlyArray<any>, TQueryInfo>
-      | ((get: GetAtomResult, ctx: QueryContext) => QueryInput<TResultSchema, ReadonlyArray<any>, TQueryInfo>)
-    reactivityGraph?: ReactivityGraph
+      | QueryInput<TResultSchema, ReadonlyArray<any>>
+      | ((get: GetAtomResult, ctx: ReactivityGraphContext) => QueryInput<TResultSchema, ReadonlyArray<any>>)
+    reactivityGraph: ReactivityGraph
     map?: (rows: TResultSchema) => TResult
-    queryInfo?: TQueryInfo
+    /** Only used for the initial query execution */
     otelContext?: otel.Context
+    def: LiveQueryDef<TResult>
   }) {
     super()
 
     let label = inputLabel ?? 'db(unknown)'
-    let queryInfo = inputQueryInfo ?? ({ _tag: 'None' } as TQueryInfo)
-    this.reactivityGraph = reactivityGraph ?? globalReactivityGraph
+    this.reactivityGraph = reactivityGraph
+    this.def = def
 
     this.mapResult = map === undefined ? (rows: any) => rows as TResult : map
 
@@ -136,13 +213,15 @@ export class LiveStoreDbQuery<
         typeof queryInput === 'function' ? undefined : isQueryBuilder(queryInput) ? undefined : queryInput.schema,
     }
 
-    const execBeforeFirstRunRef: { current: ((ctx: QueryContext, otelContext: otel.Context) => void) | undefined } = {
+    const execBeforeFirstRunRef: {
+      current: ((ctx: ReactivityGraphContext, otelContext: otel.Context) => void) | undefined
+    } = {
       current: undefined,
     }
 
-    type TQueryInputRaw = QueryInputRaw<any, any, QueryInfo>
+    type TQueryInputRaw = QueryInputRaw<any, any>
 
-    let queryInputRaw$OrQueryInputRaw: TQueryInputRaw | Thunk<TQueryInputRaw, QueryContext, RefreshReason>
+    let queryInputRaw$OrQueryInputRaw: TQueryInputRaw | Thunk<TQueryInputRaw, ReactivityGraphContext, RefreshReason>
 
     const fromQueryBuilder = (qb: QueryBuilder.Any, otelContext: otel.Context | undefined) => {
       try {
@@ -156,14 +235,13 @@ export class LiveStoreDbQuery<
             schema,
             bindValues: qbRes.bindValues,
             queriedTables: new Set([ast.tableDef.sqliteDef.name]),
-            queryInfo: ast._tag === 'RowQuery' ? { _tag: 'Row', table: ast.tableDef, id: ast.id } : { _tag: 'None' },
           } satisfies TQueryInputRaw,
           label: ast._tag === 'RowQuery' ? rowQueryLabel(ast.tableDef, ast.id) : qb.toString(),
           execBeforeFirstRun:
             ast._tag === 'RowQuery'
               ? makeExecBeforeFirstRun({
                   table: ast.tableDef,
-                  insertValues: ast.insertValues,
+                  explicitDefaultValues: ast.explicitDefaultValues,
                   id: ast.id,
                   otelContext,
                 })
@@ -178,7 +256,10 @@ export class LiveStoreDbQuery<
       queryInputRaw$OrQueryInputRaw = this.reactivityGraph.makeThunk(
         (get, setDebugInfo, ctx, otelContext) => {
           const startMs = performance.now()
-          const queryInputResult = queryInput(makeGetAtomResult(get, otelContext ?? ctx.rootOtelContext), ctx)
+          const queryInputResult = queryInput(
+            makeGetAtomResult(get, ctx, otelContext ?? ctx.rootOtelContext, this.dependencyQueriesRef),
+            ctx,
+          )
           const durationMs = performance.now() - startMs
 
           let queryInputRaw: TQueryInputRaw
@@ -197,10 +278,6 @@ export class LiveStoreDbQuery<
 
           schemaRef.current = queryInputRaw.schema
 
-          if (inputQueryInfo === undefined && queryInputRaw.queryInfo !== undefined) {
-            queryInfo = queryInputRaw.queryInfo as TQueryInfo
-          }
-
           return queryInputRaw
         },
         {
@@ -210,6 +287,8 @@ export class LiveStoreDbQuery<
           equal: (a, b) => a.query === b.query && deepEqual(a.bindValues, b.bindValues),
         },
       )
+
+      this.queryInput$ = queryInputRaw$OrQueryInputRaw
     } else {
       let queryInputRaw: TQueryInputRaw
       if (isQueryBuilder(queryInput)) {
@@ -231,10 +310,6 @@ export class LiveStoreDbQuery<
           label = `db(${rowQueryLabel(ast.tableDef, ast.id)})`
         }
       }
-
-      if (inputQueryInfo === undefined && queryInputRaw.queryInfo !== undefined) {
-        queryInfo = queryInputRaw.queryInfo as TQueryInfo
-      }
     }
 
     const queriedTablesRef: { current: Set<string> | undefined } = { current: undefined }
@@ -253,10 +328,16 @@ export class LiveStoreDbQuery<
         : undefined
 
     const results$ = this.reactivityGraph.makeThunk<TResult>(
-      (get, setDebugInfo, queryContext, otelContext) =>
+      (get, setDebugInfo, queryContext, otelContext, debugRefreshReason) =>
         queryContext.otelTracer.startActiveSpan(
           'db:...', // NOTE span name will be overridden further down
-          {},
+          {
+            attributes: {
+              'livestore.debugRefreshReason': Predicate.hasProperty(debugRefreshReason, 'label')
+                ? (debugRefreshReason.label as string)
+                : debugRefreshReason?._tag,
+            },
+          },
           otelContext ?? queryContext.rootOtelContext,
           (span) => {
             const otelContext = otel.trace.setSpan(otel.context.active(), span)
@@ -268,14 +349,14 @@ export class LiveStoreDbQuery<
             }
 
             const queryInputResult = isThunk(queryInputRaw$OrQueryInputRaw)
-              ? (get(queryInputRaw$OrQueryInputRaw, otelContext) as TQueryInputRaw)
+              ? (get(queryInputRaw$OrQueryInputRaw, otelContext, debugRefreshReason) as TQueryInputRaw)
               : (queryInputRaw$OrQueryInputRaw as TQueryInputRaw)
 
             const sqlString = queryInputResult.query
             const bindValues = queryInputResult.bindValues
 
             if (queriedTablesRef.current === undefined) {
-              queriedTablesRef.current = store.syncDbWrapper.getTablesUsed(sqlString)
+              queriedTablesRef.current = store.sqliteDbWrapper.getTablesUsed(sqlString)
             }
 
             if (bindValues !== undefined) {
@@ -285,17 +366,20 @@ export class LiveStoreDbQuery<
             // 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}`)
-              get(tableRef, otelContext)
+              get(tableRef, otelContext, debugRefreshReason)
             }
 
             span.setAttribute('sql.query', sqlString)
             span.updateName(`db:${sqlString.slice(0, 50)}`)
 
-            const rawDbResults = store.syncDbWrapper.select<any>(sqlString, {
-              queriedTables: queriedTablesRef.current,
-              bindValues: bindValues ? prepareBindValues(bindValues, sqlString) : undefined,
-              otelContext,
-            })
+            const rawDbResults = store.sqliteDbWrapper.select<any>(
+              sqlString,
+              bindValues ? prepareBindValues(bindValues, sqlString) : undefined,
+              {
+                queriedTables: queriedTablesRef.current,
+                otelContext,
+              },
+            )
 
             span.setAttribute('sql.rowsCount', rawDbResults.length)
 
@@ -306,9 +390,9 @@ export class LiveStoreDbQuery<
               const expectedSchemaStr = String(schemaRef.current!.ast)
               const bindValuesStr = bindValues === undefined ? '' : `\nBind values: ${JSON.stringify(bindValues)}`
 
-              console.error(
+              return shouldNeverHappen(
                 `\
-Error parsing SQL query result.
+Error parsing SQL query result (${label}).
 
 Query: ${sqlString}\
 ${bindValuesStr}
@@ -319,8 +403,8 @@ Error: ${parseErrorStr}
 
 Result:`,
                 rawDbResults,
+                '\n',
               )
-              return shouldNeverHappen(`Error parsing SQL query result: ${parsedResult.left}`)
             }
 
             const result = this.mapResult(parsedResult.right)
@@ -342,14 +426,19 @@ Result:`,
     this.results$ = results$
 
     this.label = label
-    this.queryInfo = queryInfo
   }
 
   destroy = () => {
+    this.isDestroyed = true
+
     if (this.queryInput$ !== undefined) {
       this.reactivityGraph.destroyNode(this.queryInput$)
     }
 
     this.reactivityGraph.destroyNode(this.results$)
+
+    for (const query of this.dependencyQueriesRef) {
+      query.deref()
+    }
   }
 }

package/src/live-queries/mod.ts

@@ -0,0 +1,4 @@
+export * from './base-class.js'
+export * from './computed.js'
+export * from './db-query.js'
+export * from './signal.js'

package/src/live-queries/signal.test.ts

@@ -0,0 +1,40 @@
+import { Effect } from '@livestore/utils/effect'
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+import { expect } from 'vitest'
+
+import { makeTodoMvc } from '../utils/tests/fixture.js'
+import { computed } from './computed.js'
+import { signal } from './signal.js'
+
+Vitest.describe('signal', () => {
+  Vitest.scopedLive('should be able to create a signal', () =>
+    Effect.gen(function* () {
+      const num$ = signal(0, { label: 'num$' })
+
+      const duplicated$ = computed((get) => get(num$) * 2, { label: 'duplicated$' })
+
+      const store = yield* makeTodoMvc({})
+
+      expect(store.query(duplicated$)).toBe(0)
+
+      store.setSignal(num$, 1)
+
+      expect(store.query(duplicated$)).toBe(2)
+    }),
+  )
+
+  Vitest.scopedLive('counter example', () =>
+    Effect.gen(function* () {
+      const count$ = signal(0, { label: 'count$' })
+
+      const store = yield* makeTodoMvc({})
+
+      const increment = () => store.setSignal(count$, (prev) => prev + 1)
+
+      increment()
+      increment()
+
+      expect(store.query(count$)).toBe(2)
+    }),
+  )
+})

package/src/live-queries/signal.ts

@@ -0,0 +1,81 @@
+import { nanoid } from '@livestore/utils/nanoid'
+
+import type * as RG from '../reactive.js'
+import type { RefreshReason } from '../store/store-types.js'
+import type { ISignal, ReactivityGraph, ReactivityGraphContext, SignalDef } from './base-class.js'
+import { LiveStoreQueryBase, withRCMap } from './base-class.js'
+
+export const signal = <T>(
+  defaultValue: T,
+  options?: {
+    label?: string
+  },
+): SignalDef<T> => {
+  const id = nanoid()
+  const def: SignalDef<T> = {
+    _tag: 'signal-def',
+    defaultValue,
+    hash: id,
+    label: options?.label ?? 'Signal',
+    make: withRCMap(
+      id,
+      (ctx) =>
+        new Signal({
+          defaultValue,
+          reactivityGraph: ctx.reactivityGraph.deref()!,
+          label: options?.label ?? 'Signal',
+          def,
+        }),
+    ),
+  }
+
+  return def
+}
+
+export class Signal<T> extends LiveStoreQueryBase<T> implements ISignal<T> {
+  _tag = 'signal' as const
+  readonly ref: RG.Ref<T, ReactivityGraphContext, RefreshReason>
+  label: string
+  reactivityGraph: ReactivityGraph
+  results$: RG.Ref<T, ReactivityGraphContext, RefreshReason>
+  def: SignalDef<T>
+  constructor(
+    // private defaultValue: T,
+    // readonly reactivityGraph: ReactivityGraph,
+    // private options?: {
+    //   label?: string
+    // },
+    {
+      defaultValue,
+      reactivityGraph,
+      label,
+      def,
+    }: {
+      defaultValue: T
+      reactivityGraph: ReactivityGraph
+      label: string
+      def: SignalDef<T>
+    },
+  ) {
+    super()
+
+    this.ref = reactivityGraph.makeRef(defaultValue, { label })
+    this.label = label
+    this.reactivityGraph = reactivityGraph
+    this.def = def
+
+    this.results$ = this.ref
+  }
+
+  set = (value: T) => {
+    this.reactivityGraph.setRef(this.ref, value)
+  }
+
+  get = () => {
+    return this.ref.computeResult()
+  }
+
+  destroy = () => {
+    this.reactivityGraph.destroyNode(this.ref)
+  }
+}

package/src/mod.ts

@@ -0,0 +1,51 @@
+export { Store } from './store/store.js'
+export { createStore, createStorePromise, type CreateStoreOptions } from './store/create-store.js'
+export type { QueryDebugInfo, RefreshReason, OtelOptions } from './store/store-types.js'
+// We're re-exporting `Schema` from `effect` for convenience
+export { Schema } from '@livestore/utils/effect'
+
+export {
+  type LiveStoreContext,
+  type LiveStoreContextRunning,
+  type ShutdownDeferred,
+  makeShutdownDeferred,
+} from './store/store-types.js'
+
+export { SqliteDbWrapper, emptyDebugInfo } from './SqliteDbWrapper.js'
+
+export {
+  queryDb,
+  computed,
+  signal,
+  type LiveQuery,
+  type LiveQueryDef,
+  type Signal,
+  type SignalDef,
+  type RcRef,
+} from './live-queries/mod.js'
+
+export * from '@livestore/common/schema'
+export {
+  sql,
+  SessionIdSymbol,
+  type BootStatus,
+  type SqliteDb,
+  type DebugInfo,
+  type MutableDebugInfo,
+  prepareBindValues,
+  type Bindable,
+  type PreparedBindValues,
+  type QueryBuilderAst,
+  type QueryBuilder,
+  type RowQuery,
+  StoreInterrupted,
+  IntentionalShutdownCause,
+  provideOtel,
+} from '@livestore/common'
+
+export { deepEqual } from '@livestore/utils'
+export { nanoid } from '@livestore/utils/nanoid'
+
+export * from './utils/stack-info.js'
+
+export type { ClientSession, Adapter, PreparedStatement } from '@livestore/common'

package/src/reactive.test.ts

@@ -245,7 +245,7 @@ describe('a trivial graph', () => {
       expect(e.isDirty).toBe(true)
 
       expect(() => c.computeResult()).toThrowErrorMatchingInlineSnapshot(
-        `[Error: This should never happen: LiveStore Error: Attempted to compute destroyed ref (node-58): b]`,
+        `[Error: This should never happen: LiveStore Error: Attempted to compute destroyed ref (node-2): b]`,
       )
     })
   })