@livestore/common 0.2.0 → 0.3.0-dev.1

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

@@ -0,0 +1,358 @@
+import { Effect, FiberMap, Option, PubSub, Queue, Stream, SubscriptionRef } from '@livestore/utils/effect'
+
+import { Devtools, IntentionalShutdownCause, liveStoreVersion, UnexpectedError } from '../index.js'
+import { MUTATION_LOG_META_TABLE, SCHEMA_META_TABLE, SCHEMA_MUTATIONS_META_TABLE } from '../schema/mod.js'
+import type { ShutdownChannel } from './shutdown-channel.js'
+import type { DevtoolsOptions, PersistenceInfoPair } from './types.js'
+import { LeaderThreadCtx } from './types.js'
+
+type SendMessageToDevtools = (
+  message: Devtools.MessageFromAppLeader,
+  options?: {
+    /** Send message even if not connected (e.g. for initial broadcast messages) */
+    force: boolean
+  },
+) => Effect.Effect<void>
+
+// TODO bind scope to the webchannel lifetime
+export const bootDevtools = (options: DevtoolsOptions) =>
+  Effect.gen(function* () {
+    if (options.enabled === false) {
+      return
+    }
+
+    const { persistenceInfo, shutdownChannel, devtoolsWebChannel } = yield* options.makeContext
+
+    const isConnected = yield* SubscriptionRef.make(true)
+
+    const incomingMessagesPubSub = yield* PubSub.unbounded<Devtools.MessageToAppLeader>().pipe(
+      Effect.acquireRelease(PubSub.shutdown),
+    )
+
+    const incomingMessages = Stream.fromPubSub(incomingMessagesPubSub)
+
+    const outgoingMessagesQueue = yield* Queue.unbounded<Devtools.MessageFromAppLeader>().pipe(
+      Effect.acquireRelease(Queue.shutdown),
+    )
+
+    const devtoolsCoordinatorChannel = devtoolsWebChannel
+    // coordinatorMessagePortOrChannel instanceof MessagePort
+    //   ? yield* WebChannel.messagePortChannel({
+    //       port: coordinatorMessagePortOrChannel,
+    //       schema: { send: Devtools.MessageFromAppLeader, listen: Devtools.MessageToAppLeader },
+    //     })
+    //   : coordinatorMessagePortOrChannel
+
+    const sendMessage: SendMessageToDevtools = (message, options) =>
+      Effect.gen(function* () {
+        if (options?.force === true || (yield* isConnected)) {
+          yield* devtoolsCoordinatorChannel.send(message)
+        } else {
+          yield* Queue.offer(outgoingMessagesQueue, message)
+        }
+      }).pipe(
+        Effect.withSpan('@livestore/common:leader-thread:devtools:sendToDevtools'),
+        Effect.interruptible,
+        Effect.ignoreLogged,
+      )
+
+    // broadcastCallbacks.add((message) => sendMessage(message))
+
+    const { connectedClientSessionPullQueues, syncProcessor } = yield* LeaderThreadCtx
+    const { localHead } = yield* syncProcessor.syncState
+
+    // TODO close queue when devtools disconnects
+    const pullQueue = yield* connectedClientSessionPullQueues.makeQueue(localHead)
+
+    yield* Stream.fromQueue(pullQueue).pipe(
+      Stream.tap((msg) =>
+        Effect.gen(function* () {
+          if (msg.payload._tag === 'upstream-advance') {
+            for (const mutationEventEncoded of msg.payload.newEvents) {
+              yield* sendMessage(
+                Devtools.MutationBroadcast.make({
+                  mutationEventEncoded,
+
+                  liveStoreVersion,
+                }),
+              )
+            }
+          } else {
+            yield* Effect.logWarning('TODO implement rebases in devtools')
+          }
+        }),
+      ),
+      Stream.runDrain,
+      Effect.forkScoped,
+    )
+
+    yield* devtoolsCoordinatorChannel.listen.pipe(
+      Stream.flatten(),
+      // Stream.tapLogWithLabel('@livestore/common:leader-thread:devtools:onPortMessage'),
+      Stream.tap((msg) =>
+        Effect.gen(function* () {
+          // yield* Effect.logDebug(`[@livestore/common:leader-thread:devtools] message from port: ${msg._tag}`, msg)
+          // if (msg._tag === 'LSD.MessagePortForStoreRes') {
+          //   yield* Deferred.succeed(storeMessagePortDeferred, msg.port)
+          // } else {
+          yield* PubSub.publish(incomingMessagesPubSub, msg)
+          // }
+        }),
+      ),
+      Stream.runDrain,
+      Effect.withSpan(`@livestore/common:leader-thread:devtools:onPortMessage`),
+      Effect.ignoreLogged,
+      Effect.forkScoped,
+    )
+
+    // yield* sendMessage(Devtools.AppHostReady.make({ appHostId, liveStoreVersion, isLeader }), { force: true })
+
+    // yield* sendMessage(Devtools.MessagePortForStoreReq.make({ appHostId, liveStoreVersion, requestId: nanoid() }), {
+    //   force: true,
+    // })
+
+    yield* listenToDevtools({
+      incomingMessages,
+      sendMessage,
+      // isConnected,
+      // disconnect,
+      // storeId,
+      // appHostId,
+      // isLeader,
+      persistenceInfo,
+      shutdownChannel,
+    })
+  }).pipe(Effect.withSpan('@livestore/common:leader-thread:devtools:boot'))
+
+const listenToDevtools = ({
+  incomingMessages,
+  sendMessage,
+  // isConnected,
+  // disconnect,
+  // appHostId,
+  // storeId,
+  // isLeader,
+  persistenceInfo,
+  shutdownChannel,
+}: {
+  incomingMessages: Stream.Stream<Devtools.MessageToAppLeader>
+  sendMessage: SendMessageToDevtools
+  // isConnected: SubscriptionRef.SubscriptionRef<boolean>
+  // disconnect: Effect.Effect<void>
+  // appHostId: string
+  // storeId: string
+  // isLeader: boolean
+  persistenceInfo: PersistenceInfoPair
+  shutdownChannel: ShutdownChannel
+}) =>
+  Effect.gen(function* () {
+    const innerWorkerCtx = yield* LeaderThreadCtx
+    const { syncBackend, makeSyncDb, db, dbLog, shutdownStateSubRef, syncProcessor } = innerWorkerCtx
+
+    type RequestId = string
+    const subscriptionFiberMap = yield* FiberMap.make<RequestId>()
+
+    yield* incomingMessages.pipe(
+      Stream.tap((decodedEvent) =>
+        Effect.gen(function* () {
+          // yield* Effect.logDebug('[@livestore/common:leader-thread:devtools] incomingMessage', decodedEvent)
+
+          if (decodedEvent._tag === 'LSD.Disconnect') {
+            // yield* SubscriptionRef.set(isConnected, false)
+
+            // yield* disconnect
+
+            // TODO is there a better place for this?
+            // yield* sendMessage(Devtools.AppHostReady.make({ appHostId, liveStoreVersion, isLeader }), {
+            //   force: true,
+            // })
+
+            return
+          }
+
+          const { requestId } = decodedEvent
+          const reqPayload = { requestId, liveStoreVersion }
+
+          switch (decodedEvent._tag) {
+            case 'LSD.Ping': {
+              yield* sendMessage(Devtools.Pong.make({ ...reqPayload }))
+              return
+            }
+            case 'LSD.Leader.SnapshotReq': {
+              const snapshot = db.export()
+
+              yield* sendMessage(Devtools.SnapshotRes.make({ snapshot, ...reqPayload }))
+
+              return
+            }
+            case 'LSD.Leader.LoadDatabaseFileReq': {
+              const { data } = decodedEvent
+
+              let tableNames: Set<string>
+
+              try {
+                const tmpSyncDb = yield* makeSyncDb({ _tag: 'in-memory' })
+                tmpSyncDb.import(data)
+                const tableNameResults = tmpSyncDb.select<{ name: string }>(
+                  `select name from sqlite_master where type = 'table'`,
+                )
+
+                tableNames = new Set(tableNameResults.map((_) => _.name))
+
+                tmpSyncDb.close()
+              } catch (e) {
+                yield* Effect.logError(`Error importing database file`, e)
+                yield* sendMessage(Devtools.LoadDatabaseFileRes.make({ ...reqPayload, status: 'unsupported-file' }))
+
+                return
+              }
+
+              if (tableNames.has(MUTATION_LOG_META_TABLE)) {
+                yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
+
+                dbLog.import(data)
+
+                db.destroy()
+              } else if (tableNames.has(SCHEMA_META_TABLE) && tableNames.has(SCHEMA_MUTATIONS_META_TABLE)) {
+                yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
+
+                db.import(data)
+
+                dbLog.destroy()
+              } else {
+                yield* sendMessage(Devtools.LoadDatabaseFileRes.make({ ...reqPayload, status: 'unsupported-database' }))
+                return
+              }
+
+              yield* sendMessage(Devtools.LoadDatabaseFileRes.make({ ...reqPayload, status: 'ok' }))
+
+              yield* shutdownChannel.send(IntentionalShutdownCause.make({ reason: 'devtools-import' }))
+
+              return
+            }
+            case 'LSD.Leader.ResetAllDataReq': {
+              const { mode } = decodedEvent
+
+              yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
+
+              db.destroy()
+
+              if (mode === 'all-data') {
+                dbLog.destroy()
+              }
+
+              yield* sendMessage(Devtools.ResetAllDataRes.make({ ...reqPayload }))
+
+              yield* shutdownChannel.send(IntentionalShutdownCause.make({ reason: 'devtools-reset' }))
+
+              return
+            }
+            case 'LSD.Leader.DatabaseFileInfoReq': {
+              const dbSizeQuery = `SELECT page_count * page_size as size FROM pragma_page_count(), pragma_page_size();`
+              const dbFileSize = db.select<{ size: number }>(dbSizeQuery, undefined)[0]!.size
+              const mutationLogFileSize = dbLog.select<{ size: number }>(dbSizeQuery, undefined)[0]!.size
+
+              yield* sendMessage(
+                Devtools.DatabaseFileInfoRes.make({
+                  db: { fileSize: dbFileSize, persistenceInfo: persistenceInfo.db },
+                  mutationLog: { fileSize: mutationLogFileSize, persistenceInfo: persistenceInfo.mutationLog },
+                  ...reqPayload,
+                }),
+              )
+
+              return
+            }
+            case 'LSD.Leader.MutationLogReq': {
+              const mutationLog = dbLog.export()
+
+              yield* sendMessage(Devtools.MutationLogRes.make({ mutationLog, ...reqPayload }))
+
+              return
+            }
+            case 'LSD.Leader.RunMutationReq': {
+              yield* syncProcessor.pushPartial(decodedEvent.mutationEventEncoded)
+
+              yield* sendMessage(Devtools.RunMutationRes.make({ ...reqPayload }))
+
+              return
+            }
+            case 'LSD.Leader.SyncHistorySubscribe': {
+              const { requestId } = decodedEvent
+
+              if (syncBackend !== undefined) {
+                // TODO consider piggybacking on the existing leader-thread sync-pulling
+                yield* syncBackend.pull(Option.none()).pipe(
+                  Stream.map((_) => _.batch),
+                  Stream.flattenIterables,
+                  Stream.tap(({ mutationEventEncoded, metadata }) =>
+                    sendMessage(Devtools.SyncHistoryRes.make({ mutationEventEncoded, metadata, ...reqPayload })),
+                  ),
+                  Stream.runDrain,
+                  Effect.acquireRelease(() => Effect.log('syncHistorySubscribe done')),
+                  Effect.interruptible,
+                  Effect.tapCauseLogPretty,
+                  FiberMap.run(subscriptionFiberMap, requestId),
+                )
+              }
+
+              return
+            }
+            case 'LSD.Leader.SyncHistoryUnsubscribe': {
+              const { requestId } = decodedEvent
+              console.log('LSD.SyncHistoryUnsubscribe', requestId)
+
+              yield* FiberMap.remove(subscriptionFiberMap, requestId)
+
+              return
+            }
+            case 'LSD.Leader.SyncingInfoReq': {
+              const syncingInfo = Devtools.SyncingInfo.make({
+                enabled: syncBackend !== undefined,
+                metadata: {},
+              })
+
+              yield* sendMessage(Devtools.SyncingInfoRes.make({ syncingInfo, ...reqPayload }))
+
+              return
+            }
+            case 'LSD.Leader.NetworkStatusSubscribe': {
+              if (syncBackend !== undefined) {
+                const { requestId } = decodedEvent
+
+                // TODO investigate and fix bug. seems that when sending messages right after
+                // the devtools have connected get sometimes lost
+                // This is probably the same "flaky databrowser loading" bug as we're seeing in the playwright tests
+                yield* Effect.sleep(1000)
+
+                yield* syncBackend.isConnected.changes.pipe(
+                  Stream.tap((isConnected) =>
+                    sendMessage(
+                      Devtools.NetworkStatusRes.make({
+                        networkStatus: { isConnected, timestampMs: Date.now() },
+                        ...reqPayload,
+                      }),
+                    ),
+                  ),
+                  Stream.runDrain,
+                  Effect.interruptible,
+                  Effect.tapCauseLogPretty,
+                  FiberMap.run(subscriptionFiberMap, requestId),
+                )
+              }
+
+              return
+            }
+            case 'LSD.Leader.NetworkStatusUnsubscribe': {
+              const { requestId } = decodedEvent
+
+              yield* FiberMap.remove(subscriptionFiberMap, requestId)
+
+              return
+            }
+          }
+        }).pipe(Effect.withSpan(`@livestore/common:leader-thread:onDevtoolsMessage:${decodedEvent._tag}`)),
+      ),
+      UnexpectedError.mapToUnexpectedErrorStream,
+      Stream.runDrain,
+    )
+  })

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

