@livestore/livestore 0.2.0 → 0.3.0-dev.10

package/src/store/store.ts

@@ -1,25 +1,36 @@
-import type { ClientSession, ParamsObject, PreparedBindValues, QueryBuilder } from '@livestore/common'
+import type {
+  ClientSession,
+  ClientSessionSyncProcessor,
+  ParamsObject,
+  PreparedBindValues,
+  QueryBuilder,
+  UnexpectedError,
+} from '@livestore/common'
 import {
+  Devtools,
   getExecArgsFromMutation,
   getResultSchema,
+  IntentionalShutdownCause,
   isQueryBuilder,
+  liveStoreVersion,
+  makeClientSessionSyncProcessor,
   prepareBindValues,
   QueryBuilderAstSymbol,
   replaceSessionIdSymbol,
 } from '@livestore/common'
-import type { LiveStoreSchema, MutationEvent } from '@livestore/common/schema'
+import type { LiveStoreSchema } from '@livestore/common/schema'
 import {
-  isPartialMutationEvent,
-  makeMutationEventSchemaMemo,
+  MutationEvent,
   SCHEMA_META_TABLE,
   SCHEMA_MUTATIONS_META_TABLE,
   SESSION_CHANGESET_META_TABLE,
 } from '@livestore/common/schema'
-import { assertNever, shouldNeverHappen } from '@livestore/utils'
+import { assertNever, isDevEnv } from '@livestore/utils'
 import type { Scope } from '@livestore/utils/effect'
-import { Data, Effect, FiberSet, Inspectable, MutableHashMap, Runtime, Schema, Stream } from '@livestore/utils/effect'
+import { Cause, Data, Effect, Inspectable, MutableHashMap, Runtime, Schema } from '@livestore/utils/effect'
+import { nanoid } from '@livestore/utils/nanoid'
 import * as otel from '@opentelemetry/api'
-import type { GraphQLSchema } from 'graphql'
+import { type GraphQLSchema } from 'graphql'
 
 import type { LiveQuery, QueryContext, ReactivityGraph } from '../live-queries/base-class.js'
 import type { Ref } from '../reactive.js'
@@ -30,7 +41,7 @@ import { downloadBlob, exposeDebugUtils } from '../utils/dev.js'
 import { getDurationMsFromSpan } from '../utils/otel.js'
 import type { BaseGraphQLContext, RefreshReason, StoreMutateOptions, StoreOptions, StoreOtel } from './store-types.js'
 
