@livestore/livestore 0.4.0-dev.21 → 0.4.0-dev.23

package/src/store/store.ts

@@ -15,12 +15,14 @@ import {
   prepareBindValues,
   QueryBuilderAstSymbol,
   replaceSessionIdSymbol,
+  type StorageMode,
+  type SyncState,
   UnknownError,
 } from '@livestore/common'
 import type { StreamEventsOptions } from '@livestore/common/leader-thread'
 import type { LiveStoreSchema } from '@livestore/common/schema'
-import { LiveStoreEvent, resolveEventDef, SystemTables } from '@livestore/common/schema'
-import { assertNever, isDevEnv, omitUndefineds, shouldNeverHappen } from '@livestore/utils'
+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 {
   Cause,
@@ -49,12 +51,13 @@ import {
   type Queryable,
   type RefreshReason,
   type StoreCommitOptions,
+  type StoreConstructorParams,
   type StoreEventsOptions,
   type StoreInternals,
   StoreInternalsSymbol,
-  type StoreOptions,
   type StoreOtel,
   type SubscribeOptions,
+  type SyncStatus,
   type Unsubscribe,
 } from './store-types.ts'
 
@@ -67,7 +70,7 @@ export type SubscribeFn = {
   <TResult>(query: Queryable<TResult>, options?: SubscribeOptions<TResult>): AsyncIterable<TResult>
 }
 
-if (isDevEnv()) {
+if (isDevEnv() === true) {
   exposeDebugUtils()
 }
 
@@ -90,8 +93,8 @@ export const STORE_DEFAULT_PARAMS = {
  * ## Creating a Store
  *
  * Use `createStore` (Effect-based) or `createStorePromise` to obtain a Store instance.
- * In React applications, use the `<LiveStoreProvider>` component which manages the Store lifecycle
- * and exposes it via React context.
+ * In React applications, use `StoreRegistry` with `<StoreRegistryProvider>` and the `useStore()` hook
+ * which manages the Store lifecycle.
  *
  * ## Querying Data
  *
@@ -136,7 +139,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
   readonly context: TContext
 
   /** Options provided to the Store constructor. */
-  readonly params: StoreOptions<TSchema, TContext>['params']
+  readonly params: StoreConstructorParams<TSchema, TContext>['params']
 
   /**
    * Reactive connectivity updates emitted by the backing sync backend.
@@ -157,12 +160,30 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
    */
   readonly networkStatus: ClientSession['leaderThread']['networkStatus']
 
+  /**
+   * Indicates how data is being stored.
+   *
+   * - `persisted`: Data is persisted to disk (e.g., via OPFS on web, SQLite file on native)
+   * - `in-memory`: Data is only stored in memory and will be lost on page refresh
+   *
+   * The store operates in `in-memory` mode when persistent storage is unavailable,
+   * such as in Safari/Firefox private browsing mode where OPFS is restricted.
+   *
+   * @example
+   * ```tsx
+   * if (store.storageMode === 'in-memory') {
+   *   showWarning('Data will not be persisted in private browsing mode')
+   * }
+   * ```
+   */
+  readonly storageMode: StorageMode
+
   /**
    * Store internals. Not part of the public API — shapes and semantics may change without notice.
    */
   readonly [StoreInternalsSymbol]: StoreInternals
 
-  // #region constructor
+  //#region constructor
   constructor({
     clientSession,
     schema,
@@ -174,7 +195,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
     params,
     confirmUnsavedChanges,
     __runningInDevtools,
-  }: StoreOptions<TSchema, TContext>) {
+  }: StoreConstructorParams<TSchema, TContext>) {
     super()
 
     this.storeId = storeId
@@ -182,15 +203,13 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
     this.context = context
     this.params = params
     this.networkStatus = clientSession.leaderThread.networkStatus
+    this.storageMode = clientSession.leaderThread.initialState.storageMode
 
     const reactivityGraph = makeReactivityGraph()
 
-    const syncSpan = otelOptions.tracer.startSpan('LiveStore:sync', {}, otelOptions.rootSpanContext)
-
     const syncProcessor = makeClientSessionSyncProcessor({
       schema,
       clientSession,
-      runtime: effectContext.runtime,
       materializeEvent: Effect.fn('client-session-sync-processor:materialize-event')(
         (eventEncoded, { withChangeset, materializerHashLeader }) =>
           // We need to use `Effect.gen` (even though we're using `Effect.fn`) so that we can pass `this` to the function
@@ -219,7 +238,8 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
               event: { decoded: undefined, encoded: eventEncoded },
             })
 
-            const materializerHash = isDevEnv() ? Option.some(hashMaterializerResults(execArgsArr)) : Option.none()
+            const materializerHash =
+              isDevEnv() === true ? Option.some(hashMaterializerResults(execArgsArr)) : Option.none()
 
             // Hash mismatch detection only occurs during the pull path (when receiving events from the leader).
             // During push path (local commits), materializerHashLeader is always Option.none(), so this condition
@@ -291,7 +311,6 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
         }
         reactivityGraph.setRefs(tablesToUpdate)
       },
-      span: syncSpan,
       params: {
         ...omitUndefineds({
           leaderPushBatchSize: params.leaderPushBatchSize,
@@ -301,7 +320,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
           : {}),
       },
       confirmUnsavedChanges,
-    })
+    }).pipe(Runtime.runSync(effectContext.runtime))
 
     // TODO generalize the `tableRefs` concept to allow finer-grained refs
     const tableRefs: { [key: string]: Ref<null, ReactivityGraphContext, RefreshReason> } = {}
