@livestore/livestore 0.0.55-dev.2 → 0.0.55

package/src/reactiveQueries/sql.ts

@@ -1,23 +1,24 @@
 import { type Bindable, prepareBindValues, type QueryInfo, type QueryInfoNone } from '@livestore/common'
 import { shouldNeverHappen } from '@livestore/utils'
-import { Schema, TreeFormatter } from '@livestore/utils/effect'
+import { Schema, SchemaEquivalence, TreeFormatter } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 
 import { globalReactivityGraph } from '../global-state.js'
 import type { Thunk } from '../reactive.js'
+import { NOT_REFRESHED_YET } from '../reactive.js'
 import type { RefreshReason } from '../store.js'
 import { getDurationMsFromSpan } from '../utils/otel.js'
 import type { GetAtomResult, LiveQuery, QueryContext, ReactivityGraph } from './base-class.js'
 import { LiveStoreQueryBase, makeGetAtomResult } from './base-class.js'
 
-export type MapRows<TResult, TRaw = any> =
-  | ((rows: ReadonlyArray<TRaw>) => TResult)
-  | Schema.Schema<TResult, ReadonlyArray<TRaw>, unknown>
-
-export const querySQL = <TResult, TRaw = any>(
+/**
+ * NOTE `querySQL` is only supposed to read data. Don't use it to insert/update/delete data but use mutations instead.
+ */
+export const querySQL = <TResultSchema, TResult = TResultSchema>(
   query: string | ((get: GetAtomResult) => string),
-  options?: {
-    map?: MapRows<TResult, TRaw>
+  options: {
+    schema: Schema.Schema<TResultSchema, ReadonlyArray<any>>
+    map?: (rows: TResultSchema) => TResult
     /**
      * Can be provided explicitly to slightly speed up initial query performance
      *
@@ -29,21 +30,23 @@ export const querySQL = <TResult, TRaw = any>(
     reactivityGraph?: ReactivityGraph
   },
 ): LiveQuery<TResult, QueryInfoNone> =>
-  new LiveStoreSQLQuery<TResult, QueryInfoNone>({
+  new LiveStoreSQLQuery<TResultSchema, TResult, QueryInfoNone>({
     label: options?.label,
     genQueryString: query,
     queriedTables: options?.queriedTables,
     bindValues: options?.bindValues,
     reactivityGraph: options?.reactivityGraph,
     map: options?.map,
+    schema: options.schema,
     queryInfo: { _tag: 'None' },
   })
 
 /* An object encapsulating a reactive SQL query */
-export class LiveStoreSQLQuery<TResult, TQueryInfo extends QueryInfo = QueryInfoNone> extends LiveStoreQueryBase<
-  TResult,
-  TQueryInfo
-> {
+export class LiveStoreSQLQuery<
+  TResultSchema,
+  TResult = TResultSchema,
+  TQueryInfo extends QueryInfo = QueryInfoNone,
+> extends LiveStoreQueryBase<TResult, TQueryInfo> {
   _tag: 'sql' = 'sql'
 
   /** A reactive thunk representing the query text */
@@ -59,7 +62,8 @@ export class LiveStoreSQLQuery<TResult, TQueryInfo extends QueryInfo = QueryInfo
   /** Currently only used by `rowQuery` for lazy table migrations and eager default row insertion */
   private execBeforeFirstRun
 
-  private mapRows
+  private mapResult: (rows: TResultSchema) => TResult
+  private schema: Schema.Schema<TResultSchema, ReadonlyArray<any>>
 
   queryInfo: TQueryInfo
 
@@ -67,8 +71,9 @@ export class LiveStoreSQLQuery<TResult, TQueryInfo extends QueryInfo = QueryInfo
     genQueryString,
     queriedTables,
     bindValues,
-    label: label_,
+    label = genQueryString.toString(),
     reactivityGraph,
+    schema,
     map,
     execBeforeFirstRun,
     queryInfo,
@@ -78,51 +83,20 @@ export class LiveStoreSQLQuery<TResult, TQueryInfo extends QueryInfo = QueryInfo
     queriedTables?: Set<string>
     bindValues?: Bindable
     reactivityGraph?: ReactivityGraph
-    map?: MapRows<TResult>
+    schema: Schema.Schema<TResultSchema, ReadonlyArray<any>>
+    map?: (rows: TResultSchema) => TResult
     execBeforeFirstRun?: (ctx: QueryContext) => void
     queryInfo?: TQueryInfo
   }) {
     super()
 
-    const label = label_ ?? genQueryString.toString()
     this.label = `sql(${label})`
     this.reactivityGraph = reactivityGraph ?? globalReactivityGraph
     this.execBeforeFirstRun = execBeforeFirstRun
     this.queryInfo = queryInfo ?? ({ _tag: 'None' } as TQueryInfo)
-    this.mapRows =
-      map === undefined
-        ? (rows: any) => rows as TResult
-        : Schema.isSchema(map)
-          ? (rows: any, opts: { sqlString: string }) => {
-              const parseResult = Schema.decodeEither(map as Schema.Schema<TResult, ReadonlyArray<any>>)(rows)
-              if (parseResult._tag === 'Left') {
-                const parseErrorStr = TreeFormatter.formatErrorSync(parseResult.left)
-                const expectedSchemaStr = String(map.ast)
-                const bindValuesStr = bindValues === undefined ? '' : `\nBind values: ${JSON.stringify(bindValues)}`
-
-                console.error(
-                  `\
-Error parsing SQL query result.
-
-Query: ${opts.sqlString}\
-${bindValuesStr}
-
-Expected schema: ${expectedSchemaStr}
 
-Error: ${parseErrorStr}
-
-Result:`,
-                  rows,
-                )
-                // console.error(`Error parsing SQL query result: ${TreeFormatter.formatErrorSync(parseResult.left)}`)
-                return shouldNeverHappen(`Error parsing SQL query result: ${parseResult.left}`)
-              } else {
-                return parseResult.right as TResult
-              }
-            }
-          : typeof map === 'function'
-            ? map
-            : shouldNeverHappen(`Invalid map function ${map}`)
+    this.schema = schema
+    this.mapResult = map === undefined ? (rows: any) => rows as TResult : map
 
     let queryString$OrQueryString: string | Thunk<string, QueryContext, RefreshReason>
     if (typeof genQueryString === 'function') {
@@ -134,7 +108,11 @@ Result:`,
           setDebugInfo({ _tag: 'js', label: `${label}:queryString`, query: queryString, durationMs })
           return queryString
         },
-        { label: `${label}:queryString`, meta: { liveStoreThunkType: 'sqlQueryString' } },
+        {
+          label: `${label}:queryString`,
+          meta: { liveStoreThunkType: 'sqlQueryString' },
+          equal: (a, b) => a === b,
+        },
       )
 
       this.queryString$ = queryString$OrQueryString
@@ -146,6 +124,15 @@ Result:`,
 
     const queriedTablesRef = { current: queriedTables }
 
+    const schemaEqual = SchemaEquivalence.make(schema)
+    // TODO also support derived equality for `map` (probably will depend on having an easy way to transform a schema without an `encode` step)
+    // This would mean dropping the `map` option
+    const equal =
+      map === undefined
+        ? (a: TResult, b: TResult) =>
+            a === NOT_REFRESHED_YET || b === NOT_REFRESHED_YET ? false : schemaEqual(a as any, b as any)
+        : undefined
+
     const results$ = this.reactivityGraph.makeThunk<TResult>(
       (get, setDebugInfo, { store, otelTracer, rootOtelContext }, otelContext) =>
         otelTracer.startActiveSpan(
@@ -186,7 +173,31 @@ Result:`,
 
             span.setAttribute('sql.rowsCount', rawResults.length)
 
-            const result = this.mapRows(rawResults, { sqlString })
+            const parsedResult = Schema.decodeEither(this.schema)(rawResults)
+
+            if (parsedResult._tag === 'Left') {
+              const parseErrorStr = TreeFormatter.formatErrorSync(parsedResult.left)
+              const expectedSchemaStr = String(this.schema.ast)
+              const bindValuesStr = bindValues === undefined ? '' : `\nBind values: ${JSON.stringify(bindValues)}`
+
+              console.error(
+                `\
+Error parsing SQL query result.
+
+Query: ${sqlString}\
+${bindValuesStr}
+
+Expected schema: ${expectedSchemaStr}
+
+Error: ${parseErrorStr}
+
+Result:`,
+                rawResults,
+              )
+              return shouldNeverHappen(`Error parsing SQL query result: ${parsedResult.left}`)
+            }
+
+            const result = this.mapResult(parsedResult.right)
 
             span.end()
 
@@ -199,45 +210,12 @@ Result:`,
             return result
           },
         ),
-      { label: queryLabel },
+      { label: queryLabel, equal },
     )
 
     this.results$ = results$
   }
 
-  /**
-   * Returns a new reactive query that contains the result of
-   * running an arbitrary JS computation on the results of this SQL query.
-   */
-  // pipe = <U>(fn: (result: Result, get: GetAtomResult) => U): LiveStoreJSQuery<U> =>
-  //   new LiveStoreJSQuery({
-  //     fn: (get) => {
-  //       const results = get(this.results$!)
-  //       return fn(results, get)
-  //     },
-  //     label: `${this.label}:js`,
-  //     onDestroy: () => this.destroy(),
-  //     reactivityGraph: this.reactivityGraph,
-  //     queryInfo: undefined,
-  //   })
-
-  /** Returns a reactive query  */
-  // getFirstRow = (args?: { defaultValue?: Result }) =>
-  //   new LiveStoreJSQuery({
-  //     fn: (get) => {
-  //       const results = get(this.results$!)
-  //       if (results.length === 0 && args?.defaultValue === undefined) {
-  //         // const queryLabel = this._tag === 'sql' ? this.queryString$!.computeResult(otelContext) : this.label
-  //         const queryLabel = this.label
-  //         return shouldNeverHappen(`Expected query ${queryLabel} to return at least one result`)
-  //       }
-  //       return results[0] ?? args!.defaultValue!
-  //     },
-  //     label: `${this.label}:first`,
-  //     onDestroy: () => this.destroy(),
-  //     reactivityGraph: this.reactivityGraph,
-  //   })
-
   destroy = () => {
     if (this.queryString$ !== undefined) {
       this.reactivityGraph.destroyNode(this.queryString$)

package/src/row-query.ts

@@ -3,7 +3,7 @@ import { sql } from '@livestore/common'
 import { DbSchema } from '@livestore/common/schema'
 import type { GetValForKey } from '@livestore/utils'
 import { shouldNeverHappen } from '@livestore/utils'
-import { Schema, TreeFormatter } from '@livestore/utils/effect'
+import { Schema } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
 import type { SqliteDsl } from 'effect-db-schema'
 
@@ -12,14 +12,16 @@ import { computed } from './reactiveQueries/js.js'
 import { LiveStoreSQLQuery } from './reactiveQueries/sql.js'
 import type { Store } from './store.js'
 
-export type RowQueryOptions = {
+export type RowQueryOptions<TTableDef extends DbSchema.TableDef, TResult = RowResult<TTableDef>> = {
   otelContext?: otel.Context
   skipInsertDefaultRow?: boolean
   reactivityGraph?: ReactivityGraph
+  map?: (result: RowResult<TTableDef>) => TResult
+  label?: string
 }
 
 export type RowQueryOptionsDefaulValues<TTableDef extends DbSchema.TableDef> = {
-  defaultValues: Partial<RowResult<TTableDef>>
+  defaultValues?: Partial<RowResult<TTableDef>>
 }
 
 export type MakeRowQuery = {
@@ -29,9 +31,10 @@ export type MakeRowQuery = {
       boolean,
       DbSchema.TableOptions & { isSingleton: true }
     >,
+    TResult = RowResult<TTableDef>,
   >(
     table: TTableDef,
-    options?: RowQueryOptions,
+    options?: RowQueryOptions<TTableDef, TResult>,
   ): LiveQuery<RowResult<TTableDef>, QueryInfoRow<TTableDef>>
   <
     TTableDef extends DbSchema.TableDef<
@@ -39,19 +42,20 @@ export type MakeRowQuery = {
       boolean,
       DbSchema.TableOptions & { isSingleton: false }
     >,
+    TResult = RowResult<TTableDef>,
   >(
     table: TTableDef,
     // TODO adjust so it works with arbitrary primary keys or unique constraints
     id: string,
-    options?: RowQueryOptions & RowQueryOptionsDefaulValues<TTableDef>,
-  ): LiveQuery<RowResult<TTableDef>, QueryInfoRow<TTableDef>>
+    options?: RowQueryOptions<TTableDef, TResult> & RowQueryOptionsDefaulValues<TTableDef>,
+  ): LiveQuery<TResult, QueryInfoRow<TTableDef>>
 }
 
 // TODO also allow other where clauses and multiple rows
 export const rowQuery: MakeRowQuery = <TTableDef extends DbSchema.TableDef>(
   table: TTableDef,
-  idOrOptions?: string | RowQueryOptions,
-  options_?: RowQueryOptions & RowQueryOptionsDefaulValues<TTableDef>,
+  idOrOptions?: string | RowQueryOptions<TTableDef, any>,
+  options_?: RowQueryOptions<TTableDef, any> & RowQueryOptionsDefaulValues<TTableDef>,
 ) => {
   const id = typeof idOrOptions === 'string' ? idOrOptions : undefined
   const options = typeof idOrOptions === 'string' ? options_ : idOrOptions
@@ -70,8 +74,10 @@ export const rowQuery: MakeRowQuery = <TTableDef extends DbSchema.TableDef>(
   const whereClause = id === undefined ? '' : `where id = '${id}'`
   const queryStr = sql`select * from ${tableName} ${whereClause} limit 1`
 
+  const rowSchema = table.isSingleColumn === true ? table.schema.pipe(Schema.pluck('value' as any)) : table.schema
+
   return new LiveStoreSQLQuery({
-    label: `rowQuery:query:${tableSchema.name}${id === undefined ? '' : `:${id}`}`,
+    label: options?.label ?? `rowQuery:query:${tableSchema.name}${id === undefined ? '' : `:${id}`}`,
     genQueryString: queryStr,
     queriedTables: new Set([tableName]),
     reactivityGraph: options?.reactivityGraph,
@@ -83,18 +89,8 @@ export const rowQuery: MakeRowQuery = <TTableDef extends DbSchema.TableDef>(
       id,
       skipInsertDefaultRow: options?.skipInsertDefaultRow,
     }),
-    map: (results): RowResult<TTableDef> => {
-      if (results.length === 0) return shouldNeverHappen(`No results for query ${queryStr}`)
-
-      const parseResult = Schema.decodeEither(table.schema)(results[0]!)
-
-      if (parseResult._tag === 'Left') {
-        console.error('decode error', TreeFormatter.formatErrorSync(parseResult.left), 'results', results)
-        return shouldNeverHappen(`Error decoding query result for ${queryStr}`)
-      }
-
-      return table.isSingleColumn === true ? parseResult.right.value : parseResult.right
-    },
+    schema: rowSchema.pipe(Schema.Array, Schema.headOrElse()),
+    map: options?.map,
     queryInfo: { _tag: 'Row', table, id: id ?? 'singleton' },
   })
 }

package/src/store-devtools.ts

@@ -1,5 +1,5 @@
 import type { DebugInfo, StoreAdapter } from '@livestore/common'
-import { Devtools, liveStoreVersion } from '@livestore/common'
+import { Devtools, liveStoreVersion, UnexpectedError } from '@livestore/common'
 import { throttle } from '@livestore/utils'
 import { BrowserChannel, Effect, Stream } from '@livestore/utils/effect'
 
@@ -9,29 +9,24 @@ import { NOT_REFRESHED_YET } from './reactive.js'
 import type { LiveQuery, ReactivityGraph } from './reactiveQueries/base-class.js'
 import type { ReferenceCountedSet } from './utils/data-structures.js'
 
-type Unsub = () => void
-type RequestId = string
-
 type IStore = {
   adapter: StoreAdapter
-  devtoolsConnectionId: string
   reactivityGraph: ReactivityGraph
   mainDbWrapper: MainDatabaseWrapper
   activeQueries: ReferenceCountedSet<LiveQuery<any>>
 }
 
-export const connectStoreToDevtools = ({ port, store }: { port: MessagePort; store: IStore }) =>
+type Unsub = () => void
+type RequestId = string
+type SubMap = Map<RequestId, Unsub>
+
+export const connectDevtoolsToStore = ({ storeMessagePort, store }: { storeMessagePort: MessagePort; store: IStore }) =>
   Effect.gen(function* () {
     const channelId = store.adapter.coordinator.devtools.channelId
 
-    const reactivityGraphSubcriptions = new Map<RequestId, Unsub>()
-    const liveQueriesSubscriptions = new Map<RequestId, Unsub>()
-    const debugInfoHistorySubscriptions = new Map<RequestId, Unsub>()
-
-    const { storeMessagePort } = yield* store.adapter.coordinator.devtools.connect({
-      port,
-      connectionId: store.devtoolsConnectionId,
-    })
+    const reactivityGraphSubcriptions: SubMap = new Map()
+    const liveQueriesSubscriptions: SubMap = new Map()
+    const debugInfoHistorySubscriptions: SubMap = new Map()
 
     const storePortChannel = yield* BrowserChannel.messagePortChannel({
       port: storeMessagePort,
@@ -210,4 +205,4 @@ export const connectStoreToDevtools = ({ port, store }: { port: MessagePort; sto
       Stream.runDrain,
       Effect.withSpan('LSD.devtools.onMessage'),
     )
-  })
+  }).pipe(UnexpectedError.mapToUnexpectedError, Effect.withSpan('LSD.devtools.connectStoreToDevtools'))

package/src/store.ts

@@ -7,15 +7,15 @@ import type {
   StoreAdapter,
   StoreAdapterFactory,
 } from '@livestore/common'
-import { Devtools, getExecArgsFromMutation, prepareBindValues, UnexpectedError } from '@livestore/common'
+import { getExecArgsFromMutation, prepareBindValues, UnexpectedError } from '@livestore/common'
 import type { LiveStoreSchema, MutationEvent } from '@livestore/common/schema'
 import { makeMutationEventSchemaMemo, SCHEMA_META_TABLE, SCHEMA_MUTATIONS_META_TABLE } from '@livestore/common/schema'
 import { assertNever, makeNoopTracer, shouldNeverHappen } from '@livestore/utils'
-import { cuid } from '@livestore/utils/cuid'
+import type { Cause } from '@livestore/utils/effect'
 import {
-  BrowserChannel,
+  Deferred,
+  Duration,
   Effect,
-  Either,
   Exit,
   FiberSet,
   Inspectable,
@@ -37,7 +37,7 @@ import { MainDatabaseWrapper } from './MainDatabaseWrapper.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 { connectStoreToDevtools } from './store-devtools.js'
+import { connectDevtoolsToStore } from './store-devtools.js'
 import { ReferenceCountedSet } from './utils/data-structures.js'
 import { downloadBlob } from './utils/dev.js'
 import { getDurationMsFromSpan } from './utils/otel.js'
@@ -58,6 +58,9 @@ export type OtelOptions = {
   rootSpanContext: otel.Context
 }
 
+export class ForceStoreShutdown extends Schema.TaggedError<ForceStoreShutdown>()('LiveStore.ForceStoreShutdown', {}) {}
+export class StoreShutdown extends Schema.TaggedError<StoreShutdown>()('LiveStore.StoreShutdown', {}) {}
+
 export type StoreOptions<
   TGraphQLContext extends BaseGraphQLContext,
   TSchema extends LiveStoreSchema = LiveStoreSchema,
@@ -126,7 +129,6 @@ export class Store<
   TSchema extends LiveStoreSchema = LiveStoreSchema,
 > extends Inspectable.Class {
   id = uniqueStoreId()
-  readonly devtoolsConnectionId = cuid()
   private fiberSet: FiberSet.FiberSet
   reactivityGraph: ReactivityGraph
   mainDbWrapper: MainDatabaseWrapper
@@ -232,14 +234,11 @@ export class Store<
           this.mutate({ wasSyncMessage: true }, mutationEventDecoded)
         }),
         Stream.runDrain,
+        Effect.interruptible,
         Effect.withSpan('LiveStore:syncMutations'),
         Effect.forkScoped,
       )
 
-      if (disableDevtools !== true) {
-        yield* this.bootDevtools().pipe(Effect.forkScoped)
-      }
-
       yield* Effect.addFinalizer(() =>
         Effect.sync(() => {
           for (const tableRef of Object.values(this.tableRefs)) {
@@ -256,7 +255,6 @@ export class Store<
       yield* Effect.never
     }).pipe(Effect.scoped, Effect.withSpan('LiveStore:store-constructor'), FiberSet.run(fiberSet), runEffectFork)
   }
-
   // #endregion constructor
 
   static createStore = <TGraphQLContext extends BaseGraphQLContext, TSchema extends LiveStoreSchema = LiveStoreSchema>(
@@ -590,52 +588,6 @@ export class Store<
       meta: { liveStoreRefType: 'table' },
     })
 
-  // #region devtools
-  private bootDevtools = () =>
-    Effect.gen(this, function* () {
-      // const webBridgeBroadcastChannel = yield* Devtools.WebBridge.makeBroadcastChannel()
-
-      // eslint-disable-next-line @typescript-eslint/no-this-alias, unicorn/no-this-assignment
-      const store = this
-      const channelId = this.adapter.coordinator.devtools.channelId
-
-      // Chrome extension bridge
-      {
-        const windowChannel = yield* BrowserChannel.windowChannel({
-          window,
-          listenSchema: Devtools.DevtoolsWindowMessage.MessageForStore,
-          sendSchema: Devtools.DevtoolsWindowMessage.MessageForContentscript,
-        })
-
-        yield* windowChannel.send(Devtools.DevtoolsWindowMessage.LoadIframe.make({}))
-
-        yield* windowChannel.listen.pipe(
-          Stream.filterMap(Either.getRight),
-          Stream.tap((message) =>
-            Effect.gen(function* () {
-              if (message._tag === 'LSD.WindowMessage.ContentscriptListening') {
-                // Send message to contentscript via window (which the contentscript iframe is listening to)
-                yield* windowChannel.send(Devtools.DevtoolsWindowMessage.StoreReady.make({ channelId }))
-                return
-              }
-
-              if (message.channelId !== channelId) return
-
-              if (message._tag === 'LSD.WindowMessage.MessagePortForStore') {
-                yield* connectStoreToDevtools({ port: message.port, store })
-              }
-            }),
-          ),
-          Stream.runDrain,
-          Effect.tapCauseLogPretty,
-          Effect.forkScoped,
-        )
-
-        yield* windowChannel.send(Devtools.DevtoolsWindowMessage.StoreReady.make({ channelId }))
-      }
-    })
-  // #endregion devtools
-
   __devDownloadDb = () => {
     const data = this.mainDbWrapper.export()
     downloadBlob(data, `livestore-${Date.now()}.db`)
@@ -728,21 +680,44 @@ export const createStore = <
 
     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_ = ({ storeMessagePort }: { storeMessagePort: MessagePort }) =>
+      Effect.gen(function* () {
+        const store = yield* Deferred.await(storeDeferred)
+        yield* connectDevtoolsToStore({ storeMessagePort, store })
+      })
+
+    // TODO close parent scope? (Needs refactor with Mike A)
+    const shutdown = (cause: Cause.Cause<unknown>) =>
+      Effect.gen(function* () {
+        yield* Effect.logWarning(`Shutting down LiveStore`, cause)
+
+        FiberSet.clear(fiberSet).pipe(
+          Effect.andThen(() => FiberSet.run(fiberSet, Effect.fail(StoreShutdown.make()))),
+          Effect.timeout(Duration.seconds(1)),
+          Effect.logWarnIfTakesLongerThan({ label: '@livestore/livestore:shutdown:clear-fiber-set', duration: 500 }),
+          Effect.catchTag('TimeoutException', () =>
+            Effect.logWarning('Store shutdown timed out. Forcing shutdown.').pipe(
+              Effect.andThen(FiberSet.run(fiberSet, Effect.fail(ForceStoreShutdown.make()))),
+            ),
+          ),
+          runEffectFork, // NOTE we need to fork this separately otherwise it will also be interrupted
+        )
+      }).pipe(Effect.withSpan('livestore:shutdown'))
+
     const adapter: StoreAdapter = yield* adapterFactory({
       schema,
       devtoolsEnabled: disableDevtools !== true,
       bootStatusQueue,
-      shutdown: (cause) =>
-        Effect.gen(function* () {
-          yield* Effect.logWarning(`Shutting down LiveStore`, cause)
-          // TODO close parent scope? (Needs refactor with Mike A)
-          yield* FiberSet.clear(fiberSet)
-        }).pipe(Effect.withSpan('livestore:shutdown')),
+      shutdown,
+      connectDevtoolsToStore: connectDevtoolsToStore_,
     }).pipe(Effect.withPerformanceMeasure('livestore:makeAdapter'), Effect.withSpan('createStore:makeAdapter'))
 
     if (batchUpdates !== undefined) {
@@ -826,7 +801,7 @@ export const createStore = <
       )
     }
 
-    return Store.createStore<TGraphQLContext, TSchema>(
+    const store = Store.createStore<TGraphQLContext, TSchema>(
       {
         adapter,
         schema,
@@ -839,6 +814,10 @@ export const createStore = <
       },
       span,
     )
+
+    yield* Deferred.succeed(storeDeferred, store as any as Store)
+
+    return store
   }).pipe(
     Effect.withSpan('createStore', {
       parent: otelOptions?.rootSpanContext