@livestore/common 0.4.0 → 0.5.0-dev.0

package/src/leader-thread/RejectedPushError.ts

@@ -1,7 +1,7 @@
 /**
  * Push validation errors returned by {@link LeaderSyncProcessor.push}.
  *
- * All three errors share a common {@link RejectedPushErrorTypeId} so consumers can catch the
+ * All errors share a common {@link RejectedPushErrorTypeId} so consumers can catch the
  * family as a group via {@link isRejectedPushError} instead of matching individual tags.
  * Recovery is the same in every case: the client should rebase and retry.
  *
@@ -23,19 +23,16 @@ export const RejectedPushErrorTypeId = '~@livestore/common/RejectedPushError' as
  */
 export class NonMonotonicBatchError extends Schema.TaggedError<NonMonotonicBatchError>(
   `${RejectedPushErrorTypeId}/NonMonotonicBatchError`,
-)(
-  'NonMonotonicBatchError',
-  {
-    /** The sequence number that broke the monotonic invariant (i.e. the one that is >= the next). */
-    precedingSeqNum: EventSequenceNumber.Client.Composite,
-    /** The sequence number that was expected to be greater than `precedingSeqNum`. */
-    violatingSeqNum: EventSequenceNumber.Client.Composite,
-    /** The index in the batch where the violation occurred. */
-    violationIndex: Schema.Number,
-    /** The session that produced the malformed batch. */
-    sessionId: Schema.String,
-  },
-) {
+)('NonMonotonicBatchError', {
+  /** The sequence number that broke the monotonic invariant (i.e. the one that is >= the next). */
+  precedingSeqNum: EventSequenceNumber.Client.Composite,
+  /** The sequence number that was expected to be greater than `precedingSeqNum`. */
+  violatingSeqNum: EventSequenceNumber.Client.Composite,
+  /** The index in the batch where the violation occurred. */
+  violationIndex: Schema.Finite,
+  /** The session that produced the malformed batch. */
+  sessionId: Schema.String,
+}) {
   readonly [RejectedPushErrorTypeId] = RejectedPushErrorTypeId
 
   override get message(): string {
@@ -43,6 +40,24 @@ export class NonMonotonicBatchError extends Schema.TaggedError<NonMonotonicBatch
   }
 }
 
+/** A pushed batch skips an event required to connect it to the leader's admitted push prefix. */
+export class NonContiguousBatchError extends Schema.TaggedError<NonContiguousBatchError>(
+  `${RejectedPushErrorTypeId}/NonContiguousBatchError`,
+)('NonContiguousBatchError', {
+  expectedSeqNum: EventSequenceNumber.Client.Composite,
+  providedSeqNum: EventSequenceNumber.Client.Composite,
+  expectedParentSeqNum: EventSequenceNumber.Client.Composite,
+  providedParentSeqNum: EventSequenceNumber.Client.Composite,
+  violationIndex: Schema.Finite,
+  sessionId: Schema.String,
+}) {
+  readonly [RejectedPushErrorTypeId] = RejectedPushErrorTypeId
+
+  override get message(): string {
+    return `Pushed events are not contiguous at index ${this.violationIndex} (session ${this.sessionId}): expected ${EventSequenceNumber.Client.toString(this.expectedSeqNum)} after ${EventSequenceNumber.Client.toString(this.expectedParentSeqNum)}, got ${EventSequenceNumber.Client.toString(this.providedSeqNum)} after ${EventSequenceNumber.Client.toString(this.providedParentSeqNum)}`
+  }
+}
+
 /**
  * A pushed batch of events failed validation because its rebase generation is older than the leader's current rebase generation.
  *
@@ -52,17 +67,14 @@ export class NonMonotonicBatchError extends Schema.TaggedError<NonMonotonicBatch
  */
 export class StaleRebaseGenerationError extends Schema.TaggedError<StaleRebaseGenerationError>(
   `${RejectedPushErrorTypeId}/StaleRebaseGenerationError`,
-)(
-  'StaleRebaseGenerationError',
-  {
-    /** The leader's current rebase generation. */
-    currentRebaseGeneration: Schema.Number,
-    /** The rebase generation carried by the dropped events. */
-    providedRebaseGeneration: Schema.Number,
-    /** The session that produced the stale batch. */
-    sessionId: Schema.String,
-  },
-) {
+)('StaleRebaseGenerationError', {
+  /** The leader's current rebase generation. */
+  currentRebaseGeneration: Schema.Finite,
+  /** The rebase generation carried by the dropped events. */
+  providedRebaseGeneration: Schema.Finite,
+  /** The session that produced the stale batch. */
+  sessionId: Schema.String,
+}) {
   readonly [RejectedPushErrorTypeId] = RejectedPushErrorTypeId
 
   override get message(): string {
@@ -94,11 +106,12 @@ export class LeaderAheadError extends Schema.TaggedError<LeaderAheadError>(
   }
 }
 
-export const RejectedPushError = Schema.Union(
+export const RejectedPushError = Schema.Union([
   LeaderAheadError,
+  NonContiguousBatchError,
   NonMonotonicBatchError,
   StaleRebaseGenerationError,
-)
+])
 
 export type RejectedPushError = typeof RejectedPushError.Type
 

package/src/leader-thread/connection.ts

@@ -83,14 +83,18 @@ export const execSql = (sqliteDb: SqliteDb, sql: string, bind: BindValues) => {
   )
 }
 
