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

package/src/cf-worker/do/observability.test.ts

@@ -0,0 +1,337 @@
+import { ROOT_CONTEXT, type SpanStatus, SpanStatusCode, trace } from '@opentelemetry/api'
+
+import { BackendIdMismatchError, UnknownError } from '@livestore/common'
+import { type CfTypes, layerProtocolDurableObject, WsContext } from '@livestore/common-cf'
+import { makeNoopSpan, makeNoopTracer } from '@livestore/utils'
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+import {
+  Deferred,
+  Effect,
+  FetchHttpClient,
+  Fiber,
+  Layer,
+  Option,
+  OtelTracer,
+  RpcClient,
+  RpcTest,
+  Schema,
+  Stream,
+  TestClock,
+  Tracer,
+} from '@livestore/utils/effect'
+
+import { SyncDoRpc } from '../../common/do-rpc-schema.ts'
+import { SyncWsRpc } from '../../common/ws-rpc-schema.ts'
+import { WebSocketAttachmentSchema } from '../shared.ts'
+import type * as DoCtx from './layer.ts'
+import { makeObservability, rpcSpanOptions, withRpcSpan, withRpcStreamSpan } from './observability.ts'
+import { createDoRpcHandler } from './transport/do-rpc-server.ts'
+import { makeRpcHandlers } from './transport/ws-rpc-server.ts'
+
+Vitest.describe('sync-cf telemetry ownership', () => {
+  Vitest.afterEach(() => Vitest.vi.restoreAllMocks())
+
+  Vitest.effect('runs sync effects and streams without exporting when telemetry is omitted', () =>
+    Effect.gen(function* () {
+      const fetch: typeof globalThis.fetch = Vitest.vi.fn(async () => new Response('{}'))
+      const observability = makeObservability(undefined)
+      const result = yield* Effect.succeed('ack').pipe(
+        Effect.withSpan('push'),
+        observability.effect,
+        Effect.provideService(FetchHttpClient.Fetch, fetch),
+      )
+      const history = yield* Stream.make('event').pipe(
+        Stream.withSpan('pull'),
+        observability.stream,
+        Stream.runCollect,
+        Effect.provideService(FetchHttpClient.Fetch, fetch),
+      )
+
+      yield* TestClock.adjust('4 seconds')
+      Vitest.expect(result).toBe('ack')
+      Vitest.expect(history).toEqual(['event'])
+      Vitest.expect(fetch).not.toHaveBeenCalled()
+    }),
+  )
+
+  Vitest.effect('builds and finalizes a supplied layer independently for overlapping operations', () =>
+    Effect.gen(function* () {
+      const firstStarted = yield* Deferred.make<void>()
+      const secondStarted = yield* Deferred.make<void>()
+      const firstGate = yield* Deferred.make<void>()
+      const secondGate = yield* Deferred.make<void>()
+      const firstReleased = yield* Deferred.make<void>()
+      const secondReleased = yield* Deferred.make<void>()
+      const builds: string[] = []
+      const releases: string[] = []
+      const layer = Layer.effectDiscard(
+        Effect.acquireRelease(
+          Effect.currentSpan.pipe(
+            Effect.orDie,
+            Effect.tap((span) => Effect.sync(() => builds.push(span.name))),
+          ),
+          (span) =>
+            Effect.sync(() => releases.push(span.name)).pipe(
+              Effect.andThen(Deferred.succeed(span.name === 'first' ? firstReleased : secondReleased, undefined)),
+            ),
+        ),
+      )
+      const observability = makeObservability(layer)
+      const first = yield* Deferred.succeed(firstStarted, undefined).pipe(
+        Effect.andThen(Deferred.await(firstGate)),
+        observability.effect,
+        Effect.withSpan('first'),
+        Effect.forkChild,
+      )
+      yield* Deferred.await(firstStarted)
+      const second = yield* Deferred.succeed(secondStarted, undefined).pipe(
+        Effect.andThen(Deferred.await(secondGate)),
+        observability.effect,
+        Effect.withSpan('second'),
+        Effect.forkChild,
+      )
+      yield* Deferred.await(secondStarted)
+      Vitest.expect(builds).toEqual(['first', 'second'])
+      Vitest.expect(releases).toEqual([])
+
+      yield* Deferred.succeed(firstGate, undefined)
+      yield* Fiber.join(first)
+      yield* Deferred.await(firstReleased)
+      Vitest.expect(releases).toEqual(['first'])
+      Vitest.expect(second.pollUnsafe()).toBeUndefined()
+
+      yield* Deferred.succeed(secondGate, undefined)
+      yield* Fiber.join(second)
+      yield* Deferred.await(secondReleased)
+      Vitest.expect(releases).toEqual(['first', 'second'])
+    }),
+  )
+
+  Vitest.effect('finalizes finite history while the live subscription is still open', () =>
+    Effect.gen(function* () {
+      const { layer, ended } = makeRecordingTracer()
+      const finalized = yield* Deferred.make<ReadonlyArray<string>>()
+      const live = yield* Deferred.make<void>()
+      const observability = makeObservability(
+        Layer.mergeAll(layer, Layer.effectDiscard(Effect.addFinalizer(() => Deferred.succeed(finalized, [...ended])))),
+      )
+      const fiber = yield* Stream.make('history').pipe(
+        Stream.withSpan('pull-history'),
+        observability.stream,
+        Stream.concat(Stream.fromEffect(Deferred.succeed(live, undefined)).pipe(Stream.concat(Stream.never))),
+        Stream.runDrain,
+        Effect.forkChild,
+      )
+      yield* Effect.addFinalizer(() => Fiber.interrupt(fiber))
+      yield* Deferred.await(live)
+      Vitest.expect(yield* Deferred.await(finalized)).toContain('pull-history')
+      Vitest.expect(fiber.pollUnsafe()).toBeUndefined()
+    }),
+  )
+
+  Vitest.effect('ends WebSocket telemetry before the production handler enters its live tail', () =>
+    Effect.gen(function* () {
+      const { layer, ended } = makeRecordingTracer()
+      const finalized = yield* Deferred.make<void>()
+      const observability = makeObservability(
+        Layer.mergeAll(layer, Layer.effectDiscard(Effect.addFinalizer(() => Deferred.succeed(finalized, undefined)))),
+      )
+      const input = makeDoInput()
+      const handlers = makeRpcHandlers({ ...input, observability }).pipe(
+        Layer.provide(Layer.succeed(WsContext, WsContext.of({ ws: makeWebSocket() }))),
+      )
+      const client = yield* RpcTest.makeClient(SyncWsRpc).pipe(Effect.provide(handlers))
+      const pullFiber = yield* client['SyncWsRpc.Pull']({
+        storeId: 'store',
+        cursor: Option.none(),
+        live: true,
+      }).pipe(Stream.runDrain, Effect.forkChild)
+      yield* Effect.addFinalizer(() => Fiber.interrupt(pullFiber))
+
+      yield* Deferred.await(finalized).pipe(Effect.timeout('1 second'))
+      Vitest.expect(ended).toContain('RpcServer.SyncWsRpc.Pull')
+      Vitest.expect(pullFiber.pollUnsafe()).toBeUndefined()
+    }),
+  )
+
+  Vitest.effect('installs telemetry inside the Durable Object RPC stream runtime', () =>
+    Effect.gen(function* () {
+      const { layer, ended } = makeRecordingTracer()
+      const observability = makeObservability(layer)
+      const input = makeDoInput()
+      const protocol = layerProtocolDurableObject({
+        callerContext: { bindingName: 'TEST', durableObjectId: 'client' },
+        callRpc: (payload) =>
+          createDoRpcHandler({
+            // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- Effect RPC owns this ArrayBuffer-backed payload.
+            payload: payload as Uint8Array<ArrayBuffer>,
+            input,
+            observability,
+          }).pipe(Effect.runPromise),
+      })
+      const responses = yield* Effect.gen(function* () {
+        const client = yield* RpcClient.make(SyncDoRpc)
+        return yield* client['SyncDoRpc.Pull']({ storeId: 'store', cursor: Option.none() }).pipe(Stream.runCollect)
+      }).pipe(Effect.provide(protocol))
+
+      Vitest.expect(responses).toHaveLength(1)
+      Vitest.expect(ended).toContain('RpcServer.SyncDoRpc.Pull')
+    }),
+  )
+
+  Vitest.effect('attaches a finite span to a sampled caller across an unexported RPC envelope', () =>
+    Effect.gen(function* () {
+      const { layer, spans, ended } = makeRecordingTracer()
+      const observability = makeObservability(layer)
+      const caller = Tracer.externalSpan({ traceId: '1'.repeat(32), spanId: '2222222222222222', sampled: true })
+      yield* Effect.flatMap(rpcSpanOptions, (options) =>
+        withRpcSpan(Effect.void.pipe(Effect.withSpan('push')), 'finite-rpc', options),
+      ).pipe(observability.effect, Effect.withSpan('unexported-rpc-envelope'), Effect.withParentSpan(caller))
+
+      Vitest.expect(spans.get('finite-rpc')?.parentId).toBe(caller.spanId)
+      Vitest.expect(spans.get('push')?.parentId).toBe(spans.get('finite-rpc')?.spanId)
+      Vitest.expect(ended).toEqual(['push', 'finite-rpc'])
+    }),
+  )
+
+  Vitest.effect('starts a backend root when the RPC caller is unsampled', () =>
+    Effect.gen(function* () {
+      const { layer, spans, ended } = makeRecordingTracer()
+      const observability = makeObservability(layer)
+      const caller = Tracer.externalSpan({ traceId: '1'.repeat(32), spanId: '2222222222222222', sampled: false })
+      yield* Effect.flatMap(rpcSpanOptions, (options) => withRpcSpan(Effect.void, 'finite-rpc', options)).pipe(
+        observability.effect,
+        Effect.withSpan('unexported-rpc-envelope'),
+        Effect.withParentSpan(caller),
+      )
+
+      Vitest.expect(spans.get('finite-rpc')?.parentId).toBeUndefined()
+      Vitest.expect(ended).toEqual(['finite-rpc'])
+    }),
+  )
+
+  Vitest.effect('keeps anticipated RPC recovery failures out of boundary error telemetry', () =>
+    Effect.gen(function* () {
+      const { layer, statuses } = makeRecordingTracer()
+      const observability = makeObservability(layer)
+      const expected = new BackendIdMismatchError({ expected: 'backend-a', received: 'backend-b' })
+      const unexpected = new UnknownError({ cause: new Error('boom') })
+
+      const effectError = yield* withRpcSpan(Effect.fail(expected), 'expected-effect').pipe(
+        observability.effect,
+        Effect.flip,
+      )
+      const streamError = yield* Stream.fail(expected).pipe(
+        (_) => withRpcStreamSpan(_, 'expected-stream'),
+        observability.stream,
+        Stream.runDrain,
+        Effect.flip,
+      )
+      const unexpectedError = yield* withRpcSpan(Effect.fail(unexpected), 'unexpected-effect').pipe(
+        observability.effect,
+        Effect.flip,
+      )
+
+      Vitest.expect(effectError).toBe(expected)
+      Vitest.expect(streamError).toBe(expected)
+      Vitest.expect(unexpectedError).toBe(unexpected)
+      Vitest.expect(statuses.get('expected-effect')).toBe(SpanStatusCode.OK)
+      Vitest.expect(statuses.get('expected-stream')).toBe(SpanStatusCode.OK)
+      Vitest.expect(statuses.get('unexpected-effect')).toBe(SpanStatusCode.ERROR)
+    }),
+  )
+
+  Vitest.effect('forwards the operation exit to supplied layer finalizers', () =>
+    Effect.gen(function* () {
+      const released = yield* Deferred.make<string>()
+      const expected = new BackendIdMismatchError({ expected: 'backend-a', received: 'backend-b' })
+      const observability = makeObservability(
+        Layer.effectDiscard(
+          Effect.acquireRelease(Effect.void, (_, exit) => Deferred.succeed(released, exit._tag).pipe(Effect.asVoid)),
+        ),
+      )
+
+      const error = yield* Effect.fail(expected).pipe(observability.effect, Effect.flip)
+
+      Vitest.expect(error).toBe(expected)
+      Vitest.expect(yield* Deferred.await(released)).toBe('Failure')
+    }),
+  )
+
+  Vitest.live('acknowledges before the owned OTLP collector responds', () =>
+    Effect.gen(function* () {
+      const started = Promise.withResolvers<void>()
+      const gate = Promise.withResolvers<void>()
+      const acknowledged = yield* Deferred.make<void>()
+      const fetch: typeof globalThis.fetch = Vitest.vi.fn(() => {
+        started.resolve()
+        return gate.promise.then(() => new Response('{}', { headers: { 'content-type': 'application/json' } }))
+      })
+      yield* Effect.addFinalizer(() => Effect.sync(() => gate.resolve()))
+      const observability = makeObservability({ baseUrl: 'http://collector.invalid' })
+      yield* Effect.void.pipe(
+        Effect.withSpan('push'),
+        observability.effect,
+        Effect.andThen(Deferred.succeed(acknowledged, undefined)),
+        Effect.provideService(FetchHttpClient.Fetch, fetch),
+        Effect.forkChild,
+      )
+      yield* Effect.promise(() => started.promise)
+      yield* Effect.yieldNow
+      Vitest.expect(yield* Deferred.isDone(acknowledged)).toBe(true)
+    }),
+  )
+})
+
+/** Record the public OTel boundary; span IDs are compared relationally, not fixed to creation order. */
+const makeRecordingTracer = () => {
+  const tracer = makeNoopTracer()
+  const ended: string[] = []
+  const statuses = new Map<string, SpanStatusCode>()
+  const spans = new Map<string, { spanId: string; parentId: string | undefined }>()
+  let nextId = 0
+  Vitest.vi.spyOn(tracer, 'startSpan').mockImplementation((name, _options, context) => {
+    const spanId = (++nextId).toString(16).padStart(16, '0')
+    spans.set(name, { spanId, parentId: trace.getSpanContext(context ?? ROOT_CONTEXT)?.spanId })
+    const noopSpan = makeNoopSpan()
+    return {
+      ...noopSpan,
+      spanContext: () => ({ traceId: '1'.repeat(32), spanId, traceFlags: 1 }),
+      setStatus: (status: SpanStatus) => {
+        statuses.set(name, status.code)
+        return noopSpan
+      },
+      end: () => {
+        ended.push(name)
+      },
+    }
+  })
+  const layer = OtelTracer.layerWithoutOtelTracer.pipe(Layer.provide(Layer.succeed(OtelTracer.OtelTracer, tracer)))
+  return { layer, ended, spans, statuses }
+}
+
+/** Minimal empty SQLite-backed Durable Object boundary for transport composition tests. */
+const makeDoInput = (): Omit<DoCtx.DoCtxInput, 'from'> => {
+  const emptyCursor = Object.assign([], { toArray: () => [] })
+  const doSelf = {
+    env: {},
+    ctx: {
+      storage: {
+        sql: { exec: () => emptyCursor },
+        kv: { get: () => undefined, put: () => undefined, delete: () => undefined },
+        deleteAll: async () => undefined,
+      },
+    },
+  }
+
+  // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- The test intentionally stubs the narrow Worker APIs reached by an empty pull.
+  return { doSelf: doSelf as unknown as DoCtx.DoCtxInput['doSelf'], doOptions: undefined }
+}
+
+const makeWebSocket = (): CfTypes.WebSocket => {
+  const attachment = Schema.encodeSync(WebSocketAttachmentSchema)({ storeId: 'store', pullRequestIds: [] })
+  const ws = { deserializeAttachment: () => attachment, close: Vitest.vi.fn() }
+
+  // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- The handler only reads the attachment and closes invalid sockets.
+  return ws as unknown as CfTypes.WebSocket
+}

