@livestore/livestore 0.3.0-dev.10 → 0.3.0-dev.11

package/src/reactive.ts

@@ -32,7 +32,11 @@ import type * as otel from '@opentelemetry/api'
 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, any>, otelContext?: otel.Context) => T
+export type GetAtom = <T>(
+  atom: Atom<T, any, any>,
+  otelContext?: otel.Context | undefined,
+  debugRefreshReason?: TODO | undefined,
+) => T
 
 export type Ref<T, TContext, TDebugRefreshReason extends DebugRefreshReason> = {
   _tag: 'ref'
@@ -42,7 +46,7 @@ export type Ref<T, TContext, TDebugRefreshReason extends DebugRefreshReason> = {
   previousResult: T
   computeResult: () => T
   sub: Set<Atom<any, TContext, TDebugRefreshReason>> // always empty
-  super: Set<Thunk<any, TContext, TDebugRefreshReason> | Effect>
+  super: Set<Thunk<any, TContext, TDebugRefreshReason> | Effect<TDebugRefreshReason>>
   label?: string
   /** Container for meta information (e.g. the LiveStore Store) */
   meta?: any
@@ -58,7 +62,7 @@ export type Thunk<TResult, TContext, TDebugRefreshReason extends DebugRefreshRea
   computeResult: (otelContext?: otel.Context, debugRefreshReason?: TDebugRefreshReason) => TResult
   previousResult: TResult | NOT_REFRESHED_YET
   sub: Set<Atom<any, TContext, TDebugRefreshReason>>
-  super: Set<Thunk<any, TContext, TDebugRefreshReason> | Effect>
+  super: Set<Thunk<any, TContext, TDebugRefreshReason> | Effect<TDebugRefreshReason>>
   label?: string
   /** Container for meta information (e.g. the LiveStore Store) */
   meta?: any
@@ -72,11 +76,11 @@ export type Atom<T, TContext, TDebugRefreshReason extends DebugRefreshReason> =
   | Ref<T, TContext, TDebugRefreshReason>
   | Thunk<T, TContext, TDebugRefreshReason>
 
-export type Effect = {
+export type Effect<TDebugRefreshReason extends DebugRefreshReason> = {
   _tag: 'effect'
   id: string
   isDestroyed: boolean
-  doEffect: (otelContext?: otel.Context) => void
+  doEffect: (otelContext?: otel.Context | undefined, debugRefreshReason?: TDebugRefreshReason | undefined) => void
   sub: Set<Atom<any, TODO, TODO>>
   label?: string
   invocations: number
@@ -84,7 +88,7 @@ export type Effect = {
 
 export type Node<T, TContext, TDebugRefreshReason extends DebugRefreshReason> =
   | Atom<T, TContext, TDebugRefreshReason>
-  | Effect
+  | Effect<TDebugRefreshReason>
 
 export const isThunk = <T, TContext, TDebugRefreshReason extends DebugRefreshReason>(
   obj: unknown,
@@ -166,7 +170,7 @@ export type SerializedThunk = Readonly<
 
 export type SerializedEffect = Readonly<
   PrettifyFlat<
-    Pick<Effect, '_tag' | 'id' | 'label' | 'invocations' | 'isDestroyed'> & {
+    Pick<Effect<any>, '_tag' | 'id' | 'label' | 'invocations' | 'isDestroyed'> & {
       sub: ReadonlyArray<string>
     }
   >
@@ -187,6 +191,13 @@ const uniqueRefreshInfoId = () => `refresh-info-${++refreshInfoIdCounter}`
 let globalGraphIdCounter = 0
 const uniqueGraphId = () => `graph-${++globalGraphIdCounter}`
 
+/** Used for testing */
+export const __resetIds = () => {
+  nodeIdCounter = 0
+  refreshInfoIdCounter = 0
+  globalGraphIdCounter = 0
+}
+
 export class ReactiveGraph<
   TDebugRefreshReason extends DebugRefreshReason,
   TDebugThunkInfo extends DebugThunkInfo,
@@ -195,7 +206,7 @@ export class ReactiveGraph<
   id = uniqueGraphId()
 
   readonly atoms: Set<Atom<any, TContext, TDebugRefreshReason>> = new Set()
-  readonly effects: Set<Effect> = new Set()
+  readonly effects: Set<Effect<TDebugRefreshReason>> = new Set()
 
   context: TContext | undefined
 
@@ -205,7 +216,7 @@ export class ReactiveGraph<
     | { refreshedAtoms: AtomDebugInfo<TDebugThunkInfo>[]; startMs: DOMHighResTimeStamp }
     | undefined
 
-  private deferredEffects: Map<Effect, Set<TDebugRefreshReason>> = new Map()
+  private deferredEffects: Map<Effect<TDebugRefreshReason>, Set<TDebugRefreshReason>> = new Map()
 
   private refreshCallbacks: Set<() => void> = new Set()
 
@@ -239,6 +250,7 @@ export class ReactiveGraph<
       setDebugInfo: (debugInfo: TDebugThunkInfo) => void,
       ctx: TContext,
       otelContext: otel.Context | undefined,
+      debugRefreshReason: TDebugRefreshReason | undefined,
     ) => T,
     options?:
       | {
@@ -266,7 +278,7 @@ export class ReactiveGraph<
 
           const getAtom = (atom: Atom<T, TContext, TDebugRefreshReason>, otelContext: otel.Context) => {
             this.addEdge(thunk, atom)
-            return compute(atom, otelContext)
+            return compute(atom, otelContext, debugRefreshReason)
           }
 
           let debugInfo: TDebugThunkInfo | undefined = undefined
@@ -279,6 +291,7 @@ export class ReactiveGraph<
             setDebugInfo,
             this.context ?? throwContextNotSetError(this),
             otelContext,
+            debugRefreshReason,
           )
 
           const resultChanged = thunk.equal(thunk.previousResult as T, result) === false
@@ -365,14 +378,18 @@ export class ReactiveGraph<
   }
 
   makeEffect(
-    doEffect: (get: GetAtom, otelContext?: otel.Context) => void,
+    doEffect: (
+      get: GetAtom,
+      otelContext: otel.Context | undefined,
+      debugRefreshReason: DebugRefreshReason | undefined,
+    ) => void,
     options?: { label?: string } | undefined,
-  ): Effect {
-    const effect: Effect = {
+  ): Effect<TDebugRefreshReason> {
+    const effect: Effect<TDebugRefreshReason> = {
       _tag: 'effect',
       id: uniqueNodeId(),
       isDestroyed: false,
-      doEffect: (otelContext) => {
+      doEffect: (otelContext, debugRefreshReason) => {
         effect.invocations++
 
         // NOTE we're not tracking any debug refresh info for effects as they're tracked by the thunks they depend on
@@ -380,12 +397,16 @@ export class ReactiveGraph<
         // 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, TContext, TDebugRefreshReason>, otelContext: otel.Context) => {
+        const getAtom = (
+          atom: Atom<any, TContext, TDebugRefreshReason>,
+          otelContext: otel.Context,
+          debugRefreshReason: DebugRefreshReason | undefined,
+        ) => {
           this.addEdge(effect, atom)
-          return compute(atom, otelContext)
+          return compute(atom, otelContext, debugRefreshReason)
         }
 
-        doEffect(getAtom as GetAtom, otelContext)
+        doEffect(getAtom as GetAtom, otelContext, debugRefreshReason)
       },
       sub: new Set(),
       label: options?.label,
@@ -421,7 +442,7 @@ export class ReactiveGraph<
         }
       | undefined,
   ) {
-    const effectsToRefresh = new Set<Effect>()
+    const effectsToRefresh = new Set<Effect<TDebugRefreshReason>>()
     for (const [ref, val] of refs) {
       ref.previousResult = val
       ref.refreshes++
@@ -448,7 +469,7 @@ export class ReactiveGraph<
   }
 
   private runEffects = (
-    effectsToRefresh: Set<Effect>,
+    effectsToRefresh: Set<Effect<TDebugRefreshReason>>,
     options: {
       debugRefreshReason: TDebugRefreshReason
       otelContext?: otel.Context
@@ -459,7 +480,7 @@ export class ReactiveGraph<
       this.currentDebugRefresh = { refreshedAtoms: [], startMs: performance.now() }
 
       for (const effect of effectsToRefresh) {
-        effect.doEffect(options?.otelContext)
+        effect.doEffect(options?.otelContext, options.debugRefreshReason)
       }
 
       const refreshedAtoms = this.currentDebugRefresh.refreshedAtoms
@@ -504,7 +525,7 @@ export class ReactiveGraph<
   }
 
   addEdge(
-    superComp: Thunk<any, TContext, TDebugRefreshReason> | Effect,
+    superComp: Thunk<any, TContext, TDebugRefreshReason> | Effect<TDebugRefreshReason>,
     subComp: Atom<any, TContext, TDebugRefreshReason>,
   ) {
     superComp.sub.add(subComp)
@@ -516,11 +537,11 @@ export class ReactiveGraph<
   }
 
   removeEdge(
-    superComp: Thunk<any, TContext, TDebugRefreshReason> | Effect,
+    superComp: Thunk<any, TContext, TDebugRefreshReason> | Effect<TDebugRefreshReason>,
     subComp: Atom<any, TContext, TDebugRefreshReason>,
   ) {
     superComp.sub.delete(subComp)
-    const effectsToRefresh = new Set<Effect>()
+    const effectsToRefresh = new Set<Effect<TDebugRefreshReason>>()
     markSuperCompDirtyRec(subComp, effectsToRefresh)
 
     for (const effect of effectsToRefresh) {
@@ -563,7 +584,11 @@ export class ReactiveGraph<
   }
 }
 
-const compute = <T>(atom: Atom<T, unknown, any>, otelContext: otel.Context): T => {
+const compute = <T>(
+  atom: Atom<T, unknown, any>,
+  otelContext: otel.Context,
+  debugRefreshReason: DebugRefreshReason | undefined,
+): T => {
   // const __getResult = atom._tag === 'thunk' ? atom.__getResult.toString() : ''
   if (atom.isDestroyed) {
     shouldNeverHappen(`LiveStore Error: Attempted to compute destroyed ${atom._tag} (${atom.id}): ${atom.label ?? ''}`)
@@ -571,7 +596,7 @@ const compute = <T>(atom: Atom<T, unknown, any>, otelContext: otel.Context): T =
 
   if (atom.isDirty) {
     // console.log('atom is dirty', atom.id, atom.label ?? '', atom._tag, __getResult)
-    const result = atom.computeResult(otelContext)
+    const result = atom.computeResult(otelContext, debugRefreshReason)
     atom.isDirty = false
     atom.previousResult = result
     return result
@@ -581,7 +606,7 @@ const compute = <T>(atom: Atom<T, unknown, any>, otelContext: otel.Context): T =
   }
 }
 
-const markSuperCompDirtyRec = <T>(atom: Atom<T, unknown, any>, effectsToRefresh: Set<Effect>) => {
+const markSuperCompDirtyRec = <T>(atom: Atom<T, unknown, any>, effectsToRefresh: Set<Effect<any>>) => {
   for (const superComp of atom.super) {
     if (superComp._tag === 'thunk') {
       superComp.isDirty = true
@@ -644,7 +669,7 @@ const serializeAtom = (atom: Atom<any, unknown, any>, includeResult: boolean): S
 }
 
 // NOTE This function is performance-optimized (i.e. not using `pick` and `Array.from`)
-const serializeEffect = (effect: Effect): SerializedEffect => {
+const serializeEffect = (effect: Effect<any>): SerializedEffect => {
   const sub: string[] = []
   for (const a of effect.sub) {
     sub.push(a.id)

package/src/row-query-utils.ts

@@ -4,28 +4,33 @@ import { DbSchema } from '@livestore/common/schema'
 import { shouldNeverHappen } from '@livestore/utils'
 import type * as otel from '@opentelemetry/api'
 
-import type { LiveQuery, LiveQueryAny, QueryContext } from './live-queries/base-class.js'
+import type { GetResult, LiveQueryDef, ReactivityGraphContext } from './live-queries/base-class.js'
 import { computed } from './live-queries/computed.js'
 
 export const rowQueryLabel = (table: DbSchema.TableDefBase, id: string | SessionIdSymbol | undefined) =>
   `row:${table.sqliteDef.name}${id === undefined ? '' : id === SessionIdSymbol ? `:sessionId` : `:${id}`}`
 
 export const deriveColQuery: {
-  <TQuery extends LiveQuery<any, QueryInfo.None>, TCol extends keyof TQuery['__result!'] & string>(
-    query$: TQuery,
+  <TQueryDef extends LiveQueryDef<any, QueryInfo.None>, TCol extends keyof GetResult<TQueryDef> & string>(
+    queryDef: TQueryDef,
     colName: TCol,
-  ): LiveQuery<TQuery['__result!'][TCol], QueryInfo.None>
-  <TQuery extends LiveQuery<any, QueryInfo.Row>, TCol extends keyof TQuery['__result!'] & string>(
-    query$: TQuery,
+  ): LiveQueryDef<GetResult<TQueryDef>[TCol], QueryInfo.None>
+  <TQueryDef extends LiveQueryDef<any, QueryInfo.Row>, TCol extends keyof GetResult<TQueryDef> & string>(
+    queryDef: TQueryDef,
     colName: TCol,
-  ): LiveQuery<TQuery['__result!'][TCol], QueryInfo.Col>
-} = (query$: LiveQueryAny, colName: string) => {
-  return computed((get) => get(query$)[colName], {
-    label: `deriveColQuery:${query$.label}:${colName}`,
+  ): LiveQueryDef<GetResult<TQueryDef>[TCol], QueryInfo.Col>
+} = (queryDef: LiveQueryDef<any, QueryInfo.Row | QueryInfo.Col>, colName: string) => {
+  return computed((get) => get(queryDef)[colName], {
+    label: `deriveColQuery:${queryDef.label}:${colName}`,
     queryInfo:
-      query$.queryInfo._tag === 'Row'
-        ? { _tag: 'Col', table: query$.queryInfo.table, column: colName, id: query$.queryInfo.id }
+      queryDef.queryInfo._tag === 'Row'
+        ? { _tag: 'Col', table: queryDef.queryInfo.table, column: colName, id: queryDef.queryInfo.id }
         : undefined,
+    deps: [
+      queryDef.queryInfo.table.sqliteDef.name,
+      queryDef.queryInfo.id === SessionIdSymbol ? 'sessionId' : queryDef.queryInfo.id,
+      queryDef.queryInfo._tag === 'Col' ? queryDef.queryInfo.column : undefined,
+    ],
   }) as any
 }
 
@@ -41,15 +46,17 @@ export const makeExecBeforeFirstRun =
     table: DbSchema.TableDefBase
     otelContext: otel.Context | undefined
   }) =>
-  ({ store }: QueryContext) => {
+  ({ store }: ReactivityGraphContext) => {
     const otelContext = otelContext_ ?? store.otel.queriesSpanContext
 
     if (table.options.isSingleton === false) {
       const idStr = id === SessionIdSymbol ? store.sessionId : id!
       const rowExists =
-        store.syncDbWrapper.select(`SELECT 1 FROM '${table.sqliteDef.name}' WHERE id = ?`, {
-          bindValues: [idStr] as any as PreparedBindValues,
-        }).length === 1
+        store.sqliteDbWrapper.select(
+          `SELECT 1 FROM '${table.sqliteDef.name}' WHERE id = ?`,
+          [idStr] as any as PreparedBindValues,
+          { otelContext },
+        ).length === 1
 
       if (rowExists) return
 
@@ -59,7 +66,11 @@ export const makeExecBeforeFirstRun =
         )
       }
 
-      // NOTE It's important that we only mutate and don't refresh here, as this function is called during a render
-      store.mutate({ otelContext, skipRefresh: true }, table.insert({ id, ...insertValues }))
+      // It's important that we only mutate and don't refresh here, as this function might be called during a render
+      // and otherwise we might end up in a "reactive loop"
+      store.mutate(
+        { otelContext, skipRefresh: true, label: `rowQuery:${table.sqliteDef.name}:${idStr}` },
+        table.insert({ id, ...insertValues }),
+      )
     }
   }

package/src/store/create-store.ts

@@ -14,6 +14,7 @@ import {
   Effect,
   Exit,
   identity,
+  Layer,
   Logger,
   LogLevel,
   MutableHashMap,
@@ -26,8 +27,7 @@ import {
 import { nanoid } from '@livestore/utils/nanoid'
 import * as otel from '@opentelemetry/api'
 
-import { globalReactivityGraph } from '../global-state.js'
-import type { ReactivityGraph } from '../live-queries/base-class.js'
+import { LiveStoreContextRunning } from '../effect/index.js'
 import { connectDevtoolsToStore } from './devtools.js'
 import { Store } from './store.js'
 import type { BaseGraphQLContext, GraphQLOptions, OtelOptions, ShutdownDeferred } from './store-types.js'
@@ -36,12 +36,11 @@ export interface CreateStoreOptions<TGraphQLContext extends BaseGraphQLContext,
   schema: TSchema
   adapter: Adapter
   storeId: string
-  reactivityGraph?: ReactivityGraph
   graphQLOptions?: GraphQLOptions<TGraphQLContext>
   boot?: (
     store: Store<TGraphQLContext, TSchema>,
     parentSpan: otel.Span,
-  ) => void | Promise<void> | Effect.Effect<void, unknown, OtelTracer.OtelTracer>
+  ) => void | Promise<void> | Effect.Effect<void, unknown, OtelTracer.OtelTracer | LiveStoreContextRunning>
   batchUpdates?: (run: () => void) => void
   disableDevtools?: boolean
   onBootStatus?: (status: BootStatus) => void
@@ -95,7 +94,6 @@ export const createStore = <
   storeId,
   graphQLOptions,
   boot,
-  reactivityGraph = globalReactivityGraph,
   batchUpdates,
   disableDevtools,
   onBootStatus,
@@ -163,29 +161,28 @@ export const createStore = <
       // TODO fill up with unsynced mutation events from the client session
       const unsyncedMutationEvents = MutableHashMap.empty<EventId.EventId, MutationEvent.ForSchema<TSchema>>()
 
-      const store = Store.createStore<TGraphQLContext, TSchema>(
-        {
-          clientSession,
-          schema,
-          graphQLOptions,
-          otelOptions: { tracer: otelTracer, rootSpanContext: otelRootSpanContext },
-          reactivityGraph,
-          disableDevtools,
-          unsyncedMutationEvents,
-          lifetimeScope,
-          runtime,
-          // NOTE during boot we're not yet executing mutations in a batched context
-          // but only set the provided `batchUpdates` function after boot
-          batchUpdates: (run) => run(),
-          storeId,
-        },
-        span,
-      )
+      const store = new Store<TGraphQLContext, TSchema>({
+        clientSession,
+        schema,
+        graphQLOptions,
+        otelOptions: { tracer: otelTracer, rootSpanContext: otelRootSpanContext },
+        disableDevtools,
+        unsyncedMutationEvents,
+        lifetimeScope,
+        runtime,
+        // NOTE during boot we're not yet executing mutations in a batched context
+        // but only set the provided `batchUpdates` function after boot
+        batchUpdates: (run) => run(),
+        storeId,
+      })
+
+      yield* store.boot
 
       if (boot !== undefined) {
         // TODO also incorporate `boot` function progress into `bootStatusQueue`
         yield* Effect.tryAll(() => boot(store, span)).pipe(
           UnexpectedError.mapToUnexpectedError,
+          Effect.provide(Layer.succeed(LiveStoreContextRunning, { stage: 'running', store: store as any as Store })),
           Effect.withSpan('createStore:boot'),
         )
       }

package/src/store/devtools.ts

@@ -6,14 +6,14 @@ import { Effect, Stream } from '@livestore/utils/effect'
 
 import type { LiveQuery, ReactivityGraph } from '../live-queries/base-class.js'
 import { NOT_REFRESHED_YET } from '../reactive.js'
-import type { SynchronousDatabaseWrapper } from '../SynchronousDatabaseWrapper.js'
-import { emptyDebugInfo as makeEmptyDebugInfo } from '../SynchronousDatabaseWrapper.js'
+import type { SqliteDbWrapper } from '../SqliteDbWrapper.js'
+import { emptyDebugInfo as makeEmptyDebugInfo } from '../SqliteDbWrapper.js'
 import type { ReferenceCountedSet } from '../utils/data-structures.js'
 
 type IStore = {
   clientSession: ClientSession
   reactivityGraph: ReactivityGraph
-  syncDbWrapper: SynchronousDatabaseWrapper
+  sqliteDbWrapper: SqliteDbWrapper
   activeQueries: ReferenceCountedSet<LiveQuery<any>>
 }
 
@@ -73,7 +73,7 @@ export const connectDevtoolsToStore = ({
       const requestIdleCallback = globalThis.requestIdleCallback ?? ((cb: () => void) => cb())
 
       switch (decodedMessage._tag) {
-        case 'LSD.ReactivityGraphSubscribe': {
+        case 'LSD.ClientSession.ReactivityGraphSubscribe': {
           const includeResults = decodedMessage.includeResults
 
           const send = () =>
@@ -104,10 +104,10 @@ export const connectDevtoolsToStore = ({
 
           break
         }
-        case 'LSD.DebugInfoReq': {
+        case 'LSD.ClientSession.DebugInfoReq': {
           sendToDevtools(
             Devtools.DebugInfoRes.make({
-              debugInfo: store.syncDbWrapper.debugInfo,
+              debugInfo: store.sqliteDbWrapper.debugInfo,
               requestId,
               clientId,
               sessionId,
@@ -116,19 +116,19 @@ export const connectDevtoolsToStore = ({
           )
           break
         }
-        case 'LSD.DebugInfoHistorySubscribe': {
+        case 'LSD.ClientSession.DebugInfoHistorySubscribe': {
           const buffer: DebugInfo[] = []
           let hasStopped = false
           let tickHandle: number | undefined
 
           const tick = () => {
-            buffer.push(store.syncDbWrapper.debugInfo)
+            buffer.push(store.sqliteDbWrapper.debugInfo)
 
             // NOTE this resets the debug info, so all other "readers" e.g. in other `requestAnimationFrame` loops,
             // will get the empty debug info
             // TODO We need to come up with a more graceful way to do store. Probably via a single global
             // `requestAnimationFrame` loop that is passed in somehow.
-            store.syncDbWrapper.debugInfo = makeEmptyDebugInfo()
+            store.sqliteDbWrapper.debugInfo = makeEmptyDebugInfo()
 
             if (buffer.length > 10) {
               sendToDevtools(
@@ -162,31 +162,31 @@ export const connectDevtoolsToStore = ({
 
           break
         }
-        case 'LSD.DebugInfoHistoryUnsubscribe': {
+        case 'LSD.ClientSession.DebugInfoHistoryUnsubscribe': {
           // NOTE given WebMesh channels have persistent retry behaviour, it can happen that a previous
           // WebMesh channel will send a unsubscribe message for an old requestId. Thus the `?.()` handling.
           debugInfoHistorySubscriptions.get(requestId)?.()
           debugInfoHistorySubscriptions.delete(requestId)
           break
         }
-        case 'LSD.DebugInfoResetReq': {
-          store.syncDbWrapper.debugInfo.slowQueries.clear()
+        case 'LSD.ClientSession.DebugInfoResetReq': {
+          store.sqliteDbWrapper.debugInfo.slowQueries.clear()
           sendToDevtools(Devtools.DebugInfoResetRes.make({ requestId, clientId, sessionId, liveStoreVersion }))
           break
         }
-        case 'LSD.DebugInfoRerunQueryReq': {
+        case 'LSD.ClientSession.DebugInfoRerunQueryReq': {
           const { queryStr, bindValues, queriedTables } = decodedMessage
-          store.syncDbWrapper.select(queryStr, { bindValues, queriedTables, skipCache: true })
+          store.sqliteDbWrapper.select(queryStr, bindValues, { queriedTables, skipCache: true })
           sendToDevtools(Devtools.DebugInfoRerunQueryRes.make({ requestId, clientId, sessionId, liveStoreVersion }))
           break
         }
-        case 'LSD.ReactivityGraphUnsubscribe': {
+        case 'LSD.ClientSession.ReactivityGraphUnsubscribe': {
           // NOTE given WebMesh channels have persistent retry behaviour, it can happen that a previous
           // WebMesh channel will send a unsubscribe message for an old requestId. Thus the `?.()` handling.
           reactivityGraphSubcriptions.get(requestId)?.()
           break
         }
-        case 'LSD.LiveQueriesSubscribe': {
+        case 'LSD.ClientSession.LiveQueriesSubscribe': {
           const send = () =>
             requestIdleCallback(
               () =>
@@ -222,7 +222,7 @@ export const connectDevtoolsToStore = ({
 
           break
         }
-        case 'LSD.LiveQueriesUnsubscribe': {
+        case 'LSD.ClientSession.LiveQueriesUnsubscribe': {
           // NOTE given WebMesh channels have persistent retry behaviour, it can happen that a previous
           // WebMesh channel will send a unsubscribe message for an old requestId. Thus the `?.()` handling.
           liveQueriesSubscriptions.get(requestId)?.()

package/src/store/store-types.ts

@@ -5,9 +5,8 @@ import { Schema } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
 import type { GraphQLSchema } from 'graphql'
 
-import type { ReactivityGraph } from '../live-queries/base-class.js'
 import type { DebugRefreshReasonBase } from '../reactive.js'
-import type { SynchronousDatabaseWrapper } from '../SynchronousDatabaseWrapper.js'
+import type { SqliteDbWrapper } from '../SqliteDbWrapper.js'
 import type { StackInfo } from '../utils/stack-info.js'
 import type { Store } from './store.js'
 
@@ -43,7 +42,7 @@ export type BaseGraphQLContext = {
 
 export type GraphQLOptions<TContext> = {
   schema: GraphQLSchema
-  makeContext: (db: SynchronousDatabaseWrapper, tracer: otel.Tracer, sessionId: string) => TContext
+  makeContext: (db: SqliteDbWrapper, tracer: otel.Tracer, sessionId: string) => TContext
 }
 
 export type OtelOptions = {
@@ -61,7 +60,6 @@ export type StoreOptions<
   // TODO remove graphql-related stuff from store and move to GraphQL query directly
   graphQLOptions?: GraphQLOptions<TGraphQLContext>
   otelOptions: OtelOptions
-  reactivityGraph: ReactivityGraph
   disableDevtools?: boolean
   lifetimeScope: Scope.Scope
   runtime: Runtime.Runtime<Scope.Scope>
@@ -87,6 +85,8 @@ export type RefreshReason =
       label?: string
       stackInfo?: StackInfo
     }
+  | { _tag: 'subscribe.initial'; label?: string }
+  | { _tag: 'subscribe.update'; label?: string }
   | { _tag: 'manual'; label?: string }
 
 export type QueryDebugInfo = {
@@ -108,3 +108,5 @@ export type StoreMutateOptions = {
   spanLinks?: otel.Link[]
   otelContext?: otel.Context
 }
+
+export type Unsubscribe = () => void