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

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

@@ -1,53 +1,62 @@
 import { UnknownError } from '@livestore/common'
 import { type CfTypes, toDurableObjectHandler } from '@livestore/common-cf'
-import {
-  Effect,
-  Headers,
-  HttpServer,
-  Layer,
-  Logger,
-  LogLevel,
-  Option,
-  RpcSerialization,
-  Stream,
-} from '@livestore/utils/effect'
+import { Effect, Headers, Option, Stream } from '@livestore/utils/effect'
 
 import { SyncDoRpc } from '../../../common/do-rpc-schema.ts'
-import { SyncMessage } from '../../../common/mod.ts'
-import { DoCtx, type DoCtxInput } from '../layer.ts'
+import { rpcSubscriptionKeyPrefix, type RpcSubscription } from '../../shared.ts'
+import * as DoCtx from '../layer.ts'
+import { makeRpcSpanOptions, type makeObservability, withRpcStreamSpan } from '../observability.ts'
 import { makeEndingPullStream } from '../pull.ts'
 import { makePush } from '../push.ts'
 
 export interface DoRpcHandlerOptions {
   payload: Uint8Array<ArrayBuffer>
-  input: Omit<DoCtxInput, 'from'>
+  input: Omit<DoCtx.DoCtxInput, 'from'>
+  observability: ReturnType<typeof makeObservability>
+}
+
+/**
+ * Drops a live-pull subscription row only if it still belongs to the pull that asked. A replacement store booted on
+ * the same client DO while a slow shutdown is still draining overwrites the row with its own request id, and the
+ * earlier pull's late unsubscribe must not take that subscription down.
+ */
+export const dropRpcSubscription = (
+  kv: { get: (key: string) => RpcSubscription | undefined; delete: (key: string) => unknown },
+  { durableObjectId, requestId }: { durableObjectId: string; requestId: string },
+): void => {
+  const key = `${rpcSubscriptionKeyPrefix}${durableObjectId}`
+  if (kv.get(key)?.requestId === requestId) {
+    kv.delete(key)
+  }
 }
 
 export const createDoRpcHandler = (
   options: DoRpcHandlerOptions,
 ): Effect.Effect<Uint8Array<ArrayBuffer> | CfTypes.ReadableStream> =>
