@livestore/common 0.4.0 → 0.5.0-dev.1

package/src/leader-thread/stream-events.ts

@@ -1,5 +1,4 @@
-import type { Subscribable } from '@livestore/utils/effect'
-import { Chunk, Effect, Option, Queue, Stream } from '@livestore/utils/effect'
+import { type Subscribable, Effect, Option, Queue, Stream } from '@livestore/utils/effect'
 
 import { EventSequenceNumber, type LiveStoreEvent } from '../schema/mod.ts'
 import type * as SyncState from '../sync/syncstate.ts'
@@ -15,19 +14,17 @@ import type { LeaderSqliteDb, StreamEventsOptions } from './types.ts'
  * The batch size is set to 100 by default as this was meassured to provide the
  * best performance and 1000 as the upper limit.
  *
- * Adapters that call this helper:
+ * Adapters that call this helper include:
  * - `packages/@livestore/adapter-web/src/in-memory/in-memory-adapter.ts`
  * - `packages/@livestore/adapter-web/src/web-worker/leader-worker/make-leader-worker.ts`
- * - `packages/@livestore/adapter-node/src/client-session/adapter.ts`
- * - `packages/@livestore/adapter-node/src/make-leader-worker.ts`
  * - `packages/@livestore/adapter-cloudflare/src/make-adapter.ts`
+ * - external leader-thread adapters
  *
  * Each caller resolves dependencies inside the leader scope before invoking this helper,
  * so the stream stays environment-agnostic and does not leak `LeaderThreadCtx` into runtime
  * entry points such as `Store.eventsStream`.
  *
  * Test files:
- * Unit: `tests/package-common/src/leader-thread/stream-events.test.ts`
  * Integration: `packages/@livestore/livestore/src/store/store-eventstream.test.ts`
  * Performance: `tests/perf-eventlog/tests/suites/event-streaming.test.ts`
  *
@@ -48,7 +45,7 @@ import type { LeaderSqliteDb, StreamEventsOptions } from './types.ts'
  * Fetch plans into sink and decompose into windows
  * https://gist.github.com/slashv/a8f55f50121c080937f42e44b4039ac8
  *