@@ -0,0 +1,192 @@
+import type { HttpClient, Scope, WebChannel } from '@livestore/utils/effect'
+import { Deferred, Effect, FiberSet, Layer, Queue, SubscriptionRef } from '@livestore/utils/effect'
+
+import type { BootStatus, MakeSynchronousDatabase, SqliteError, SynchronousDatabase } from '../adapter-types.js'
+import { UnexpectedError } from '../adapter-types.js'
+import type { LiveStoreSchema } from '../schema/mod.js'
+import { EventId, MutationEvent, mutationLogMetaTable, SYNC_STATUS_TABLE, syncStatusTable } from '../schema/mod.js'
+import { migrateTable } from '../schema-management/migrations.js'
+import type { InvalidPullError, IsOfflineError, SyncBackend } from '../sync/sync.js'
+import { sql } from '../util.js'
+import { execSql } from './connection.js'
+import { makeLeaderSyncProcessor } from './leader-sync-processor.js'
+import { bootDevtools } from './leader-worker-devtools.js'
+import { makePullQueueSet } from './pull-queue-set.js'
+import { recreateDb } from './recreate-db.js'
+import type { DevtoolsOptions, InitialBlockingSyncContext, InitialSyncOptions, ShutdownState } from './types.js'
+import { LeaderThreadCtx } from './types.js'
+
+export const makeLeaderThreadLayer = ({
+  schema,
+  storeId,
+  originId,
+  makeSyncDb,
+  makeSyncBackend,
+  db,
+  dbLog,
+  devtoolsOptions,
+  initialSyncOptions = { _tag: 'Skip' },
+}: {
+  storeId: string
+  originId: string
+  schema: LiveStoreSchema
+  makeSyncDb: MakeSynchronousDatabase
+  makeSyncBackend: Effect.Effect<SyncBackend, UnexpectedError, Scope.Scope> | undefined
+  db: SynchronousDatabase
+  dbLog: SynchronousDatabase
+  devtoolsOptions: DevtoolsOptions
+  initialSyncOptions: InitialSyncOptions | undefined
+}): Layer.Layer<LeaderThreadCtx, UnexpectedError, Scope.Scope | HttpClient.HttpClient> =>
+  Effect.gen(function* () {
+    const bootStatusQueue = yield* Queue.unbounded<BootStatus>().pipe(Effect.acquireRelease(Queue.shutdown))
+
+    // TODO do more validation here than just checking the count of tables
+    // Either happens on initial boot or if schema changes
+    const dbMissing = db.select<{ count: number }>(sql`select count(*) as count from sqlite_master`)[0]!.count === 0
+
+    const syncBackend = makeSyncBackend === undefined ? undefined : yield* makeSyncBackend
+
+    const initialBlockingSyncContext = yield* makeInitialBlockingSyncContext({ initialSyncOptions, bootStatusQueue })
+
+    const syncProcessor = yield* makeLeaderSyncProcessor({ schema, dbMissing, dbLog, initialBlockingSyncContext })
+
+    const ctx = {
+      schema,
+      bootStatusQueue,
+      storeId,
+      originId,
+      db,
+      dbLog,
+      makeSyncDb,
+      mutationEventSchema: MutationEvent.makeMutationEventSchema(schema),
+      shutdownStateSubRef: yield* SubscriptionRef.make<ShutdownState>('running'),
+      syncBackend,
+      syncProcessor,
+      connectedClientSessionPullQueues: yield* makePullQueueSet,
+    } satisfies typeof LeaderThreadCtx.Service
+
+    // @ts-expect-error For debugging purposes
+    globalThis.__leaderThreadCtx = ctx
+
+    const layer = Layer.succeed(LeaderThreadCtx, ctx)
+
+    yield* bootLeaderThread({ dbMissing, initialBlockingSyncContext, devtoolsOptions }).pipe(Effect.provide(layer))
+
+    return layer
+  }).pipe(
+    Effect.withSpan('@livestore/common:leader-thread:boot'),
+    Effect.withSpanScoped('@livestore/common:leader-thread'),
+    UnexpectedError.mapToUnexpectedError,
+    Layer.unwrapScoped,
+  )
+
+const makeInitialBlockingSyncContext = ({
+  initialSyncOptions,
+  bootStatusQueue,
+}: {
+  initialSyncOptions: InitialSyncOptions
+  bootStatusQueue: Queue.Queue<BootStatus>
+}) =>
+  Effect.gen(function* () {
+    const ctx = {
+      isDone: false,
+      processedMutations: 0,
+      total: -1,
+    }
+
+    const blockingDeferred = initialSyncOptions._tag === 'Blocking' ? yield* Deferred.make<void>() : undefined
+
+    if (blockingDeferred !== undefined && initialSyncOptions._tag === 'Blocking') {
+      yield* Deferred.succeed(blockingDeferred, void 0).pipe(
+        Effect.delay(initialSyncOptions.timeout),
+        Effect.forkScoped,
+      )
+    }
+
+    return {
+      blockingDeferred,
+      update: ({ processed, remaining }) =>
+        Effect.gen(function* () {
+          if (ctx.isDone === true) return
+
+          if (ctx.total === -1) {
+            ctx.total = remaining + processed
+          }
+
+          ctx.processedMutations += processed
+          yield* Queue.offer(bootStatusQueue, {
+            stage: 'syncing',
+            progress: { done: ctx.processedMutations, total: ctx.total },
+          })
+
+          if (remaining === 0 && blockingDeferred !== undefined) {
+            yield* Deferred.succeed(blockingDeferred, void 0)
+            ctx.isDone = true
+          }
+        }),
+    } satisfies InitialBlockingSyncContext
+  })
+
+/**
+ * Blocks until the leader thread has finished its initial setup.
+ * It also starts various background processes (e.g. syncing)
+ */
+const bootLeaderThread = ({
+  dbMissing,
+  initialBlockingSyncContext,
+  devtoolsOptions,
+}: {
+  dbMissing: boolean
+  initialBlockingSyncContext: InitialBlockingSyncContext
+  devtoolsOptions: DevtoolsOptions
+}): Effect.Effect<
+  void,
+  UnexpectedError | SqliteError | IsOfflineError | InvalidPullError,
+  LeaderThreadCtx | Scope.Scope | HttpClient.HttpClient
+> =>
+  Effect.gen(function* () {
+    const { dbLog, bootStatusQueue, syncProcessor } = yield* LeaderThreadCtx
+
+    yield* migrateTable({
+      db: dbLog,
+      behaviour: 'create-if-not-exists',
+      tableAst: mutationLogMetaTable.sqliteDef.ast,
+      skipMetaTable: true,
+    })
+
+    yield* migrateTable({
+      db: dbLog,
+      behaviour: 'create-if-not-exists',
+      tableAst: syncStatusTable.sqliteDef.ast,
+      skipMetaTable: true,
+    })
+
+    // Create sync status row if it doesn't exist
+    yield* execSql(
+      dbLog,
+      sql`INSERT INTO ${SYNC_STATUS_TABLE} (head)
+          SELECT ${EventId.ROOT.global}
+          WHERE NOT EXISTS (SELECT 1 FROM ${SYNC_STATUS_TABLE})`,
+      {},
+    )
+
+    const dbReady = yield* Deferred.make<void>()
+
+    // We're already starting pulling from the sync backend concurrently but wait until the db is ready before
+    // processing any incoming mutations
+    yield* syncProcessor.boot({ dbReady })
+
+    if (dbMissing) {
+      yield* recreateDb
+    }
+
+    yield* Deferred.succeed(dbReady, void 0)
+
+    if (initialBlockingSyncContext.blockingDeferred !== undefined) {
+      yield* initialBlockingSyncContext.blockingDeferred
+    }
+
+    yield* Queue.offer(bootStatusQueue, { stage: 'done' })
+
+    yield* bootDevtools(devtoolsOptions).pipe(Effect.tapCauseLogPretty, Effect.forkScoped)
+  })

