@livestore/livestore 0.0.58-dev.8 → 0.1.0-dev.0

package/src/{store.ts → store/store.ts}

@@ -1,139 +1,29 @@
-import type {
-  BootDb,
-  BootStatus,
-  EventId,
-  IntentionalShutdownCause,
-  ParamsObject,
-  PreparedBindValues,
-  StoreAdapter,
-  StoreAdapterFactory,
-  StoreDevtoolsChannel,
-} from '@livestore/common'
-import { getExecArgsFromMutation, prepareBindValues, UnexpectedError } from '@livestore/common'
+import type { ClientSession, ParamsObject } from '@livestore/common'
+import { getExecArgsFromMutation, prepareBindValues, replaceSessionIdSymbol } from '@livestore/common'
 import type { LiveStoreSchema, MutationEvent } from '@livestore/common/schema'
 import {
+  isPartialMutationEvent,
   makeMutationEventSchemaMemo,
   SCHEMA_META_TABLE,
   SCHEMA_MUTATIONS_META_TABLE,
   SESSION_CHANGESET_META_TABLE,
 } from '@livestore/common/schema'
-import { assertNever, makeNoopTracer, shouldNeverHappen } from '@livestore/utils'
-import {
-  Cause,
-  Data,
-  Deferred,
-  Duration,
-  Effect,
-  Exit,
-  FiberSet,
-  Inspectable,
-  Layer,
-  Logger,
-  LogLevel,
-  MutableHashMap,
-  OtelTracer,
-  Queue,
-  Runtime,
-  Schema,
-  Scope,
-  Stream,
-} from '@livestore/utils/effect'
+import { assertNever, shouldNeverHappen } from '@livestore/utils'
+import type { Scope } from '@livestore/utils/effect'
+import { Data, Effect, FiberSet, Inspectable, MutableHashMap, Runtime, Schema, Stream } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 import type { GraphQLSchema } from 'graphql'
 
-import { globalReactivityGraph } from './global-state.js'
-import type { StackInfo } from './react/utils/stack-info.js'
-import type { DebugRefreshReasonBase, Ref } from './reactive.js'
-import type { LiveQuery, QueryContext, ReactivityGraph } from './reactiveQueries/base-class.js'
-import { connectDevtoolsToStore } from './store-devtools.js'
-import { SynchronousDatabaseWrapper } from './SynchronousDatabaseWrapper.js'
-import { ReferenceCountedSet } from './utils/data-structures.js'
-import { downloadBlob } from './utils/dev.js'
-import { getDurationMsFromSpan } from './utils/otel.js'
-
-export type BaseGraphQLContext = {
-  queriedTables: Set<string>
-  /** Needed by Pothos Otel plugin for resolver tracing to work */
-  otelContext?: otel.Context
-}
-
-export type GraphQLOptions<TContext> = {
-  schema: GraphQLSchema
-  makeContext: (db: SynchronousDatabaseWrapper, tracer: otel.Tracer) => TContext
-}
+import type { Ref } from '../reactive.js'
+import type { LiveQuery, QueryContext, ReactivityGraph } from '../reactiveQueries/base-class.js'
+import { SynchronousDatabaseWrapper } from '../SynchronousDatabaseWrapper.js'
+import { ReferenceCountedSet } from '../utils/data-structures.js'
+import { downloadBlob, exposeDebugUtils } from '../utils/dev.js'
+import { getDurationMsFromSpan } from '../utils/otel.js'
+import type { BaseGraphQLContext, RefreshReason, StoreMutateOptions, StoreOptions, StoreOtel } from './store-types.js'
 
