@livestore/livestore 0.4.0 → 0.5.0-dev.0

package/src/store/store-eventstream.test.ts

@@ -9,8 +9,17 @@ import type { ShutdownDeferred, Store } from '@livestore/livestore'
 import { createStore, makeShutdownDeferred } from '@livestore/livestore'
 import { omitUndefineds } from '@livestore/utils'
 import { Vitest } from '@livestore/utils-dev/node-vitest'
-import type { OtelTracer, Scope } from '@livestore/utils/effect'
-import { Context, Effect, FetchHttpClient, Layer, Logger, LogLevel, Queue, Stream } from '@livestore/utils/effect'
+import {
+  type OtelTracer,
+  type Scope,
+  Context,
+  Effect,
+  FetchHttpClient,
+  Layer,
+  Queue,
+  References,
+  Stream,
+} from '@livestore/utils/effect'
 import { nanoid } from '@livestore/utils/nanoid'
 import { PlatformNode } from '@livestore/utils/node'
 
@@ -22,7 +31,7 @@ const withTestCtx = Vitest.makeWithTestCtx({
       TestContextLive,
       PlatformNode.NodeFileSystem.layer,
       FetchHttpClient.layer,
-      Logger.minimumLogLevel(LogLevel.Debug),
+      Layer.succeed(References.MinimumLogLevel, 'Debug'),
     ),
 })
 