-// const selectSqlPrepared = <T>(stmt: PreparedStatement, bind: BindValues) => {
-//   const bindValues = prepareBindValues(bind, stmt.sql)
-//   return Effect.try({
-//     try: () => stmt.select<T>(bindValues),
-//     catch: (cause) =>
-//       new SqliteError({ cause, query: { bindValues, sql: stmt.sql }, code: (cause as WaSqlite.SQLiteError).code }),
-//   })
-// }
+export const selectSql = <T>(sqliteDb: SqliteDb, sql: string, bind: BindValues) => {
+  const bindValues = prepareBindValues(bind, sql)
+  return Effect.try({
+    try: () => sqliteDb.select<T>(sql, bindValues),
+    catch: (cause) =>
+      new SqliteError({ cause, query: { bindValues, sql }, code: (cause as WaSqlite.SQLiteError).code }),
+  }).pipe(
+    Effect.withSpan(`@livestore/common:selectSql`, {
+      attributes: { 'span.label': sql, sql, bindValueKeys: Object.keys(bindValues) },
+    }),
+  )
+}
 
 // TODO actually use prepared statements
 export const execSqlPrepared = (sqliteDb: SqliteDb, sql: string, bindValues: PreparedBindValues) => {

package/src/leader-thread/eventlog.ts

@@ -1,5 +1,5 @@
 import { LS_DEV, shouldNeverHappen } from '@livestore/utils'
-import { Chunk, Effect, Option, Schema } from '@livestore/utils/effect'
+import { Effect, Option, Schema } from '@livestore/utils/effect'
 
 import type { SqliteDb } from '../adapter-types.ts'
 import { migrateTable } from '../schema-management/migrations.ts'
@@ -107,7 +107,7 @@ export const getEventsFromEventlog = ({
 }: {
   dbEventlog: SqliteDb
   options: StreamEventsOptions
-}): Effect.Effect<Chunk.Chunk<LiveStoreEvent.Client.Encoded>> =>
+}): Effect.Effect<ReadonlyArray<LiveStoreEvent.Client.Encoded>> =>
   Effect.gen(function* () {
     const since = options.since ?? EventSequenceNumber.Client.ROOT
     const batchSize = options.batchSize ?? STREAM_EVENTS_BATCH_SIZE_DEFAULT
@@ -146,7 +146,7 @@ export const getEventsFromEventlog = ({
     const eventlogEvents = yield* Effect.sync(() => dbEventlog.select(makeQuery()))
 
     if (eventlogEvents.length === 0) {
-      return Chunk.empty<LiveStoreEvent.Client.Encoded>()
+      return []
     }
 
     const spanAttributes = {
@@ -174,7 +174,7 @@ export const getEventsFromEventlog = ({
         })
       })
 
-      return Chunk.fromIterable(encodedEvents)
+      return encodedEvents
     }).pipe(Effect.withSpan('@livestore/common:eventlog:getEventsFromEventlog', { attributes: spanAttributes }))
   })
 
