@livestore/livestore 0.0.54-dev.22 → 0.0.54-dev.24

package/src/store.ts

@@ -1,5 +1,6 @@
 import type {
   BootDb,
+  BootStatus,
   ParamsObject,
   PreparedBindValues,
   ResetMode,
@@ -7,12 +8,12 @@ import type {
   StoreAdapterFactory,
   UnexpectedError,
 } from '@livestore/common'
-import { Devtools, getExecArgsFromMutation, prepareBindValues } from '@livestore/common'
-import { version as liveStoreVersion } from '@livestore/common/package.json'
+import { Devtools, getExecArgsFromMutation, liveStoreVersion, prepareBindValues } from '@livestore/common'
 import type { LiveStoreSchema, MutationEvent } from '@livestore/common/schema'
 import { makeMutationEventSchemaMemo } from '@livestore/common/schema'
-import { assertNever, isPromise, makeNoopTracer, shouldNeverHappen } from '@livestore/utils'
-import { Effect, Layer, OtelTracer, Schema, Stream } from '@livestore/utils/effect'
+import { assertNever, isPromise, makeNoopTracer, shouldNeverHappen, throttle } from '@livestore/utils'
+import { cuid } from '@livestore/utils/cuid'
+import { Effect, Layer, Logger, LogLevel, OtelTracer, Queue, Schema, Stream } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 import type { GraphQLSchema } from 'graphql'
 
@@ -52,6 +53,8 @@ export type StoreOptions<
   otelOptions: OtelOptions
   reactivityGraph: ReactivityGraph
   disableDevtools?: boolean
+  // TODO remove this temporary solution and find a better way to avoid re-processing the same mutation
+  __processedMutationIds: Set<string>
 }
 
 export type RefreshReason =
@@ -106,6 +109,7 @@ export class Store<
   TSchema extends LiveStoreSchema = LiveStoreSchema,
 > {
   id = uniqueStoreId()
+  readonly devtoolsConnectionId = cuid()
   reactivityGraph: ReactivityGraph
   mainDbWrapper: MainDatabaseWrapper
   adapter: StoreAdapter
@@ -120,8 +124,8 @@ export class Store<
   tableRefs: { [key: string]: Ref<null, QueryContext, RefreshReason> }
 
   // TODO remove this temporary solution and find a better way to avoid re-processing the same mutation
-  __processedMutationIds = new Set<string>()
-  __processedMutationWithoutRefreshIds = new Set<string>()
+  private __processedMutationIds
+  private __processedMutationWithoutRefreshIds = new Set<string>()
 
   /** RC-based set to see which queries are currently subscribed to */
   activeQueries: ReferenceCountedSet<LiveQuery<any>>
@@ -135,6 +139,7 @@ export class Store<
     reactivityGraph,
     otelOptions,
     disableDevtools,
+    __processedMutationIds,
   }: StoreOptions<TGraphQLContext, TSchema>) {
     this.mainDbWrapper = new MainDatabaseWrapper({ otel: otelOptions, db: adapter.mainDb })
     this.adapter = adapter
@@ -143,6 +148,9 @@ export class Store<
     // TODO refactor
     this.__mutationEventSchema = makeMutationEventSchemaMemo(schema)
 
+    // TODO remove this temporary solution and find a better way to avoid re-processing the same mutation
+    this.__processedMutationIds = __processedMutationIds
+
     // TODO generalize the `tableRefs` concept to allow finer-grained refs
     this.tableRefs = {}
     this.activeQueries = new ReferenceCountedSet()
@@ -165,8 +173,7 @@ export class Store<
         this.mutate({ wasSyncMessage: true }, mutationEventDecoded)
       }),
       Stream.runDrain,
-      Effect.tapCauseLogPretty,
-      Effect.runFork,
+      runEffectFork,
     )
 
     if (disableDevtools !== true) {
@@ -180,11 +187,7 @@ export class Store<
     }
 
     // Need a set here since `schema.tables` might contain duplicates and some componentStateTables