-if (import.meta.env.DEV) {
+if (isDevEnv()) {
   exposeDebugUtils()
 }
 
@@ -52,7 +63,6 @@ export class Store<
    */
   tableRefs: { [key: string]: Ref<null, QueryContext, RefreshReason> }
 
-  private fiberSet: FiberSet.FiberSet
   private runtime: Runtime.Runtime<Scope.Scope>
 
   /** RC-based set to see which queries are currently subscribed to */
@@ -61,6 +71,8 @@ export class Store<
   // NOTE this is currently exposed for the Devtools databrowser to emit mutation events
   readonly __mutationEventSchema
   private unsyncedMutationEvents
+  private syncProcessor: ClientSessionSyncProcessor
+  readonly lifetimeScope: Scope.Scope
 
   // #region constructor
   private constructor({
@@ -73,24 +85,80 @@ export class Store<
     batchUpdates,
     unsyncedMutationEvents,
     storeId,
-    fiberSet,
+    lifetimeScope,
     runtime,
   }: StoreOptions<TGraphQLContext, TSchema>) {
     super()
 
     this.storeId = storeId
-
     this.unsyncedMutationEvents = unsyncedMutationEvents
 
     this.syncDbWrapper = new SynchronousDatabaseWrapper({ otel: otelOptions, db: clientSession.syncDb })
     this.clientSession = clientSession
     this.schema = schema
 
-    this.fiberSet = fiberSet
+    this.lifetimeScope = lifetimeScope
     this.runtime = runtime
 
-    // TODO refactor
-    this.__mutationEventSchema = makeMutationEventSchemaMemo(schema)
+    const syncSpan = otelOptions.tracer.startSpan('LiveStore:sync', {}, otelOptions.rootSpanContext)
+
+    this.syncProcessor = makeClientSessionSyncProcessor({
+      schema,
+      initialLeaderHead: clientSession.leaderThread.mutations.initialMutationEventId,
+      pushToLeader: (batch) =>
+        clientSession.leaderThread.mutations.push(batch).pipe(
+          // NOTE we don't want to shutdown in case of an invalid push error, since it will be retried
+          Effect.catchTag('InvalidPushError', Effect.ignoreLogged),
+          this.runEffectFork,
+        ),
+      pullFromLeader: clientSession.leaderThread.mutations.pull,
+      applyMutation: (mutationEventDecoded, { otelContext, withChangeset }) => {
+        const mutationDef = schema.mutations.get(mutationEventDecoded.mutation)!
+        const execArgsArr = getExecArgsFromMutation({
+          mutationDef,
+          mutationEvent: { decoded: mutationEventDecoded, encoded: undefined },
+        })
+
+        const writeTablesForEvent = new Set<string>()
+
+        const exec = () => {
+          for (const {
+            statementSql,
+            bindValues,
+            writeTables = this.syncDbWrapper.getTablesUsed(statementSql),
+          } of execArgsArr) {
+            this.syncDbWrapper.execute(statementSql, bindValues, writeTables, { otelContext })
+
+            // durationMsTotal += durationMs
+            writeTables.forEach((table) => writeTablesForEvent.add(table))
+          }
+        }
+
+        let sessionChangeset: Uint8Array | undefined
+        if (withChangeset === true) {
+          sessionChangeset = this.syncDbWrapper.withChangeset(exec).changeset
+        } else {
+          exec()
+        }
+
+        return { writeTables: writeTablesForEvent, sessionChangeset }
+      },
+      rollback: (changeset) => {
+        this.syncDbWrapper.rollback(changeset)
+      },
+      refreshTables: (tables) => {
+        const tablesToUpdate = [] as [Ref<null, QueryContext, RefreshReason>, null][]
+        for (const tableName of tables) {
+          const tableRef = this.tableRefs[tableName]
+          assertNever(tableRef !== undefined, `No table ref found for ${tableName}`)
+          tablesToUpdate.push([tableRef!, null])
+        }
+        this.reactivityGraph.setRefs(tablesToUpdate)
+      },
+      span: syncSpan,
+    })
+
+    this.__mutationEventSchema = MutationEvent.makeMutationEventSchemaMemo(schema)
 
     // TODO generalize the `tableRefs` concept to allow finer-grained refs
     this.tableRefs = {}
@@ -141,26 +209,10 @@ export class Store<
 
     if (graphQLOptions) {
       this.graphQLSchema = graphQLOptions.schema
-      this.graphQLContext = graphQLOptions.makeContext(
-        this.syncDbWrapper,
-        this.otel.tracer,
-        clientSession.coordinator.sessionId,
-      )
+      this.graphQLContext = graphQLOptions.makeContext(this.syncDbWrapper, this.otel.tracer, clientSession.sessionId)
     }
 
     Effect.gen(this, function* () {
-      yield* this.clientSession.coordinator.syncMutations.pipe(
-        Stream.tapChunk((mutationsEventsDecodedChunk) =>
-          Effect.sync(() => {
-            this.mutate({ wasSyncMessage: true }, ...mutationsEventsDecodedChunk)
-          }),
-        ),
-        Stream.runDrain,
-        Effect.interruptible,
-        Effect.withSpan('LiveStore:syncMutations'),
-        Effect.forkScoped,
-      )
-
       yield* Effect.addFinalizer(() =>
         Effect.sync(() => {
           // Remove all table refs from the reactivity graph
@@ -171,13 +223,14 @@ export class Store<
           }
 
           // End the otel spans
-          otel.trace.getSpan(this.otel.mutationsSpanContext)!.end()
-          otel.trace.getSpan(this.otel.queriesSpanContext)!.end()
+          syncSpan.end()
+          mutationsSpan.end()
+          queriesSpan.end()
         }),
       )
 
-      yield* Effect.never // to keep the scope alive and bind to the parent scope
-    }).pipe(Effect.scoped, Effect.withSpan('LiveStore:constructor'), this.runEffectFork)
+      yield* this.syncProcessor.boot
+    }).pipe(this.runEffectFork)
   }
   // #endregion constructor
 