package/src/leader-thread/mod.ts

@@ -0,0 +1,6 @@
+export * from './connection.js'
+export * from './types.js'
+export * as ShutdownChannel from './shutdown-channel.js'
+export * from './leader-worker-devtools.js'
+export * from './make-leader-thread-layer.js'
+export * from './mutationlog.js'

package/src/leader-thread/mutationlog.ts

@@ -0,0 +1,42 @@
+import { Effect, Schema } from '@livestore/utils/effect'
+
+import type { SynchronousDatabase } from '../adapter-types.js'
+import * as EventId from '../schema/EventId.js'
+import { MUTATION_LOG_META_TABLE, mutationLogMetaTable, SYNC_STATUS_TABLE } from '../schema/system-tables.js'
+import { prepareBindValues, sql } from '../util.js'
+import { LeaderThreadCtx } from './types.js'
+
+export const getMutationEventsSince = (since: EventId.EventId) =>
+  Effect.gen(function* () {
+    const { dbLog } = yield* LeaderThreadCtx
+
+    const query = mutationLogMetaTable.query.where('idGlobal', '>=', since.global).asSql()
+    const pendingMutationEventsRaw = dbLog.select(query.query, prepareBindValues(query.bindValues, query.query))
+    const pendingMutationEvents = Schema.decodeUnknownSync(mutationLogMetaTable.schema.pipe(Schema.Array))(
+      pendingMutationEventsRaw,
+    )
+
+    return pendingMutationEvents
+      .map((_) => ({
+        mutation: _.mutation,
+        args: _.argsJson,
+        id: { global: _.idGlobal, local: _.idLocal },
+        parentId: { global: _.parentIdGlobal, local: _.parentIdLocal },
+      }))
+      .filter((_) => EventId.compare(_.id, since) > 0)
+  })
+
+export const getLocalHeadFromDb = (dbLog: SynchronousDatabase) => {
+  const res = dbLog.select<{ idGlobal: number; idLocal: number }>(
+    sql`select idGlobal, idLocal from ${MUTATION_LOG_META_TABLE} order by idGlobal DESC, idLocal DESC limit 1`,
+  )[0]
+
+  return res ? { global: res.idGlobal, local: res.idLocal } : EventId.ROOT
+}
+
+export const getBackendHeadFromDb = (dbLog: SynchronousDatabase) =>
+  dbLog.select<{ head: number }>(sql`select head from ${SYNC_STATUS_TABLE}`)[0]?.head ?? EventId.ROOT.global
+
+// TODO use prepared statements
+export const updateBackendHead = (dbLog: SynchronousDatabase, head: EventId.EventId) =>
+  dbLog.execute(sql`UPDATE ${SYNC_STATUS_TABLE} SET head = ${head.global}`)