-    const allTableNames = new Set(
-      this.schema.tables.keys(),
-      // TODO activate dynamic tables
-      // ...Array.from(dynamicallyRegisteredTables.values()).map((_) => _.sqliteDef.name),
-    )
+    const allTableNames = new Set(this.schema.tables.keys())
     const existingTableRefs = new Map(
       Array.from(this.reactivityGraph.atoms.values())
         .filter((_): _ is Ref<any, any, any> => _._tag === 'ref' && _.label?.startsWith('tableRef:') === true)
@@ -272,7 +275,7 @@ export class Store<
     otel.trace.getSpan(this.otel.mutationsSpanContext)!.end()
     otel.trace.getSpan(this.otel.queriesSpanContext)!.end()
 
-    await this.adapter.coordinator.shutdown.pipe(Effect.tapCauseLogPretty, Effect.runPromise)
+    await this.adapter.coordinator.shutdown.pipe(runEffectPromise)
   }
 
   mutate: {
@@ -491,7 +494,7 @@ export class Store<
           // Asynchronously apply mutation to a persistent storage (we're not awaiting this promise here)
           this.adapter.coordinator
             .mutate(mutationEventEncoded as MutationEvent.AnyEncoded, { persisted: coordinatorMode !== 'skip-persist' })
-            .pipe(Effect.tapCauseLogPretty, Effect.runFork)
+            .pipe(runEffectFork)
         }
 
         // Uncomment to print a list of queries currently registered on the store
@@ -517,9 +520,7 @@ export class Store<
   ) => {
     this.mainDbWrapper.execute(query, prepareBindValues(params, query), writeTables, { otelContext })
 
-    this.adapter.coordinator
-      .execute(query, prepareBindValues(params, query))
-      .pipe(Effect.tapCauseLogPretty, Effect.runFork)
+    this.adapter.coordinator.execute(query, prepareBindValues(params, query)).pipe(runEffectFork)
   }
 
   select = (query: string, params: ParamsObject = {}) => {
@@ -533,118 +534,268 @@ export class Store<
       meta: { liveStoreRefType: 'table' },
     })
 