@@ -332,7 +351,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
     const allTableNames = new Set(
       // NOTE we're excluding the LiveStore schema and events tables as they are not user-facing
       // unless LiveStore is running in the devtools
-      __runningInDevtools
+      __runningInDevtools === true
         ? this.schema.state.sqlite.tables.keys()
         : Array.from(this.schema.state.sqlite.tables.keys()).filter((_) => !SystemTables.isStateSystemTable(_)),
     )
@@ -346,7 +365,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
         existingTableRefs.get(tableName) ??
         reactivityGraph.makeRef(null, {
           equal: () => false,
-          label: `tableRef:${tableName}`,
+          label: `tableRef:${String(tableName)}`,
           meta: { liveStoreRefType: 'table' },
         })
     }
@@ -362,7 +381,6 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
           }
 
           // End the otel spans
-          syncSpan.end()
           commitsSpan.end()
           queriesSpan.end()
         }),
@@ -395,7 +413,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
     // Initialize stable network status property from client session
     this.networkStatus = clientSession.leaderThread.networkStatus
   }
-  // #endregion constructor
+  //#endregion constructor
 
   /**
    * Current session identifier for this Store instance.
@@ -418,7 +436,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
   }
 
   private checkShutdown = (operation: string): void => {
-    if (this[StoreInternalsSymbol].isShutdown) {
+    if (this[StoreInternalsSymbol].isShutdown === true) {
       throw new UnknownError({
         cause: `Store has been shut down (while performing "${operation}").`,
         note: `You cannot perform this operation after the store has been shut down.`,
@@ -465,19 +483,25 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
 
     return this[StoreInternalsSymbol].otel.tracer.startActiveSpan(
       `LiveStore.subscribe`,
-      { attributes: { label: options?.label, queryLabel: isQueryBuilder(query) ? query.toString() : query.label } },
+      {
+        attributes: {
+          label: options?.label,
+          queryLabel: isQueryBuilder(query) === true ? query.toString() : query.label,
+        },
+      },
       options?.otelContext ?? this[StoreInternalsSymbol].otel.queriesSpanContext,
       (span) => {
         const otelContext = otel.trace.setSpan(otel.context.active(), span)
 
-        const queryRcRef = isQueryBuilder(query)
-          ? queryDb(query).make(this[StoreInternalsSymbol].reactivityGraph.context!)
-          : query._tag === 'def' || query._tag === 'signal-def'
-            ? query.make(this[StoreInternalsSymbol].reactivityGraph.context!)
-            : {
-                value: query as LiveQuery<TResult>,
-                deref: () => {},
-              }
+        const queryRcRef =
+          isQueryBuilder(query) === true
+            ? queryDb(query).make(this[StoreInternalsSymbol].reactivityGraph.context!)
+            : query._tag === 'def' || query._tag === 'signal-def'
+              ? query.make(this[StoreInternalsSymbol].reactivityGraph.context!)
+              : {
+                  value: query,
+                  deref: () => {},
+                }
         const query$ = queryRcRef.value
 
         const label = `subscribe:${options?.label}`
@@ -485,7 +509,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
         const effect = this[StoreInternalsSymbol].reactivityGraph.makeEffect(
           (get, _otelContext, debugRefreshReason) => {
             const result = get(query$.results$, otelContext, debugRefreshReason)
-            if (suppressCallback) {
+            if (suppressCallback === true) {
               return
             }
             onUpdate(result)
@@ -499,7 +523,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
           })
         }
 
-        if (options?.stackInfo) {
+        if (options?.stackInfo !== undefined) {
           query$.activeSubscriptions.add(options.stackInfo)
         }
 
@@ -507,8 +531,8 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
 
         this[StoreInternalsSymbol].activeQueries.add(query$ as LiveQuery<TResult>)
 
-        if (!query$.isDestroyed) {
-          if (suppressCallback) {
+        if (query$.isDestroyed === false) {
+          if (suppressCallback === true) {
             // We still run once to register dependencies in the reactive graph, but suppress the initial callback so the
             // caller truly skips the first emission; subsequent runs (after commits) will call the callback.
             runInitialEffect()
@@ -523,7 +547,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
             this[StoreInternalsSymbol].reactivityGraph.destroyNode(effect)
             this[StoreInternalsSymbol].activeQueries.remove(query$ as LiveQuery<TResult>)
 
-            if (options?.stackInfo) {
+            if (options?.stackInfo !== undefined) {
               query$.activeSubscriptions.delete(options.stackInfo)
             }
 
@@ -555,12 +579,13 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
         const otelSpan = yield* OtelTracer.currentOtelSpan.pipe(
           Effect.catchTag('NoSuchElementException', () => Effect.succeed(undefined)),
         )
-        const otelContext = otelSpan ? otel.trace.setSpan(otel.context.active(), otelSpan) : otel.context.active()
+        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 ?? {}),
+              ...options,
               otelContext,
             }),
           ),
@@ -597,11 +622,11 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
           ...omitUndefineds({ otelContext: options?.otelContext }),
         },
       ) as any
-      if (query.schema) {
+      if (query.schema !== undefined) {
         return Schema.decodeSync(query.schema)(res)
       }
       return res
-    } else if (isQueryBuilder(query)) {
+    } else if (isQueryBuilder(query) === true) {
       const ast = query[QueryBuilderAstSymbol]
       if (ast._tag === 'RowQuery') {
         makeExecBeforeFirstRun({
@@ -616,7 +641,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
       const schema = getResultSchema(query)
 
       // Replace SessionIdSymbol in bind values before executing the query
-      if (sqlRes.bindValues) {
+      if (sqlRes.bindValues !== undefined) {
         replaceSessionIdSymbol(sqlRes.bindValues, this[StoreInternalsSymbol].clientSession.sessionId)
       }
 
@@ -634,8 +659,8 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
         return decodeResult.right
       } else {
         return shouldNeverHappen(
-          `Failed to decode query result with for schema:`,
-          schema.toString(),
+          'Failed to decode query result with for schema:',
+          objectToString(schema),
           'raw result:',
           rawRes,
           'decode error:',
@@ -689,7 +714,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
     }
   }
 
-  // #region commit
+  //#region commit
   /**
    * Commit a list of events to the store which will immediately update the local database
    * and sync the events across other clients (similar to a `git commit`).
@@ -777,23 +802,20 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
 
       const localRuntime = yield* Effect.runtime()
 
-      const materializeEventsTx = Effect.try({
-        try: () => {
-          const runMaterializeEvents = () => {
-            return this[StoreInternalsSymbol].syncProcessor.push(events).pipe(Runtime.runSync(localRuntime))
-          }
+      const encodedEvents = yield* this[StoreInternalsSymbol].syncProcessor.encodeEvents(events)
 
-          if (events.length > 1) {
-            return this[StoreInternalsSymbol].sqliteDbWrapper.txn(runMaterializeEvents)
-          } else {
-            return runMaterializeEvents()
-          }
+      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()
         },
         catch: (cause) => UnknownError.make({ cause }),
       })
 
-      // Materialize events to state
-      const { writeTables } = yield* materializeEventsTx
+      yield* this[StoreInternalsSymbol].syncProcessor.push(encodedEvents)
 
       const tablesToUpdate: [Ref<null, ReactivityGraphContext, RefreshReason>, null][] = []
       for (const tableName of writeTables) {
@@ -837,7 +859,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
       Runtime.runSync(this[StoreInternalsSymbol].effectContext.runtime),
     )
   }
-  // #endregion commit
+  //#endregion commit
 
   /**
    * Returns an async iterable of events from the eventlog.
@@ -918,6 +940,113 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
     )
   }
 
+  /**
+   * Returns the current synchronization status of the store.
+   *
+   * This is a synchronous operation that returns the sync state between the
+   * client session and the leader thread. Use this to display sync indicators
+   * or check if local changes have been pushed to the leader.
+   *
+   * @example
+   * ```ts
+   * const status = store.syncStatus()
+   * console.log(status.isSynced ? 'Synced' : `${status.pendingCount} pending`)
+   * ```
+   *
+   * @example
+   * ```ts
+   * // Health check for backend connectivity
+   * const status = store.syncStatus()
+   * if (!status.isSynced && status.pendingCount > 100) {
+   *   console.warn('Large backlog of unsynced events')
+   * }
+   * ```
+   */
+  syncStatus = (): SyncStatus => {
+    this.checkShutdown('syncStatus')
+
+    const syncState = this[StoreInternalsSymbol].syncProcessor.syncState.pipe(Effect.runSync)
+    const pendingCount = syncState.pending.length
+
+    return {
+      localHead: EventSequenceNumber.Client.toString(syncState.localHead),
+      upstreamHead: EventSequenceNumber.Client.toString(syncState.upstreamHead),
+      pendingCount,
+      isSynced: pendingCount === 0,
+    }
+  }
+
+  /**
+   * Returns an Effect Stream of sync status updates.
+   *
+   * Emits the current status immediately and then whenever the sync state changes.
+   * Use this for Effect-based workflows or when you need more control over the stream.
+   *
+   * @example
+   * ```ts
+   * store.syncStatusStream().pipe(
+   *   Stream.tap((status) => Effect.log(`Sync status: ${status.isSynced}`)),
+   *   Stream.runDrain,
+   * )
+   * ```
+   */
+  syncStatusStream = (): Stream.Stream<SyncStatus> => {
+    const syncStateSubscribable = this[StoreInternalsSymbol].syncProcessor.syncState
+
+    return Stream.concat(
+      Stream.fromEffect(syncStateSubscribable.pipe(Effect.map(this.makeSyncStatus))),
+      syncStateSubscribable.changes.pipe(Stream.map(this.makeSyncStatus)),
+    )
+  }
+
+  /**
+   * Subscribes to sync status changes.
+   *
+   * The callback is invoked immediately with the current status and then
+   * whenever the sync state changes (e.g., when events are pushed or confirmed).
+   *
+   * @param onUpdate - Callback invoked with the current sync status
+   * @returns Unsubscribe function to stop receiving updates
+   *
+   * @example
+   * ```ts
+   * const unsubscribe = store.subscribeSyncStatus((status) => {
+   *   updateUI(status.isSynced ? 'Synced' : 'Syncing...')
+   * })
+   *
+   * // Later, stop listening
+   * unsubscribe()
+   * ```
+   */
+  subscribeSyncStatus = (onUpdate: (status: SyncStatus) => void): Unsubscribe => {
+    this.checkShutdown('subscribeSyncStatus')
+
+    const fiber = this.syncStatusStream().pipe(
+      Stream.tap((status) => Effect.sync(() => onUpdate(status))),
+      Stream.runDrain,
+      this.runEffectFork,
+    )
+
+    return () => {
+      Fiber.interrupt(fiber).pipe(Runtime.runFork(this[StoreInternalsSymbol].effectContext.runtime))
+    }
+  }
+
+  private makeSyncStatus = (syncState: {
+    localHead: EventSequenceNumber.Client.Composite
+    upstreamHead: EventSequenceNumber.Client.Composite
+    pending: readonly any[]
+  }): SyncStatus => {
+    const pendingCount = syncState.pending.length
+
+    return {
+      localHead: EventSequenceNumber.Client.toString(syncState.localHead),
+      upstreamHead: EventSequenceNumber.Client.toString(syncState.upstreamHead),
+      pendingCount,
+      isSynced: pendingCount === 0,
+    }
+  }
+
   /**
    * This can be used in combination with `skipRefresh` when committing events.
    * We might need a better solution for this. Let's see.
@@ -947,7 +1076,11 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
     this.checkShutdown('shutdownPromise')
 
     this[StoreInternalsSymbol].isShutdown = true
-    await this.shutdown(cause ? Cause.fail(cause) : undefined).pipe(this.runEffectFork, Fiber.join, Effect.runPromise)
+    await this.shutdown(cause !== undefined ? Cause.fail(cause) : undefined).pipe(
+      this.runEffectFork,
+      Fiber.join,
+      Effect.runPromise,
+    )
   }
 
   /**
@@ -958,7 +1091,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
   shutdown = (cause?: Cause.Cause<UnknownError | MaterializeError>): Effect.Effect<void> => {
     this[StoreInternalsSymbol].isShutdown = true
     return this[StoreInternalsSymbol].clientSession.shutdown(
-      cause ? Exit.failCause(cause) : Exit.succeed(IntentionalShutdownCause.make({ reason: 'manual' })),
+      cause !== undefined ? Exit.failCause(cause) : Exit.succeed(IntentionalShutdownCause.make({ reason: 'manual' })),
     )
   }
 
@@ -1008,7 +1141,8 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
         .pipe(this.runEffectFork)
     },
 
-    syncStates: () =>
+    // 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* () {
         const session = yield* this[StoreInternalsSymbol].syncProcessor.syncState
         const leader = yield* this[StoreInternalsSymbol].clientSession.leaderThread.syncState
@@ -1019,11 +1153,14 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
       Effect.gen(this, function* () {
         const session = yield* this[StoreInternalsSymbol].syncProcessor.syncState
         yield* Effect.log(
-          `Session sync state: ${session.localHead} (upstream: ${session.upstreamHead})`,
+          `Session sync state: ${objectToString(session.localHead)} (upstream: ${objectToString(session.upstreamHead)})`,
           session.toJSON(),
         )
         const leader = yield* this[StoreInternalsSymbol].clientSession.leaderThread.syncState
-        yield* Effect.log(`Leader sync state: ${leader.localHead} (upstream: ${leader.upstreamHead})`, leader.toJSON())
+        yield* Effect.log(
+          `Leader sync state: ${objectToString(leader.localHead)} (upstream: ${objectToString(leader.upstreamHead)})`,
+          leader.toJSON(),
+        )
       }).pipe(this.runEffectFork)
     },
 

package/src/utils/dev.ts

@@ -33,8 +33,8 @@ export const downloadURL = (data: string, fileName: string) => {
 export const exposeDebugUtils = () => {
   globalThis.__debugLiveStoreUtils = {
     downloadBlob,
-    runSync: (effect: Effect.Effect<any, any, never>) => Effect.runSync(effect),
-    runFork: (effect: Effect.Effect<any, any, never>) => Effect.runFork(effect),
+    runSync: <A, E>(effect: Effect.Effect<A, E>) => Effect.runSync(effect),
+    runFork: <A, E>(effect: Effect.Effect<A, E>) => 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) {

package/src/utils/stack-info.ts

@@ -41,12 +41,12 @@ 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') || name.startsWith('Module.use')) && 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.')
 
       frames.unshift({ name: name.replace(/^Module\./, ''), filePath })
-    } else if (hasReachedStart) {
+    } else if (hasReachedStart === true) {
       // We've reached the end of the `use*` functions, so we're adding the component name and stop
       // Unless it's `react-stack-bottom-frame`, which we skip
       if (name !== 'Object.react-stack-bottom-frame') {

package/src/utils/tests/fixture.ts

@@ -1,9 +1,10 @@
+import type * as otel from '@opentelemetry/api'
+
 import { makeInMemoryAdapter } from '@livestore/adapter-web'
 import { provideOtel } from '@livestore/common'
 import { createStore, Events, makeSchema, State } from '@livestore/livestore'
 import { omitUndefineds } from '@livestore/utils'
 import { Effect, Schema } from '@livestore/utils/effect'
-import type * as otel from '@opentelemetry/api'
 
 export type Todo = {
   id: string

package/src/utils/tests/otel.ts

@@ -1,8 +1,9 @@
-import { omitUndefineds } from '@livestore/utils'
-import { identity } from '@livestore/utils/effect'
 import type { Attributes } from '@opentelemetry/api'
 import type { InMemorySpanExporter, ReadableSpan } from '@opentelemetry/sdk-trace-base'
 
+import { omitUndefineds } from '@livestore/utils'
+import { identity } from '@livestore/utils/effect'
+
 type SimplifiedNestedSpan = { _name: string; attributes: any; children: SimplifiedNestedSpan[] }
 
 type NestedSpan = { span: ReadableSpan; children: NestedSpan[] }
@@ -19,8 +20,8 @@ const buildSimplifiedRootSpans = (
 
   spansMap.forEach((nestedSpan) => {
     const parentId = nestedSpan.span.parentSpanContext?.spanId
-    const parentSpan = parentId ? spansMap.get(parentId) : undefined
-    if (parentSpan) {
+    const parentSpan = parentId !== undefined ? spansMap.get(parentId) : undefined
+    if (parentSpan !== undefined) {
       parentSpan.children.push(nestedSpan)
     }
   })
@@ -55,7 +56,7 @@ export const getSimplifiedRootSpan = (
 ): SimplifiedNestedSpan => {
   const results = buildSimplifiedRootSpans(exporter, rootSpanName, mapAttributes)
   const firstResult = results[0]
-  if (!firstResult) throw new Error(`Could not find the root span named '${rootSpanName}'.`)
+  if (firstResult == null) throw new Error(`Could not find the root span named '${rootSpanName}'.`)
   return firstResult
 }
 
@@ -77,7 +78,7 @@ const omitEmpty = (obj: any) => {
   for (const key in obj) {
     if (
       obj[key] !== undefined &&
-      !(Array.isArray(obj[key]) && obj[key].length === 0) &&
+      !(Array.isArray(obj[key]) === true && obj[key].length === 0) &&
       Object.keys(obj[key]).length > 0
     ) {
       result[key] = obj[key]
@@ -119,7 +120,7 @@ export const toTraceFile = (spans: ReadableSpan[]) => {
                   typeof value === 'string'
                     ? { stringValue: value }
                     : typeof value === 'number'
-                      ? Number.isInteger(value)
+                      ? Number.isInteger(value) === true
                         ? { intValue: value }
                         : { doubleValue: value }
                       : typeof value === 'boolean'

package/docs/api/index.md

@@ -1,3 +0,0 @@
-# API reference
-
-The API reference is autogenerated from the source code.

package/docs/building-with-livestore/complex-ui-state/index.md

@@ -1,5 +0,0 @@
-# Complex UI state
-
-LiveStore is a great fit for building apps with complex UI state.
-
-TODO: actually write this section

package/docs/building-with-livestore/crud/index.md

@@ -1,5 +0,0 @@
-# CRUD
-
-## CRUD
-
-TBD

package/docs/building-with-livestore/data-modeling/index.md

@@ -1 +0,0 @@
-# Data modeling

package/docs/building-with-livestore/debugging/index.md

@@ -1,17 +0,0 @@
-# Debugging a LiveStore app
-
-When working on a LiveStore app you might end up in situations where you need to debug things. LiveStore is built with debuggability in mind and tries to make your life as a developer as easy as possible.
-
-Here are a few things that LiveStore offers to help you debug your app:
-
-- [OpenTelemetry](/building-with-livestore/opentelemetry) integration for tracing / metrics
-- [Devtools](/building-with-livestore/devtools) for inspecting the state of the store
-- Store helper methods
-
-## Debugging helpers on the store
-
-The `store` exposes a `_dev` property which contains a few helpers that can help you debug your app.
-
-## Other recommended practices and tools
-
-- Use the step debugger