package/src/cf-worker/do/observability.ts

@@ -0,0 +1,121 @@
+import type { BackendIdMismatchError, ServerAheadError, UnknownError } from '@livestore/common'
+import {
+  Effect,
+  FetchHttpClient,
+  Layer,
+  Option,
+  Otlp,
+  Ref,
+  Result,
+  Scope,
+  Stream,
+  type Tracer,
+} from '@livestore/utils/effect'
+
+import type { SyncBackendOtelOptions } from '../shared.ts'
+
+/** Keep exporter ownership separate from sync scopes: their finalizers must not delay acknowledgments. */
+export const makeObservability = (options: SyncBackendOtelOptions | undefined) => {
+  const layer = makeLayer(options)
+
+  const backgroundLayer = Layer.effectContext(
+    Effect.acquireRelease(Scope.make(), (scope, exit) => Scope.close(scope, exit).pipe(runInBackground)).pipe(
+      Effect.flatMap((scope) => Layer.buildWithScope(layer, scope)),
+    ),
+  )
+
+  return {
+    effect: <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+      options === undefined ? effect : effect.pipe(Effect.provide(backgroundLayer, { local: true })),
+    stream: <A, E, R>(stream: Stream.Stream<A, E, R>) =>
+      options === undefined ? stream : stream.pipe(Stream.provide(backgroundLayer, { local: true })),
+  }
+}
+
+/**
+ * Effect RPC's envelope lives until a live subscription closes and may never be exported.
+ * Give finite sync work its own exported boundary, attached to a sampled caller or a new backend root.
+ */
+export const rpcSpanOptions = Effect.currentSpan.pipe(
+  Effect.map((span) => makeRpcSpanOptions(span.parent)),
+  Effect.catchTag('NoSuchElementError', () => Effect.succeed({ root: true })),
+)
+
+export const makeRpcSpanOptions = (parent: Option.Option<Tracer.AnySpan>): Tracer.SpanOptions => ({
+  // Client runtimes use an unsampled no-op span by default. Parenting to it would suppress backend-only telemetry.
+  parent: parent.pipe(
+    Option.filter((span) => span.sampled),
+    Option.getOrUndefined,
+  ),
+  root: true,
+})
+
+/** Keep expected sync-recovery results out of error telemetry while preserving the typed failure for RPC callers. */
+export const withRpcSpan = <A, E extends SyncRpcError, R>(
+  effect: Effect.Effect<A, E, R>,
+  name: string,
+  options?: Tracer.SpanOptions,
+): Effect.Effect<A, E, R> =>
+  effect.pipe(
+    Effect.map(Result.succeed),
+    Effect.catchIf(isExpectedSyncError, (error) => Effect.succeed(Result.fail(error))),
+    Effect.withSpan(name, options),
+    Effect.flatMap(resultToEffect),
+  )
+
+/** Stream equivalent of `withRpcSpan`; expected failures are restored after the boundary span ends successfully. */
+export const withRpcStreamSpan = <A, E extends SyncRpcError, R>(
+  stream: Stream.Stream<A, E, R>,
+  name: string,
+  options?: Tracer.SpanOptions,
+): Stream.Stream<A, E, R> =>
+  Stream.unwrap(
+    Effect.gen(function* () {
+      const expectedError = yield* Ref.make(Option.none<E>())
+      const instrumented = stream.pipe(
+        Stream.catchIf(isExpectedSyncError, (error) =>
+          Stream.fromEffect(Ref.set(expectedError, Option.some(error))).pipe(Stream.drain),
+        ),
+        Stream.withSpan(name, options),
+      )
+      const restoreExpectedError = Stream.fromEffect(Ref.get(expectedError)).pipe(
+        Stream.flatMap(
+          Option.match({
+            onNone: () => Stream.empty,
+            onSome: Stream.fail,
+          }),
+        ),
+      )
+
+      return instrumented.pipe(Stream.concat(restoreExpectedError))
+    }),
+  )
+
+type SyncRpcError = UnknownError | ServerAheadError | BackendIdMismatchError
+
+const makeLayer = (options: SyncBackendOtelOptions | undefined): Layer.Layer<never> => {
+  if (isTracerLayer(options) === true) return options
+  if (options?.baseUrl !== undefined) {
+    return Otlp.layerJson({
+      baseUrl: options.baseUrl,
+      tracerExportInterval: 50,
+      shutdownTimeout: 3000,
+      resource: { serviceName: options.serviceName ?? 'sync-cf-do' },
+    }).pipe(Layer.provide(FetchHttpClient.layer))
+  }
+  return Layer.empty
+}
+
+/** DOs stay active for pending work; no shutdown hook or connection-wide timer is required. */
+const runInBackground = (effect: Effect.Effect<void>) =>
+  effect.pipe(Effect.ignoreCause, Effect.withTracerEnabled(false), Effect.forkDetach, Effect.asVoid)
+
+/** Preserve the known Layer requirements when narrowing the configuration union. */
+const isTracerLayer = (options: SyncBackendOtelOptions | undefined): options is Layer.Layer<never> =>
+  Layer.isLayer(options)
+
+const isExpectedSyncError = (error: SyncRpcError): boolean =>
+  error._tag === 'ServerAheadError' || error._tag === 'BackendIdMismatchError'
+
+const resultToEffect = <A, E>(result: Result.Result<A, E>): Effect.Effect<A, E> =>
+  Result.isSuccess(result) === true ? Effect.succeed(result.success) : Effect.fail(result.failure)

