@livestore/sync-cf 0.4.0 → 0.5.0-dev.0

package/src/cf-worker/do/transport/http-rpc-server.ts

@@ -1,10 +1,10 @@
 import type { CfTypes } from '@livestore/common-cf'
-import { Effect, HttpApp, Layer, RpcSerialization, RpcServer } from '@livestore/utils/effect'
+import { Effect, HttpEffect, Layer, RpcSerialization, RpcServer } from '@livestore/utils/effect'
 
 import { SyncHttpRpc } from '../../../common/http-rpc-schema.ts'
 import * as SyncMessage from '../../../common/sync-message-types.ts'
 import { headersRecordToMap } from '../../shared.ts'
-import { DoCtx } from '../layer.ts'
+import * as DoCtx from '../layer.ts'
 import { makeEndingPullStream } from '../pull.ts'
 import { makePush } from '../push.ts'
 
@@ -18,8 +18,8 @@ export const createHttpRpcHandler = Effect.fn('createHttpRpcHandler')(function*
   forwardedHeaders?: Record<string, string>
 }) {
   const handlerLayer = createHttpRpcLayer(forwardedHeaders)
-  const httpApp = RpcServer.toHttpApp(SyncHttpRpc).pipe(Effect.provide(handlerLayer))
-  const webHandler = yield* httpApp.pipe(Effect.map(HttpApp.toWebHandler))
+  const httpEffect = yield* RpcServer.toHttpEffect(SyncHttpRpc).pipe(Effect.provide(handlerLayer))
+  const webHandler = HttpEffect.toWebHandler(httpEffect)
 
   const response = yield* Effect.promise(
     () => webHandler(request as TODO as Request) as TODO as Promise<CfTypes.Response>,
@@ -43,15 +43,12 @@ const createHttpRpcLayer = (forwardedHeaders: Record<string, string> | undefined
 
     'SyncHttpRpc.Push': (req) =>
       Effect.gen(function* () {
-        const { ctx, env, doOptions, storeId } = yield* DoCtx
-        const push = makePush({ payload: undefined, headers, options: doOptions, storeId, ctx, env })
+        const { ctx, env, doOptions, storeId } = yield* DoCtx.DoCtx
+        const push = makePush({ payload: req.payload, headers, options: doOptions, storeId, ctx, env })
 
         return yield* push(req)
       }),
 
     'SyncHttpRpc.Ping': () => Effect.succeed(SyncMessage.Pong.make({})),
-  }).pipe(
-    Layer.provideMerge(RpcServer.layerProtocolHttp({ path: '/http-rpc' })),
-    Layer.provideMerge(RpcSerialization.layerJson),
-  )
+  }).pipe(Layer.provideMerge(RpcSerialization.layerJson))
 }

package/src/cf-worker/do/transport/ws-rpc-server.ts

@@ -1,14 +1,14 @@
 import { UnknownError } from '@livestore/common'
 import { WsContext } from '@livestore/common-cf'
-import { Effect, identity, Layer, RpcServer, Schema, Stream } from '@livestore/utils/effect'
+import { Effect, identity, Layer, Result, RpcServer, Schema, Stream } from '@livestore/utils/effect'
 
 import { SyncWsRpc } from '../../../common/ws-rpc-schema.ts'
 import { headersRecordToMap, WebSocketAttachmentSchema } from '../../shared.ts'
-import { DoCtx, type DoCtxInput } from '../layer.ts'
+import * as DoCtx from '../layer.ts'
 import { makeEndingPullStream } from '../pull.ts'
 import { makePush } from '../push.ts'
 