@@ -201,7 +201,7 @@ export const updateBackendHead = (dbEventlog: SqliteDb, head: EventSequenceNumbe
   dbEventlog.execute(sql`UPDATE ${SYNC_STATUS_TABLE} SET head = ${head.global}`)
 
 export const getBackendIdFromDb = (dbEventlog: SqliteDb): Option.Option<string> =>
-  Option.fromNullable(
+  Option.fromNullishOr(
     dbEventlog.select<{ backendId: string | null }>(sql`select backendId from ${SYNC_STATUS_TABLE}`)[0]?.backendId,
   )
 
@@ -284,14 +284,14 @@ export const getSyncBackendCursorInfo = ({ remoteHead }: { remoteHead: EventSequ
     if (remoteHead === EventSequenceNumber.Client.ROOT.global) return Option.none()
 
     const EventlogQuerySchema = Schema.Struct({
-      syncMetadataJson: Schema.parseJson(Schema.Option(Schema.JsonValue)),
+      syncMetadataJson: Schema.fromJsonString(Schema.toCodecJson(Schema.Option(Schema.Json))),
     }).pipe(Schema.pluck('syncMetadataJson'), Schema.Array, Schema.head)
 
     const syncMetadataOption = yield* Effect.sync(() =>
       dbEventlog.select<{ syncMetadataJson: string }>(
         sql`SELECT syncMetadataJson FROM ${EVENTLOG_META_TABLE} WHERE seqNumGlobal = ${remoteHead} ORDER BY seqNumClient ASC LIMIT 1`,
       ),
-    ).pipe(Effect.andThen(Schema.decode(EventlogQuerySchema)), Effect.map(Option.flatten), Effect.orDie)
+    ).pipe(Effect.andThen(Schema.decodeEffect(EventlogQuerySchema)), Effect.map(Option.flatten), Effect.orDie)
 
     return Option.some({
       eventSequenceNumber: remoteHead,

package/src/leader-thread/leader-worker-devtools.ts

@@ -1,4 +1,4 @@
-import { Effect, FiberMap, Option, Stream, SubscriptionRef } from '@livestore/utils/effect'
+import { Cause, Effect, FiberMap, Option, Stream, SubscriptionRef } from '@livestore/utils/effect'
 import { nanoid } from '@livestore/utils/nanoid'
 
 import {
@@ -18,7 +18,8 @@ type SendMessageToDevtools = (message: Devtools.Leader.MessageFromApp) => Effect
 
 /**
  * Type guard for DevtoolsViteNotInstalledError.
- * This error is defined in @livestore/adapter-node but we need to handle it here.
+ * Adapter-specific devtools boot implementations may surface this tagged error;
+ * common handles it structurally to keep devtools startup environment-agnostic.
  */
 const isDevtoolsViteNotInstalledError = (
   error: unknown,
@@ -47,7 +48,7 @@ export const bootDevtools = Effect.fn('@livestore/common:leader-thread:devtools:
         Effect.as(Option.none()),
       ),
     ),
-    Effect.catchAllCause((cause) =>
+    Effect.catchCause((cause) =>
       Effect.logWarning(
         `[@livestore/devtools] Failed to start devtools server. Devtools will be disabled.`,
         cause,
@@ -80,7 +81,7 @@ export const bootDevtools = Effect.fn('@livestore/common:leader-thread:devtools:
             .pipe(
               Effect.withSpan('@livestore/common:leader-thread:devtools:sendToDevtools'),
               Effect.interruptible,
-              Effect.ignoreLogged,
+              Effect.ignore,
             )
 
         const syncState = yield* syncProcessor.syncState
@@ -92,7 +93,7 @@ export const bootDevtools = Effect.fn('@livestore/common:leader-thread:devtools:
         )
 
         yield* listenToDevtools({
-          incomingMessages: channel.listen.pipe(Stream.flatten(), Stream.orDie),
+          incomingMessages: channel.listen.pipe(Stream.mapEffect(Effect.fromResult), Stream.orDie),
           sendMessage,
           persistenceInfo,
         })
@@ -181,7 +182,9 @@ const listenToDevtools = ({
                     appVersion: liveStoreVersion,
                     receivedVersion: decodedEvent.liveStoreVersion,
                     appDevtoolsProtocolVersion: devtoolsProtocolVersion,
-                    receivedDevtoolsProtocolVersion: resolveDevtoolsProtocolVersion(decodedEvent.devtoolsProtocolVersion),
+                    receivedDevtoolsProtocolVersion: resolveDevtoolsProtocolVersion(
+                      decodedEvent.devtoolsProtocolVersion,
+                    ),
                   }),
                 )
                 return
@@ -204,10 +207,13 @@ const listenToDevtools = ({
                   Effect.sync(() => db.close()),
                 ).pipe(
                   Effect.flatMap((db) =>
-                    Effect.try(() => {
-                      db.import(data)
-                      const rows = db.select<{ name: string }>(`select name from sqlite_master where type = 'table'`)
-                      return new Set(rows.map((r) => r.name))
+                    Effect.try({
+                      try: () => {
+                        db.import(data)
+                        const rows = db.select<{ name: string }>(`select name from sqlite_master where type = 'table'`)
+                        return new Set(rows.map((r) => r.name))
+                      },
+                      catch: (cause) => new Cause.UnknownError(cause),
                     }),
                   ),
                 )
@@ -217,10 +223,16 @@ const listenToDevtools = ({
                 if (tableNames.has(SystemTables.EVENTLOG_META_TABLE) === true) {
                   databaseKind = 'eventlog'
                   yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
-                  yield* Effect.try(() => dbEventlog.import(data))
+                  yield* Effect.try({
+                    try: () => dbEventlog.import(data),
+                    catch: (cause) => new Cause.UnknownError(cause),
+                  })
 
                   if (batchId === undefined) {
-                    yield* Effect.try(() => dbState.destroy())
+                    yield* Effect.try({
+                      try: () => dbState.destroy(),
+                      catch: (cause) => new Cause.UnknownError(cause),
+                    })
                   }
                 } else if (
                   tableNames.has(SystemTables.SCHEMA_META_TABLE) === true &&
@@ -228,10 +240,16 @@ const listenToDevtools = ({
                 ) {
                   databaseKind = 'state'
                   yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
-                  yield* Effect.try(() => dbState.import(data))
+                  yield* Effect.try({
+                    try: () => dbState.import(data),
+                    catch: (cause) => new Cause.UnknownError(cause),
+                  })
 
                   if (batchId === undefined) {
-                    yield* Effect.try(() => dbEventlog.destroy())
+                    yield* Effect.try({
+                      try: () => dbEventlog.destroy(),
+                      catch: (cause) => new Cause.UnknownError(cause),
+                    })
                   }
                 } else {
                   return yield* Effect.fail({ _tag: 'unsupported-database' } as const)
@@ -261,9 +279,9 @@ const listenToDevtools = ({
                     }),
                   ),
                 ),
-                Effect.catchAll((cause) =>
+                Effect.catch((cause) =>
                   Effect.logWarning('Error importing database file', cause).pipe(
-                    Effect.zipRight(
+                    Effect.andThen(
                       sendMessage(
                         Devtools.Leader.LoadDatabaseFile.Error.make({
                           ...reqPayload,
@@ -339,7 +357,7 @@ const listenToDevtools = ({
                 // TODO consider piggybacking on the existing leader-thread sync-pulling
                 yield* syncBackend.pull(Option.none(), { live: true }).pipe(
                   Stream.map((_) => _.batch),
-                  Stream.flattenIterables,
+                  Stream.flattenIterable,
                   Stream.tap(({ eventEncoded, metadata }) =>
                     sendMessage(
                       Devtools.Leader.SyncHistoryRes.make({
@@ -388,9 +406,9 @@ const listenToDevtools = ({
                 yield* Effect.sleep(1000)
 
                 yield* Stream.zipLatest(
-                  syncBackend.isConnected.changes,
+                  SubscriptionRef.changes(syncBackend.isConnected),
                   devtools.enabled === true
-                    ? devtools.syncBackendLatchState.changes
+                    ? SubscriptionRef.changes(devtools.syncBackendLatchState)
                     : Stream.make({ latchClosed: false }),
                 ).pipe(
                   Stream.tap(([isConnected, { latchClosed }]) =>

package/src/leader-thread/make-leader-thread-layer.test.ts

@@ -1,5 +1,5 @@
 import { Vitest } from '@livestore/utils-dev/node-vitest'
-import { Effect, Stream, SubscriptionRef } from '@livestore/utils/effect'
+import { Effect, Fiber, Latch, Stream, SubscriptionRef } from '@livestore/utils/effect'
 
 import { makeMockSyncBackend } from '../sync/mock-sync-backend.ts'
 import type { SyncBackend } from '../sync/sync.ts'
@@ -7,7 +7,7 @@ import { makeNetworkStatusSubscribable } from './make-leader-thread-layer.ts'
 import type { DevtoolsContext } from './types.ts'
 
 Vitest.describe('makeNetworkStatusSubscribable', () => {
-  Vitest.scopedLive('tracks sync backend connectivity and devtools latch state', () =>
+  Vitest.live('tracks sync backend connectivity and devtools latch state', () =>
     Effect.gen(function* () {
       const mockBackend = yield* makeMockSyncBackend({ startConnected: false })
       const syncBackend = yield* mockBackend.makeSyncBackend
@@ -15,7 +15,7 @@ Vitest.describe('makeNetworkStatusSubscribable', () => {
 
       const devtoolsContext: DevtoolsContext = {
         enabled: true,
-        syncBackendLatch: yield* Effect.makeLatch(true),
+        syncBackendLatch: yield* Latch.make(true),
         syncBackendLatchState: latchStateRef,
       }
 
@@ -26,17 +26,17 @@ Vitest.describe('makeNetworkStatusSubscribable', () => {
       Vitest.expect(initial.devtools.latchClosed).toBe(false)
 
       const waitFor = (predicate: (status: SyncBackend.NetworkStatus) => boolean) =>
-        networkStatus.changes.pipe(Stream.filter(predicate), Stream.runHead, Effect.flatten)
+        networkStatus.changes.pipe(Stream.filter(predicate), Stream.runFirstUnsafe)
 
       const onlineFiber = yield* waitFor((status) => status.isConnected).pipe(Effect.forkScoped)
       yield* mockBackend.connect
-      const online = yield* onlineFiber
+      const online = yield* Fiber.join(onlineFiber)
       Vitest.expect(online.isConnected).toBe(true)
-      Vitest.expect(online.timestampMs).toBeGreaterThan(initial.timestampMs)
+      Vitest.expect(online.timestampMs).toBeGreaterThanOrEqual(initial.timestampMs)
 
       const latchedFiber = yield* waitFor((status) => status.devtools.latchClosed).pipe(Effect.forkScoped)
       yield* SubscriptionRef.set(latchStateRef, { latchClosed: true })
-      const latched = yield* latchedFiber
+      const latched = yield* Fiber.join(latchedFiber)
       Vitest.expect(latched.devtools.latchClosed).toBe(true)
       Vitest.expect(latched.timestampMs).toBeGreaterThanOrEqual(online.timestampMs)
     }),

package/src/leader-thread/make-leader-thread-layer.ts

@@ -1,12 +1,15 @@
 import { omitUndefineds, shouldNeverHappen } from '@livestore/utils'
-import type { HttpClient, Scope } from '@livestore/utils/effect'
 import {
+  type HttpClient,
+  type Scope,
   Deferred,
   Effect,
   KeyValueStore,
+  Latch,
   Layer,
-  PlatformError,
+  Option,
   Queue,
+  ReadonlyArray,
   Schema,
   Stream,
   Subscribable,
@@ -24,12 +27,13 @@ import type { MigrationsReport } from '../defs.ts'
 import type * as Devtools from '../devtools/mod.ts'
 import type { LiveStoreSchema } from '../schema/mod.ts'
 import { EventSequenceNumber, LiveStoreEvent, SystemTables } from '../schema/mod.ts'
+import type * as StateHead from '../StateHead.ts'
 import type { SyncBackend, SyncOptions } from '../sync/sync.ts'
 import { SyncState } from '../sync/syncstate.ts'
 import { sql } from '../util.ts'
 import * as Eventlog from './eventlog.ts'
-import { makeLeaderSyncProcessor } from './LeaderSyncProcessor.ts'
 import { bootDevtools } from './leader-worker-devtools.ts'
+import * as LeaderSyncProcessor from './LeaderSyncProcessor.ts'
 import { makeMaterializeEvent } from './materialize-event.ts'
 import { recreateDb } from './recreate-db.ts'
 import type { ShutdownChannel } from './shutdown-channel.ts'
@@ -45,8 +49,8 @@ import { LeaderThreadCtx } from './types.ts'
 
 export interface MakeLeaderThreadLayerParams {
   storeId: string
-  syncPayloadSchema: Schema.Schema<any> | undefined
-  syncPayloadEncoded: Schema.JsonValue | undefined
+  syncPayloadSchema: Schema.Decoder<Schema.Json> | undefined
+  syncPayloadEncoded: Schema.Json | undefined
   clientId: string
   schema: LiveStoreSchema
   makeSqliteDb: MakeSqliteDb
@@ -66,6 +70,9 @@ export interface MakeLeaderThreadLayerParams {
       delays?: {
         localPushProcessing?: Effect.Effect<void>
       }
+      hooks?: {
+        localPushAdmitted?: (events: ReadonlyArray<LiveStoreEvent.Client.EncodedWithMeta>) => Effect.Effect<void>
+      }
     }
   }
 }
@@ -74,7 +81,7 @@ export const makeLeaderThreadLayer = ({
   schema,
   storeId,
   clientId,
-  syncPayloadSchema = Schema.JsonValue,
+  syncPayloadSchema = Schema.Json,
   syncPayloadEncoded,
   makeSqliteDb,
   syncOptions,
@@ -85,12 +92,18 @@ export const makeLeaderThreadLayer = ({
   bootWarning,
   params,
   testing,
-}: MakeLeaderThreadLayerParams): Layer.Layer<LeaderThreadCtx, UnknownError, Scope.Scope | HttpClient.HttpClient> =>
+}: MakeLeaderThreadLayerParams): Layer.Layer<
+  LeaderThreadCtx,
+  UnknownError,
+  Scope.Scope | HttpClient.HttpClient | StateHead.StateHead
+> =>
   Effect.gen(function* () {
     const syncPayloadDecoded =
-      syncPayloadEncoded === undefined ? undefined : yield* Schema.decodeUnknown(syncPayloadSchema)(syncPayloadEncoded)
+      syncPayloadEncoded === undefined
+        ? undefined
+        : yield* Schema.decodeUnknownEffect(syncPayloadSchema)(syncPayloadEncoded)
 
-    const bootStatusQueue = yield* Queue.unbounded<BootStatus>().pipe(Effect.acquireRelease(Queue.shutdown))
+    const bootStatusQueue = yield* Effect.acquireRelease(Queue.unbounded<BootStatus>(), Queue.shutdown)
 
     // Emit boot warning if present (e.g., OPFS unavailable in private browsing)
     if (bootWarning !== undefined) {
@@ -114,29 +127,30 @@ export const makeLeaderThreadLayer = ({
                 KeyValueStore.makeStringOnly({
                   get: (_key) =>
                     Effect.sync(() => Eventlog.getBackendIdFromDb(dbEventlog)).pipe(
-                      Effect.catchAllDefect((cause) =>
-                        PlatformError.BadArgument.make({
-                          method: 'getBackendIdFromDb',
-                          description: 'Failed to get backendId',
-                          module: 'KeyValueStore',
-                          cause,
-                        }),
+                      Effect.map(Option.getOrUndefined),
+                      Effect.catchDefect(
+                        (cause) =>
+                          new KeyValueStore.KeyValueStoreError({
+                            method: 'getBackendIdFromDb',
+                            message: 'Failed to get backendId',
+                            cause,
+                          }),
                       ),
                     ),
                   set: (_key, value) =>
                     Effect.sync(() => Eventlog.updateBackendId(dbEventlog, value)).pipe(
-                      Effect.catchAllDefect((cause) =>
-                        PlatformError.BadArgument.make({
-                          method: 'updateBackendId',
-                          module: 'KeyValueStore',
-                          description: 'Failed to update backendId',
-                          cause,
-                        }),
+                      Effect.catchDefect(
+                        (cause) =>
+                          new KeyValueStore.KeyValueStoreError({
+                            method: 'updateBackendId',
+                            message: 'Failed to update backendId',
+                            cause,
+                          }),
                       ),
                     ),
-                  clear: Effect.dieMessage(`Not implemented. Should never be used.`),
-                  remove: () => Effect.dieMessage(`Not implemented. Should never be used.`),
-                  size: Effect.dieMessage(`Not implemented. Should never be used.`),
+                  clear: Effect.die(new Error(`Not implemented. Should never be used.`)),
+                  remove: () => Effect.die(new Error(`Not implemented. Should never be used.`)),
+                  size: Effect.die(new Error(`Not implemented. Should never be used.`)),
                 }),
               ),
             ),
@@ -161,7 +175,7 @@ export const makeLeaderThreadLayer = ({
         ? yield* recreateDb({ dbState, dbEventlog, schema, bootStatusQueue, materializeEvent })
         : { migrationsReport: { migrations: [] } }
 
-    const syncProcessor = yield* makeLeaderSyncProcessor({
+    const syncProcessor = yield* LeaderSyncProcessor.make({
       schema,
       dbState,
       initialSyncState: getInitialSyncState({ dbEventlog, dbState, dbEventlogMissing }),
@@ -176,19 +190,20 @@ export const makeLeaderThreadLayer = ({
         }),
       },
       testing: {
-        ...omitUndefineds({ delays: testing?.syncProcessor?.delays }),
+        ...omitUndefineds({ delays: testing?.syncProcessor?.delays, hooks: testing?.syncProcessor?.hooks }),
       },
     })
 
-    const extraIncomingMessagesQueue = yield* Queue.unbounded<Devtools.Leader.MessageToApp>().pipe(
-      Effect.acquireRelease(Queue.shutdown),
+    const extraIncomingMessagesQueue = yield* Effect.acquireRelease(
+      Queue.unbounded<Devtools.Leader.MessageToApp>(),
+      Queue.shutdown,
     )
 
     const devtoolsContext =
       devtoolsOptions.enabled === true
         ? {
             enabled: true as const,
-            syncBackendLatch: yield* Effect.makeLatch(true),
+            syncBackendLatch: yield* Latch.make(true),
             syncBackendLatchState: yield* SubscriptionRef.make<{ latchClosed: boolean }>({ latchClosed: false }),
           }
         : { enabled: false as const }
@@ -213,13 +228,13 @@ export const makeLeaderThreadLayer = ({
       devtools: devtoolsContext,
       networkStatus,
       // State will be set during `bootLeaderThread`
-      initialState: {} as any as LeaderThreadCtx['Type']['initialState'],
-    } satisfies typeof LeaderThreadCtx.Service
+      initialState: {} as any as LeaderThreadCtx['Service']['initialState'],
+    } satisfies LeaderThreadCtx['Service']
 
     // @ts-expect-error For debugging purposes
     globalThis.__leaderThreadCtx = ctx
 
-    const layer = Layer.succeed(LeaderThreadCtx, ctx)
+    const layer = Layer.succeed(LeaderThreadCtx, LeaderThreadCtx.of(ctx))
 
     ctx.initialState = yield* bootLeaderThread({
       migrationsReport,
@@ -233,29 +248,17 @@ export const makeLeaderThreadLayer = ({
     Effect.withSpanScoped('@livestore/common:leader-thread'),
     UnknownError.mapToUnknownError,
     Effect.tapCauseLogPretty,
-    Layer.unwrapScoped,
+    Layer.unwrap,
   )
 
 const hasEventlogTables = (db: SqliteDb) => {
   const tableNames = new Set(db.select<{ name: string }>(sql`select name from sqlite_master`).map((_) => _.name))
-  const eventlogTables = new Set(SystemTables.eventlogSystemTables.map((_) => _.sqliteDef.name))
-  return isSubsetOf(eventlogTables, tableNames)
+  return ReadonlyArray.every(SystemTables.eventlogSystemTables, (_) => tableNames.has(_.sqliteDef.name))
 }
 
 const hasStateTables = (db: SqliteDb) => {
   const tableNames = new Set(db.select<{ name: string }>(sql`select name from sqlite_master`).map((_) => _.name))
-  const stateTables = new Set(SystemTables.stateSystemTables.map((_) => _.sqliteDef.name))
-  return isSubsetOf(stateTables, tableNames)
-}
-
-const isSubsetOf = (a: Set<string>, b: Set<string>): boolean => {
-  for (const item of a) {
-    if (b.has(item) === false) {
-      return false
-    }
-  }
-
-  return true
+  return ReadonlyArray.every(SystemTables.stateSystemTables, (_) => tableNames.has(_.sqliteDef.name))
 }
 
 const getInitialSyncState = ({
@@ -361,7 +364,7 @@ const bootLeaderThread = ({
   initialBlockingSyncContext: InitialBlockingSyncContext
   devtoolsOptions: DevtoolsOptions
 }): Effect.Effect<
-  LeaderThreadCtx['Type']['initialState'],
+  LeaderThreadCtx['Service']['initialState'],
   UnknownError | MaterializerHashMismatchError,
   LeaderThreadCtx | Scope.Scope | HttpClient.HttpClient
 > =>
@@ -378,7 +381,7 @@ const bootLeaderThread = ({
         progress: { done: 0, total: -1 },
       })
 
-      yield* initialBlockingSyncContext.blockingDeferred.pipe(
+      yield* Deferred.await(initialBlockingSyncContext.blockingDeferred).pipe(
         Effect.withSpan('@livestore/common:leader-thread:initial-sync-blocking'),
       )
     }
@@ -421,7 +424,7 @@ export const makeNetworkStatusSubscribable = ({
       }))
 
     if (syncBackend !== undefined) {
-      yield* syncBackend.isConnected.changes.pipe(
+      yield* SubscriptionRef.changes(syncBackend.isConnected).pipe(
         Stream.tap((isConnected) => updateNetworkStatus({ isConnected })),
         Stream.runDrain,
         Effect.interruptible,
@@ -431,7 +434,7 @@ export const makeNetworkStatusSubscribable = ({
     }
 
     if (devtoolsContext.enabled === true) {
-      yield* devtoolsContext.syncBackendLatchState.changes.pipe(
+      yield* SubscriptionRef.changes(devtoolsContext.syncBackendLatchState).pipe(
         Stream.tap(({ latchClosed }) => updateNetworkStatus({ latchClosed })),
         Stream.runDrain,
         Effect.interruptible,