@@ -196,7 +249,7 @@ export class Store<
   }
 
   get sessionId(): string {
-    return this.clientSession.coordinator.sessionId
+    return this.clientSession.sessionId
   }
 
   /**
@@ -242,6 +295,20 @@ export class Store<
       },
     )
 
+  /**
+   * Synchronously queries the database without creating a LiveQuery.
+   * This is useful for queries that don't need to be reactive.
+   *
+   * Example: Query builder
+   * ```ts
+   * const completedTodos = store.query(tables.todo.where({ complete: true }))
+   * ```
+   *
+   * Example: Raw SQL query
+   * ```ts
+   * const completedTodos = store.query({ query: 'SELECT * FROM todo WHERE complete = 1', bindValues: {} })
+   * ```
+   */
   query = <TResult>(
     query: QueryBuilder<TResult, any, any> | LiveQuery<TResult, any> | { query: string; bindValues: ParamsObject },
     options?: { otelContext?: otel.Context },
@@ -294,39 +361,16 @@ export class Store<
       ) => void,
     ): void
   } = (firstMutationOrTxnFnOrOptions: any, ...restMutations: any[]) => {
-    let mutationsEvents: MutationEvent.ForSchema<TSchema>[]
-    let options: StoreMutateOptions | undefined
+    const { mutationsEvents, options } = this.getMutateArgs(firstMutationOrTxnFnOrOptions, restMutations)
 
-    if (typeof firstMutationOrTxnFnOrOptions === 'function') {
-      // TODO ensure that function is synchronous and isn't called in a async way (also write tests for this)
-      mutationsEvents = firstMutationOrTxnFnOrOptions((arg: any) => mutationsEvents.push(arg))
-    } else if (
-      firstMutationOrTxnFnOrOptions?.label !== undefined ||
-      firstMutationOrTxnFnOrOptions?.skipRefresh !== undefined ||
-      firstMutationOrTxnFnOrOptions?.wasSyncMessage !== undefined ||
-      firstMutationOrTxnFnOrOptions?.persisted !== undefined
-    ) {
-      options = firstMutationOrTxnFnOrOptions
-      mutationsEvents = restMutations
-    } else if (firstMutationOrTxnFnOrOptions === undefined) {
-      // When `mutate` is called with no arguments (which sometimes happens when dynamically filtering mutations)
-      mutationsEvents = []
-    } else {
-      mutationsEvents = [firstMutationOrTxnFnOrOptions, ...restMutations]
+    for (const mutationEvent of mutationsEvents) {
+      replaceSessionIdSymbol(mutationEvent.args, this.clientSession.sessionId)
     }
 
-    mutationsEvents = mutationsEvents.filter(
-      (_) => _.id === undefined || !MutableHashMap.has(this.unsyncedMutationEvents, Data.struct(_.id)),
-    )
-
-    if (mutationsEvents.length === 0) {
-      return
-    }
+    if (mutationsEvents.length === 0) return
 
     const label = options?.label ?? 'mutate'
     const skipRefresh = options?.skipRefresh ?? false
-    const wasSyncMessage = options?.wasSyncMessage ?? false
-    const persisted = options?.persisted ?? true
 
     const mutationsSpan = otel.trace.getSpan(this.otel.mutationsSpanContext)!
     mutationsSpan.addEvent('mutate')
@@ -337,47 +381,30 @@ export class Store<
 
     let durationMs: number
 
-    const res = this.otel.tracer.startActiveSpan(
+    return this.otel.tracer.startActiveSpan(
       'LiveStore:mutate',
-      { attributes: { 'livestore.mutateLabel': label } },
-      this.otel.mutationsSpanContext,
+      { attributes: { 'livestore.mutateLabel': label }, links: options?.spanLinks },
+      options?.otelContext ?? this.otel.mutationsSpanContext,
       (span) => {
         const otelContext = otel.trace.setSpan(otel.context.active(), span)
 
         try {
-          const writeTables: Set<string> = new Set()
-
-          this.otel.tracer.startActiveSpan(
-            'LiveStore:processWrites',
+          const { writeTables } = this.otel.tracer.startActiveSpan(
+            'LiveStore:mutate:applyMutations',
             { attributes: { 'livestore.mutateLabel': label } },
             otel.trace.setSpan(otel.context.active(), span),
             (span) => {
               try {
                 const otelContext = otel.trace.setSpan(otel.context.active(), span)
+                // 5
 
-                const applyMutations = () => {
-                  for (const mutationEvent of mutationsEvents) {
-                    try {
-                      const { writeTables: writeTablesForEvent } = this.mutateWithoutRefresh(mutationEvent, {
-                        otelContext,
-                        // NOTE if it was a sync message, it's already coming from the coordinator, so we can skip the coordinator
-                        coordinatorMode: wasSyncMessage ? 'skip-coordinator' : persisted ? 'default' : 'skip-persist',
-                      })
-                      for (const tableName of writeTablesForEvent) {
-                        writeTables.add(tableName)
-                      }
-                    } catch (e: any) {
-                      console.error(e, mutationEvent)
-                      throw e
-                    }
-                  }
-                }
+                const applyMutations = () => this.syncProcessor.push(mutationsEvents, { otelContext })
 
                 if (mutationsEvents.length > 1) {
-                  // TODO: what to do about coordinator transaction here?
-                  this.syncDbWrapper.txn(applyMutations)
+                  // TODO: what to do about leader transaction here?
+                  return this.syncDbWrapper.txn(applyMutations)
                 } else {
-                  applyMutations()
+                  return applyMutations()
                 }
               } catch (e: any) {
                 console.error(e)
@@ -417,16 +444,6 @@ export class Store<
         return { durationMs }
       },
     )
-
-    // NOTE we need to add the mutation events to the unsynced mutation events map only after running the code above
-    // so the short-circuiting in `mutateWithoutRefresh` doesn't kick in for those events
-    for (const mutationEvent of mutationsEvents) {
-      if (mutationEvent.id !== undefined) {
-        MutableHashMap.set(this.unsyncedMutationEvents, Data.struct(mutationEvent.id), mutationEvent)
-      }
-    }
-
-    return res
   }
   // #endregion mutate
 
@@ -448,117 +465,6 @@ export class Store<
     )
   }
 
-  // #region mutateWithoutRefresh
-  /**
-   * Apply a mutation to the store.
-   * Returns the tables that were affected by the event.
-   * This is an internal method that doesn't trigger a refresh;
-   * the caller must refresh queries after calling this method.
-   */
-  mutateWithoutRefresh = (
-    mutationEventDecoded_: MutationEvent.ForSchema<TSchema> | MutationEvent.PartialForSchema<TSchema>,
-    options: {
-      otelContext: otel.Context
-      // TODO adjust `skip-persist` with new rebase sync strategy
-      coordinatorMode: 'default' | 'skip-coordinator' | 'skip-persist'
-    },
-  ): { writeTables: ReadonlySet<string>; durationMs: number } => {
-    const mutationDef =
-      this.schema.mutations.get(mutationEventDecoded_.mutation) ??
-      shouldNeverHappen(`Unknown mutation type: ${mutationEventDecoded_.mutation}`)
-
-    // Needs to happen only for partial mutation events (thus a function)
-    const nextMutationEventId = () => {
-      const { id, parentId } = this.clientSession.coordinator
-        .nextMutationEventIdPair({ localOnly: mutationDef.options.localOnly })
-        .pipe(Effect.runSync)
-
-      return { id, parentId }
-    }
-
-    const mutationEventDecoded: MutationEvent.ForSchema<TSchema> = isPartialMutationEvent(mutationEventDecoded_)
-      ? { ...mutationEventDecoded_, ...nextMutationEventId() }
-      : mutationEventDecoded_
-
-    // NOTE we also need this temporary workaround here since some code-paths use `mutateWithoutRefresh` directly
-    // e.g. the row-query functionality
-    if (MutableHashMap.has(this.unsyncedMutationEvents, Data.struct(mutationEventDecoded.id))) {
-      // NOTE this data should never be used
-      return { writeTables: new Set(), durationMs: 0 }
-    } else {
-      MutableHashMap.set(this.unsyncedMutationEvents, Data.struct(mutationEventDecoded.id), mutationEventDecoded)
-    }
-
-    const { otelContext, coordinatorMode = 'default' } = options
-
-    return this.otel.tracer.startActiveSpan(
-      'LiveStore:mutateWithoutRefresh',
-      {
-        attributes: {
-          'livestore.mutation': mutationEventDecoded.mutation,
-          'livestore.args': JSON.stringify(mutationEventDecoded.args, null, 2),
-        },
-      },
-      otelContext,
-      (span) => {
-        const otelContext = otel.trace.setSpan(otel.context.active(), span)
-
-        const allWriteTables = new Set<string>()
-        let durationMsTotal = 0
-
-        replaceSessionIdSymbol(mutationEventDecoded.args, this.clientSession.coordinator.sessionId)
-
-        const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
-
-        for (const {
-          statementSql,
-          bindValues,
-          writeTables = this.syncDbWrapper.getTablesUsed(statementSql),
-        } of execArgsArr) {
-          // TODO when the store doesn't have the lock, we need wait for the coordinator to confirm the mutation
-          // before executing the mutation on the main db
-          const { durationMs } = this.syncDbWrapper.execute(statementSql, bindValues, writeTables, { otelContext })
-
-          durationMsTotal += durationMs
-          writeTables.forEach((table) => allWriteTables.add(table))
-        }
-
-        const mutationEventEncoded = Schema.encodeUnknownSync(this.__mutationEventSchema)(mutationEventDecoded)
-
-        if (coordinatorMode !== 'skip-coordinator') {
-          // Asynchronously apply mutation to a persistent storage (we're not awaiting this promise here)
-          this.clientSession.coordinator
-            .mutate(mutationEventEncoded as MutationEvent.AnyEncoded, { persisted: coordinatorMode !== 'skip-persist' })
-            .pipe(this.runEffectFork)
-        }
-
-        // Uncomment to print a list of queries currently registered on the store
-        // console.debug(JSON.parse(JSON.stringify([...this.queries].map((q) => `${labelForKey(q.componentKey)}/${q.label}`))))
-
-        span.end()
-
-        return { writeTables: allWriteTables, durationMs: durationMsTotal }
-      },
-    )
-  }
-  // #endregion mutateWithoutRefresh
-
-  /**
-   * Directly execute a SQL query on the Store.
-   * This should only be used for framework-internal purposes;
-   * all app writes should go through mutate.
-   */
-  __execute = (
-    query: string,
-    params: ParamsObject = {},
-    writeTables?: ReadonlySet<string>,
-    otelContext?: otel.Context,
-  ) => {
-    this.syncDbWrapper.execute(query, prepareBindValues(params, query), writeTables, { otelContext })
-
-    this.clientSession.coordinator.execute(query, prepareBindValues(params, query)).pipe(this.runEffectFork)
-  }
-
   private makeTableRef = (tableName: string) =>
     this.reactivityGraph.makeRef(null, {
       equal: () => false,
@@ -566,27 +472,85 @@ export class Store<
       meta: { liveStoreRefType: 'table' },
     })
 
-  __devDownloadDb = () => {
-    const data = this.syncDbWrapper.export()
-    downloadBlob(data, `livestore-${Date.now()}.db`)
+  __devDownloadDb = (source: 'local' | 'leader' = 'local') => {
+    Effect.gen(this, function* () {
+      const data = source === 'local' ? this.syncDbWrapper.export() : yield* this.clientSession.leaderThread.export
+      downloadBlob(data, `livestore-${Date.now()}.db`)
+    }).pipe(this.runEffectFork)
   }
 
-  __devDownloadMutationLogDb = () =>
+  __devDownloadMutationLogDb = () => {
     Effect.gen(this, function* () {
-      const data = yield* this.clientSession.coordinator.getMutationLogData
+      const data = yield* this.clientSession.leaderThread.getMutationLogData
       downloadBlob(data, `livestore-mutationlog-${Date.now()}.db`)
     }).pipe(this.runEffectFork)
+  }
+
+  __devHardReset = (mode: 'all-data' | 'only-app-db' = 'all-data') => {
+    Effect.gen(this, function* () {
+      yield* this.clientSession.leaderThread.sendDevtoolsMessage(
+        Devtools.ResetAllDataReq.make({ liveStoreVersion, mode, requestId: nanoid() }),
+      )
+    }).pipe(this.runEffectFork)
+  }
+
+  __devSyncStates = () => {
+    Effect.gen(this, function* () {
+      const session = this.syncProcessor.syncStateRef.current
+      console.log('Session sync state:', session.toJSON())
+      const leader = yield* this.clientSession.leaderThread.getSyncState
+      console.log('Leader sync state:', leader.toJSON())
+    }).pipe(this.runEffectFork)
+  }
 
-  __devCurrentMutationEventId = () => this.clientSession.coordinator.getCurrentMutationEventId.pipe(Effect.runSync)
+  __devShutdown = (cause?: Cause.Cause<UnexpectedError>) => {
+    this.clientSession
+      .shutdown(cause ?? Cause.fail(IntentionalShutdownCause.make({ reason: 'manual' })))
+      .pipe(Effect.tapCauseLogPretty, Effect.provide(this.runtime), Effect.runFork)
+  }
 
   // NOTE This is needed because when booting a Store via Effect it seems to call `toJSON` in the error path
-  toJSON = () => {
-    return {
-      _tag: 'livestore.Store',
-      reactivityGraph: this.reactivityGraph.getSnapshot({ includeResults: true }),
+  toJSON = () => ({
+    _tag: 'livestore.Store',
+    reactivityGraph: this.reactivityGraph.getSnapshot({ includeResults: true }),
+  })
+
+  private runEffectFork = <A, E>(effect: Effect.Effect<A, E, Scope.Scope>) =>
+    effect.pipe(Effect.forkIn(this.lifetimeScope), Effect.tapCauseLogPretty, Runtime.runFork(this.runtime))
+
+  private getMutateArgs = (
+    firstMutationOrTxnFnOrOptions: any,
+    restMutations: any[],
+  ): {
+    mutationsEvents: (MutationEvent.ForSchema<TSchema> | MutationEvent.PartialForSchema<TSchema>)[]
+    options: StoreMutateOptions | undefined
+  } => {
+    let mutationsEvents: (MutationEvent.ForSchema<TSchema> | MutationEvent.PartialForSchema<TSchema>)[]
+    let options: StoreMutateOptions | undefined
+
+    if (typeof firstMutationOrTxnFnOrOptions === 'function') {
+      // TODO ensure that function is synchronous and isn't called in a async way (also write tests for this)
+      mutationsEvents = firstMutationOrTxnFnOrOptions((arg: any) => mutationsEvents.push(arg))
+    } else if (
+      firstMutationOrTxnFnOrOptions?.label !== undefined ||
+      firstMutationOrTxnFnOrOptions?.skipRefresh !== undefined ||
+      firstMutationOrTxnFnOrOptions?.otelContext !== undefined ||
+      firstMutationOrTxnFnOrOptions?.spanLinks !== undefined
+    ) {
+      options = firstMutationOrTxnFnOrOptions
+      mutationsEvents = restMutations
+    } else if (firstMutationOrTxnFnOrOptions === undefined) {
+      // When `mutate` is called with no arguments (which sometimes happens when dynamically filtering mutations)
+      mutationsEvents = []
+    } else {
+      mutationsEvents = [firstMutationOrTxnFnOrOptions, ...restMutations]
     }
-  }
 
-  private runEffectFork = <A, E>(effect: Effect.Effect<A, E, never>) =>
-    effect.pipe(Effect.tapCauseLogPretty, FiberSet.run(this.fiberSet), Runtime.runFork(this.runtime))
+    mutationsEvents = mutationsEvents.filter(
+      // @ts-expect-error TODO
+      (_) => _.id === undefined || !MutableHashMap.has(this.unsyncedMutationEvents, Data.struct(_.id)),
+    )
+
+    return { mutationsEvents, options }
+  }
 }

package/src/utils/dev.ts

@@ -1,3 +1,5 @@
+import { isDevEnv } from '@livestore/utils'
+
 /* eslint-disable unicorn/prefer-global-this */
 export const downloadBlob = (
   data: Uint8Array | Blob | string,
@@ -24,7 +26,7 @@ export const downloadURL = (data: string, fileName: string) => {
 }
 
 export const exposeDebugUtils = () => {
-  if (import.meta.env.DEV) {
-    globalThis.__debugDownloadBlob = downloadBlob
+  if (isDevEnv()) {
+    globalThis.__debugLiveStoreUtils = { downloadBlob }
   }
 }

package/src/utils/tests/fixture.ts

@@ -1,7 +1,8 @@
+import { provideOtel } from '@livestore/common'
 import type { FromInputSchema } from '@livestore/common/schema'
 import type { Store } from '@livestore/livestore'
 import { createStore, DbSchema, globalReactivityGraph, makeReactivityGraph, makeSchema } from '@livestore/livestore'
-import { Effect, FiberSet } from '@livestore/utils/effect'
+import { Effect } from '@livestore/utils/effect'
 import { makeInMemoryAdapter } from '@livestore/web'
 import type * as otel from '@opentelemetry/api'
 
@@ -55,19 +56,13 @@ export const makeTodoMvc = ({
   Effect.gen(function* () {
     const reactivityGraph = useGlobalReactivityGraph ? globalReactivityGraph : makeReactivityGraph()
 
-    const fiberSet = yield* FiberSet.make()
-
     const store: Store<any, FixtureSchema> = yield* createStore({
       schema,
       storeId: 'default',
       adapter: makeInMemoryAdapter(),
       reactivityGraph,
-      otelOptions: {
-        tracer: otelTracer,
-        rootSpanContext: otelContext,
-      },
-      fiberSet,
+      debug: { instanceId: 'test' },
     })
 
     return { store, reactivityGraph }
-  })
+  }).pipe(provideOtel({ parentSpanContext: otelContext, otelTracer: otelTracer }))