-  Effect.gen(this, function* () {
-    const { payload, input } = options
-    // const { rpcSubscriptions, backendId, doOptions, ctx, env } = yield* DoCtx
+  Effect.gen({ self: this }, function* () {
+    const { payload, input, observability } = options
+    const parent = yield* Effect.currentParentSpan.pipe(Effect.option)
 
     // TODO add admin RPCs
     const RpcLive = SyncDoRpc.toLayer({
-      'SyncDoRpc.Ping': (_req) => {
-        return Effect.succeed(SyncMessage.Pong.make({}))
-      },
+      'SyncDoRpc.Ping': () => Effect.void,
+      'SyncDoRpc.Unsubscribe': (req) => Effect.sync(() => dropRpcSubscription(input.doSelf.ctx.storage.kv, req)),
       'SyncDoRpc.Pull': (req, { headers }) =>
-        Effect.gen(this, function* () {
-          const { rpcSubscriptions } = yield* DoCtx
+        Effect.gen({ self: this }, function* () {
+          const { ctx } = yield* DoCtx.DoCtx
 
           // TODO rename `req.rpcContext` to something more appropriate
           if (req.rpcContext !== undefined) {
-            rpcSubscriptions.set(req.storeId, {
+            const subscription: RpcSubscription = {
               storeId: req.storeId,
               subscribedAt: Date.now(),
               requestId: Headers.get(headers, 'x-rpc-request-id').pipe(Option.getOrThrow),
               callerContext: req.rpcContext.callerContext,
               ...(req.payload !== undefined ? { payload: req.payload } : {}),
-            })
+            }
+            // Keyed by client DO id (not storeId — one backend serves many client DOs). The DO's synchronous KV
+            // storage is the single source of truth, so the entry outlives backend reconstruction.
+            ctx.storage.kv.put(`${rpcSubscriptionKeyPrefix}${subscription.callerContext.durableObjectId}`, subscription)
           }
 
           // DO-RPC doesn't have HTTP headers context - headers are undefined
@@ -58,25 +67,30 @@ export const createDoRpcHandler = (
             ...res,
             rpcRequestId: Headers.get(headers, 'x-rpc-request-id').pipe(Option.getOrThrow),
           })),
-          Stream.provideLayer(DoCtx.Default({ ...input, from: { storeId: req.storeId } })),
+          Stream.provide(DoCtx.layer({ ...input, from: { storeId: req.storeId } })),
           Stream.mapError((cause) =>
             cause._tag === 'UnknownError' || cause._tag === 'BackendIdMismatchError'
               ? cause
               : new UnknownError({ cause }),
           ),
-          Stream.tapErrorCause(Effect.log),
+          Stream.tapCause(Effect.log),
+          // The bridge runs this stream in a separate runtime. Install telemetry there too.
+          (_) => withRpcStreamSpan(_, 'RpcServer.SyncDoRpc.Pull', makeRpcSpanOptions(parent)),
+          observability.stream,
         ),
       'SyncDoRpc.Push': (req) =>
-        Effect.gen(this, function* () {
-          const { doOptions, ctx, env, storeId } = yield* DoCtx
+        Effect.gen({ self: this }, function* () {
+          const { doOptions, ctx, env, storeId } = yield* DoCtx.DoCtx
           // DO-RPC doesn't have HTTP headers context - headers are undefined
           const push = makePush({ storeId, payload: req.payload, headers: undefined, options: doOptions, ctx, env })
 
           return yield* push(req)
         }).pipe(
-          Effect.provide(DoCtx.Default({ ...input, from: { storeId: req.storeId } })),
+          Effect.provide(DoCtx.layer({ ...input, from: { storeId: req.storeId } })),
           Effect.mapError((cause) =>
-            cause._tag === 'UnknownError' || cause._tag === 'ServerAheadError' || cause._tag === 'BackendIdMismatchError'
+            cause._tag === 'UnknownError' ||
+            cause._tag === 'ServerAheadError' ||
+            cause._tag === 'BackendIdMismatchError'
               ? cause
               : new UnknownError({ cause }),
           ),
@@ -85,11 +99,8 @@ export const createDoRpcHandler = (
     })
 
     const handler = toDurableObjectHandler(SyncDoRpc, {
-      layer: Layer.mergeAll(RpcLive, RpcSerialization.layerJson, HttpServer.layerContext).pipe(
-        Layer.provide(Logger.consoleWithThread('SyncDo')),
-        Layer.provide(Logger.minimumLogLevel(LogLevel.Debug)),
-      ),
+      layer: RpcLive,
     })
 
-    return yield* handler(payload)
+    return yield* handler(payload).pipe(Effect.annotateLogs({ thread: 'SyncDo' }))
   }).pipe(Effect.withSpan('createDoRpcHandler'))

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,62 +1,86 @@
 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 { type makeObservability, rpcSpanOptions, withRpcSpan, withRpcStreamSpan } from '../observability.ts'
 import { makeEndingPullStream } from '../pull.ts'
 import { makePush } from '../push.ts'
 
-export const makeRpcServer = ({ doSelf, doOptions }: Omit<DoCtxInput, 'from'>) => {
-  const handlersLayer = SyncWsRpc.toLayer({
+export const makeRpcServer = ({
+  doSelf,
+  doOptions,
+  observability,
+}: Omit<DoCtx.DoCtxInput, 'from'> & { observability: ReturnType<typeof makeObservability> }) => {
+  const handlersLayer = makeRpcHandlers({ doSelf, doOptions, observability })
+
+  return RpcServer.layer(SyncWsRpc).pipe(Layer.provide(handlersLayer))
+}
+
+/** Production handler layer, exported so transport tests can exercise the exact RPC composition in memory. */
+export const makeRpcHandlers = ({
+  doSelf,
+  doOptions,
+  observability,
+}: Omit<DoCtx.DoCtxInput, 'from'> & { observability: ReturnType<typeof makeObservability> }) =>
+  SyncWsRpc.toLayer({
     'SyncWsRpc.Pull': (req) =>
       Effect.gen(function* () {
+        const spanOptions = yield* rpcSpanOptions
         const headers = yield* getForwardedHeaders
         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
               : new UnknownError({ cause }),
           ),
+          (_) => withRpcStreamSpan(_, 'RpcServer.SyncWsRpc.Pull', spanOptions),
         )
-      }).pipe(Stream.unwrap),
+      }).pipe(
+        Stream.unwrap,
+        // Drain finite history before entering the live phase, which survives DO hibernation.
+        observability.stream,
+        // Keep the client subscription open without retaining an exporter scope or timer.
+        req.live === true ? Stream.concat(Stream.never) : identity,
+      ),
     'SyncWsRpc.Push': (req) =>
-      Effect.gen(function* () {
-        const { doOptions, storeId, ctx, env } = yield* DoCtx
-        const headers = yield* getForwardedHeaders
+      Effect.flatMap(rpcSpanOptions, (spanOptions) =>
+        Effect.gen(function* () {
+          const { doOptions, storeId, ctx, env } = yield* DoCtx.DoCtx
+          const headers = yield* getForwardedHeaders
 
-        const push = makePush({ options: doOptions, storeId, payload: req.payload, headers, ctx, env })
+          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.mapError((cause) =>
-          cause._tag === 'UnknownError' || cause._tag === 'ServerAheadError' || cause._tag === 'BackendIdMismatchError'
-            ? cause
-            : new UnknownError({ cause }),
+          return yield* push(req)
+        }).pipe(
+          Effect.provide(DoCtx.layer({ doSelf, doOptions, from: { storeId: req.storeId } })),
+          Effect.mapError((cause) =>
+            cause._tag === 'UnknownError' ||
+            cause._tag === 'ServerAheadError' ||
+            cause._tag === 'BackendIdMismatchError'
+              ? cause
+              : new UnknownError({ cause }),
+          ),
+          Effect.tapCauseLogPretty,
+          (_) => withRpcSpan(_, 'RpcServer.SyncWsRpc.Push', spanOptions),
         ),
-        Effect.tapCauseLogPretty,
-      ),
+      ).pipe(observability.effect),
   })
 
-  return RpcServer.layer(SyncWsRpc).pipe(Layer.provide(handlersLayer))
-}
-
 /** Extracts forwarded headers from the WebSocket attachment */
 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, Layer } 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
 }
@@ -106,12 +107,19 @@ export type MakeDurableObjectClassOptions = {
     responseHeaders?: Record<string, string>
   }
 
-  otel?: {
-    baseUrl?: string
-    serviceName?: string
-  }
+  /** Optional telemetry. Omit to avoid creating an exporter or sending telemetry. */
+  otel?: SyncBackendOtelOptions
 }
 
+export type SyncBackendOtelOptions =
+  /** Application-supplied tracer layer; LiveStore builds and finalizes its resources per sync operation. */
+  | Layer.Layer<never>
+  | {
+      /** Convenience OTLP/HTTP JSON exporter owned by LiveStore for each operation. */
+      baseUrl?: string
+      serviceName?: string
+    }
+
 export type StoreId = string
 export type DurableObjectId = string
 
@@ -133,8 +141,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 +153,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.decodeResult(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 +175,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 +186,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.decodeResult(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 } : {}) })
         }
       }
     }