+  // TODO shutdown behaviour
   private bootDevtools = () => {
-    const devtoolsChannel = Devtools.makeBroadcastChannels()
+    const sendToDevtoolsContentscript = (
+      message: typeof Devtools.DevtoolsWindowMessage.MessageForContentscript.Type,
+    ) => {
+      window.postMessage(Schema.encodeSync(Devtools.DevtoolsWindowMessage.MessageForContentscript)(message), '*')
+    }
 
-    type Unsub = () => void
-    type RequestId = string
+    const channelId = this.adapter.coordinator.devtools.channelId
 
-    const reactivityGraphSubcriptions = new Map<RequestId, Unsub>()
-    const liveQueriesSubscriptions = new Map<RequestId, Unsub>()
-    devtoolsChannel.toAppHost.addEventListener('message', async (event) => {
-      const decoded = Schema.decodeUnknownOption(Devtools.MessageToAppHost)(event.data)
-      if (
-        decoded._tag === 'None' ||
-        decoded.value._tag === 'LSD.DevtoolsReady' ||
-        decoded.value._tag === 'LSD.DevtoolsConnected' ||
-        decoded.value.channelId !== this.adapter.coordinator.devtools.channelId
-      ) {
-        // console.log(`Unknown message`, event)
+    window.addEventListener('message', (event) => {
+      const decodedMessageRes = Schema.decodeOption(Devtools.DevtoolsWindowMessage.MessageForStore)(event.data)
+      if (decodedMessageRes._tag === 'None') return
+
+      const message = decodedMessageRes.value
+
+      if (message._tag === 'LSD.WindowMessage.ContentscriptListening') {
+        sendToDevtoolsContentscript(Devtools.DevtoolsWindowMessage.StoreReady.make({ channelId }))
         return
       }
 
-      const requestId = decoded.value.requestId
-      const sendToDevtools = (message: Devtools.MessageFromAppHost) =>
-        devtoolsChannel.fromAppHost.postMessage(Schema.encodeSync(Devtools.MessageFromAppHost)(message))
-
-      switch (decoded.value._tag) {
-        case 'LSD.ReactivityGraphSubscribe': {
-          const includeResults = decoded.value.includeResults
-          const send = () =>
-            sendToDevtools(
-              Devtools.ReactivityGraphRes.make({
-                reactivityGraph: this.reactivityGraph.getSnapshot({ includeResults }),
-                requestId,
-                liveStoreVersion,
-              }),
-            )
-
-          send()
-
-          reactivityGraphSubcriptions.set(
-            requestId,
-            this.reactivityGraph.subscribeToRefresh(() => send()),
-          )
+      if (message.channelId !== channelId) return
 
-          break
-        }
-        case 'LSD.DebugInfoReq': {
-          sendToDevtools(
-            Devtools.DebugInfoRes.make({ debugInfo: this.mainDbWrapper.debugInfo, requestId, liveStoreVersion }),
-          )
-          break
-        }
-        case 'LSD.DebugInfoResetReq': {
-          this.mainDbWrapper.debugInfo.slowQueries.clear()
-          sendToDevtools(Devtools.DebugInfoResetRes.make({ requestId, liveStoreVersion }))
-          break
-        }
-        case 'LSD.DebugInfoRerunQueryReq': {
-          const { queryStr, bindValues, queriedTables } = decoded.value
-          this.mainDbWrapper.select(queryStr, { bindValues, queriedTables, skipCache: true })
-          sendToDevtools(Devtools.DebugInfoRerunQueryRes.make({ requestId, liveStoreVersion }))
-          break
-        }
-        case 'LSD.ReactivityGraphUnsubscribe': {
-          reactivityGraphSubcriptions.get(requestId)!()
-          break
-        }
-        case 'LSD.LiveQueriesSubscribe': {
-          const send = () =>
-            sendToDevtools(
-              Devtools.LiveQueriesRes.make({
-                liveQueries: [...this.activeQueries].map((q) => ({
-                  _tag: q._tag,
-                  id: q.id,
-                  label: q.label,
-                  runs: q.runs,
-                  executionTimes: q.executionTimes.map((_) => Number(_.toString().slice(0, 5))),
-                  lastestResult:
-                    q.results$.previousResult === NOT_REFRESHED_YET
-                      ? 'SYMBOL_NOT_REFRESHED_YET'
-                      : q.results$.previousResult,
-                  activeSubscriptions: Array.from(q.activeSubscriptions),
-                })),
-                requestId,
-                liveStoreVersion,
-              }),
-            )
-
-          send()
-
-          liveQueriesSubscriptions.set(
-            requestId,
-            this.reactivityGraph.subscribeToRefresh(() => send()),
-          )
+      if (message._tag === 'LSD.WindowMessage.MessagePortForStore') {
+        this.adapter.coordinator.devtools.connect({ port: message.port, connectionId: this.devtoolsConnectionId }).pipe(
+          Effect.tapSync(({ storeMessagePort }) => {
+            // console.log('storeMessagePort', storeMessagePort)
+            storeMessagePort.addEventListener('message', (event) => {
+              const decodedMessage = Schema.decodeUnknownSync(Devtools.MessageToAppHostStore)(event.data)
+              // console.log('storeMessagePort message', decodedMessage)
 
-          break
-        }
-        case 'LSD.LiveQueriesUnsubscribe': {
-          liveQueriesSubscriptions.get(requestId)!()
-          break
-        }
-        case 'LSD.ResetAllDataReq': {
-          await this.adapter.coordinator
-            .dangerouslyReset(decoded.value.mode)
-            .pipe(Effect.tapCauseLogPretty, Effect.runPromise)
+              if (decodedMessage.channelId !== this.adapter.coordinator.devtools.channelId) {
+                // console.log(`Unknown message`, event)
+                return
+              }
+
+              const requestId = decodedMessage.requestId
+              const sendToDevtools = (message: Devtools.MessageFromAppHostStore) =>
+                storeMessagePort.postMessage(Schema.encodeSync(Devtools.MessageFromAppHostStore)(message))
+
+              const requestIdleCallback = window.requestIdleCallback ?? ((cb: Function) => cb())
+
+              switch (decodedMessage._tag) {
+                case 'LSD.ReactivityGraphSubscribe': {
+                  const includeResults = decodedMessage.includeResults
+
+                  const send = () =>
+                    // In order to not add more work to the current tick, we use requestIdleCallback
+                    // to send the reactivity graph updates to the devtools
+                    requestIdleCallback(
+                      () =>
+                        sendToDevtools(
+                          Devtools.ReactivityGraphRes.make({
+                            reactivityGraph: this.reactivityGraph.getSnapshot({ includeResults }),
+                            requestId,
+                            liveStoreVersion,
+                          }),
+                        ),
+                      { timeout: 500 },
+                    )
+
+                  send()
+
+                  // In some cases, there can be A LOT of reactivity graph updates in a short period of time
+                  // so we throttle the updates to avoid sending too much data
+                  // This might need to be tweaked further and possibly be exposed to the user in some way.
+                  const throttledSend = throttle(send, 20)
+
+                  reactivityGraphSubcriptions.set(requestId, this.reactivityGraph.subscribeToRefresh(throttledSend))
+
+                  break
+                }
+                case 'LSD.DebugInfoReq': {
+                  sendToDevtools(
+                    Devtools.DebugInfoRes.make({
+                      debugInfo: this.mainDbWrapper.debugInfo,
+                      requestId,
+                      liveStoreVersion,
+                    }),
+                  )
+                  break
+                }
+                case 'LSD.DebugInfoResetReq': {
+                  this.mainDbWrapper.debugInfo.slowQueries.clear()
+                  sendToDevtools(Devtools.DebugInfoResetRes.make({ requestId, liveStoreVersion }))
+                  break
+                }
+                case 'LSD.DebugInfoRerunQueryReq': {
+                  const { queryStr, bindValues, queriedTables } = decodedMessage
+                  this.mainDbWrapper.select(queryStr, { bindValues, queriedTables, skipCache: true })
+                  sendToDevtools(Devtools.DebugInfoRerunQueryRes.make({ requestId, liveStoreVersion }))
+                  break
+                }
+                case 'LSD.ReactivityGraphUnsubscribe': {
+                  reactivityGraphSubcriptions.get(requestId)!()
+                  break
+                }
+                case 'LSD.LiveQueriesSubscribe': {
+                  const send = () =>
+                    requestIdleCallback(
+                      () =>
+                        sendToDevtools(
+                          Devtools.LiveQueriesRes.make({
+                            liveQueries: [...this.activeQueries].map((q) => ({
+                              _tag: q._tag,
+                              id: q.id,
+                              label: q.label,
+                              runs: q.runs,
+                              executionTimes: q.executionTimes.map((_) => Number(_.toString().slice(0, 5))),
+                              lastestResult:
+                                q.results$.previousResult === NOT_REFRESHED_YET
+                                  ? 'SYMBOL_NOT_REFRESHED_YET'
+                                  : q.results$.previousResult,
+                              activeSubscriptions: Array.from(q.activeSubscriptions),
+                            })),
+                            requestId,
+                            liveStoreVersion,
+                          }),
+                        ),
+                      { timeout: 500 },
+                    )
+
+                  send()
+
+                  // Same as in the reactivity graph subscription case above, we need to throttle the updates
+                  const throttledSend = throttle(send, 20)
+
+                  liveQueriesSubscriptions.set(requestId, this.reactivityGraph.subscribeToRefresh(throttledSend))
+
+                  break
+                }
+                case 'LSD.LiveQueriesUnsubscribe': {
+                  liveQueriesSubscriptions.get(requestId)!()
+                  break
+                }
+                // No default
+              }
+            })
 
-          sendToDevtools(Devtools.ResetAllDataRes.make({ requestId, liveStoreVersion }))
+            storeMessagePort.start()
+          }),
+          runEffectFork,
+        )
 
-          break
-        }
-        // No default
+        return
       }
     })
+
+    sendToDevtoolsContentscript(Devtools.DevtoolsWindowMessage.StoreReady.make({ channelId }))
+
+    // const devtoolsChannel = Devtools.makeBroadcastChannels()
+
+    type Unsub = () => void
+    type RequestId = string
+
+    const reactivityGraphSubcriptions = new Map<RequestId, Unsub>()
+    const liveQueriesSubscriptions = new Map<RequestId, Unsub>()
+    // devtoolsChannel.toAppHost.addEventListener('message', async (event) => {
+    //   const decoded = Schema.decodeUnknownOption(Devtools.MessageToAppHostStore)(event.data)
+    //   if (decoded._tag === 'None' || decoded.value.channelId !== this.adapter.coordinator.devtools.channelId) {
+    //     // console.log(`Unknown message`, event)
+    //     return
+    //   }
+
+    //   const requestId = decoded.value.requestId
+    //   const sendToDevtools = (message: Devtools.MessageFromAppHostStore) =>
+    //     devtoolsChannel.fromAppHost.postMessage(Schema.encodeSync(Devtools.MessageFromAppHostStore)(message))
+
+    //   const requestIdleCallback = window.requestIdleCallback ?? ((cb: Function) => cb())
+
+    //   switch (decoded.value._tag) {
+    //     case 'LSD.ReactivityGraphSubscribe': {
+    //       const includeResults = decoded.value.includeResults
+
+    //       const send = () =>
+    //         // In order to not add more work to the current tick, we use requestIdleCallback
+    //         // to send the reactivity graph updates to the devtools
+    //         requestIdleCallback(
+    //           () =>
+    //             sendToDevtools(
+    //               Devtools.ReactivityGraphRes.make({
+    //                 reactivityGraph: this.reactivityGraph.getSnapshot({ includeResults }),
+    //                 requestId,
+    //                 liveStoreVersion,
+    //               }),
+    //             ),
+    //           { timeout: 500 },
+    //         )
+
+    //       send()
+
+    //       // In some cases, there can be A LOT of reactivity graph updates in a short period of time
+    //       // so we throttle the updates to avoid sending too much data
+    //       // This might need to be tweaked further and possibly be exposed to the user in some way.
+    //       const throttledSend = throttle(send, 20)
+
+    //       reactivityGraphSubcriptions.set(requestId, this.reactivityGraph.subscribeToRefresh(throttledSend))
+
+    //       break
+    //     }
+    //     case 'LSD.DebugInfoReq': {
+    //       sendToDevtools(
+    //         Devtools.DebugInfoRes.make({ debugInfo: this.mainDbWrapper.debugInfo, requestId, liveStoreVersion }),
+    //       )
+    //       break
+    //     }
+    //     case 'LSD.DebugInfoResetReq': {
+    //       this.mainDbWrapper.debugInfo.slowQueries.clear()
+    //       sendToDevtools(Devtools.DebugInfoResetRes.make({ requestId, liveStoreVersion }))
+    //       break
+    //     }
+    //     case 'LSD.DebugInfoRerunQueryReq': {
+    //       const { queryStr, bindValues, queriedTables } = decoded.value
+    //       this.mainDbWrapper.select(queryStr, { bindValues, queriedTables, skipCache: true })
+    //       sendToDevtools(Devtools.DebugInfoRerunQueryRes.make({ requestId, liveStoreVersion }))
+    //       break
+    //     }
+    //     case 'LSD.ReactivityGraphUnsubscribe': {
+    //       reactivityGraphSubcriptions.get(requestId)!()
+    //       break
+    //     }
+    //     case 'LSD.LiveQueriesSubscribe': {
+    //       const send = () =>
+    //         requestIdleCallback(
+    //           () =>
+    //             sendToDevtools(
+    //               Devtools.LiveQueriesRes.make({
+    //                 liveQueries: [...this.activeQueries].map((q) => ({
+    //                   _tag: q._tag,
+    //                   id: q.id,
+    //                   label: q.label,
+    //                   runs: q.runs,
+    //                   executionTimes: q.executionTimes.map((_) => Number(_.toString().slice(0, 5))),
+    //                   lastestResult:
+    //                     q.results$.previousResult === NOT_REFRESHED_YET
+    //                       ? 'SYMBOL_NOT_REFRESHED_YET'
+    //                       : q.results$.previousResult,
+    //                   activeSubscriptions: Array.from(q.activeSubscriptions),
+    //                 })),
+    //                 requestId,
+    //                 liveStoreVersion,
+    //               }),
+    //             ),
+    //           { timeout: 500 },
+    //         )
+
+    //       send()
+
+    //       // Same as in the reactivity graph subscription case above, we need to throttle the updates
+    //       const throttledSend = throttle(send, 20)
+
+    //       liveQueriesSubscriptions.set(requestId, this.reactivityGraph.subscribeToRefresh(throttledSend))
+
+    //       break
+    //     }
+    //     case 'LSD.LiveQueriesUnsubscribe': {
+    //       liveQueriesSubscriptions.get(requestId)!()
+    //       break
+    //     }
+    //     // No default
+    //   }
+    // })
   }
 
   __devDownloadDb = () => {
@@ -653,13 +804,12 @@ export class Store<
   }
 
   __devDownloadMutationLogDb = async () => {
-    const data = await this.adapter.coordinator.getMutationLogData.pipe(Effect.tapCauseLogPretty, Effect.runPromise)
+    const data = await this.adapter.coordinator.getMutationLogData.pipe(runEffectPromise)
     downloadBlob(data, `livestore-mutationlog-${Date.now()}.db`)
   }
 
   // TODO allow for graceful store reset without requiring a full page reload (which should also call .boot)
-  dangerouslyResetStorage = (mode: ResetMode) =>
-    this.adapter.coordinator.dangerouslyReset(mode).pipe(Effect.tapCauseLogPretty, Effect.runPromise)
+  dangerouslyResetStorage = (mode: ResetMode) => this.adapter.coordinator.dangerouslyReset(mode).pipe(runEffectPromise)
 }
 
 export type CreateStoreOptions<TGraphQLContext extends BaseGraphQLContext, TSchema extends LiveStoreSchema> = {
@@ -671,6 +821,7 @@ export type CreateStoreOptions<TGraphQLContext extends BaseGraphQLContext, TSche
   boot?: (db: BootDb, parentSpan: otel.Span) => unknown | Promise<unknown>
   batchUpdates?: (run: () => void) => void
   disableDevtools?: boolean
+  onBootStatus?: (status: BootStatus) => void
 }
 
 /** Create a new LiveStore Store */
@@ -679,7 +830,7 @@ export const createStore = async <
   TSchema extends LiveStoreSchema = LiveStoreSchema,
 >(
   options: CreateStoreOptions<TGraphQLContext, TSchema>,
-): Promise<Store<TGraphQLContext, TSchema>> => createStoreEff(options).pipe(Effect.tapCauseLogPretty, Effect.runPromise)
+): Promise<Store<TGraphQLContext, TSchema>> => createStoreEff(options).pipe(runEffectPromise)
 
 export const createStoreEff = <
   TGraphQLContext extends BaseGraphQLContext,
@@ -693,6 +844,7 @@ export const createStoreEff = <
   reactivityGraph = globalReactivityGraph,
   batchUpdates,
   disableDevtools,
+  onBootStatus,
 }: CreateStoreOptions<TGraphQLContext, TSchema>): Effect.Effect<Store<TGraphQLContext, TSchema>, UnexpectedError> => {
   const otelTracer = otelOptions?.tracer ?? makeNoopTracer()
   const otelRootSpanContext = otelOptions?.rootSpanContext ?? otel.context.active()
@@ -704,17 +856,29 @@ export const createStoreEff = <
   return Effect.gen(function* () {
     const span = yield* OtelTracer.currentOtelSpan.pipe(Effect.orDie)
 
-    const adapter = yield* adapterFactory({ schema }).pipe(
-      Effect.withPerformanceMeasure('livestore:makeAdapter'),
-      Effect.withSpan('createStore:makeAdapter'),
+    const bootStatusQueue = yield* Queue.unbounded<BootStatus>()
+
+    yield* Queue.take(bootStatusQueue).pipe(
+      Effect.tapSync((status) => onBootStatus?.(status)),
+      Effect.forever,
+      Effect.tapCauseLogPretty,
+      Effect.forkScoped,
     )
 
+    const adapter: StoreAdapter = yield* adapterFactory({
+      schema,
+      devtoolsEnabled: disableDevtools !== true,
+      bootStatusQueue,
+    }).pipe(Effect.withPerformanceMeasure('livestore:makeAdapter'), Effect.withSpan('createStore:makeAdapter'))
+
     if (batchUpdates !== undefined) {
       reactivityGraph.effectsWrapper = batchUpdates
     }
 
     const mutationEventSchema = makeMutationEventSchemaMemo(schema)
 
+    const __processedMutationIds = new Set<string>()
+
     // TODO consider moving booting into the storage backend
     if (boot !== undefined) {
       let isInTxn = false
@@ -729,7 +893,7 @@ export const createStoreEff = <
           if (isInTxn === true) {
             txnExecuteStmnts.push([queryStr, bindValues])
           } else {
-            adapter.coordinator.execute(queryStr, bindValues).pipe(Effect.tapCauseLogPretty, Effect.runFork)
+            adapter.coordinator.execute(queryStr, bindValues).pipe(runEffectFork)
           }
         },
         mutate: (...list) => {
@@ -738,6 +902,8 @@ export const createStoreEff = <
               schema.mutations.get(mutationEventDecoded.mutation) ??
               shouldNeverHappen(`Unknown mutation type: ${mutationEventDecoded.mutation}`)
 
+            __processedMutationIds.add(mutationEventDecoded.id)
+
             const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
             // const { bindValues, statementSql } = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
 
@@ -749,7 +915,7 @@ export const createStoreEff = <
 
             adapter.coordinator
               .mutate(mutationEventEncoded as MutationEvent.AnyEncoded, { persisted: true })
-              .pipe(Effect.tapCauseLogPretty, Effect.runFork)
+              .pipe(runEffectFork)
           }
         },
         select: (queryStr, bindValues) => {
@@ -767,7 +933,7 @@ export const createStoreEff = <
 
             // adapter.coordinator.execute('BEGIN', undefined, undefined)
             for (const [queryStr, bindValues] of txnExecuteStmnts) {
-              adapter.coordinator.execute(queryStr, bindValues).pipe(Effect.tapCauseLogPretty, Effect.runFork)
+              adapter.coordinator.execute(queryStr, bindValues).pipe(runEffectFork)
             }
             // adapter.coordinator.execute('COMMIT', undefined, undefined)
           } catch (e: any) {
@@ -798,10 +964,12 @@ export const createStoreEff = <
         otelOptions: { tracer: otelTracer, rootSpanContext: otelRootSpanContext },
         reactivityGraph,
         disableDevtools,
+        __processedMutationIds,
       },
       span,
     )
   }).pipe(
+    Effect.scoped,
     Effect.withSpan('createStore', {
       parent: otelOptions?.rootSpanContext
         ? OtelTracer.makeExternalSpan(otel.trace.getSpanContext(otelOptions.rootSpanContext)!)
@@ -811,6 +979,7 @@ export const createStoreEff = <
   )
 }
 
+// TODO consider replacing with Effect's RC data structures
 class ReferenceCountedSet<T> {
   private map: Map<T, number>
 
@@ -846,3 +1015,21 @@ class ReferenceCountedSet<T> {
     }
   }
 }
+
+const runEffectFork = <A, E>(effect: Effect.Effect<A, E, never>) =>
+  effect.pipe(
+    Effect.tapCauseLogPretty,
+    Effect.annotateLogs({ thread: 'window' }),
+    Effect.provide(Logger.pretty),
+    Logger.withMinimumLogLevel(LogLevel.Debug),
+    Effect.runFork,
+  )
+
+const runEffectPromise = <A, E>(effect: Effect.Effect<A, E, never>) =>
+  effect.pipe(
+    Effect.tapCauseLogPretty,
+    Effect.annotateLogs({ thread: 'window' }),
+    Effect.provide(Logger.pretty),
+    Logger.withMinimumLogLevel(LogLevel.Debug),
+    Effect.runPromise,
+  )