package/src/cf-worker/do/pull.ts

@@ -1,11 +1,11 @@
 import { BackendIdMismatchError, SyncBackend, UnknownError } from '@livestore/common'
-import { splitChunkBySize } from '@livestore/common/sync'
-import { Chunk, Effect, Option, Schema, Stream } from '@livestore/utils/effect'
+import { splitArrayBySize } from '@livestore/common/sync'
+import { Effect, Option, Schema, Stream } from '@livestore/utils/effect'
 
 import { MAX_PULL_EVENTS_PER_MESSAGE, MAX_WS_MESSAGE_BYTES } from '../../common/constants.ts'
 import { SyncMessage } from '../../common/mod.ts'
 import type { ForwardedHeaders } from '../shared.ts'
-import { DoCtx } from './layer.ts'
+import * as DoCtx from './layer.ts'
 
 const encodePullResponse = Schema.encodeSync(SyncMessage.PullResponse)
 
@@ -24,22 +24,20 @@ export const makeEndingPullStream = ({
   headers,
 }: {
   req: SyncMessage.PullRequest
-  payload: Schema.JsonValue | undefined
+  payload: Schema.Json | undefined
   headers: ForwardedHeaders | undefined
-}): Stream.Stream<SyncMessage.PullResponse, UnknownError | BackendIdMismatchError, DoCtx> =>
+}): Stream.Stream<SyncMessage.PullResponse, UnknownError | BackendIdMismatchError, DoCtx.DoCtx> =>
   Effect.gen(function* () {
-    const { doOptions, backendId, storeId, storage } = yield* DoCtx
+    const { doOptions, backendId, storeId, storage } = yield* DoCtx.DoCtx
 
     if (doOptions?.onPull !== undefined) {
-      yield* Effect.tryAll(() =>
+      yield* Effect.trySyncOrPromiseOrEffect(() =>
         doOptions.onPull!(req, {
           storeId,
           ...(payload !== undefined ? { payload } : {}),
           ...(headers !== undefined ? { headers } : {}),
         }),
-      ).pipe(
-        UnknownError.mapToUnknownError,
-      )
+      ).pipe(UnknownError.mapToUnknownError)
     }
 
     if (req.cursor._tag === 'Some' && req.cursor.value.backendId !== backendId) {
@@ -51,8 +49,8 @@ export const makeEndingPullStream = ({
     )
 
     return storedEvents.pipe(
-      Stream.mapChunksEffect(
-        splitChunkBySize({
+      Stream.mapArrayEffect(
+        splitArrayBySize({
           maxItems: MAX_PULL_EVENTS_PER_MESSAGE,
           maxBytes: MAX_WS_MESSAGE_BYTES,
           encode: (batch) =>
@@ -61,23 +59,27 @@ export const makeEndingPullStream = ({
             ),
         }),
       ),
-      Stream.mapAccum(total, (remaining, chunk) => {
-        const asArray = Chunk.toReadonlyArray(chunk)
-        const nextRemaining = Math.max(0, remaining - asArray.length)
+      Stream.mapAccum(
+        () => total,
+        (remaining, array) => {
+          const nextRemaining = Math.max(0, remaining - array.length)
 
-        return [
-          nextRemaining,
-          SyncMessage.PullResponse.make({
-            batch: asArray,
-            pageInfo: nextRemaining > 0 ? SyncBackend.pageInfoMoreKnown(nextRemaining) : SyncBackend.pageInfoNoMore,
-            backendId,
-          }),
-        ] as const
-      }),
+          return [
+            nextRemaining,
+            [
+              SyncMessage.PullResponse.make({
+                batch: array,
+                pageInfo: nextRemaining > 0 ? SyncBackend.pageInfoMoreKnown(nextRemaining) : SyncBackend.pageInfoNoMore,
+                backendId,
+              }),
+            ],
+          ] as const
+        },
+      ),
       Stream.tap(
         Effect.fn(function* (res) {
           if (doOptions?.onPullRes !== undefined) {
-            yield* Effect.tryAll(() => doOptions.onPullRes!(res)).pipe(UnknownError.mapToUnknownError)
+            yield* Effect.trySyncOrPromiseOrEffect(() => doOptions.onPullRes!(res)).pipe(UnknownError.mapToUnknownError)
           }
         }),
       ),
@@ -86,9 +88,7 @@ export const makeEndingPullStream = ({
   }).pipe(
     Stream.unwrap,
     Stream.mapError((cause) =>
-      cause._tag === 'BackendIdMismatchError' || cause._tag === 'UnknownError'
-        ? cause
-        : new UnknownError({ cause }),
+      cause._tag === 'BackendIdMismatchError' || cause._tag === 'UnknownError' ? cause : new UnknownError({ cause }),
     ),
     Stream.withSpan('cloudflare-provider:pull'),
   )

package/src/cf-worker/do/push.test.ts

@@ -0,0 +1,40 @@
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+import { Deferred, Duration, Effect, Fiber, Semaphore } from '@livestore/utils/effect'
+
+import { runSerializedPushAdmission } from './push.ts'
+
+Vitest.describe('sync-cf push admission', () => {
+  Vitest.live('publishes an admitted push before honoring interruption', () =>
+    Effect.gen(function* () {
+      const semaphore = yield* Semaphore.make(1)
+      const persisted = yield* Deferred.make<void>()
+      const allowBroadcast = yield* Deferred.make<void>()
+      const broadcasted = yield* Deferred.make<void>()
+
+      const admissionFiber = yield* runSerializedPushAdmission(
+        semaphore,
+        Effect.gen(function* () {
+          yield* Deferred.succeed(persisted, undefined)
+          yield* Deferred.await(allowBroadcast)
+          yield* Deferred.succeed(broadcasted, undefined)
+        }),
+      ).pipe(Effect.forkChild)
+
+      // Reproduce cancellation after persistence but before the pull broadcast handoff.
+      yield* Deferred.await(persisted)
+      const interruptStarted = yield* Deferred.make<void>()
+      const interruptFiber = yield* Effect.gen(function* () {
+        yield* Deferred.succeed(interruptStarted, undefined)
+        yield* Fiber.interrupt(admissionFiber)
+      }).pipe(Effect.forkChild)
+      yield* Deferred.await(interruptStarted)
+      yield* Effect.yieldNow
+
+      yield* Deferred.succeed(allowBroadcast, undefined)
+      yield* Deferred.await(broadcasted).pipe(Effect.timeout(Duration.seconds(1)))
+      yield* Fiber.join(interruptFiber)
+
+      Vitest.expect(yield* Deferred.isDone(broadcasted)).toBe(true)
+    }),
+  )
+})