-export const makeRpcServer = ({ doSelf, doOptions }: Omit<DoCtxInput, 'from'>) => {
+export const makeRpcServer = ({ doSelf, doOptions }: Omit<DoCtx.DoCtxInput, 'from'>) => {
   const handlersLayer = SyncWsRpc.toLayer({
     'SyncWsRpc.Pull': (req) =>
       Effect.gen(function* () {
@@ -16,7 +16,7 @@ export const makeRpcServer = ({ doSelf, doOptions }: Omit<DoCtxInput, 'from'>) =
         return makeEndingPullStream({ req, payload: req.payload, headers }).pipe(
           // Needed to keep the stream alive on the client side for phase 2 (i.e. not send the `Exit` stream RPC message)
           req.live === true ? Stream.concat(Stream.never) : identity,
-          Stream.provideLayer(DoCtx.Default({ doSelf, doOptions, from: { storeId: req.storeId } })),
+          Stream.provide(DoCtx.layer({ doSelf, doOptions, from: { storeId: req.storeId } })),
           Stream.mapError((cause) =>
             cause._tag === 'UnknownError' || cause._tag === 'BackendIdMismatchError'
               ? cause
@@ -26,14 +26,14 @@ export const makeRpcServer = ({ doSelf, doOptions }: Omit<DoCtxInput, 'from'>) =
       }).pipe(Stream.unwrap),
     'SyncWsRpc.Push': (req) =>
       Effect.gen(function* () {
-        const { doOptions, storeId, ctx, env } = yield* DoCtx
+        const { doOptions, storeId, ctx, env } = yield* DoCtx.DoCtx
         const headers = yield* getForwardedHeaders
 
         const push = makePush({ options: doOptions, storeId, payload: req.payload, headers, ctx, env })
 
         return yield* push(req)
       }).pipe(
-        Effect.provide(DoCtx.Default({ doSelf, doOptions, from: { storeId: req.storeId } })),
+        Effect.provide(DoCtx.layer({ doSelf, doOptions, from: { storeId: req.storeId } })),
         Effect.mapError((cause) =>
           cause._tag === 'UnknownError' || cause._tag === 'ServerAheadError' || cause._tag === 'BackendIdMismatchError'
             ? cause
@@ -50,13 +50,13 @@ export const makeRpcServer = ({ doSelf, doOptions }: Omit<DoCtxInput, 'from'>) =
 const getForwardedHeaders = Effect.gen(function* () {
   const { ws } = yield* WsContext
   const attachment = ws.deserializeAttachment()
-  const decoded = Schema.decodeUnknownEither(WebSocketAttachmentSchema)(attachment)
-  if (decoded._tag === 'Left') {
-    yield* Effect.logError('Failed to decode WebSocket attachment for forwarded headers', { error: decoded.left })
+  const decoded = Schema.decodeUnknownResult(WebSocketAttachmentSchema)(attachment)
+  if (Result.isFailure(decoded) === true) {
+    yield* Effect.logError('Failed to decode WebSocket attachment for forwarded headers', { error: decoded.failure })
     ws.close(1011, 'invalid-attachment')
     return yield* Effect.die('Invalid WebSocket attachment (headers decode failed)')
   }
 
-  const headers = headersRecordToMap(decoded.right.headers)
+  const headers = headersRecordToMap(decoded.success.headers)
   return headers
 })

package/src/cf-worker/shared.ts

@@ -1,6 +1,7 @@
 import type { UnknownError } from '@livestore/common'
 import type { CfTypes } from '@livestore/common-cf'
-import { Effect, Schema, UrlParams } from '@livestore/utils/effect'
+import type { Effect } from '@livestore/utils/effect'
+import { Result, Schema } from '@livestore/utils/effect'
 
 import type { SearchParams } from '../common/mod.ts'
 import { SearchParamsSchema, SyncMessage } from '../common/mod.ts'
@@ -20,7 +21,7 @@ export type ForwardHeadersOption = readonly string[] | ((request: CfTypes.Reques
 /** Context passed to onPush/onPull callbacks */
 export type CallbackContext = {
   storeId: StoreId
-  payload?: Schema.JsonValue
+  payload?: Schema.Json
   /** Headers forwarded from the request (only present if `forwardHeaders` is configured) */
   headers?: ForwardedHeaders
 }
@@ -133,8 +134,10 @@ export type DurableObjectId = string
  */
 export const PERSISTENCE_FORMAT_VERSION = 7
 
-export const encodeOutgoingMessage = Schema.encodeSync(Schema.parseJson(SyncMessage.BackendToClientMessage))
-export const encodeIncomingMessage = Schema.encodeSync(Schema.parseJson(SyncMessage.ClientToBackendMessage))
+export const encodeOutgoingMessage = Schema.encodeSync(Schema.fromJsonString(SyncMessage.BackendToClientMessage))
+export const encodeIncomingMessage = Schema.encodeSync(Schema.fromJsonString(SyncMessage.ClientToBackendMessage))
+
+const SearchParamsFromUrlSearchParams = Schema.fromURLSearchParams(SearchParamsSchema)
 
 /**
  * Extracts the LiveStore sync search parameters from a request. Returns
@@ -143,20 +146,19 @@ export const encodeIncomingMessage = Schema.encodeSync(Schema.parseJson(SyncMess
  */
 export const matchSyncRequest = (request: CfTypes.Request): SearchParams | undefined => {
   const url = new URL(request.url)
-  const urlParams = UrlParams.fromInput(url.searchParams)
-  const paramsResult = UrlParams.schemaStruct(SearchParamsSchema)(urlParams).pipe(Effect.option, Effect.runSync)
+  const paramsResult = Schema.decodeUnknownResult(SearchParamsFromUrlSearchParams)(url.searchParams)
 
-  if (paramsResult._tag === 'None') {
+  if (Result.isFailure(paramsResult) === true) {
     return undefined
   }
 
-  return paramsResult.value
+  return paramsResult.success
 }
 
 // RPC subscription storage (TODO refactor)
 export type RpcSubscription = {
   storeId: StoreId
-  payload?: Schema.JsonValue
+  payload?: Schema.Json
   subscribedAt: number
   /** Effect RPC request ID */
   requestId: string
@@ -166,6 +168,9 @@ export type RpcSubscription = {
   }
 }
 
+/** Key prefix for DO-RPC subscriptions persisted in the DO's synchronous KV storage. */
+export const rpcSubscriptionKeyPrefix = 'rpc-sub:'
+
 /**
  * Durable Object interface supporting the DO RPC protocol for DO <> DO syncing.
  */
@@ -174,15 +179,15 @@ export interface SyncBackendRpcInterface {
   rpc(payload: Uint8Array): Promise<Uint8Array | CfTypes.ReadableStream>
 }
 
-export const WebSocketAttachmentSchema = Schema.parseJson(
+export const WebSocketAttachmentSchema = Schema.fromJsonString(
   Schema.Struct({
     // Same across all websocket connections
     storeId: Schema.String,
     // Different for each websocket connection
-    payload: Schema.optional(Schema.JsonValue),
-    pullRequestIds: Schema.Array(Schema.String),
+    payload: Schema.optional(Schema.Json),
+    pullRequestIds: Schema.Array(Schema.Union([Schema.String, Schema.Finite])),
     // Headers forwarded from the initial request (via forwardHeaders option)
-    headers: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.String })),
+    headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
   }),
 )
 

package/src/cf-worker/worker.ts

@@ -2,14 +2,13 @@ import { env as importedEnv } from 'cloudflare:workers'
 
 import { UnknownError } from '@livestore/common'
 import type { HelperTypes } from '@livestore/common-cf'
-import { Effect, Schema } from '@livestore/utils/effect'
+import { CfDeclare } from '@livestore/common-cf/declare'
+import { Effect, Result, Schema } from '@livestore/utils/effect'
 
 import type { CfTypes, SearchParams } from '../common/mod.ts'
-import type { CfDeclare } from './mod.ts'
 import { type Env, type ForwardedHeaders, matchSyncRequest } from './shared.ts'
 
-// NOTE We need to redeclare runtime types here to avoid type conflicts with the lib.dom Response type.
-declare class Response extends CfDeclare.Response {}
+const Response = CfDeclare.Response
 
 // HINT: If we ever extend user's custom worker RPC, type T can help here with expected return type safety. Currently unused.
 export type CFWorker<TEnv extends Env = Env, _T extends CfTypes.Rpc.DurableObjectBranded | undefined = undefined> = {
@@ -31,7 +30,7 @@ export type ValidatePayloadContext = {
  * Options accepted by {@link makeWorker}. The Durable Object binding has to be
  * supplied explicitly so we never fall back to deprecated defaults when Cloudflare config changes.
  */
-export type MakeWorkerOptions<TEnv extends Env = Env, TSyncPayload = Schema.JsonValue> = {
+export type MakeWorkerOptions<TEnv extends Env = Env, TSyncPayload = Schema.Json> = {
   /**
    * Binding name of the sync Durable Object declared in wrangler config.
    */
@@ -40,7 +39,7 @@ export type MakeWorkerOptions<TEnv extends Env = Env, TSyncPayload = Schema.Json
    * Optionally pass a schema to decode the client-provided payload into a typed object
    * before calling {@link validatePayload}. If omitted, the raw JSON value is forwarded.
    */
-  syncPayloadSchema?: Schema.Schema<TSyncPayload>
+  syncPayloadSchema?: Schema.Decoder<TSyncPayload>
   /**
    * Validates the (optionally decoded) payload during WebSocket connection establishment.
    * If {@link syncPayloadSchema} is provided, `payload` will be of the schema's inferred type.
@@ -74,7 +73,7 @@ export type MakeWorkerOptions<TEnv extends Env = Env, TSyncPayload = Schema.Json
 export const makeWorker = <
   TEnv extends Env = Env,
   TDurableObjectRpc extends CfTypes.Rpc.DurableObjectBranded | undefined = undefined,
-  TSyncPayload = Schema.JsonValue,
+  TSyncPayload = Schema.Json,
 >(
   options: MakeWorkerOptions<TEnv, TSyncPayload>,
 ): CFWorker<TEnv, TDurableObjectRpc> => {
@@ -150,7 +149,7 @@ const requestHeadersToMap = (request: CfTypes.Request): ForwardedHeaders => {
  *
  * @example Token-based authentication
  * ```ts
- * const validatePayload = (payload: Schema.JsonValue | undefined, context: { storeId: string }) => {
+ * const validatePayload = (payload: Schema.Json | undefined, context: { storeId: string }) => {
  *   if (payload?.authToken !== 'insecure-token-change-me') {
  *     throw new Error('Invalid auth token')
  *   }
@@ -159,7 +158,7 @@ const requestHeadersToMap = (request: CfTypes.Request): ForwardedHeaders => {
  *
  * @example Cookie-based authentication
  * ```ts
- * const validatePayload = async (payload: Schema.JsonValue | undefined, { storeId, headers }) => {
+ * const validatePayload = async (payload: Schema.Json | undefined, { storeId, headers }) => {
  *   const cookie = headers.get('cookie')
  *   const session = await validateSessionFromCookie(cookie)
  *   if (!session) throw new Error('Unauthorized')
@@ -172,7 +171,7 @@ export const handleSyncRequest = <
   TEnv extends Env = Env,
   TDurableObjectRpc extends CfTypes.Rpc.DurableObjectBranded | undefined = undefined,
   CFHostMetada = unknown,
-  TSyncPayload = Schema.JsonValue,
+  TSyncPayload = Schema.Json,
 >({
   request,
   searchParams: { storeId, payload, transport },
@@ -201,29 +200,29 @@ export const handleSyncRequest = <
       // Always decode with the supplied schema when present, even if payload is undefined.
       // This ensures required payloads are enforced by the schema.
       if (syncPayloadSchema !== undefined) {
-        const decodedEither = Schema.decodeUnknownEither(syncPayloadSchema)(payload)
-        if (decodedEither._tag === 'Left') {
-          const message = decodedEither.left.toString()
+        const decodedResult = Schema.decodeUnknownResult(syncPayloadSchema)(payload)
+        if (Result.isFailure(decodedResult) === true) {
+          const message = decodedResult.failure.toString()
           console.error('Invalid payload (decode failed)', message)
           return new Response(message, { status: 400, ...(headers !== undefined ? { headers } : {}) })
         }
 
         const result = yield* Effect.promise(async () =>
-          validatePayload(decodedEither.right, { storeId, headers: requestHeaders }),
-        ).pipe(UnknownError.mapToUnknownError, Effect.either)
+          validatePayload(decodedResult.success, { storeId, headers: requestHeaders }),
+        ).pipe(UnknownError.mapToUnknownError, Effect.result)
 
-        if (result._tag === 'Left') {
-          console.error('Invalid payload (validation failed)', result.left)
-          return new Response(result.left.toString(), { status: 400, ...(headers !== undefined ? { headers } : {}) })
+        if (Result.isFailure(result) === true) {
+          console.error('Invalid payload (validation failed)', result.failure)
+          return new Response(result.failure.toString(), { status: 400, ...(headers !== undefined ? { headers } : {}) })
         }
       } else {
         const result = yield* Effect.promise(async () =>
           validatePayload(payload as TSyncPayload, { storeId, headers: requestHeaders }),
-        ).pipe(UnknownError.mapToUnknownError, Effect.either)
+        ).pipe(UnknownError.mapToUnknownError, Effect.result)
 
-        if (result._tag === 'Left') {
-          console.error('Invalid payload (validation failed)', result.left)
-          return new Response(result.left.toString(), { status: 400, ...(headers !== undefined ? { headers } : {}) })
+        if (Result.isFailure(result) === true) {
+          console.error('Invalid payload (validation failed)', result.failure)
+          return new Response(result.failure.toString(), { status: 400, ...(headers !== undefined ? { headers } : {}) })
         }
       }
     }

package/src/client/transport/do-rpc-client.ts

@@ -1,18 +1,19 @@
 import { SyncBackend, UnknownError } from '@livestore/common'
-import { splitChunkBySize } from '@livestore/common/sync'
 import { type CfTypes, layerProtocolDurableObject } from '@livestore/common-cf'
-import { omit, shouldNeverHappen } from '@livestore/utils'
+import { splitArrayBySize } from '@livestore/common/sync'
+import { shouldNeverHappen } from '@livestore/utils'
 import {
-  Chunk,
   Effect,
   identity,
   Layer,
-  Mailbox,
   Option,
+  Queue,
+  ReadonlyArray as EffectArray,
   RpcClient,
   RpcSerialization,
   Schema,
   Stream,
+  Struct,
   SubscriptionRef,
 } from '@livestore/utils/effect'
 
@@ -22,15 +23,18 @@ import { SyncDoRpc } from '../../common/do-rpc-schema.ts'
 import { SyncMessage } from '../../common/mod.ts'
 import type { SyncMetadata } from '../../common/sync-message-types.ts'
 
-export interface SyncBackendRpcStub extends CfTypes.DurableObjectStub, SyncBackendRpcInterface {}
+type PushBatchItem = SyncMessage.PushRequest['batch'][number]
 
-// TODO we probably need better scoping for the requestIdMailboxMap (i.e. support multiple stores, ...)
-type EffectRpcRequestId = string // 0, 1, 2, ...
-const requestIdMailboxMap = new Map<EffectRpcRequestId, Mailbox.Mailbox<SyncMessage.PullResponse>>()
+export interface SyncBackendRpcStub extends CfTypes.DurableObjectStub, SyncBackendRpcInterface {}
 
 export interface DoRpcSyncOptions {
   /** Durable Object stub that implements the SyncDoRpc interface */
   syncBackendStub: SyncBackendRpcStub
+  /**
+   * State handle of the client DurableObject running this sync backend. Scopes live-pull routing to
+   * this instance so it resets when the DO is reconstructed (see {@link handleSyncUpdateRpc}).
+   */
+  durableObjectState: CfTypes.DurableObjectState
   /** Information about this DurableObject instance so the Sync DO instance can call back to this instance */
   durableObjectContext: {
     /** See `wrangler.toml` for the binding name */
@@ -46,7 +50,11 @@ export interface DoRpcSyncOptions {
  * Used internally by `@livestore/adapter-cf` to connect to the sync backend.
  */
 export const makeDoRpcSync =
-  ({ syncBackendStub, durableObjectContext }: DoRpcSyncOptions): SyncBackend.SyncBackendConstructor<SyncMetadata> =>
+  ({
+    syncBackendStub,
+    durableObjectState,
+    durableObjectContext,
+  }: DoRpcSyncOptions): SyncBackend.SyncBackendConstructor<SyncMetadata> =>
   ({ storeId, payload }) =>
     Effect.gen(function* () {
       const isConnected = yield* SubscriptionRef.make(true)
@@ -66,7 +74,7 @@ export const makeDoRpcSync =
       const backendIdHelper = yield* SyncBackend.makeBackendIdHelper
 
       const pull: SyncBackend.SyncBackend<SyncMetadata>['pull'] = (cursor, options) =>
-        rpcClient.SyncDoRpc.Pull({
+        rpcClient['SyncDoRpc.Pull']({
           cursor: cursor.pipe(
             Option.map((a) => ({
               eventSequenceNumber: a.eventSequenceNumber,
@@ -82,18 +90,22 @@ export const makeDoRpcSync =
                   if (res._tag === 'None')
                     return shouldNeverHappen('There should at least be a no-more page info response')
 
-                  const mailbox = yield* Mailbox.make<SyncMessage.PullResponse>().pipe(
-                    Effect.acquireRelease((mailbox) => mailbox.shutdown),
+                  const requestId = res.value.rpcRequestId
+                  const routing = pullRoutingFor(durableObjectState)
+
+                  const queue = yield* Effect.acquireRelease(Queue.unbounded<SyncMessage.PullResponse>(), (queue) =>
+                    // Drop the routing entry on release so it can't outlive its (now shut-down) queue
+                    Effect.sync(() => routing.delete(requestId)).pipe(Effect.andThen(Queue.shutdown(queue))),
                   )
 
-                  requestIdMailboxMap.set(res.value.rpcRequestId, mailbox)
+                  routing.set(requestId, queue)
 
-                  return Mailbox.toStream(mailbox)
-                }).pipe(Stream.unwrapScoped),
+                  return Stream.fromQueue(queue)
+                }).pipe(Stream.unwrap),
               )
             : identity,
           Stream.tap((res) => backendIdHelper.lazySet(res.backendId)),
-          Stream.map((res) => omit(res, ['backendId'])),
+          Stream.map((res) => Struct.omit(res, ['backendId'])),
           Stream.mapError((cause) =>
             cause._tag === 'UnknownError' || cause._tag === 'BackendIdMismatchError'
               ? cause
@@ -109,22 +121,22 @@ export const makeDoRpcSync =
           }
 
           const backendId = backendIdHelper.get()
-          const batchChunks = yield* Chunk.fromIterable(batch).pipe(
-            splitChunkBySize({
-              maxItems: MAX_PUSH_EVENTS_PER_REQUEST,
-              maxBytes: MAX_DO_RPC_REQUEST_BYTES,
-              encode: (items) => ({
-                batch: items,
-                storeId,
-                backendId,
-              }),
+          if (EffectArray.isReadonlyArrayNonEmpty(batch) === false) {
+            return
+          }
+
+          const batchChunks = yield* splitArrayBySize({
+            maxItems: MAX_PUSH_EVENTS_PER_REQUEST,
+            maxBytes: MAX_DO_RPC_REQUEST_BYTES,
+            encode: (items: ReadonlyArray<PushBatchItem>) => ({
+              batch: items,
+              storeId,
+              backendId,
             }),
-            Effect.mapError((cause) => new UnknownError({ cause })),
-          )
+          })(batch).pipe(Effect.mapError((cause) => new UnknownError({ cause })))
 
-          for (const chunk of Chunk.toReadonlyArray(batchChunks)) {
-            const chunkArray = Chunk.toReadonlyArray(chunk)
-            yield* rpcClient.SyncDoRpc.Push({ batch: chunkArray, storeId, backendId })
+          for (const batchChunk of batchChunks) {
+            yield* rpcClient['SyncDoRpc.Push']({ batch: batchChunk, storeId, backendId })
           }
         },
         Effect.mapError((cause) =>
@@ -134,7 +146,7 @@ export const makeDoRpcSync =
         ),
       )
 
-      const ping: SyncBackend.SyncBackend<{ createdAt: string }>['ping'] = rpcClient.SyncDoRpc.Ping({
+      const ping: SyncBackend.SyncBackend<{ createdAt: string }>['ping'] = rpcClient['SyncDoRpc.Ping']({
         storeId,
         payload,
       }).pipe(UnknownError.mapToUnknownError, Effect.withSpan('rpc-sync-client:ping'))
@@ -159,6 +171,9 @@ export const makeDoRpcSync =
     }).pipe(Effect.withSpan('rpc-sync-client:makeDoRpcSync'))
 
 /**
+ * Routes an update from the sync backend into this client's live pull.
+ *
+ * Only `ctx` and `payload` go here; `storeId` is for reloading your store on a rebuilt DO (see example).
  *
  * ```ts
  * import { DurableObject } from 'cloudflare:workers'
@@ -167,25 +182,31 @@ export const makeDoRpcSync =
  * export class MyDurableObject extends DurableObject implements ClientDoWithRpcCallback {
  *   // ...
  *
- *   async syncUpdateRpc(payload: RpcMessage.ResponseChunkEncoded) {
- *     return handleSyncUpdateRpc(payload)
+ *   async syncUpdateRpc(payload: Uint8Array<ArrayBuffer>, storeId: string) {
+ *     await this.getStore(storeId)
+ *     return handleSyncUpdateRpc(this.ctx, payload)
  *   }
  * }
  * ```
  */
-export const handleSyncUpdateRpc = (payload: unknown) =>
+export const handleSyncUpdateRpc = (ctx: CfTypes.DurableObjectState, payload: Uint8Array<ArrayBuffer>) =>
   Effect.gen(function* () {
-    const decodedPayload = yield* Schema.decodeUnknown(ResponseChunkEncoded)(payload)
-    const decoded = yield* Schema.decodeUnknown(SyncMessage.PullResponse)(decodedPayload.values[0])
+    const parser = RpcSerialization.msgPack.makeUnsafe()
+    const decodedMessage = parser.decode(payload)
+    const [response] = Array.isArray(decodedMessage) === true ? decodedMessage.flat(1) : [decodedMessage]
+    const decodedPayload = yield* Schema.decodeUnknownEffect(ResponseChunkEncoded)(response)
+    const decoded = yield* Schema.decodeUnknownEffect(Schema.toCodecJson(SyncMessage.PullResponse))(
+      decodedPayload.values[0],
+    )
 
-    const pullStreamMailbox = requestIdMailboxMap.get(decodedPayload.requestId)
+    const pullStreamQueue = pullRoutingFor(ctx).get(decodedPayload.requestId)
 
-    if (pullStreamMailbox === undefined) {
+    if (pullStreamQueue === undefined) {
       // Case: DO was hibernated, so we need to manually update the store
-      yield* Effect.log(`No mailbox found for ${decodedPayload.requestId}`)
+      yield* Effect.log(`No pull stream queue found for ${decodedPayload.requestId}`)
     } else {
       // Case: DO was still alive, so the existing `pull` will pick up the new events
-      yield* pullStreamMailbox.offer(decoded)
+      yield* Queue.offer(pullStreamQueue, decoded)
     }
   }).pipe(Effect.withSpan('rpc-sync-client:rpcCallback'), Effect.tapCauseLogPretty, Effect.runPromise)
 
@@ -193,3 +214,24 @@ const ResponseChunkEncoded = Schema.Struct({
   requestId: Schema.String,
   values: Schema.Array(Schema.Any),
 })
+
+type EffectRpcRequestId = string // 0, 1, 2, ...
+type PullRouting = Map<EffectRpcRequestId, Queue.Queue<SyncMessage.PullResponse>>
+
+/**
+ * Per-instance map from a live pull's request id to its response queue, keyed off the client DO's
+ * `DurableObjectState` (not a module global) for two independent reasons:
+ * - Per-instance: a reconstructed DO starts empty, so a reverse-RPC whose store is gone hits the
+ *   `handleSyncUpdateRpc` drop branch (the recovery hook) instead of a stale queue that outlived it.
+ * - Keyed by request id: a late chunk from a superseded pull generation finds no entry and is
+ *   dropped here — never reaching `SyncState.merge`, which dies on an event at/below the upstream head.
+ */
+const pullRoutingByInstance = new WeakMap<CfTypes.DurableObjectState, PullRouting>()
+
+const pullRoutingFor = (ctx: CfTypes.DurableObjectState): PullRouting => {
+  const existing = pullRoutingByInstance.get(ctx)
+  if (existing !== undefined) return existing
+  const routing: PullRouting = new Map()
+  pullRoutingByInstance.set(ctx, routing)
+  return routing
+}