-export type OtelOptions = {
-  tracer: otel.Tracer
-  rootSpanContext: otel.Context
-}
-
-export type StoreOptions<
-  TGraphQLContext extends BaseGraphQLContext,
-  TSchema extends LiveStoreSchema = LiveStoreSchema,
-> = {
-  adapter: StoreAdapter
-  schema: TSchema
-  storeId: string
-  // TODO remove graphql-related stuff from store and move to GraphQL query directly
-  graphQLOptions?: GraphQLOptions<TGraphQLContext>
-  otelOptions: OtelOptions
-  reactivityGraph: ReactivityGraph
-  disableDevtools?: boolean
-  fiberSet: FiberSet.FiberSet
-  runtime: Runtime.Runtime<Scope.Scope>
-  batchUpdates: (runUpdates: () => void) => void
-  currentMutationEventIdRef: { current: EventId }
-  unsyncedMutationEvents: MutableHashMap.MutableHashMap<EventId, MutationEvent.ForSchema<TSchema>>
-}
-
-export type RefreshReason =
-  | DebugRefreshReasonBase
-  | {
-      _tag: 'mutate'
-      /** The mutations that were applied */
-      mutations: ReadonlyArray<MutationEvent.Any>
-
-      /** The tables that were written to by the event */
-      writeTables: ReadonlyArray<string>
-    }
-  | {
-      _tag: 'react'
-      api: string
-      label?: string
-      stackInfo?: StackInfo
-    }
-  | { _tag: 'manual'; label?: string }
-
-export type QueryDebugInfo = {
-  _tag: 'graphql' | 'sql' | 'js' | 'unknown'
-  label: string
-  query: string
-  durationMs: number
-}
-
-export type StoreOtel = {
-  tracer: otel.Tracer
-  mutationsSpanContext: otel.Context
-  queriesSpanContext: otel.Context
-}
-
-export type StoreMutateOptions = {
-  label?: string
-  skipRefresh?: boolean
-  wasSyncMessage?: boolean
-  /**
-   * When set to `false` the mutation won't be persisted in the mutation log and sync server (but still synced).
-   * This can be useful e.g. for fine-granular update events (e.g. position updates during drag & drop)
-   *
-   * @default true
-   */
-  persisted?: boolean
-}
-
-// eslint-disable-next-line unicorn/prefer-global-this
-if (import.meta.env.DEV && typeof window !== 'undefined') {
-  // eslint-disable-next-line unicorn/prefer-global-this
-  window.__debugDownloadBlob = downloadBlob
+if (import.meta.env.DEV) {
+  exposeDebugUtils()
 }
 
 export class Store<
@@ -143,7 +33,7 @@ export class Store<
   readonly storeId: string
   reactivityGraph: ReactivityGraph
   syncDbWrapper: SynchronousDatabaseWrapper
-  adapter: StoreAdapter
+  clientSession: ClientSession
   schema: LiveStoreSchema
   graphQLSchema?: GraphQLSchema
   graphQLContext?: TGraphQLContext
@@ -162,20 +52,17 @@ export class Store<
 
   // NOTE this is currently exposed for the Devtools databrowser to emit mutation events
   readonly __mutationEventSchema
-
-  private currentMutationEventIdRef
   private unsyncedMutationEvents
 
   // #region constructor
   private constructor({
-    adapter,
+    clientSession,
     schema,
     graphQLOptions,
     reactivityGraph,
     otelOptions,
     disableDevtools,
     batchUpdates,
-    currentMutationEventIdRef,
     unsyncedMutationEvents,
     storeId,
     fiberSet,
@@ -185,11 +72,10 @@ export class Store<
 
     this.storeId = storeId
 
-    this.currentMutationEventIdRef = currentMutationEventIdRef
     this.unsyncedMutationEvents = unsyncedMutationEvents
 
-    this.syncDbWrapper = new SynchronousDatabaseWrapper({ otel: otelOptions, db: adapter.syncDb })
-    this.adapter = adapter
+    this.syncDbWrapper = new SynchronousDatabaseWrapper({ otel: otelOptions, db: clientSession.syncDb })
+    this.clientSession = clientSession
     this.schema = schema
 
     this.fiberSet = fiberSet
@@ -247,11 +133,15 @@ export class Store<
 
     if (graphQLOptions) {
       this.graphQLSchema = graphQLOptions.schema
-      this.graphQLContext = graphQLOptions.makeContext(this.syncDbWrapper, this.otel.tracer)
+      this.graphQLContext = graphQLOptions.makeContext(
+        this.syncDbWrapper,
+        this.otel.tracer,
+        clientSession.coordinator.sessionId,
+      )
     }
 
     Effect.gen(this, function* () {
-      yield* this.adapter.coordinator.syncMutations.pipe(
+      yield* this.clientSession.coordinator.syncMutations.pipe(
         Stream.tapChunk((mutationsEventsDecodedChunk) =>
           Effect.sync(() => {
             this.mutate({ wasSyncMessage: true }, ...mutationsEventsDecodedChunk)
@@ -265,18 +155,20 @@ export class Store<
 
       yield* Effect.addFinalizer(() =>
         Effect.sync(() => {
+          // Remove all table refs from the reactivity graph
           for (const tableRef of Object.values(this.tableRefs)) {
             for (const superComp of tableRef.super) {
               this.reactivityGraph.removeEdge(superComp, tableRef)
             }
           }
 
+          // End the otel spans
           otel.trace.getSpan(this.otel.mutationsSpanContext)!.end()
           otel.trace.getSpan(this.otel.queriesSpanContext)!.end()
         }),
       )
 
-      yield* Effect.never
+      yield* Effect.never // to keep the scope alive and bind to the parent scope
     }).pipe(Effect.scoped, Effect.withSpan('LiveStore:constructor'), this.runEffectFork)
   }
   // #endregion constructor
@@ -295,6 +187,10 @@ export class Store<
     })
   }
 
+  get sessionId(): string {
+    return this.clientSession.coordinator.sessionId
+  }
+
   /**
    * Subscribe to the results of a query
    * Returns a function to cancel the subscription.
@@ -491,6 +387,7 @@ export class Store<
 
     return res
   }
+  // #endregion mutate
 
   /**
    * This can be used in combination with `skipRefresh` when applying mutations.
@@ -510,6 +407,7 @@ export class Store<
     )
   }
 
+  // #region mutateWithoutRefresh
   /**
    * Apply a mutation to the store.
    * Returns the tables that were affected by the event.
@@ -520,6 +418,7 @@ export class Store<
     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 } => {
@@ -527,12 +426,18 @@ export class Store<
       this.schema.mutations.get(mutationEventDecoded_.mutation) ??
       shouldNeverHappen(`Unknown mutation type: ${mutationEventDecoded_.mutation}`)
 
-    const mutationEventDecoded: MutationEvent.ForSchema<TSchema> = mutationEventDecoded_.hasOwnProperty('id')
-      ? (mutationEventDecoded_ as MutationEvent.ForSchema<TSchema>)
-      : {
-          ...mutationEventDecoded_,
-          ...this.getNextMutationEventId({ localOnly: mutationDef.options.localOnly }),
-        }
+    // 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
@@ -560,6 +465,8 @@ export class Store<
         const allWriteTables = new Set<string>()
         let durationMsTotal = 0
 
+        replaceSessionIdSymbol(mutationEventDecoded.args, this.clientSession.coordinator.sessionId)
+
         const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
 
         for (const {
@@ -579,7 +486,7 @@ export class Store<
 
         if (coordinatorMode !== 'skip-coordinator') {
           // Asynchronously apply mutation to a persistent storage (we're not awaiting this promise here)
-          this.adapter.coordinator
+          this.clientSession.coordinator
             .mutate(mutationEventEncoded as MutationEvent.AnyEncoded, { persisted: coordinatorMode !== 'skip-persist' })
             .pipe(this.runEffectFork)
         }
@@ -593,7 +500,7 @@ export class Store<
       },
     )
   }
-  // #endregion mutate
+  // #endregion mutateWithoutRefresh
 
   /**
    * Directly execute a SQL query on the Store.
@@ -608,24 +515,13 @@ export class Store<
   ) => {
     this.syncDbWrapper.execute(query, prepareBindValues(params, query), writeTables, { otelContext })
 
-    this.adapter.coordinator.execute(query, prepareBindValues(params, query)).pipe(this.runEffectFork)
+    this.clientSession.coordinator.execute(query, prepareBindValues(params, query)).pipe(this.runEffectFork)
   }
 
   __select = (query: string, params: ParamsObject = {}) => {
     return this.syncDbWrapper.select(query, { bindValues: prepareBindValues(params, query) })
   }
 
-  private getNextMutationEventId = ({ localOnly }: { localOnly: boolean }): { id: EventId; parentId: EventId } => {
-    const id = this.adapter.coordinator.getNextMutationEventId({ localOnly }).pipe(Effect.runSync)
-    const parentId = localOnly
-      ? this.currentMutationEventIdRef.current
-      : { global: this.currentMutationEventIdRef.current.global, local: 0 }
-
-    this.currentMutationEventIdRef.current = id
-
-    return { id, parentId }
-  }
-
   private makeTableRef = (tableName: string) =>
     this.reactivityGraph.makeRef(null, {
       equal: () => false,
@@ -640,14 +536,16 @@ export class Store<
 
   __devDownloadMutationLogDb = () =>
     Effect.gen(this, function* () {
-      const data = yield* this.adapter.coordinator.getMutationLogData
+      const data = yield* this.clientSession.coordinator.getMutationLogData
       downloadBlob(data, `livestore-mutationlog-${Date.now()}.db`)
     }).pipe(this.runEffectFork)
 
+  __devCurrentMutationEventId = () => this.clientSession.coordinator.getCurrentMutationEventId.pipe(Effect.runSync)
+
   // NOTE This is needed because when booting a Store via Effect it seems to call `toJSON` in the error path
   toJSON = () => {
     return {
-      _tag: 'Store',
+      _tag: 'livestore.Store',
       reactivityGraph: this.reactivityGraph.getSnapshot({ includeResults: true }),
     }
   }
@@ -655,260 +553,3 @@ export class Store<
   private runEffectFork = <A, E>(effect: Effect.Effect<A, E, never>) =>
     effect.pipe(Effect.tapCauseLogPretty, FiberSet.run(this.fiberSet), Runtime.runFork(this.runtime))
 }
-
-export type CreateStoreOptions<TGraphQLContext extends BaseGraphQLContext, TSchema extends LiveStoreSchema> = {
-  schema: TSchema
-  adapter: StoreAdapterFactory
-  storeId: string
-  reactivityGraph?: ReactivityGraph
-  graphQLOptions?: GraphQLOptions<TGraphQLContext>
-  otelOptions?: Partial<OtelOptions>
-  boot?: (db: BootDb, parentSpan: otel.Span) => void | Promise<void> | Effect.Effect<void, unknown, otel.Tracer>
-  batchUpdates?: (run: () => void) => void
-  disableDevtools?: boolean
-  onBootStatus?: (status: BootStatus) => void
-}
-
-/** Create a new LiveStore Store */
-export const createStorePromise = async <
-  TGraphQLContext extends BaseGraphQLContext,
-  TSchema extends LiveStoreSchema = LiveStoreSchema,
->({
-  signal,
-  ...options
-}: CreateStoreOptions<TGraphQLContext, TSchema> & { signal?: AbortSignal }): Promise<Store<TGraphQLContext, TSchema>> =>
-  Effect.gen(function* () {
-    const scope = yield* Scope.make()
-    const runtime = yield* Effect.runtime()
-
-    if (signal !== undefined) {
-      signal.addEventListener('abort', () => {
-        Scope.close(scope, Exit.void).pipe(Effect.tapCauseLogPretty, Runtime.runFork(runtime))
-      })
-    }
-
-    return yield* FiberSet.make().pipe(
-      Effect.andThen((fiberSet) => createStore({ ...options, fiberSet })),
-      Scope.extend(scope),
-    )
-  }).pipe(
-    Effect.withSpan('createStore'),
-    Effect.tapCauseLogPretty,
-    Effect.annotateLogs({ thread: 'window' }),
-    Effect.provide(Logger.pretty),
-    Logger.withMinimumLogLevel(LogLevel.Debug),
-    Effect.runPromise,
-  )
-
-// #region createStore
-export const createStore = <
-  TGraphQLContext extends BaseGraphQLContext,
-  TSchema extends LiveStoreSchema = LiveStoreSchema,
->({
-  schema,
-  adapter: adapterFactory,
-  storeId,
-  graphQLOptions,
-  otelOptions,
-  boot,
-  reactivityGraph = globalReactivityGraph,
-  batchUpdates,
-  disableDevtools,
-  onBootStatus,
-  fiberSet,
-}: CreateStoreOptions<TGraphQLContext, TSchema> & { fiberSet: FiberSet.FiberSet }): Effect.Effect<
-  Store<TGraphQLContext, TSchema>,
-  UnexpectedError,
-  Scope.Scope
-> => {
-  const otelTracer = otelOptions?.tracer ?? makeNoopTracer()
-  const otelRootSpanContext = otelOptions?.rootSpanContext ?? otel.context.active()
-
-  const TracingLive = Layer.unwrapEffect(Effect.map(OtelTracer.make, Layer.setTracer)).pipe(
-    Layer.provide(Layer.sync(OtelTracer.Tracer, () => otelTracer)),
-  )
-
-  return Effect.gen(function* () {
-    const span = yield* OtelTracer.currentOtelSpan.pipe(Effect.orDie)
-
-    const bootStatusQueue = yield* Queue.unbounded<BootStatus>().pipe(Effect.acquireRelease(Queue.shutdown))
-
-    yield* Queue.take(bootStatusQueue).pipe(
-      Effect.tapSync((status) => onBootStatus?.(status)),
-      Effect.tap((status) => (status.stage === 'done' ? Queue.shutdown(bootStatusQueue) : Effect.void)),
-      Effect.forever,
-      Effect.tapCauseLogPretty,
-      Effect.forkScoped,
-    )
-
-    const storeDeferred = yield* Deferred.make<Store>()
-
-    const connectDevtoolsToStore_ = (storeDevtoolsChannel: StoreDevtoolsChannel) =>
-      Effect.gen(function* () {
-        const store = yield* Deferred.await(storeDeferred)
-        yield* connectDevtoolsToStore({ storeDevtoolsChannel, store })
-      })
-
-    const runtime = yield* Effect.runtime<Scope.Scope>()
-
-    const runEffectFork = (effect: Effect.Effect<any, any, never>) =>
-      effect.pipe(Effect.tapCauseLogPretty, FiberSet.run(fiberSet), Runtime.runFork(runtime))
-
-    // TODO close parent scope? (Needs refactor with Mike A)
-    const shutdown = (cause: Cause.Cause<UnexpectedError | IntentionalShutdownCause>) =>
-      Effect.gen(function* () {
-        // NOTE we're calling `cause.toString()` here to avoid triggering a `console.error` in the grouped log
-        const logCause =
-          Cause.isFailType(cause) && cause.error._tag === 'LiveStore.IntentionalShutdownCause'
-            ? cause.toString()
-            : cause
-        yield* Effect.logDebug(`Shutting down LiveStore`, logCause)
-
-        FiberSet.clear(fiberSet).pipe(
-          Effect.andThen(() => FiberSet.run(fiberSet, Effect.failCause(cause))),
-          Effect.timeout(Duration.seconds(1)),
-          Effect.logWarnIfTakesLongerThan({ label: '@livestore/livestore:shutdown:clear-fiber-set', duration: 500 }),
-          Effect.catchTag('TimeoutException', (err) =>
-            Effect.logError('Store shutdown timed out. Forcing shutdown.', err).pipe(
-              Effect.andThen(FiberSet.run(fiberSet, Effect.failCause(cause))),
-            ),
-          ),
-          Runtime.runFork(runtime), // NOTE we need to fork this separately otherwise it will also be interrupted
-        )
-      }).pipe(Effect.withSpan('livestore:shutdown'))
-
-    const adapter: StoreAdapter = yield* adapterFactory({
-      schema,
-      storeId,
-      devtoolsEnabled: disableDevtools !== true,
-      bootStatusQueue,
-      shutdown,
-      connectDevtoolsToStore: connectDevtoolsToStore_,
-    }).pipe(Effect.withPerformanceMeasure('livestore:makeAdapter'), Effect.withSpan('createStore:makeAdapter'))
-
-    const mutationEventSchema = makeMutationEventSchemaMemo(schema)
-
-    // TODO get rid of this
-    // const __processedMutationIds = new Set<number>()
-
-    const currentMutationEventIdRef = { current: yield* adapter.coordinator.getCurrentMutationEventId }
-
-    // TODO fill up with unsynced mutation events from the coordinator
-    const unsyncedMutationEvents = MutableHashMap.empty<EventId, MutationEvent.ForSchema<TSchema>>()
-
-    // TODO consider moving booting into the storage backend
-    if (boot !== undefined) {
-      let isInTxn = false
-      let txnExecuteStmnts: [string, PreparedBindValues | undefined][] = []
-
-      const bootDbImpl: BootDb = {
-        _tag: 'BootDb',
-        execute: (queryStr, bindValues) => {
-          const stmt = adapter.syncDb.prepare(queryStr)
-          stmt.execute(bindValues)
-
-          if (isInTxn === true) {
-            txnExecuteStmnts.push([queryStr, bindValues])
-          } else {
-            adapter.coordinator.execute(queryStr, bindValues).pipe(runEffectFork)
-          }
-        },
-        mutate: (...list) => {
-          for (const mutationEventDecoded_ of list) {
-            const mutationDef =
-              schema.mutations.get(mutationEventDecoded_.mutation) ??
-              shouldNeverHappen(`Unknown mutation type: ${mutationEventDecoded_.mutation}`)
-
-            const parentId = mutationDef.options.localOnly
-              ? currentMutationEventIdRef.current
-              : { global: currentMutationEventIdRef.current.global, local: 0 }
-
-            currentMutationEventIdRef.current = adapter.coordinator
-              .getNextMutationEventId({ localOnly: mutationDef.options.localOnly })
-              .pipe(Effect.runSync)
-
-            const mutationEventDecoded = { ...mutationEventDecoded_, id: currentMutationEventIdRef.current, parentId }
-
-            MutableHashMap.set(unsyncedMutationEvents, Data.struct(mutationEventDecoded.id), mutationEventDecoded)
-
-            // __processedMutationIds.add(mutationEventDecoded.id.global)
-
-            const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
-            // const { bindValues, statementSql } = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
-
-            for (const { statementSql, bindValues } of execArgsArr) {
-              adapter.syncDb.execute(statementSql, bindValues)
-            }
-
-            const mutationEventEncoded = Schema.encodeUnknownSync(mutationEventSchema)(mutationEventDecoded)
-
-            adapter.coordinator
-              .mutate(mutationEventEncoded as MutationEvent.AnyEncoded, { persisted: true })
-              .pipe(runEffectFork)
-          }
-        },
-        select: (queryStr, bindValues) => {
-          const stmt = adapter.syncDb.prepare(queryStr)
-          return stmt.select(bindValues)
-        },
-        txn: (callback) => {
-          try {
-            isInTxn = true
-            // adapter.syncDb.execute('BEGIN TRANSACTION', undefined)
-
-            callback()
-
-            // adapter.syncDb.execute('COMMIT', undefined)
-
-            // adapter.coordinator.execute('BEGIN', undefined, undefined)
-            for (const [queryStr, bindValues] of txnExecuteStmnts) {
-              adapter.coordinator.execute(queryStr, bindValues).pipe(runEffectFork)
-            }
-            // adapter.coordinator.execute('COMMIT', undefined, undefined)
-          } catch (e: any) {
-            // adapter.syncDb.execute('ROLLBACK', undefined)
-            throw e
-          } finally {
-            isInTxn = false
-            txnExecuteStmnts = []
-          }
-        },
-      }
-
-      yield* Effect.tryAll(() => boot(bootDbImpl, span)).pipe(
-        UnexpectedError.mapToUnexpectedError,
-        Effect.withSpan('createStore:boot'),
-      )
-    }
-
-    const store = Store.createStore<TGraphQLContext, TSchema>(
-      {
-        adapter,
-        schema,
-        graphQLOptions,
-        otelOptions: { tracer: otelTracer, rootSpanContext: otelRootSpanContext },
-        reactivityGraph,
-        disableDevtools,
-        currentMutationEventIdRef,
-        unsyncedMutationEvents,
-        fiberSet,
-        runtime,
-        batchUpdates: batchUpdates ?? ((run) => run()),
-        storeId,
-      },
-      span,
-    )
-
-    yield* Deferred.succeed(storeDeferred, store as any as Store)
-
-    return store
-  }).pipe(
-    Effect.withSpan('createStore', {
-      parent: otelOptions?.rootSpanContext
-        ? OtelTracer.makeExternalSpan(otel.trace.getSpanContext(otelOptions.rootSpanContext)!)
-        : undefined,
-    }),
-    Effect.provide(TracingLive),
-  )
-}
-// #endregion createStore

package/src/utils/dev.ts

@@ -22,3 +22,9 @@ export const downloadURL = (data: string, fileName: string) => {
   a.click()
   a.remove()
 }
+
+export const exposeDebugUtils = () => {
+  if (import.meta.env.DEV) {
+    globalThis.__debugDownloadBlob = downloadBlob
+  }
+}

package/src/{__tests__/react/utils → utils}/stack-info.test.ts

@@ -1,6 +1,6 @@
 import { expect, it } from 'vitest'
 
-import { extractStackInfoFromStackTrace } from '../../../react/utils/stack-info.js'
+import { extractStackInfoFromStackTrace } from './stack-info.js'
 
 it('RouteLink stacktrace', async () => {
   const stackTrace = `\

package/src/{react/utils → utils}/stack-info.ts

@@ -1,7 +1,3 @@
-import React from 'react'
-
-export const originalStackLimit = Error.stackTraceLimit
-
 export type StackInfo = {
   frames: StackFrame[]
 }
@@ -54,11 +50,5 @@ export const extractStackInfoFromStackTrace = (stackTrace: string): StackInfo =>
   return { frames }
 }
 
-export const useStackInfo = (): StackInfo =>
-  React.useMemo(() => {
-    Error.stackTraceLimit = 10
-    // eslint-disable-next-line unicorn/error-message
-    const stack = new Error().stack!
-    Error.stackTraceLimit = originalStackLimit
-    return extractStackInfoFromStackTrace(stack)
-  }, [])
+export const stackInfoToString = (stackInfo: StackInfo): string =>
+  stackInfo.frames.map((f) => `${f.name} (${f.filePath})`).join('\n')