- * Mailbox and Latch approach (suggestion by Tim Smart)
+ * Queue and Latch approach (suggestion by Tim Smart)
  * https://gist.github.com/slashv/d6b12395c85415bf0d3363372a1636c3
  */
 export const streamEventsWithSyncState = ({
@@ -63,7 +60,7 @@ export const streamEventsWithSyncState = ({
   const initialCursor = options.since ?? EventSequenceNumber.Client.ROOT
   const batchSize = options.batchSize ?? 100
 
-  return Stream.unwrapScoped(
+  return Stream.unwrap(
     Effect.gen(function* () {
       /**
        * Single-element Queue allows suspending the event stream until head
@@ -101,105 +98,109 @@ export const streamEventsWithSyncState = ({
         Effect.forkScoped,
       )
 
-      return Stream.paginateChunkEffect(
-        { cursor: initialCursor, head: EventSequenceNumber.Client.ROOT },
-        ({ cursor, head }) =>
-          Effect.gen(function* () {
-            /**
-             * Early check guards agains:
-             * since === until : Prevent empty query
-             * since > until : Incorrectly inverted interval
-             */
-            if (
-              options.until !== undefined &&
-              EventSequenceNumber.Client.isGreaterThanOrEqual(cursor, options.until) === true
-            ) {
-              return [Chunk.empty(), Option.none()]
-            }
+      return Stream.paginate({ cursor: initialCursor, head: EventSequenceNumber.Client.ROOT }, ({ cursor, head }) =>
+        Effect.gen(function* () {
+          /**
+           * Early check guards agains:
+           * since === until : Prevent empty query
+           * since > until : Incorrectly inverted interval
+           */
+          if (
+            options.until !== undefined &&
+            EventSequenceNumber.Client.isGreaterThanOrEqual(cursor, options.until) === true
+          ) {
+            const done: readonly [
+              ReadonlyArray<LiveStoreEvent.Client.Encoded>,
+              Option.Option<{
+                cursor: EventSequenceNumber.Client.Composite
+                head: EventSequenceNumber.Client.Composite
+              }>,
+            ] = [[], Option.none()]
+            return done
+          }
+
+          /**
+           * There are two scenarios where we take the next head from the headQueue:
+           *
+           * 1. We need to wait for the head to advance
+           * The Stream suspends until a new head is available on the headQueue
+           *
+           * 2. Head has advanced during itteration
+           * While itterating towards the lastest head taken from the headQueue
+           * in increments of batchSize it's possible the head could have
+           * advanced. This leads to a suboptimal amount of queries. Therefor we
+           * check if the headQueue is full which tells us that there's a new
+           * head available to take. Example:
+           *
+           * batchSize: 2
+           *
+           * --> head at: e3
+           * First query: e0 -> e2 (two events)
+           * --> head advances to: e4
+           * Second query: e2 -> e3 (one event but we could have taken 2)
+           * --> Take the new head of e4
+           * Third query: e3 -> e4 (unnecessary third query)
+           *
+           *
+           * To define the target, which will be used as the temporary until
+           * marker for the eventlog query, we select the lowest of three possible values:
+           *
+           * hardStop: A user supplied until marker
+           * current cursor + batchSize: A batchSize step towards the latest head from headQueue
+           * nextHead: The latest head from headQueue
+           */
+          const waitForHead = EventSequenceNumber.Client.isGreaterThanOrEqual(cursor, head)
+          const maybeHead =
+            waitForHead === true ? yield* Queue.take(headQueue).pipe(Effect.asSome) : yield* Queue.poll(headQueue)
+          const nextHead = Option.getOrElse(maybeHead, () => head)
+          const hardStop = options.until?.global ?? Number.POSITIVE_INFINITY
+          const target = EventSequenceNumber.Client.Composite.make({
+            global: Math.min(hardStop, cursor.global + batchSize, nextHead.global),
+            client: EventSequenceNumber.Client.DEFAULT,
+          })
 
-            /**
-             * There are two scenarios where we take the next head from the headQueue:
-             *
-             * 1. We need to wait for the head to advance
-             * The Stream suspends until a new head is available on the headQueue
-             *
-             * 2. Head has advanced during itteration
-             * While itterating towards the lastest head taken from the headQueue
-             * in increments of batchSize it's possible the head could have
-             * advanced. This leads to a suboptimal amount of queries. Therefor we
-             * check if the headQueue is full which tells us that there's a new
-             * head available to take. Example:
-             *
-             * batchSize: 2
-             *
-             * --> head at: e3
-             * First query: e0 -> e2 (two events)
-             * --> head advances to: e4
-             * Second query: e2 -> e3 (one event but we could have taken 2)
-             * --> Take the new head of e4
-             * Third query: e3 -> e4 (unnecessary third query)
-             *
-             *
-             * To define the target, which will be used as the temporary until
-             * marker for the eventlog query, we select the lowest of three possible values:
-             *
-             * hardStop: A user supplied until marker
-             * current cursor + batchSize: A batchSize step towards the latest head from headQueue
-             * nextHead: The latest head from headQueue
-             */
-            const waitForHead = EventSequenceNumber.Client.isGreaterThanOrEqual(cursor, head)
-            const maybeHead =
-              waitForHead === true
-                ? yield* Queue.take(headQueue).pipe(Effect.map(Option.some))
-                : yield* Queue.poll(headQueue)
-            const nextHead = Option.getOrElse(maybeHead, () => head)
-            const hardStop = options.until?.global ?? Number.POSITIVE_INFINITY
-            const target = EventSequenceNumber.Client.Composite.make({
-              global: Math.min(hardStop, cursor.global + batchSize, nextHead.global),
-              client: EventSequenceNumber.Client.DEFAULT,
-            })
+          /**
+           * Eventlog.getEventsFromEventlog returns a batch from each query
+           * which is what we emit at each itteration.
+           */
+          const events = yield* Eventlog.getEventsFromEventlog({
+            dbEventlog,
+            options: {
+              ...options,
+              since: cursor,
+              until: target,
+            },
+          })
 
-            /**
-             * Eventlog.getEventsFromEventlog returns a Chunk from each
-             * query which is what we emit at each itteration.
-             */
-            const chunk = yield* Eventlog.getEventsFromEventlog({
-              dbEventlog,
-              options: {
-                ...options,
-                since: cursor,
-                until: target,
-              },
-            })
+          /**
+           * We construct the state for the following itteration of the stream
+           * loop by setting the current target as the since cursor and pass
+           * along the latest head.
+           *
+           * If we have the reached the user supplied until marker we signal the
+           * finalization of the stream by passing Option.none() instead.
+           */
+          const reachedUntil =
+            options.until !== undefined && EventSequenceNumber.Client.isGreaterThanOrEqual(target, options.until)
 
-            /**
-             * We construct the state for the following itteration of the stream
-             * loop by setting the current target as the since cursor and pass
-             * along the latest head.
-             *
-             * If we have the reached the user supplied until marker we signal the
-             * finalization of the stream by passing Option.none() instead.
-             */
-            const reachedUntil =
-              options.until !== undefined && EventSequenceNumber.Client.isGreaterThanOrEqual(target, options.until)
+          const nextState: Option.Option<{
+            cursor: EventSequenceNumber.Client.Composite
+            head: EventSequenceNumber.Client.Composite
+          }> = reachedUntil === true ? Option.none() : Option.some({ cursor: target, head: nextHead })
 
-            const nextState: Option.Option<{
-              cursor: EventSequenceNumber.Client.Composite
-              head: EventSequenceNumber.Client.Composite
-            }> = reachedUntil === true ? Option.none() : Option.some({ cursor: target, head: nextHead })
+          const spanAttributes = {
+            'livestore.streamEvents.cursor.global': cursor.global,
+            'livestore.streamEvents.target.global': target.global,
+            'livestore.streamEvents.batchSize': batchSize,
+            'livestore.streamEvents.waitedForHead': waitForHead,
+          }
 
-            const spanAttributes = {
-              'livestore.streamEvents.cursor.global': cursor.global,
-              'livestore.streamEvents.target.global': target.global,
-              'livestore.streamEvents.batchSize': batchSize,
-              'livestore.streamEvents.waitedForHead': waitForHead,
-            }
+          const result: readonly [ReadonlyArray<LiveStoreEvent.Client.Encoded>, typeof nextState] = [events, nextState]
 
-            return yield* Effect.succeed<[Chunk.Chunk<LiveStoreEvent.Client.Encoded>, typeof nextState]>([
-              chunk,
-              nextState,
-            ]).pipe(Effect.withSpan('@livestore/common:streamEvents:segment', { attributes: spanAttributes }))
-          }),
+          return yield* Effect.succeed(result).pipe(
+            Effect.withSpan('@livestore/common:streamEvents:segment', { attributes: spanAttributes }),
+          )
+        }),
       )
     }),
   )

package/src/leader-thread/types.ts

@@ -1,15 +1,17 @@
-import type {
-  Deferred,
-  Effect,
-  HttpClient,
-  Option,
-  Queue,
-  Scope,
-  Stream,
-  Subscribable,
-  SubscriptionRef,
+import {
+  type Deferred,
+  type Effect,
+  type HttpClient,
+  type Latch,
+  type Option,
+  type Queue,
+  type Scope,
+  type Stream,
+  type Subscribable,
+  type SubscriptionRef,
+  Context,
+  Schema,
 } from '@livestore/utils/effect'
-import { Context, Schema } from '@livestore/utils/effect'
 import type { MeshNode } from '@livestore/webmesh'
 
 import type { MigrationsReport } from '../defs.ts'
@@ -22,11 +24,10 @@ import type {
   SqliteDb,
   SyncBackend,
   UnknownError,
-  UnknownEventError,
 } from '../index.ts'
-import type { RejectedPushError } from './RejectedPushError.ts'
 import { EventSequenceNumber, type LiveStoreEvent, type LiveStoreSchema } from '../schema/mod.ts'
 import type * as SyncState from '../sync/syncstate.ts'
+import type * as LeaderSyncProcessor from './LeaderSyncProcessor.ts'
 import type { ShutdownChannel } from './shutdown-channel.ts'
 
 export type ShutdownState = 'running' | 'shutting-down'
@@ -35,17 +36,17 @@ export const InitialSyncOptionsSkip = Schema.TaggedStruct('Skip', {})
 export type InitialSyncOptionsSkip = typeof InitialSyncOptionsSkip.Type
 
 export const InitialSyncOptionsBlocking = Schema.TaggedStruct('Blocking', {
-  timeout: Schema.Union(Schema.DurationFromMillis, Schema.Number),
+  timeout: Schema.Union([Schema.DurationFromMillis, Schema.Finite]),
 })
 
 export type InitialSyncOptionsBlocking = typeof InitialSyncOptionsBlocking.Type
 
-export const InitialSyncOptions = Schema.Union(InitialSyncOptionsSkip, InitialSyncOptionsBlocking)
+export const InitialSyncOptions = Schema.Union([InitialSyncOptionsSkip, InitialSyncOptionsBlocking])
 export type InitialSyncOptions = typeof InitialSyncOptions.Type
 
 export type InitialSyncInfo = Option.Option<{
   eventSequenceNumber: EventSequenceNumber.Global.Type
-  metadata: Option.Option<Schema.JsonValue>
+  metadata: Option.Option<Schema.Json>
 }>
 
 // export type InitialSetup =
@@ -75,16 +76,16 @@ export type DevtoolsOptions =
 export type DevtoolsContext =
   | {
       enabled: true
-      // syncBackendPullLatch: Effect.Latch
-      // syncBackendPushLatch: Effect.Latch
-      syncBackendLatch: Effect.Latch
+      // syncBackendPullLatch: Latch.Latch
+      // syncBackendPushLatch: Latch.Latch
+      syncBackendLatch: Latch.Latch
       syncBackendLatchState: SubscriptionRef.SubscriptionRef<{ latchClosed: boolean }>
     }
   | {
       enabled: false
     }
 
-export class LeaderThreadCtx extends Context.Tag('LeaderThreadCtx')<
+export class LeaderThreadCtx extends Context.Service<
   LeaderThreadCtx,
   {
     schema: LiveStoreSchema
@@ -100,7 +101,7 @@ export class LeaderThreadCtx extends Context.Tag('LeaderThreadCtx')<
     eventSchema: LiveStoreEvent.ForEventDef.ForRecord<any>
     devtools: DevtoolsContext
     syncBackend: SyncBackend.SyncBackend | undefined
-    syncProcessor: LeaderSyncProcessor
+    syncProcessor: LeaderSyncProcessor.Service
     materializeEvent: MaterializeEvent
     initialState: {
       leaderHead: EventSequenceNumber.Client.Composite
@@ -114,7 +115,7 @@ export class LeaderThreadCtx extends Context.Tag('LeaderThreadCtx')<
     extraIncomingMessagesQueue: Queue.Queue<Devtools.Leader.MessageToApp>
     networkStatus: Subscribable.Subscribable<SyncBackend.NetworkStatus>
   }
->() {}
+>()('LeaderThreadCtx') {}
 
 export type MaterializeEvent = (
   eventEncoded: LiveStoreEvent.Client.EncodedWithMeta,
@@ -138,13 +139,18 @@ export type InitialBlockingSyncContext = {
 export const STREAM_EVENTS_BATCH_SIZE_DEFAULT = 100
 export const STREAM_EVENTS_BATCH_SIZE_MAX = 1_000
 
+export const STATE_REBUILD_BATCH_SIZE_DEFAULT = 100
+export const StateRebuildBatchSizeSchema = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)).annotate({
+  title: 'stateRebuildBatchSize',
+})
+
 export const StreamEventsOptionsFields = {
   since: Schema.optional(EventSequenceNumber.Client.Composite),
   until: Schema.optional(EventSequenceNumber.Client.Composite),
   filter: Schema.optional(Schema.Array(Schema.String)),
   clientIds: Schema.optional(Schema.Array(Schema.String)),
   sessionIds: Schema.optional(Schema.Array(Schema.String)),
-  batchSize: Schema.optional(Schema.Int.pipe(Schema.between(1, STREAM_EVENTS_BATCH_SIZE_MAX))),
+  batchSize: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: STREAM_EVENTS_BATCH_SIZE_MAX }))),
   includeClientOnly: Schema.optional(Schema.Boolean),
 } as const
 
@@ -182,42 +188,3 @@ export interface StreamEventsOptions {
    */
   includeClientOnly?: boolean
 }
-
-export interface LeaderSyncProcessor {
-  /** Used by client sessions to subscribe to upstream sync state changes */
-  pull: (args: {
-    cursor: EventSequenceNumber.Client.Composite
-  }) => Stream.Stream<{ payload: typeof SyncState.PayloadUpstream.Type }>
-  /** The `pullQueue` API can be used instead of `pull` when more convenient */
-  pullQueue: (args: {
-    cursor: EventSequenceNumber.Client.Composite
-  }) => Effect.Effect<Queue.Queue<{ payload: typeof SyncState.PayloadUpstream.Type }>, never, Scope.Scope>
-
-  /** Used by client sessions to push events to the leader thread */
-  push: (
-    /** `batch` needs to follow the same rules as `batch` in `SyncBackend.push` */
-    batch: ReadonlyArray<LiveStoreEvent.Client.EncodedWithMeta>,
-    options?: {
-      /**
-       * If true, the effect will only finish when the local push has been processed (i.e. succeeded or was rejected).
-       * `true` doesn't mean the events have been pushed to the sync backend.
-       * @default false
-       */
-      waitForProcessing?: boolean
-    },
-  ) => Effect.Effect<void, RejectedPushError>
-
-  /** Currently only used by devtools which don't provide their own event numbers */
-  pushPartial: (args: {
-    event: LiveStoreEvent.Input.Encoded
-    clientId: string
-    sessionId: string
-  }) => Effect.Effect<void, UnknownEventError>
-
-  boot: Effect.Effect<
-    { initialLeaderHead: EventSequenceNumber.Client.Composite },
-    never,
-    LeaderThreadCtx | Scope.Scope | HttpClient.HttpClient
-  >
-  syncState: Subscribable.Subscribable<SyncState.SyncState>
-}

package/src/logging.ts

@@ -1,62 +1,15 @@
-import { isDevEnv } from '@livestore/utils'
-import { Effect, type Layer, Logger, LogLevel } from '@livestore/utils/effect'
+import type { Layer, LogLevel } from '@livestore/utils/effect'
 
 /**
- * Optional Effect logger configuration that LiveStore entry points accept.
+ * Optional Effect logger configuration accepted by LiveStore entry points.
  *
- * When provided, `logger` replaces the default pretty logger for the runtime.
- * Use `logLevel` to control verbosity. Set to `LogLevel.None` to disable logging
+ * When provided, `logger` replaces the default logger for the runtime.
+ * Use `logLevel` to control verbosity. Set to `"None"` to disable logging
  * entirely while keeping the same logger implementation.
  */
-export type WithLoggerOptions = {
+export type LoggerOptions = {
   /** Optional Effect logger layer to control logging output. */
   logger?: Layer.Layer<never> | undefined
   /** Optional minimum log level for the runtime. */
   logLevel?: LogLevel.LogLevel | undefined
 }
-
-/**
- * Common defaults for resolving a logger configuration.
- * - `threadName` is used by the default pretty logger when `logger` is not provided.
- * - `mode` selects pretty logger mode (e.g. 'browser' for web workers).
- * - `defaultLogLevel` is used when `logLevel` is not provided.
- */
-export type LoggerDefaults = {
-  threadName?: string
-  mode?: 'tty' | 'browser'
-  defaultLogLevel?: LogLevel.LogLevel
-  /** Optional default logger layer to use when `config.logger` is not provided. */
-  defaultLogger?: Layer.Layer<never>
-}
-
-/**
- * Resolve the logger layer to provide to the Effect runtime.
- */
-export const resolveLoggerLayer = (config?: WithLoggerOptions, defaults?: LoggerDefaults): Layer.Layer<never> => {
-  if (config?.logger !== undefined) return config.logger
-  if (defaults?.defaultLogger !== undefined) return defaults.defaultLogger
-  const threadName = defaults?.threadName ?? 'livestore'
-  const mode = defaults?.mode
-  return Logger.prettyWithThread(threadName, mode !== undefined ? { mode } : {})
-}
-
-/**
- * Resolve the minimum log level, falling back to `defaults.defaultLogLevel` then `LogLevel.Debug`.
- */
-export const resolveLogLevel = (config?: WithLoggerOptions, defaults?: LoggerDefaults): LogLevel.LogLevel => {
-  if (config?.logLevel !== undefined) return config.logLevel
-  if (defaults?.defaultLogLevel !== undefined) return defaults.defaultLogLevel
-  return isDevEnv() === true ? LogLevel.Debug : LogLevel.Info
-}
-
-/**
- * Wrap an effect by applying the resolved minimum log level and providing the resolved logger layer.
- */
-export const withLoggerConfig = <TEnv, TError, TOut>(
-  config?: WithLoggerOptions,
-  defaults?: LoggerDefaults,
-): ((effect: Effect.Effect<TOut, TError, TEnv>) => Effect.Effect<TOut, TError, TEnv>) => {
-  const level = resolveLogLevel(config, defaults)
-  const layer = resolveLoggerLayer(config, defaults)
-  return (effect) => effect.pipe(Logger.withMinimumLogLevel(level), Effect.provide(layer))
-}

package/src/make-client-session.ts

@@ -1,5 +1,4 @@
-import type { Scope, SubscriptionRef } from '@livestore/utils/effect'
-import { Effect, Stream } from '@livestore/utils/effect'
+import { type Scope, type SubscriptionRef, Effect, Latch, Stream } from '@livestore/utils/effect'
 import * as Webmesh from '@livestore/webmesh'
 
 import type {
@@ -51,9 +50,10 @@ export const makeClientSession = <R>({
   origin: string | undefined
 }): Effect.Effect<ClientSession, never, Scope.Scope | R> =>
   Effect.gen(function* () {
-    const devtools: ClientSession['devtools'] = devtoolsEnabled === true
-      ? { enabled: true, pullLatch: yield* Effect.makeLatch(true), pushLatch: yield* Effect.makeLatch(true) }
-      : { enabled: false }
+    const devtools: ClientSession['devtools'] =
+      devtoolsEnabled === true
+        ? { enabled: true, pullLatch: yield* Latch.make(true), pushLatch: yield* Latch.make(true) }
+        : { enabled: false }
 
     if (devtoolsEnabled === true) {
       yield* Effect.gen(function* () {
@@ -116,7 +116,7 @@ export const makeClientSession = <R>({
                 yield* connectDevtoolsToStore(clientSessionDevtoolsChannel)
               },
               Effect.tapCauseLogPretty,
-              Effect.forkScoped,
+              Effect.forkScoped(),
             ),
           ),
           Stream.runDrain,

package/src/materializer-helper.ts

@@ -1,8 +1,7 @@
-import { isDevEnv, isNil, isReadonlyArray } from '@livestore/utils'
-import { Hash, Option, Schema } from '@livestore/utils/effect'
+import { isDevEnv } from '@livestore/utils'
+import { Hash, Option, Predicate, ReadonlyArray, Schema } from '@livestore/utils/effect'
 
 import type { SqliteDb } from './adapter-types.ts'
-import { SessionIdSymbol } from './adapter-types.ts'
 import type { EventDef, Materializer, MaterializerContextQuery, MaterializerResult } from './schema/EventDef/mod.ts'
 import type * as LiveStoreEvent from './schema/LiveStoreEvent/mod.ts'
 import type { LiveStoreSchema } from './schema/schema.ts'
@@ -39,9 +38,10 @@ export const getExecStatementsFromMaterializer = ({
         }
       : event.decoded
 
-  const eventArgsEncoded = isNil(event.decoded?.args) === true
-    ? undefined
-    : Schema.encodeUnknownSync(eventDef.schema)(event.decoded.args)
+  const eventArgsEncoded =
+    Predicate.isNotUndefined(event.decoded) === true && Predicate.isNotNullish(event.decoded.args) === true
+      ? Schema.encodeUnknownSync(eventDef.schema)(event.decoded.args)
+      : undefined
 
   const query: MaterializerContextQuery = (
     rawQueryOrQueryBuilder:
@@ -126,7 +126,7 @@ const fromMaterializerResult = (
   bindValues: BindValues
   writeTables: ReadonlySet<string> | undefined
 }> => {
-  if (isReadonlyArray(materializerResult) === true) {
+  if (ReadonlyArray.isArray<MaterializerResult | ReadonlyArray<MaterializerResult>>(materializerResult) === true) {
     return materializerResult.flatMap(fromMaterializerResult)
   }
   if (isQueryBuilder(materializerResult) === true) {
@@ -144,32 +144,3 @@ const fromMaterializerResult = (
     ]
   }
 }
-
-// NOTE we should explore whether there is a more elegant solution
-// e.g. by leveraging the schema to replace the sessionIdSymbol
-export const replaceSessionIdSymbol = (
-  bindValues: Record<string, unknown> | ReadonlyArray<unknown>,
-  sessionId: string,
-) => {
-  deepReplaceValue(bindValues, SessionIdSymbol, sessionId)
-}
-
-const deepReplaceValue = <S, R>(input: any, searchValue: S, replaceValue: R): void => {
-  if (Array.isArray(input) === true) {
-    for (const i in input) {
-      if (input[i] === searchValue) {
-        input[i] = replaceValue
-      } else {
-        deepReplaceValue(input[i], searchValue, replaceValue)
-      }
-    }
-  } else if (typeof input === 'object' && input !== null) {
-    for (const key in input) {
-      if (input[key] === searchValue) {
-        input[key] = replaceValue
-      } else {
-        deepReplaceValue(input[key], searchValue, replaceValue)
-      }
-    }
-  }
-}

package/src/otel.ts

@@ -1,26 +1,25 @@
 import * as otel from '@opentelemetry/api'
 
 import { makeNoopTracer } from '@livestore/utils'
+import type { Tracer } from '@livestore/utils/effect'
 import { Effect, identity, Layer, OtelTracer } from '@livestore/utils/effect'
 
 export const OtelLiveDummy: Layer.Layer<OtelTracer.OtelTracer> = Layer.suspend(() => {
   const OtelTracerLive = Layer.succeed(OtelTracer.OtelTracer, makeNoopTracer())
 
-  const TracingLive = Layer.unwrapEffect(Effect.map(OtelTracer.make, Layer.setTracer)).pipe(
-    Layer.provideMerge(OtelTracerLive),
-  )
+  const TracingLive = OtelTracer.layerWithoutOtelTracer.pipe(Layer.provideMerge(OtelTracerLive))
 
   return TracingLive
 })
 
 export const provideOtel =
   ({ otelTracer, parentSpanContext }: { otelTracer?: otel.Tracer; parentSpanContext?: otel.Context }) =>
-  <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, Exclude<R, OtelTracer.OtelTracer>> => {
+  <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, Exclude<R, OtelTracer.OtelTracer | Tracer.Tracer>> => {
     const OtelTracerLive = Layer.succeed(OtelTracer.OtelTracer, otelTracer ?? makeNoopTracer())
 
-    const TracingLive = Layer.unwrapEffect(Effect.map(OtelTracer.make, Layer.setTracer)).pipe(
+    const TracingLive = OtelTracer.layerWithoutOtelTracer.pipe(
       Layer.provideMerge(OtelTracerLive),
-    ) as any as Layer.Layer<OtelTracer.OtelTracer>
+    ) as any as Layer.Layer<OtelTracer.OtelTracer | Tracer.Tracer>
 
     return effect.pipe(
       parentSpanContext !== undefined
@@ -29,11 +28,3 @@ export const provideOtel =
       Effect.provide(TracingLive),
     )
   }
-
-export const getDurationMsFromSpan = (span: otel.Span): number => {
-  const durationHr: [seconds: number, nanos: number] = (span as any)._duration
-  return durationHr[0] * 1000 + durationHr[1] / 1_000_000
-}
-
-export const getStartTimeHighResFromSpan = (span: otel.Span): DOMHighResTimeStamp =>
-  (span as any)._performanceStartTime as DOMHighResTimeStamp