package/src/leader-thread/pull-queue-set.ts

@@ -0,0 +1,58 @@
+import { Effect, Queue } from '@livestore/utils/effect'
+
+import * as MutationEvent from '../schema/MutationEvent.js'
+import { getMutationEventsSince } from './mutationlog.js'
+import { type PullQueueItem, type PullQueueSet } from './types.js'
+
+export const makePullQueueSet = Effect.gen(function* () {
+  const set = new Set<Queue.Queue<PullQueueItem>>()
+
+  yield* Effect.addFinalizer(() =>
+    Effect.gen(function* () {
+      for (const queue of set) {
+        yield* Queue.shutdown(queue)
+      }
+
+      set.clear()
+    }),
+  )
+
+  const makeQueue: PullQueueSet['makeQueue'] = (since) =>
+    Effect.gen(function* () {
+      const queue = yield* Queue.unbounded<PullQueueItem>().pipe(Effect.acquireRelease(Queue.shutdown))
+
+      yield* Effect.addFinalizer(() => Effect.sync(() => set.delete(queue)))
+
+      const mutationEvents = yield* getMutationEventsSince(since)
+
+      if (mutationEvents.length > 0) {
+        const newEvents = mutationEvents.map((mutationEvent) => new MutationEvent.EncodedWithMeta(mutationEvent))
+        yield* queue.offer({ payload: { _tag: 'upstream-advance', newEvents }, remaining: 0 })
+      }
+
+      set.add(queue)
+
+      return queue
+    })
+
+  const offer: PullQueueSet['offer'] = (item) =>
+    Effect.gen(function* () {
+      // Short-circuit if the payload is an empty upstream advance
+      if (
+        item.payload._tag === 'upstream-advance' &&
+        item.payload.newEvents.length === 0 &&
+        item.payload.trimRollbackUntil === undefined
+      ) {
+        return
+      }
+
+      for (const queue of set) {
+        yield* Queue.offer(queue, item)
+      }
+    })
+
+  return {
+    makeQueue,
+    offer,
+  }
+})