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

package/dist/utils/tests/fixture.d.ts

@@ -33,29 +33,10 @@ export declare const todos: State.SQLite.TableDef<State.SQLite.SqliteTableDefFor
         nullable: false;
         primaryKey: false;
     };
-}>, State.SQLite.WithDefaults<{
-    readonly id: {
-        columnType: "text";
-        schema: Schema.Schema<string, string, never>;
-        default: import("effect/Option").None<never>;
-        nullable: false;
-        primaryKey: true;
-    };
-    readonly text: {
-        columnType: "text";
-        schema: Schema.Schema<string, string, never>;
-        default: import("effect/Option").Some<"">;
-        nullable: false;
-        primaryKey: false;
-    };
-    readonly completed: {
-        columnType: "integer";
-        schema: Schema.Schema<boolean, number, never>;
-        default: import("effect/Option").Some<false>;
-        nullable: false;
-        primaryKey: false;
-    };
-}>, Schema.Schema<{
+}>, {
+    isClientDocumentTable: false;
+    requiredInsertColumnNames: "id";
+}, Schema.Schema<{
     readonly id: string;
     readonly text: string;
     readonly completed: boolean;
@@ -103,29 +84,10 @@ export declare const tables: {
             nullable: false;
             primaryKey: false;
         };
-    }>, State.SQLite.WithDefaults<{
-        readonly id: {
-            columnType: "text";
-            schema: Schema.Schema<string, string, never>;
-            default: import("effect/Option").None<never>;
-            nullable: false;
-            primaryKey: true;
-        };
-        readonly text: {
-            columnType: "text";
-            schema: Schema.Schema<string, string, never>;
-            default: import("effect/Option").Some<"">;
-            nullable: false;
-            primaryKey: false;
-        };
-        readonly completed: {
-            columnType: "integer";
-            schema: Schema.Schema<boolean, number, never>;
-            default: import("effect/Option").Some<false>;
-            nullable: false;
-            primaryKey: false;
-        };
-    }>, Schema.Schema<{
+    }>, {
+        isClientDocumentTable: false;
+        requiredInsertColumnNames: "id";
+    }, Schema.Schema<{
         readonly id: string;
         readonly text: string;
         readonly completed: boolean;

package/dist/utils/tests/fixture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fixture.d.ts","sourceRoot":"","sources":["../../../src/utils/tests/fixture.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmC,KAAK,EAAE,MAAM,sBAAsB,CAAA;AAC7E,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,KAAK,KAAK,IAAI,MAAM,oBAAoB,CAAA;AAE/C,MAAM,MAAM,IAAI,GAAG;IACjB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,OAAO,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,WAAW,CAAA;AAEnD,MAAM,MAAM,QAAQ,GAAG;IACrB,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAOhB,CAAA;AAEF,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;EAOd,CAAA;AAEF,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAiB,CAAA;AAEpC,eAAO,MAAM,MAAM;;;;;;;;;;CASlB,CAAA;AAMD,eAAO,MAAM,KAAK,8CAAoD,CAAA;AACtE,eAAO,MAAM,MAAM;;;;;;;;;;;;;EAAgC,CAAA;AAEnD,eAAO,MAAM,WAAW,GAAI,+BAGzB;IACD,UAAU,CAAC,EAAE,IAAI,CAAC,MAAM,CAAA;IACxB,WAAW,CAAC,EAAE,IAAI,CAAC,OAAO,CAAA;CACtB;;;;;;;;;;;;;mFAU4E,CAAA"}
+{"version":3,"file":"fixture.d.ts","sourceRoot":"","sources":["../../../src/utils/tests/fixture.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmC,KAAK,EAAE,MAAM,sBAAsB,CAAA;AAC7E,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,KAAK,KAAK,IAAI,MAAM,oBAAoB,CAAA;AAE/C,MAAM,MAAM,IAAI,GAAG;IACjB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,OAAO,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,WAAW,CAAA;AAEnD,MAAM,MAAM,QAAQ,GAAG;IACrB,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAOhB,CAAA;AAEF,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;EAOd,CAAA;AAEF,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAiB,CAAA;AAEpC,eAAO,MAAM,MAAM;;;;;;;;;;CASlB,CAAA;AAMD,eAAO,MAAM,KAAK,8CAAoD,CAAA;AACtE,eAAO,MAAM,MAAM;;;;;;;;;;;;;EAAgC,CAAA;AAEnD,eAAO,MAAM,WAAW,GAAI,+BAGzB;IACD,UAAU,CAAC,EAAE,IAAI,CAAC,MAAM,CAAA;IACxB,WAAW,CAAC,EAAE,IAAI,CAAC,OAAO,CAAA;CACtB;;;;;;;;;;;;;mFAU4E,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livestore/livestore",
-  "version": "0.3.2-dev.10",
+  "version": "0.3.2-dev.11",
   "type": "module",
   "sideEffects": false,
   "exports": {
@@ -11,17 +11,17 @@
   },
   "dependencies": {
     "@opentelemetry/api": "1.9.0",
-    "@livestore/common": "0.3.2-dev.10",
-    "@livestore/utils": "0.3.2-dev.10"
+    "@livestore/common": "0.3.2-dev.11",
+    "@livestore/utils": "0.3.2-dev.11"
   },
   "devDependencies": {
-    "@opentelemetry/sdk-trace-base": "^2.0.0",
-    "jsdom": "^26.0.0",
+    "@opentelemetry/sdk-trace-base": "^2.0.1",
+    "jsdom": "^26.1.0",
     "typescript": "^5.8.3",
-    "vite": "^7.0.0",
+    "vite": "^7.0.6",
     "vitest": "3.2.4",
-    "@livestore/adapter-web": "0.3.2-dev.10",
-    "@livestore/utils-dev": "0.3.2-dev.10"
+    "@livestore/adapter-web": "0.3.2-dev.11",
+    "@livestore/utils-dev": "0.3.2-dev.11"
   },
   "files": [
     "package.json",

package/src/live-queries/base-class.ts

@@ -1,5 +1,5 @@
 import { isNotNil } from '@livestore/utils'
-import { Predicate } from '@livestore/utils/effect'
+import { Equal, Hash, Predicate } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
 
 import * as RG from '../reactive.ts'
@@ -41,6 +41,8 @@ export interface SignalDef<T> extends LiveQueryDef<T, 'signal-def'> {
   hash: string
   label: string
   make: (ctx: ReactivityGraphContext) => RcRef<ISignal<T>>
+  [Equal.symbol](that: SignalDef<T>): boolean
+  [Hash.symbol](): number
 }
 
 export interface ISignal<T> extends LiveQuery<T> {
@@ -77,6 +79,8 @@ export interface LiveQueryDef<TResult, TTag extends string = 'def'> {
   make: (ctx: ReactivityGraphContext, otelContext?: otel.Context) => RcRef<LiveQuery<TResult> | ISignal<TResult>>
   label: string
   hash: string
+  [Equal.symbol](that: LiveQueryDef<TResult, TTag>): boolean
+  [Hash.symbol](): number
 }
 
 export namespace LiveQueryDef {

package/src/live-queries/computed.ts

@@ -1,4 +1,5 @@
 import { getDurationMsFromSpan } from '@livestore/common'
+import { Equal, Hash } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 
 import type { Thunk } from '../reactive.ts'
@@ -35,6 +36,12 @@ export const computed = <TResult>(
     // TODO we should figure out whether this could cause some problems and/or if there's a better way to do this
     // NOTE `fn.toString()` doesn't work in Expo as it always produces `[native code]`
     hash,
+    [Equal.symbol](that: LiveQueryDef<any>): boolean {
+      return this.hash === that.hash
+    },
+    [Hash.symbol](): number {
+      return Hash.string(this.hash)
+    },
   }
 
   return def

package/src/live-queries/db-query.ts

@@ -10,7 +10,7 @@ import {
   UnexpectedError,
 } from '@livestore/common'
 import { deepEqual, shouldNeverHappen } from '@livestore/utils'
-import { Predicate, Schema, TreeFormatter } from '@livestore/utils/effect'
+import { Equal, Hash, Predicate, Schema, TreeFormatter } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 
 import type { Thunk } from '../reactive.ts'
@@ -131,6 +131,12 @@ export const queryDb: {
     }),
     label,
     hash,
+    [Equal.symbol](that: LiveQueryDef<any>): boolean {
+      return this.hash === that.hash
+    },
+    [Hash.symbol](): number {
+      return Hash.string(this.hash)
+    },
   }
 
   return def
@@ -314,8 +320,11 @@ export class LiveStoreDbQuery<TResultSchema, TResult = TResultSchema> extends Li
 
     const queriedTablesRef: { current: Set<string> | undefined } = { current: undefined }
 
-    const makeResultsEqual = (resultSchema: Schema.Schema<any, any>) => (a: TResult, b: TResult) =>
-      a === NOT_REFRESHED_YET || b === NOT_REFRESHED_YET ? false : Schema.equivalence(resultSchema)(a, b)
+    const makeResultsEqual = (resultSchema: Schema.Schema<any, any>) => {
+      // Creating the equivalence function eagerly in outer scope as it might be expensive
+      const eq = Schema.equivalence(resultSchema)
+      return (a: TResult, b: TResult) => a === NOT_REFRESHED_YET || b === NOT_REFRESHED_YET ? false : eq(a, b)
+    }
 
     // NOTE we try to create the equality function eagerly as it might be expensive
     // TODO also support derived equality for `map` (probably will depend on having an easy way to transform a schema without an `encode` step)

package/src/live-queries/signal.ts

@@ -1,3 +1,4 @@
+import { Equal, Hash } from '@livestore/utils/effect'
 import { nanoid } from '@livestore/utils/nanoid'
 
 import type * as RG from '../reactive.ts'
@@ -27,6 +28,12 @@ export const signal = <T>(
           def,
         }),
     ),
+    [Equal.symbol](that: SignalDef<T>): boolean {
+      return this.hash === that.hash
+    },
+    [Hash.symbol](): number {
+      return Hash.string(this.hash)
+    },
   }
 
   return def

package/src/mod.ts

@@ -35,11 +35,12 @@ export {
 export { emptyDebugInfo, SqliteDbWrapper } from './SqliteDbWrapper.ts'
 export { type CreateStoreOptions, createStore, createStorePromise } from './store/create-store.ts'
 export { Store } from './store/store.ts'
-export type { OtelOptions, QueryDebugInfo, RefreshReason } from './store/store-types.ts'
+export type { OtelOptions, QueryDebugInfo, RefreshReason, Unsubscribe } from './store/store-types.ts'
 export {
   type LiveStoreContext,
   type LiveStoreContextRunning,
   makeShutdownDeferred,
   type ShutdownDeferred,
 } from './store/store-types.ts'
+export { exposeDebugUtils } from './utils/dev.ts'
 export * from './utils/stack-info.ts'

package/src/reactive.ts

@@ -211,8 +211,10 @@ export class ReactiveGraph<
 
   private refreshCallbacks: Set<() => void> = new Set()
 
+  // biome-ignore lint/correctness/noUnusedPrivateClassMembers: for debugging
   private nodeIdCounter = 0
   private uniqueNodeId = () => `node-${++this.nodeIdCounter}`
+  // biome-ignore lint/correctness/noUnusedPrivateClassMembers: for debugging
   private refreshInfoIdCounter = 0
   private uniqueRefreshInfoId = () => `refresh-info-${++this.refreshInfoIdCounter}`
 

package/src/store/create-store.ts

@@ -1,16 +1,17 @@
-import type {
-  Adapter,
-  BootStatus,
-  ClientSession,
-  ClientSessionDevtoolsChannel,
-  ClientSessionSyncProcessorSimulationParams,
-  IntentionalShutdownCause,
-  MigrationsReport,
+import {
+  type Adapter,
+  type BootStatus,
+  type ClientSession,
+  type ClientSessionDevtoolsChannel,
+  type ClientSessionSyncProcessorSimulationParams,
+  type IntentionalShutdownCause,
+  type MigrationsReport,
+  provideOtel,
+  type SyncError,
+  UnexpectedError,
 } from '@livestore/common'
-import { provideOtel, UnexpectedError } from '@livestore/common'
 import type { LiveStoreSchema } from '@livestore/common/schema'
 import { isDevEnv, LS_DEV } from '@livestore/utils'
-import type { Cause, Schema } from '@livestore/utils/effect'
 import {
   Context,
   Deferred,
@@ -24,6 +25,7 @@ import {
   OtelTracer,
   Queue,
   Runtime,
+  type Schema,
   Scope,
   TaskTracing,
 } from '@livestore/utils/effect'
@@ -96,7 +98,7 @@ export interface CreateStoreOptions<TSchema extends LiveStoreSchema, TContext =
       migrationsReport: MigrationsReport
       parentSpan: otel.Span
     },
-  ) => void | Promise<void> | Effect.Effect<void, unknown, OtelTracer.OtelTracer | LiveStoreContextRunning>
+  ) => Effect.SyncOrPromiseOrEffect<void, unknown, OtelTracer.OtelTracer | LiveStoreContextRunning>
   batchUpdates?: (run: () => void) => void
   /**
    * Whether to disable devtools.
@@ -131,7 +133,7 @@ export interface CreateStoreOptions<TSchema extends LiveStoreSchema, TContext =
 }
 
 /** Create a new LiveStore Store */
-export const createStorePromise = async <TSchema extends LiveStoreSchema = LiveStoreSchema, TContext = {}>({
+export const createStorePromise = async <TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TContext = {}>({
   signal,
   otelOptions,
   ...options
@@ -162,7 +164,7 @@ export const createStorePromise = async <TSchema extends LiveStoreSchema = LiveS
     Effect.runPromise,
   )
 
-export const createStore = <TSchema extends LiveStoreSchema = LiveStoreSchema, TContext = {}>({
+export const createStore = <TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TContext = {}>({
   schema,
   adapter,
   storeId,
@@ -215,9 +217,9 @@ export const createStore = <TSchema extends LiveStoreSchema = LiveStoreSchema, T
 
       const runtime = yield* Effect.runtime<Scope.Scope>()
 
-      const shutdown = (cause: Cause.Cause<UnexpectedError | IntentionalShutdownCause>) =>
+      const shutdown = (exit: Exit.Exit<IntentionalShutdownCause, UnexpectedError | SyncError>) =>
         Effect.gen(function* () {
-          yield* Scope.close(lifetimeScope, Exit.failCause(cause)).pipe(
+          yield* Scope.close(lifetimeScope, exit).pipe(
             Effect.logWarnIfTakesLongerThan({ label: '@livestore/livestore:shutdown', duration: 500 }),
             Effect.timeout(1000),
             Effect.catchTag('TimeoutException', () =>
@@ -226,7 +228,7 @@ export const createStore = <TSchema extends LiveStoreSchema = LiveStoreSchema, T
           )
 
           if (shutdownDeferred) {
-            yield* Deferred.failCause(shutdownDeferred, cause)
+            yield* Deferred.done(shutdownDeferred, exit)
           }
 
           yield* Effect.logDebug('LiveStore shutdown complete')

package/src/store/store-types.ts

@@ -3,6 +3,7 @@ import type {
   ClientSessionSyncProcessorSimulationParams,
   IntentionalShutdownCause,
   StoreInterrupted,
+  SyncError,
   UnexpectedError,
 } from '@livestore/common'
 import type { EventSequenceNumber, LiveStoreEvent, LiveStoreSchema } from '@livestore/common/schema'
@@ -22,13 +23,16 @@ export type LiveStoreContext =
     }
   | {
       stage: 'shutdown'
-      cause: IntentionalShutdownCause | StoreInterrupted
+      cause: IntentionalShutdownCause | StoreInterrupted | SyncError
     }
 
-export type ShutdownDeferred = Deferred.Deferred<void, UnexpectedError | IntentionalShutdownCause | StoreInterrupted>
+export type ShutdownDeferred = Deferred.Deferred<
+  IntentionalShutdownCause,
+  UnexpectedError | SyncError | StoreInterrupted
+>
 export const makeShutdownDeferred: Effect.Effect<ShutdownDeferred> = Deferred.make<
-  void,
-  UnexpectedError | IntentionalShutdownCause | StoreInterrupted
+  IntentionalShutdownCause,
+  UnexpectedError | SyncError | StoreInterrupted
 >()
 
 export type LiveStoreContextRunning = {
@@ -41,7 +45,7 @@ export type OtelOptions = {
   rootSpanContext: otel.Context
 }
 
-export type StoreOptions<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext = {}> = {
+export type StoreOptions<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TContext = {}> = {
   clientSession: ClientSession
   schema: TSchema
   storeId: string

package/src/store/store.ts

@@ -22,7 +22,18 @@ import type { LiveStoreSchema } from '@livestore/common/schema'
 import { getEventDef, LiveStoreEvent, SystemTables } from '@livestore/common/schema'
 import { assertNever, isDevEnv, notYetImplemented } from '@livestore/utils'
 import type { Scope } from '@livestore/utils/effect'
-import { Cause, Effect, Fiber, Inspectable, Option, OtelTracer, Runtime, Schema, Stream } from '@livestore/utils/effect'
+import {
+  Cause,
+  Effect,
+  Exit,
+  Fiber,
+  Inspectable,
+  Option,
+  OtelTracer,
+  Runtime,
+  Schema,
+  Stream,
+} from '@livestore/utils/effect'
 import { nanoid } from '@livestore/utils/nanoid'
 import * as otel from '@opentelemetry/api'
 
@@ -54,7 +65,7 @@ if (isDevEnv()) {
   exposeDebugUtils()
 }
 
-export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext = {}> extends Inspectable.Class {
+export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TContext = {}> extends Inspectable.Class {
   readonly storeId: string
   reactivityGraph: ReactivityGraph
   sqliteDbWrapper: SqliteDbWrapper
@@ -68,6 +79,9 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
    */
   tableRefs: { [key: string]: Ref<null, ReactivityGraphContext, RefreshReason> }
 
+  /** Tracks whether the store has been shut down */
+  private isShutdown = false
+
   private effectContext: {
     runtime: Runtime.Runtime<Scope.Scope>
     lifetimeScope: Scope.Scope
@@ -282,6 +296,15 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
     return this.clientSession.clientId
   }
 
+  private checkShutdown = (operation: string): void => {
+    if (this.isShutdown) {
+      throw new UnexpectedError({
+        cause: `Store has been shut down (while performing "${operation}").`,
+        note: `You cannot perform this operation after the store has been shut down.`,
+      })
+    }
+  }
+
   /**
    * Subscribe to the results of a query
    * Returns a function to cancel the subscription.
@@ -309,8 +332,10 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
       /** If provided, the stack info will be added to the `activeSubscriptions` set of the query */
       stackInfo?: StackInfo
     },
-  ): Unsubscribe =>
-    this.otel.tracer.startActiveSpan(
+  ): Unsubscribe => {
+    this.checkShutdown('subscribe')
+
+    return this.otel.tracer.startActiveSpan(
       `LiveStore.subscribe`,
       { attributes: { label: options?.label, queryLabel: isQueryBuilder(query) ? query.toString() : query.label } },
       options?.otelContext ?? this.otel.queriesSpanContext,
@@ -369,6 +394,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
         return unsubscribe
       },
     )
+  }
 
   subscribeStream = <TResult>(
     query$: LiveQueryDef<TResult>,
@@ -417,6 +443,8 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
       | { query: string; bindValues: Bindable; schema?: Schema.Schema<TResult> },
     options?: { otelContext?: otel.Context; debugRefreshReason?: RefreshReason },
   ): TResult => {
+    this.checkShutdown('query')
+
     if (typeof query === 'object' && 'query' in query && 'bindValues' in query) {
       const res = this.sqliteDbWrapper.cachedSelect(query.query, prepareBindValues(query.bindValues, query.query), {
         otelContext: options?.otelContext,
@@ -438,6 +466,12 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
 
       const sqlRes = query.asSql()
       const schema = getResultSchema(query)
+
+      // Replace SessionIdSymbol in bind values before executing the query
+      if (sqlRes.bindValues) {
+        replaceSessionIdSymbol(sqlRes.bindValues, this.clientSession.sessionId)
+      }
+
       const rawRes = this.sqliteDbWrapper.cachedSelect(sqlRes.query, sqlRes.bindValues as any as PreparedBindValues, {
         otelContext: options?.otelContext,
         queriedTables: new Set([query[QueryBuilderAstSymbol].tableDef.sqliteDef.name]),
@@ -473,6 +507,8 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
    * ```
    */
   setSignal = <T>(signalDef: SignalDef<T>, value: T | ((prev: T) => T)): void => {
+    this.checkShutdown('setSignal')
+
     const signalRef = signalDef.make(this.reactivityGraph.context!)
     const newValue: T = typeof value === 'function' ? (value as any)(signalRef.value.get()) : value
     signalRef.value.set(newValue)
@@ -557,6 +593,8 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
       ) => void,
     ): void
   } = (firstEventOrTxnFnOrOptions: any, ...restEvents: any[]) => {
+    this.checkShutdown('commit')
+
     const { events, options } = this.getCommitArgs(firstEventOrTxnFnOrOptions, restEvents)
 
     for (const event of events) {
@@ -660,10 +698,14 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
    * ```
    */
   events = (_options?: StoreEventsOptions<TSchema>): AsyncIterable<LiveStoreEvent.ForSchema<TSchema>> => {
+    this.checkShutdown('events')
+
     return notYetImplemented(`store.events() is not yet implemented but planned soon`)
   }
 
   eventsStream = (_options?: StoreEventsOptions<TSchema>): Stream.Stream<LiveStoreEvent.ForSchema<TSchema>> => {
+    this.checkShutdown('eventsStream')
+
     return notYetImplemented(`store.eventsStream() is not yet implemented but planned soon`)
   }
 
@@ -672,6 +714,8 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
    * We might need a better solution for this. Let's see.
    */
   manualRefresh = (options?: { label?: string }) => {
+    this.checkShutdown('manualRefresh')
+
     const { label } = options ?? {}
     this.otel.tracer.startActiveSpan(
       'LiveStore:manualRefresh',
@@ -690,10 +734,25 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
    *
    * This is called automatically when the store was created using the React or Effect API.
    */
-  shutdown = async (cause?: Cause.Cause<UnexpectedError>) => {
-    await this.clientSession
-      .shutdown(cause ?? Cause.fail(IntentionalShutdownCause.make({ reason: 'manual' })))
-      .pipe(this.runEffectFork, Fiber.join, Effect.runPromise)
+  shutdownPromise = async (cause?: UnexpectedError) => {
+    this.checkShutdown('shutdownPromise')
+
+    this.isShutdown = true
+    await this.shutdown(cause ? Cause.fail(cause) : undefined).pipe(this.runEffectFork, Fiber.join, Effect.runPromise)
+  }
+
+  /**
+   * Shuts down the store and closes the client session.
+   *
+   * This is called automatically when the store was created using the React or Effect API.
+   */
+  shutdown = (cause?: Cause.Cause<UnexpectedError>): Effect.Effect<void> => {
+    this.checkShutdown('shutdown')
+
+    this.isShutdown = true
+    return this.clientSession.shutdown(
+      cause ? Exit.failCause(cause) : Exit.succeed(IntentionalShutdownCause.make({ reason: 'manual' })),
+    )
   }
 
   /**

package/src/utils/dev.ts

@@ -1,4 +1,5 @@
-import { isDevEnv } from '@livestore/utils'
+import type { SqliteDb } from '@livestore/common'
+import { prettyBytes } from '@livestore/utils'
 import { Effect } from '@livestore/utils/effect'
 
 export const downloadBlob = (
@@ -26,11 +27,17 @@ export const downloadURL = (data: string, fileName: string) => {
 }
 
 export const exposeDebugUtils = () => {
-  if (isDevEnv()) {
-    globalThis.__debugLiveStoreUtils = {
-      downloadBlob,
-      runSync: (effect: Effect.Effect<any, any, never>) => Effect.runSync(effect),
-      runFork: (effect: Effect.Effect<any, any, never>) => Effect.runFork(effect),
-    }
+  globalThis.__debugLiveStoreUtils = {
+    downloadBlob,
+    runSync: (effect: Effect.Effect<any, any, never>) => Effect.runSync(effect),
+    runFork: (effect: Effect.Effect<any, any, never>) => Effect.runFork(effect),
+    dumpDb: (db: SqliteDb) => {
+      const tables = db.select<{ name: string }>(`SELECT name FROM sqlite_master WHERE type='table'`)
+      for (const table of tables) {
+        const rows = db.select<any>(`SELECT * FROM ${table.name}`)
+        console.log(`Table: ${table.name} (${prettyBytes(table.name.length)}, ${rows.length} rows)`)
+        console.table(rows)
+      }
+    },
   }
 }