@@ -32,7 +41,7 @@ const withTestCtx = Vitest.makeWithTestCtx({
  * tests/package-common/src/leader-thread/stream-events.test.ts
  */
 Vitest.describe('Store events API', () => {
-  Vitest.scopedLive('should resume when reconnected to sync backend', (test) =>
+  Vitest.live('should resume when reconnected to sync backend', (test) =>
     Effect.gen(function* () {
       const { makeStore, mockSyncBackend } = yield* TestContext
       const store = yield* makeStore()
@@ -69,7 +78,7 @@ Vitest.describe('Store events API', () => {
   )
 })
 
-class TestContext extends Context.Tag('TestContext')<
+class TestContext extends Context.Service<
   TestContext,
   {
     makeStore: (args?: {
@@ -87,9 +96,9 @@ class TestContext extends Context.Tag('TestContext')<
     mockSyncBackend: MockSyncBackend
     shutdownDeferred: ShutdownDeferred
   }
->() {}
+>()('TestContext') {}
 
-const TestContextLive = Layer.scoped(
+const TestContextLive = Layer.effect(
   TestContext,
   Effect.gen(function* () {
     const mockSyncBackend = yield* makeMockSyncBackend()

package/src/store/store-types.test.ts

@@ -20,7 +20,7 @@ describe('isQueryable', () => {
   it('identifies live query definitions', () => {
     const def = queryDb({
       query: 'select 1 as value',
-      schema: Schema.Array(Schema.Struct({ value: Schema.Number })),
+      schema: Schema.Array(Schema.Struct({ value: Schema.Finite })),
     })
 
     expect(isQueryable(def)).toBe(true)

package/src/store/store-types.ts

@@ -1,21 +1,19 @@
 import type * as otel from '@opentelemetry/api'
 
 import {
+  type BackendIdMismatchError,
   type ClientSession,
   type ClientSessionSyncProcessor,
-  type ClientSessionSyncProcessorSimulationParams,
   type IntentionalShutdownCause,
   isQueryBuilder,
   type MaterializeError,
   type QueryBuilder,
   type StoreInterrupted,
-  type BackendIdMismatchError,
   type UnknownError,
 } from '@livestore/common'
 import type { StreamEventsOptions } from '@livestore/common/leader-thread'
 import type { LiveStoreEvent, LiveStoreSchema } from '@livestore/common/schema'
-import type { Effect, Runtime, Schema, Scope } from '@livestore/utils/effect'
-import { Deferred, Predicate } from '@livestore/utils/effect'
+import { type Context, Deferred, type Effect, Predicate, type Schema, type Scope } from '@livestore/utils/effect'
 
 import type {
   LiveQuery,
@@ -24,7 +22,7 @@ import type {
   ReactivityGraphContext,
   SignalDef,
 } from '../live-queries/base-class.ts'
-import { TypeId } from '../live-queries/base-class.ts'
+import { isLiveQueryDef, TypeId } from '../live-queries/base-class.ts'
 import type { DebugRefreshReasonBase, Ref } from '../reactive.ts'
 import type { SqliteDbWrapper } from '../SqliteDbWrapper.ts'
 import type { ReferenceCountedSet } from '../utils/data-structures.ts'
@@ -98,7 +96,7 @@ export type StoreInternals = {
    * Exposed primarily for Devtools (e.g. databrowser) to validate ad‑hoc
    * event payloads. Application code should not depend on it directly.
    */
-  readonly eventSchema: Schema.Schema<LiveStoreEvent.Client.Decoded, LiveStoreEvent.Client.Encoded>
+  readonly eventSchema: Schema.Codec<LiveStoreEvent.Client.Decoded, LiveStoreEvent.Client.Encoded>
 
   /**
    * The active client session backing this Store. Provides access to the
@@ -115,14 +113,14 @@ export type StoreInternals = {
   readonly sqliteDbWrapper: SqliteDbWrapper
 
   /**
-   * Effect runtime and scope used to fork background fibers for the Store.
+   * Effect context and scope used to fork background fibers for the Store.
    *
-   * - `runtime` executes effects from imperative Store APIs.
+   * - `services` provides services when executing effects from imperative Store APIs.
    * - `lifetimeScope` owns forked fibers; closed during Store shutdown.
    */
   readonly effectContext: {
-    /** Effect runtime to run Store effects with proper environment. */
-    readonly runtime: Runtime.Runtime<Scope.Scope>
+    /** Effect context used to run Store effects with proper services. */
+    readonly services: Context.Context<Scope.Scope>
     /** Scope that owns all long‑lived fibers spawned by the Store. */
     readonly lifetimeScope: Scope.Scope
   }
@@ -189,7 +187,7 @@ export type StoreConstructorParams<TSchema extends LiveStoreSchema = LiveStoreSc
   context: TContext
   otelOptions: OtelOptions
   effectContext: {
-    runtime: Runtime.Runtime<Scope.Scope>
+    services: Context.Context<Scope.Scope>
     lifetimeScope: Scope.Scope
   }
   confirmUnsavedChanges: boolean
@@ -197,9 +195,6 @@ export type StoreConstructorParams<TSchema extends LiveStoreSchema = LiveStoreSc
   params: {
     leaderPushBatchSize: number
     eventQueryBatchSize?: number
-    simulation?: {
-      clientSessionSyncProcessor: typeof ClientSessionSyncProcessorSimulationParams.Type
-    }
   }
   __runningInDevtools: boolean
 }
@@ -335,48 +330,7 @@ export namespace Queryable {
   export type Result<TQueryable extends Queryable<any>> = TQueryable extends Queryable<infer TResult> ? TResult : never
 }
 
-/**
- * Type guard that checks if a value is a query or signal definition.
- *
- * Use this to distinguish between definitions (blueprints) and instances (live queries).
- * Definitions are created by `queryDb()`, `computed()`, and `signal()`.
- *
- * @example
- * ```ts
- * const todos$ = queryDb(tables.todos.all())
- *
- * if (isLiveQueryDef(todos$)) {
- *   console.log('This is a definition:', todos$.label)
- * }
- * ```
- */
-export const isLiveQueryDef = (value: unknown): value is LiveQueryDef<any> | SignalDef<any> => {
-  if (typeof value !== 'object' || value === null) {
-    return false
-  }
-
-  if (!('_tag' in value)) {
-    return false
-  }
-
-  const tag = (value as LiveQueryDef<any> | SignalDef<any>)._tag
-  if (tag !== 'def' && tag !== 'signal-def') {
-    return false
-  }
-
-  const candidate = value as LiveQueryDef<any>
-  if (typeof candidate.make !== 'function') {
-    // The store calls make() to turn the definition into a live query instance.
-    return false
-  }
-
-  if (typeof candidate.hash !== 'string' || typeof candidate.label !== 'string') {
-    // Both identifiers must be present so the store can cache and log the query.
-    return false
-  }
-
-  return true
-}
+export { isLiveQueryDef }
 
 /**
  * Type guard that checks if a value is a live query instance.

package/src/store/store.ts

@@ -1,3 +1,5 @@
+import * as otel from '@opentelemetry/api'
+
 import {
   type Bindable,
   type ClientSession,
@@ -11,10 +13,11 @@ import {
   MaterializeError,
   MaterializerHashMismatchError,
   makeClientSessionSyncProcessor,
-  type PreparedBindValues,
   prepareBindValues,
   QueryBuilderAstSymbol,
-  replaceSessionIdSymbol,
+  resolveSessionIdSymbolInBindValues,
+  SqliteDbHelper,
+  StateHead,
   type StorageMode,
   type SyncState,
   UnknownError,
@@ -23,8 +26,8 @@ import type { StreamEventsOptions } from '@livestore/common/leader-thread'
 import type { LiveStoreSchema } from '@livestore/common/schema'
 import { EventSequenceNumber, LiveStoreEvent, resolveEventDef, SystemTables } from '@livestore/common/schema'
 import { assertNever, isDevEnv, objectToString, omitUndefineds, shouldNeverHappen } from '@livestore/utils'
-import type { Scope } from '@livestore/utils/effect'
 import {
+  type Scope,
   Cause,
   Effect,
   Exit,
@@ -32,12 +35,12 @@ import {
   Inspectable,
   Option,
   OtelTracer,
-  Runtime,
+  Queue,
+  Result,
   Schema,
   Stream,
 } from '@livestore/utils/effect'
 import { nanoid } from '@livestore/utils/nanoid'
-import * as otel from '@opentelemetry/api'
 
 import type { LiveQuery, ReactivityGraphContext, SignalDef } from '../live-queries/base-class.ts'
 import { makeReactivityGraph } from '../live-queries/base-class.ts'
@@ -206,14 +209,15 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
     this.storageMode = clientSession.leaderThread.initialState.storageMode
 
     const reactivityGraph = makeReactivityGraph()
+    const stateHead = StateHead.make({ dbState: clientSession.sqliteDb })
 
     const syncProcessor = makeClientSessionSyncProcessor({
       schema,
       clientSession,
       materializeEvent: Effect.fn('client-session-sync-processor:materialize-event')(
-        (eventEncoded, { withChangeset, materializerHashLeader }) =>
+        (eventEncoded, { materializerHashLeader }) =>
           // We need to use `Effect.gen` (even though we're using `Effect.fn`) so that we can pass `this` to the function
-          Effect.gen(this, function* () {
+          Effect.gen({ self: this }, function* () {
             const resolution = yield* resolveEventDef(schema, {
               operation: '@livestore/livestore:store:materializeEvent',
               event: eventEncoded,
@@ -222,6 +226,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
             if (resolution._tag === 'unknown') {
               // Runtime schema doesn't know this event yet; skip materialization but
               // keep the log entry so upgraded clients can replay it later.
+              yield* stateHead.set(eventEncoded.seqNum)
               return {
                 writeTables: new Set<string>(),
                 sessionChangeset: { _tag: 'no-op' as const },
@@ -286,18 +291,14 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
               }
             }
 
-            let sessionChangeset:
-              | { _tag: 'sessionChangeset'; data: Uint8Array<ArrayBuffer>; debug: any }
-              | { _tag: 'no-op' }
-              | { _tag: 'unset' } = { _tag: 'unset' }
-            if (withChangeset === true) {
-              sessionChangeset = this[StoreInternalsSymbol].sqliteDbWrapper.withChangeset(exec).changeset
-            } else {
-              exec()
-            }
+            const sessionChangeset = this[StoreInternalsSymbol].sqliteDbWrapper.withChangeset(exec).changeset
+            yield* stateHead.set(eventEncoded.seqNum)
 
             return { writeTables: writeTablesForEvent, sessionChangeset, materializerHash }
-          }).pipe(Effect.mapError((cause) => MaterializeError.make({ cause }))),
+          }).pipe(
+            SqliteDbHelper.withSavepoint(clientSession.sqliteDb),
+            Effect.mapError((cause) => MaterializeError.make({ cause })),
+          ),
       ),
       rollback: (changeset) => {
         this[StoreInternalsSymbol].sqliteDbWrapper.rollback(changeset)
@@ -315,12 +316,9 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
         ...omitUndefineds({
           leaderPushBatchSize: params.leaderPushBatchSize,
         }),
-        ...(params.simulation?.clientSessionSyncProcessor !== undefined
-          ? { simulation: params.simulation.clientSessionSyncProcessor }
-          : {}),
       },
       confirmUnsavedChanges,
-    }).pipe(Runtime.runSync(effectContext.runtime))
+    }).pipe(Effect.provideService(StateHead.StateHead, stateHead), Effect.runSyncWith(effectContext.services))
 
     // TODO generalize the `tableRefs` concept to allow finer-grained refs
     const tableRefs: { [key: string]: Ref<null, ReactivityGraphContext, RefreshReason> } = {}
@@ -370,7 +368,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
         })
     }
 
-    const boot = Effect.gen(this, function* () {
+    const boot = Effect.gen({ self: this }, function* () {
       yield* Effect.addFinalizer(() =>
         Effect.sync(() => {
           // Remove all table refs from the reactivity graph
@@ -394,7 +392,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
 
     // Initialize internals bag
     this[StoreInternalsSymbol] = {
-      eventSchema: LiveStoreEvent.Client.makeSchemaMemo(schema) as Schema.Schema<
+      eventSchema: LiveStoreEvent.Client.makeSchemaMemo(schema) as Schema.Codec<
         LiveStoreEvent.Client.Decoded,
         LiveStoreEvent.Client.Encoded
       >,
@@ -570,24 +568,111 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
   ): AsyncIterable<TResult> => {
     this.checkShutdown('subscribe')
 
-    return Stream.toAsyncIterable(this.subscribeStream(query, options))
+    // This used to delegate to `Stream.toAsyncIterable(this.subscribeStream(...))`.
+    // With Effect v4, the callback-backed stream producer is forked during stream startup, so a caller could request
+    // `next()`, commit an update, and race the actual subscription registration. Register directly here so the first
+    // pending `next()` observes post-subscription updates. In the future, this should be refactored back toward a shared
+    // stream/async-iterable bridge if Effect exposes a primitive with that synchronous registration guarantee.
+    return {
+      [Symbol.asyncIterator]: () => {
+        const services = this[StoreInternalsSymbol].effectContext.services
+        const runSync = Effect.runSyncWith(services)
+        const runPromiseExit = Effect.runPromiseExitWith(services)
+        let queue: Queue.Queue<TResult, Cause.Done> | undefined
+        let isDone = false
+        let unsubscribe: Unsubscribe | undefined
+
+        const done = (): IteratorResult<TResult> => ({ done: true, value: undefined })
+        const isClosed = () => isDone
+        const isQueueDone = (cause: Cause.Cause<Cause.Done>) => {
+          const error = Cause.findError(cause)
+          return Result.isSuccess(error) && Cause.isDone(error.success)
+        }
+
+        const ensureQueue = () => {
+          // Lazily allocate the queue so creating an async iterator without consuming it has no subscription-side work.
+          queue ??= Queue.unbounded<TResult, Cause.Done>().pipe(runSync)
+          return queue
+        }
+
+        const emit = (value: TResult) => {
+          if (isDone === true) return
+
+          Queue.offerUnsafe(ensureQueue(), value)
+        }
+
+        const ensureSubscribed = () => {
+          // Subscribe from the first `next()` call so callers that request a value before
+          // committing updates don't race the asynchronous Stream-to-iterator startup path.
+          unsubscribe ??= this.subscribeWithCallback(query, emit, options)
+        }
+
+        const close = (): IteratorResult<TResult> => {
+          if (isDone === false) {
+            isDone = true
+            unsubscribe?.()
+            unsubscribe = undefined
+
+            if (queue !== undefined) {
+              // Wake any pending `next()` call and prevent later callback emissions from being buffered.
+              Queue.shutdown(queue).pipe(runSync)
+            }
+          }
+
+          return done()
+        }
+
+        return {
+          next: async () => {
+            if (isDone === true) {
+              return done()
+            }
+
+            ensureSubscribed()
+
+            // Delegate buffering and pending-consumer wakeups to Effect's queue implementation.
+            const exit = await runPromiseExit(Queue.take(ensureQueue()))
+            if (Exit.isSuccess(exit) === true) {
+              return { done: false, value: exit.value }
+            }
+
+            if (isClosed() === true || isQueueDone(exit.cause) === true) {
+              return done()
+            }
+
+            throw Cause.squash(exit.cause)
+          },
+          return: () => Promise.resolve(close()),
+          throw: (cause) => {
+            close()
+            return Promise.reject(cause)
+          },
+        }
+      },
+    }
   }
 
   subscribeStream = <TResult>(query: Queryable<TResult>, options?: SubscribeOptions<TResult>): Stream.Stream<TResult> =>
-    Stream.asyncPush<TResult>((emit) =>
-      Effect.gen(this, function* () {
+    Stream.callback<TResult>((emit) =>
+      Effect.gen({ self: this }, function* () {
         const otelSpan = yield* OtelTracer.currentOtelSpan.pipe(
-          Effect.catchTag('NoSuchElementException', () => Effect.succeed(undefined)),
+          Effect.catchTag('NoSuchElementError', () => Effect.void),
         )
         const otelContext =
           otelSpan !== undefined ? otel.trace.setSpan(otel.context.active(), otelSpan) : otel.context.active()
 
         yield* Effect.acquireRelease(
           Effect.sync(() =>
-            this.subscribe(query, (result) => emit.single(result), {
-              ...options,
-              otelContext,
-            }),
+            this.subscribe(
+              query,
+              (result) => {
+                Queue.offerUnsafe(emit, result)
+              },
+              {
+                ...options,
+                otelContext,
+              },
+            ),
           ),
           (unsub) => Effect.sync(() => unsub()),
         )
@@ -609,7 +694,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
    * ```
    */
   query = <TResult>(
-    query: Queryable<TResult> | { query: string; bindValues: Bindable; schema?: Schema.Schema<TResult> },
+    query: Queryable<TResult> | { query: string; bindValues: Bindable; schema?: Schema.Decoder<TResult> },
     options?: { otelContext?: otel.Context; debugRefreshReason?: RefreshReason },
   ): TResult => {
     this.checkShutdown('query')
@@ -623,7 +708,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
         },
       ) as any
       if (query.schema !== undefined) {
-        return Schema.decodeSync(query.schema)(res)
+        return Schema.decodeUnknownSync(query.schema)(res)
       }
       return res
     } else if (isQueryBuilder(query) === true) {
@@ -640,23 +725,25 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
       const sqlRes = query.asSql()
       const schema = getResultSchema(query)
 
-      // Replace SessionIdSymbol in bind values before executing the query
-      if (sqlRes.bindValues !== undefined) {
-        replaceSessionIdSymbol(sqlRes.bindValues, this[StoreInternalsSymbol].clientSession.sessionId)
-      }
+      // Query builders preserve SessionIdSymbol so client-document queries can be reused across sessions.
+      // SQLite bind values must be concrete primitives, so resolve the symbol only at execution time.
+      const resolvedBindValues =
+        sqlRes.bindValues === undefined
+          ? undefined
+          : resolveSessionIdSymbolInBindValues(sqlRes.bindValues, this[StoreInternalsSymbol].clientSession.sessionId)
 
       const rawRes = this[StoreInternalsSymbol].sqliteDbWrapper.cachedSelect(
         sqlRes.query,
-        sqlRes.bindValues as any as PreparedBindValues,
+        resolvedBindValues === undefined ? undefined : prepareBindValues(resolvedBindValues, sqlRes.query),
         {
           ...omitUndefineds({ otelContext: options?.otelContext }),
           queriedTables: new Set([query[QueryBuilderAstSymbol].tableDef.sqliteDef.name]),
         },
       )
 
-      const decodeResult = Schema.decodeEither(schema)(rawRes)
-      if (decodeResult._tag === 'Right') {
-        return decodeResult.right
+      const decodeResult = Schema.decodeResult(schema)(rawRes)
+      if (Result.isSuccess(decodeResult) === true) {
+        return decodeResult.success
       } else {
         return shouldNeverHappen(
           'Failed to decode query result with for schema:',
@@ -664,7 +751,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
           'raw result:',
           rawRes,
           'decode error:',
-          decodeResult.left,
+          decodeResult.failure,
         )
       }
     } else if (query._tag === 'def') {
@@ -788,29 +875,25 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
 
     const { events, options } = this.getCommitArgs(firstEventOrTxnFnOrOptions, restEvents)
 
-    Effect.gen(this, function* () {
+    Effect.gen({ self: this }, function* () {
       const commitsSpan = otel.trace.getSpan(this[StoreInternalsSymbol].otel.commitsSpanContext)
       commitsSpan?.addEvent('commit')
       const currentSpan = yield* OtelTracer.currentOtelSpan.pipe(Effect.orDie)
       commitsSpan?.addLink({ context: currentSpan.spanContext() })
 
-      for (const event of events) {
-        replaceSessionIdSymbol(event.args, this[StoreInternalsSymbol].clientSession.sessionId)
-      }
-
       if (events.length === 0) return
 
-      const localRuntime = yield* Effect.runtime()
+      const localServices = yield* Effect.context()
 
       const encodedEvents = yield* this[StoreInternalsSymbol].syncProcessor.encodeEvents(events)
 
       const { writeTables } = yield* Effect.try({
         try: () => {
           const materialize = () =>
-            this[StoreInternalsSymbol].syncProcessor.materializeEvents(encodedEvents).pipe(Runtime.runSync(localRuntime))
-          return events.length > 1
-            ? this[StoreInternalsSymbol].sqliteDbWrapper.txn(materialize)
-            : materialize()
+            this[StoreInternalsSymbol].syncProcessor
+              .materializeEvents(encodedEvents)
+              .pipe(Effect.runSyncWith(localServices))
+          return events.length > 1 ? this[StoreInternalsSymbol].sqliteDbWrapper.txn(materialize) : materialize()
         },
         catch: (cause) => UnknownError.make({ cause }),
       })
@@ -854,9 +937,9 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
           ...(options?.spanLinks?.map(OtelTracer.makeSpanLink) ?? []),
         ],
       }),
-      Effect.tapErrorCause(Effect.logError),
-      Effect.catchAllCause((cause) => Effect.fork(this.shutdown(cause))),
-      Runtime.runSync(this[StoreInternalsSymbol].effectContext.runtime),
+      Effect.tapCause(Effect.logError),
+      Effect.catchCause((cause) => Effect.forkChild(this.shutdown(cause))),
+      Effect.runSyncWith(this[StoreInternalsSymbol].effectContext.services),
     )
   }
   //#endregion commit
@@ -934,8 +1017,8 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
     }
 
     return clientSession.leaderThread.events.stream(baseOptions).pipe(
-      Stream.mapChunksEffect(Schema.decode(Schema.ChunkFromSelf(eventSchema))),
-      Stream.catchTag('ParseError', (cause) => Stream.fail(UnknownError.make({ cause }))),
+      Stream.mapEffect((event) => Schema.decodeEffect(eventSchema)(event)),
+      Stream.catchTag('SchemaError', (cause) => Stream.fail(UnknownError.make({ cause }))),
       Stream.tapError((error) => Effect.logError('Error in eventsStream', error)),
     )
   }
@@ -1028,7 +1111,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
     )
 
     return () => {
-      Fiber.interrupt(fiber).pipe(Runtime.runFork(this[StoreInternalsSymbol].effectContext.runtime))
+      Fiber.interrupt(fiber).pipe(Effect.runForkWith(this[StoreInternalsSymbol].effectContext.services))
     }
   }
 
@@ -1102,7 +1185,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
    */
   _dev = {
     downloadDb: (source: 'local' | 'leader' = 'local') => {
-      Effect.gen(this, function* () {
+      Effect.gen({ self: this }, function* () {
         const data =
           source === 'local'
             ? this[StoreInternalsSymbol].sqliteDbWrapper.export()
@@ -1112,14 +1195,14 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
     },
 
     downloadEventlogDb: () => {
-      Effect.gen(this, function* () {
+      Effect.gen({ self: this }, function* () {
         const data = yield* this[StoreInternalsSymbol].clientSession.leaderThread.getEventlogData
         downloadBlob(data, `livestore-eventlog-${Date.now()}.db`)
       }).pipe(this.runEffectFork)
     },
 
     hardReset: (mode: 'all-data' | 'only-app-db' = 'all-data') => {
-      Effect.gen(this, function* () {
+      Effect.gen({ self: this }, function* () {
         const clientId = this[StoreInternalsSymbol].clientSession.clientId
         yield* this[StoreInternalsSymbol].clientSession.leaderThread.sendDevtoolsMessage(
           Devtools.Leader.ResetAllData.Request.make({ liveStoreVersion, mode, requestId: nanoid(), clientId }),
@@ -1143,14 +1226,14 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
 
     // NOTE: Explicit return type needed to avoid TS2742 (inferred type references internal path)
     syncStates: (): Promise<{ session: SyncState.SyncState; leader: SyncState.SyncState }> =>
-      Effect.gen(this, function* () {
+      Effect.gen({ self: this }, function* () {
         const session = yield* this[StoreInternalsSymbol].syncProcessor.syncState
         const leader = yield* this[StoreInternalsSymbol].clientSession.leaderThread.syncState
         return { session, leader }
       }).pipe(this.runEffectPromise),
 
     printSyncStates: () => {
-      Effect.gen(this, function* () {
+      Effect.gen({ self: this }, function* () {
         const session = yield* this[StoreInternalsSymbol].syncProcessor.syncState
         yield* Effect.log(
           `Session sync state: ${objectToString(session.localHead)} (upstream: ${objectToString(session.upstreamHead)})`,
@@ -1181,11 +1264,11 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
     effect.pipe(
       Effect.forkIn(this[StoreInternalsSymbol].effectContext.lifetimeScope),
       Effect.tapCauseLogPretty,
-      Runtime.runFork(this[StoreInternalsSymbol].effectContext.runtime),
+      Effect.runForkWith(this[StoreInternalsSymbol].effectContext.services),
     )
 
   private runEffectPromise = <A, E>(effect: Effect.Effect<A, E, Scope.Scope>) =>
-    effect.pipe(Effect.tapCauseLogPretty, Runtime.runPromise(this[StoreInternalsSymbol].effectContext.runtime))
+    effect.pipe(Effect.tapCauseLogPretty, Effect.runPromiseWith(this[StoreInternalsSymbol].effectContext.services))
 
   private getCommitArgs = (
     firstEventOrTxnFnOrOptions: any,
@@ -1215,12 +1298,6 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
       events = [firstEventOrTxnFnOrOptions, ...restEvents]
     }
 
-    // for (const event of events) {
-    //   if (event.args.id === SessionIdSymbol) {
-    //     event.args.id = this.sessionId
-    //   }
-    // }
-
     return { events, options }
   }
 }

package/src/utils/dev.ts

@@ -24,7 +24,7 @@ export const downloadURL = (data: string, fileName: string) => {
   const a = document.createElement('a')
   a.href = data
   a.download = fileName
-  document.body.append(a)
+  document.body.appendChild(a)
   a.style.display = 'none'
   a.click()
   a.remove()

package/src/utils/stack-info.ts

@@ -41,7 +41,10 @@ export const extractStackInfoFromStackTrace = (stackTrace: string): StackInfo =>
     // console.debug(name, filePath)
 
     // NOTE No idea where this `Module.` comes from - possibly a Vite thing?
-    if ((name.startsWith('use') === true || name.startsWith('Module.use') === true) && name.endsWith('QueryRef') === false) {
+    if (
+      (name.startsWith('use') === true || name.startsWith('Module.use') === true) &&
+      name.endsWith('QueryRef') === false
+    ) {
       hasReachedStart = true
       // console.debug('hasReachedStart. adding one more frame.')