@livestore/sync-cf 0.3.0-dev.8 → 0.3.0

package/src/cf-worker/worker.ts

@@ -1,41 +1,150 @@
+import { UnexpectedError } from '@livestore/common'
+import type { Schema } from '@livestore/utils/effect'
+import { Effect, UrlParams } from '@livestore/utils/effect'
+
+import { SearchParamsSchema } from '../common/mod.js'
 import type { Env } from './durable-object.js'
 
 export type CFWorker = {
   fetch: (request: Request, env: Env, ctx: ExecutionContext) => Promise<Response>
 }
 
-export const makeWorker = (): CFWorker => {
+export type MakeWorkerOptions = {
+  validatePayload?: (payload: Schema.JsonValue | undefined) => void | Promise<void>
+  /** @default false */
+  enableCORS?: boolean
+  durableObject?: {
+    /**
+     * Needs to match the binding name from the wrangler config
+     *
+     * @default 'WEBSOCKET_SERVER'
+     */
+    name?: string
+  }
+}
+
+export const makeWorker = (options: MakeWorkerOptions = {}): CFWorker => {
   return {
     fetch: async (request, env, _ctx) => {
       const url = new URL(request.url)
-      const searchParams = url.searchParams
-      const roomId = searchParams.get('room')
 
-      if (roomId === null) {
-        return new Response('Room ID is required', { status: 400 })
+      await new Promise((resolve) => setTimeout(resolve, 500))
+
+      if (request.method === 'GET' && url.pathname === '/') {
+        return new Response('Info: WebSocket sync backend endpoint for @livestore/sync-cf.', {
+          status: 200,
+          headers: { 'Content-Type': 'text/plain' },
+        })
       }
 
-      // This example will refer to the same Durable Object instance,
-      // since the name "foo" is hardcoded.
-      const id = env.WEBSOCKET_SERVER.idFromName(roomId)
-      const durableObject = env.WEBSOCKET_SERVER.get(id)
+      const corsHeaders: HeadersInit = options.enableCORS
+        ? {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+            'Access-Control-Allow-Headers': request.headers.get('Access-Control-Request-Headers') ?? '*',
+          }
+        : {}
 
-      if (url.pathname.endsWith('/websocket')) {
-        const upgradeHeader = request.headers.get('Upgrade')
-        if (!upgradeHeader || upgradeHeader !== 'websocket') {
-          return new Response('Durable Object expected Upgrade: websocket', { status: 426 })
-        }
+      if (request.method === 'OPTIONS' && options.enableCORS) {
+        return new Response(null, {
+          status: 204,
+          headers: corsHeaders,
+        })
+      }
 
-        return durableObject.fetch(request)
+      if (url.pathname.endsWith('/websocket')) {
+        return handleWebSocket(request, env, _ctx, {
+          headers: corsHeaders,
+          validatePayload: options.validatePayload,
+          durableObject: options.durableObject,
+        })
       }
 
-      return new Response(null, {
+      console.error('Invalid path', url.pathname)
+
+      return new Response('Invalid path', {
         status: 400,
         statusText: 'Bad Request',
         headers: {
+          ...corsHeaders,
           'Content-Type': 'text/plain',
         },
       })
     },
   }
 }
+
+/**
+ * Handles `/websocket` endpoint.
+ *
+ * @example
+ * ```ts
+ * const validatePayload = (payload: Schema.JsonValue | undefined) => {
+ *   if (payload?.authToken !== 'insecure-token-change-me') {
+ *     throw new Error('Invalid auth token')
+ *   }
+ * }
+ *
+ * export default {
+ *   fetch: async (request, env, ctx) => {
+ *     if (request.url.endsWith('/websocket')) {
+ *       return handleWebSocket(request, env, ctx, { headers: {}, validatePayload })
+ *     }
+ *
+ *     return new Response('Invalid path', { status: 400, headers: corsHeaders })
+ *   }
+ * }
+ * ```
+ *
+ * @throws {UnexpectedError} If the payload is invalid
+ */
+export const handleWebSocket = (
+  request: Request,
+  env: Env,
+  _ctx: ExecutionContext,
+  options: {
+    headers?: HeadersInit
+    durableObject?: MakeWorkerOptions['durableObject']
+    validatePayload?: (payload: Schema.JsonValue | undefined) => void | Promise<void>
+  },
+): Promise<Response> =>
+  Effect.gen(function* () {
+    const url = new URL(request.url)
+
+    const urlParams = UrlParams.fromInput(url.searchParams)
+    const paramsResult = yield* UrlParams.schemaStruct(SearchParamsSchema)(urlParams).pipe(Effect.either)
+
+    if (paramsResult._tag === 'Left') {
+      return new Response(`Invalid search params: ${paramsResult.left.toString()}`, {
+        status: 500,
+        headers: options?.headers,
+      })
+    }
+
+    const { storeId, payload } = paramsResult.right
+
+    if (options.validatePayload !== undefined) {
+      const result = yield* Effect.promise(async () => options.validatePayload!(payload)).pipe(
+        UnexpectedError.mapToUnexpectedError,
+        Effect.either,
+      )
+
+      if (result._tag === 'Left') {
+        console.error('Invalid payload', result.left)
+        return new Response(result.left.toString(), { status: 400, headers: options.headers })
+      }
+    }
+
+    const durableObjectName = options.durableObject?.name ?? 'WEBSOCKET_SERVER'
+    const durableObjectNamespace = (env as any)[durableObjectName] as DurableObjectNamespace
+
+    const id = durableObjectNamespace.idFromName(storeId)
+    const durableObject = durableObjectNamespace.get(id)
+
+    const upgradeHeader = request.headers.get('Upgrade')
+    if (!upgradeHeader || upgradeHeader !== 'websocket') {
+      return new Response('Durable Object expected Upgrade: websocket', { status: 426, headers: options?.headers })
+    }
+
+    return yield* Effect.promise(() => durableObject.fetch(request))
+  }).pipe(Effect.tapCauseLogPretty, Effect.runPromise)

package/src/common/mod.ts

@@ -1 +1,8 @@
+import { Schema } from '@livestore/utils/effect'
+
 export * as WSMessage from './ws-message-types.js'
+
+export const SearchParamsSchema = Schema.Struct({
+  storeId: Schema.String,
+  payload: Schema.compose(Schema.StringFromUriComponent, Schema.parseJson(Schema.JsonValue)).pipe(Schema.UndefinedOr),
+})

package/src/common/ws-message-types.ts

@@ -1,89 +1,83 @@
-import { MutationEvent } from '@livestore/common/schema'
+import { LiveStoreEvent } from '@livestore/common/schema'
 import { Schema } from '@livestore/utils/effect'
 
 export const PullReq = Schema.TaggedStruct('WSMessage.PullReq', {
   requestId: Schema.String,
   /** Omitting the cursor will start from the beginning */
   cursor: Schema.optional(Schema.Number),
-})
+}).annotations({ title: '@livestore/sync-cf:PullReq' })
 
 export type PullReq = typeof PullReq.Type
 
 export const SyncMetadata = Schema.Struct({
   /** ISO date format */
   createdAt: Schema.String,
-})
+}).annotations({ title: '@livestore/sync-cf:SyncMetadata' })
 
 export type SyncMetadata = typeof SyncMetadata.Type
 
 export const PullRes = Schema.TaggedStruct('WSMessage.PullRes', {
-  requestId: Schema.String,
-  events: Schema.Array(
+  batch: Schema.Array(
     Schema.Struct({
-      mutationEventEncoded: MutationEvent.AnyEncodedGlobal,
+      eventEncoded: LiveStoreEvent.AnyEncodedGlobal,
       metadata: Schema.Option(SyncMetadata),
     }),
   ),
+  requestId: Schema.Struct({ context: Schema.Literal('pull', 'push'), requestId: Schema.String }),
   remaining: Schema.Number,
-})
+}).annotations({ title: '@livestore/sync-cf:PullRes' })
 
 export type PullRes = typeof PullRes.Type
 
-export const PushBroadcast = Schema.TaggedStruct('WSMessage.PushBroadcast', {
-  mutationEventEncoded: MutationEvent.AnyEncodedGlobal,
-  metadata: Schema.Option(SyncMetadata),
-})
-
-export type PushBroadcast = typeof PushBroadcast.Type
-
 export const PushReq = Schema.TaggedStruct('WSMessage.PushReq', {
   requestId: Schema.String,
-  batch: Schema.Array(MutationEvent.AnyEncodedGlobal),
-})
+  batch: Schema.Array(LiveStoreEvent.AnyEncodedGlobal),
+}).annotations({ title: '@livestore/sync-cf:PushReq' })
 
 export type PushReq = typeof PushReq.Type
 
 export const PushAck = Schema.TaggedStruct('WSMessage.PushAck', {
   requestId: Schema.String,
-  mutationId: Schema.Number,
-})
+}).annotations({ title: '@livestore/sync-cf:PushAck' })
 
 export type PushAck = typeof PushAck.Type
 
 export const Error = Schema.TaggedStruct('WSMessage.Error', {
   requestId: Schema.String,
   message: Schema.String,
-})
+}).annotations({ title: '@livestore/sync-cf:Error' })
+
+export type Error = typeof Error.Type
 
 export const Ping = Schema.TaggedStruct('WSMessage.Ping', {
   requestId: Schema.Literal('ping'),
-})
+}).annotations({ title: '@livestore/sync-cf:Ping' })
 
 export type Ping = typeof Ping.Type
 
 export const Pong = Schema.TaggedStruct('WSMessage.Pong', {
   requestId: Schema.Literal('ping'),
-})
+}).annotations({ title: '@livestore/sync-cf:Pong' })
 
 export type Pong = typeof Pong.Type
 
 export const AdminResetRoomReq = Schema.TaggedStruct('WSMessage.AdminResetRoomReq', {
   requestId: Schema.String,
   adminSecret: Schema.String,
-})
+}).annotations({ title: '@livestore/sync-cf:AdminResetRoomReq' })
 
 export type AdminResetRoomReq = typeof AdminResetRoomReq.Type
 
 export const AdminResetRoomRes = Schema.TaggedStruct('WSMessage.AdminResetRoomRes', {
   requestId: Schema.String,
-})
+}).annotations({ title: '@livestore/sync-cf:AdminResetRoomRes' })
 
 export type AdminResetRoomRes = typeof AdminResetRoomRes.Type
 
 export const AdminInfoReq = Schema.TaggedStruct('WSMessage.AdminInfoReq', {
   requestId: Schema.String,
   adminSecret: Schema.String,
-})
+}).annotations({ title: '@livestore/sync-cf:AdminInfoReq' })
 
 export type AdminInfoReq = typeof AdminInfoReq.Type
 
@@ -92,14 +86,13 @@ export const AdminInfoRes = Schema.TaggedStruct('WSMessage.AdminInfoRes', {
   info: Schema.Struct({
     durableObjectId: Schema.String,
   }),
-})
+}).annotations({ title: '@livestore/sync-cf:AdminInfoRes' })
 
 export type AdminInfoRes = typeof AdminInfoRes.Type
 
 export const Message = Schema.Union(
   PullReq,
   PullRes,
-  PushBroadcast,
   PushReq,
   PushAck,
   Error,
@@ -109,19 +102,12 @@ export const Message = Schema.Union(
   AdminResetRoomRes,
   AdminInfoReq,
   AdminInfoRes,
-)
+).annotations({ title: '@livestore/sync-cf:Message' })
+
 export type Message = typeof Message.Type
 export type MessageEncoded = typeof Message.Encoded
 
-export const BackendToClientMessage = Schema.Union(
-  PullRes,
-  PushBroadcast,
-  PushAck,
-  AdminResetRoomRes,
-  AdminInfoRes,
-  Error,
-  Pong,
-)
+export const BackendToClientMessage = Schema.Union(PullRes, PushAck, AdminResetRoomRes, AdminInfoRes, Error, Pong)
 export type BackendToClientMessage = typeof BackendToClientMessage.Type
 
 export const ClientToBackendMessage = Schema.Union(PullReq, PushReq, AdminResetRoomReq, AdminInfoReq, Ping)

package/src/sync-impl/ws-impl.ts

@@ -1,9 +1,9 @@
 /// <reference lib="dom" />
 
-import type { SyncBackend } from '@livestore/common'
-import { InvalidPullError, InvalidPushError } from '@livestore/common'
-import { pick } from '@livestore/utils'
-import type { Scope } from '@livestore/utils/effect'
+import type { SyncBackend, SyncBackendConstructor } from '@livestore/common'
+import { InvalidPullError, InvalidPushError, UnexpectedError } from '@livestore/common'
+import { EventSequenceNumber } from '@livestore/common/schema'
+import { LS_DEV, shouldNeverHappen } from '@livestore/utils'
 import {
   Deferred,
   Effect,
@@ -14,89 +14,139 @@ import {
   Schema,
   Stream,
   SubscriptionRef,
+  UrlParams,
   WebSocket,
 } from '@livestore/utils/effect'
 import { nanoid } from '@livestore/utils/nanoid'
 
-import { WSMessage } from '../common/mod.js'
+import { SearchParamsSchema, WSMessage } from '../common/mod.js'
 import type { SyncMetadata } from '../common/ws-message-types.js'
 
 export interface WsSyncOptions {
   url: string
-  roomId: string
 }
 
-export const makeWsSync = (options: WsSyncOptions): Effect.Effect<SyncBackend<SyncMetadata>, never, Scope.Scope> =>
-  Effect.gen(function* () {
-    const wsUrl = `${options.url}/websocket?room=${options.roomId}`
-
-    const { isConnected, incomingMessages, send } = yield* connect(wsUrl)
-
-    const api = {
-      isConnected,
-      pull: (args) =>
-        Effect.gen(function* () {
-          const requestId = nanoid()
-          const cursor = Option.getOrUndefined(args)?.cursor.global
-
-          yield* send(WSMessage.PullReq.make({ cursor, requestId }))
-
-          return Stream.fromPubSub(incomingMessages).pipe(
-            Stream.filter((_) => (_._tag === 'WSMessage.PullRes' ? _.requestId === requestId : true)),
-            Stream.tap((_) =>
-              _._tag === 'WSMessage.Error' && _.requestId === requestId
-                ? new InvalidPullError({ message: _.message })
-                : Effect.void,
-            ),
-            Stream.filter(Schema.is(Schema.Union(WSMessage.PushBroadcast, WSMessage.PullRes))),
-            Stream.map((msg) =>
-              msg._tag === 'WSMessage.PushBroadcast'
-                ? { batch: [pick(msg, ['mutationEventEncoded', 'metadata'])], remaining: 0 }
-                : {
-                    batch: msg.events.map(({ mutationEventEncoded, metadata }) => ({
-                      mutationEventEncoded,
-                      metadata,
-                    })),
-                    remaining: msg.remaining,
-                  },
-            ),
-          )
-        }).pipe(Stream.unwrap),
-
-      push: (batch) =>
-        Effect.gen(function* () {
-          const ready = yield* Deferred.make<void, InvalidPushError>()
-          const requestId = nanoid()
-
-          yield* Stream.fromPubSub(incomingMessages).pipe(
-            Stream.filter((_) => _._tag !== 'WSMessage.PushBroadcast' && _.requestId === requestId),
-            Stream.tap((_) =>
-              _._tag === 'WSMessage.Error'
-                ? Deferred.fail(ready, new InvalidPushError({ reason: { _tag: 'Unexpected', message: _.message } }))
-                : Effect.void,
-            ),
-            Stream.filter(Schema.is(WSMessage.PushAck)),
-            // TODO bring back filterting of "own events"
-            // Stream.filter((_) => _.mutationId === mutationEventEncoded.id.global),
-            Stream.take(1),
-            Stream.tap(() => Deferred.succeed(ready, void 0)),
-            Stream.runDrain,
-            Effect.tapCauseLogPretty,
-            Effect.fork,
-          )
-
-          yield* send(WSMessage.PushReq.make({ batch, requestId }))
-
-          yield* ready
+export const makeCfSync =
+  (options: WsSyncOptions): SyncBackendConstructor<SyncMetadata> =>
+  ({ storeId, payload }) =>
+    Effect.gen(function* () {
+      const urlParamsData = yield* Schema.encode(SearchParamsSchema)({
+        storeId,
+        payload,
+      }).pipe(UnexpectedError.mapToUnexpectedError)
+
+      const urlParams = UrlParams.fromInput(urlParamsData)
+      const wsUrl = `${options.url}/websocket?${UrlParams.toString(urlParams)}`
+
+      const { isConnected, incomingMessages, send } = yield* connect(wsUrl)
+
+      /**
+       * We need to account for the scenario where push-caused PullRes message arrive before the pull-caused PullRes message.
+       * i.e. a scenario where the WS connection is created but before the server processed the initial pull, a push from
+       * another client triggers a PullRes message sent to this client which we need to stash until our pull-caused
+       * PullRes message arrives at which point we can combine the stashed events with the pull-caused events and continue.
+       */
+      const stashedPullBatch: WSMessage.PullRes['batch'][number][] = []
+
+      // We currently only support one pull stream for a sync backend.
+      let pullStarted = false
+
+      const api = {
+        isConnected,
+        // Currently we're already eagerly connecting when the sync backend is created but we might want to refactor this later to clean this up
+        connect: Effect.void,
+        pull: (args) =>
+          Effect.gen(function* () {
+            if (pullStarted) {
+              return shouldNeverHappen(`Pull already started for this sync backend.`)
+            }
 
-          const createdAt = new Date().toISOString()
-
-          return { metadata: Array.from({ length: batch.length }, () => Option.some({ createdAt })) }
-        }),
-    } satisfies SyncBackend<SyncMetadata>
-
-    return api
-  })
+            pullStarted = true
+
+            let pullResponseReceived = false
+
+            const requestId = nanoid()
+            const cursor = Option.getOrUndefined(args)?.cursor.global
+
+            yield* send(WSMessage.PullReq.make({ cursor, requestId }))
+
+            return Stream.fromPubSub(incomingMessages).pipe(
+              Stream.tap((_) =>
+                _._tag === 'WSMessage.Error' && _.requestId === requestId
+                  ? new InvalidPullError({ message: _.message })
+                  : Effect.void,
+              ),
+              Stream.filterMap((msg) => {
+                if (msg._tag === 'WSMessage.PullRes') {
+                  if (msg.requestId.context === 'pull') {
+                    if (msg.requestId.requestId === requestId) {
+                      pullResponseReceived = true
+
+                      if (stashedPullBatch.length > 0 && msg.remaining === 0) {
+                        const pullResHead = msg.batch.at(-1)?.eventEncoded.seqNum ?? EventSequenceNumber.ROOT.global
+                        // Index where stashed events are greater than pullResHead
+                        const newPartialBatchIndex = stashedPullBatch.findIndex(
+                          (batchItem) => batchItem.eventEncoded.seqNum > pullResHead,
+                        )
+                        const batchWithNewStashedEvents =
+                          newPartialBatchIndex === -1 ? [] : stashedPullBatch.slice(newPartialBatchIndex)
+                        const combinedBatch = [...msg.batch, ...batchWithNewStashedEvents]
+                        return Option.some({ ...msg, batch: combinedBatch, remaining: 0 })
+                      } else {
+                        return Option.some(msg)
+                      }
+                    } else {
+                      // Ignore
+                      return Option.none()
+                    }
+                  } else {
+                    if (pullResponseReceived) {
+                      return Option.some(msg)
+                    } else {
+                      stashedPullBatch.push(...msg.batch)
+                      return Option.none()
+                    }
+                  }
+                }
+
+                return Option.none()
+              }),
+            )
+          }).pipe(Stream.unwrap),
+
+        push: (batch) =>
+          Effect.gen(function* () {
+            const pushAck = yield* Deferred.make<void, InvalidPushError>()
+            const requestId = nanoid()
+
+            yield* Stream.fromPubSub(incomingMessages).pipe(
+              Stream.tap((_) =>
+                _._tag === 'WSMessage.Error' && _.requestId === requestId
+                  ? Deferred.fail(pushAck, new InvalidPushError({ reason: { _tag: 'Unexpected', message: _.message } }))
+                  : Effect.void,
+              ),
+              Stream.filter((_) => _._tag === 'WSMessage.PushAck' && _.requestId === requestId),
+              Stream.take(1),
+              Stream.tap(() => Deferred.succeed(pushAck, void 0)),
+              Stream.runDrain,
+              Effect.tapCauseLogPretty,
+              Effect.fork,
+            )
+
+            yield* send(WSMessage.PushReq.make({ batch, requestId }))
+
+            yield* pushAck
+          }),
+        metadata: {
+          name: '@livestore/cf-sync',
+          description: 'LiveStore sync backend implementation using Cloudflare Workers & Durable Objects',
+          protocol: 'ws',
+          url: options.url,
+        },
+      } satisfies SyncBackend<SyncMetadata>
+
+      return api
+    })
 
 const connect = (wsUrl: string) =>
   Effect.gen(function* () {
@@ -114,21 +164,23 @@ const connect = (wsUrl: string) =>
         // Wait first until we're online
         yield* waitUntilOnline
 
-        yield* Effect.spanEvent(
-          `Sending message: ${message._tag}`,
-          message._tag === 'WSMessage.PushReq'
-            ? {
-                id: message.batch[0]!.id,
-                parentId: message.batch[0]!.parentId,
-                batchLength: message.batch.length,
-              }
-            : message._tag === 'WSMessage.PullReq'
-              ? { cursor: message.cursor ?? '-' }
-              : {},
-        )
-
         // TODO use MsgPack instead of JSON to speed up the serialization / reduce the size of the messages
         socketRef.current!.send(Schema.encodeSync(Schema.parseJson(WSMessage.Message))(message))
+
+        if (LS_DEV) {
+          yield* Effect.spanEvent(
+            `Sent message: ${message._tag}`,
+            message._tag === 'WSMessage.PushReq'
+              ? {
+                  seqNum: message.batch[0]!.seqNum,
+                  parentSeqNum: message.batch[0]!.parentSeqNum,
+                  batchLength: message.batch.length,
+                }
+              : message._tag === 'WSMessage.PullReq'
+                ? { cursor: message.cursor ?? '-' }
+                : {},
+          )
+        }
       })
 
     const innerConnect = Effect.gen(function* () {
@@ -137,11 +189,13 @@ const connect = (wsUrl: string) =>
       while (typeof navigator !== 'undefined' && navigator.onLine === false) {
         yield* Effect.sleep(1000)
       }
+      // TODO bring this back in a cross-platform way
       // if (navigator.onLine === false) {
       //   yield* Effect.async((cb) => self.addEventListener('online', () => cb(Effect.void)))
       // }
 
       const socket = yield* WebSocket.makeWebSocket({ url: wsUrl, reconnect: Schedule.exponential(100) })
+      // socket.binaryType = 'arraybuffer'
 
       yield* SubscriptionRef.set(isConnected, true)
       socketRef.current = socket
@@ -182,7 +236,8 @@ const connect = (wsUrl: string) =>
       // NOTE it seems that this callback doesn't work reliably on a worker but only via `window.addEventListener`
       // We might need to proxy the event from the main thread to the worker if we want this to work reliably.
       // eslint-disable-next-line unicorn/prefer-global-this
-      if (typeof self !== 'undefined') {
+      if (typeof self !== 'undefined' && typeof self.addEventListener === 'function') {
+        // TODO support an Expo equivalent for this
         // eslint-disable-next-line unicorn/prefer-global-this
         yield* Effect.eventListener(self, 'offline', () => Deferred.succeed(connectionClosed, void 0))
       }

package/dist/cf-worker/index.d.ts

@@ -1,3 +0,0 @@
-/// <reference no-default-lib="true"/>
-export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/cf-worker/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cf-worker/index.ts"],"names":[],"mappings":""}

package/dist/cf-worker/index.js

@@ -1,33 +0,0 @@
-/// <reference no-default-lib="true"/>
-/// <reference lib="esnext" />
-export {};
-// export * from './durable-object.js'
-// export default {
-//   fetch: async (request: Request, env: Env, _ctx: ExecutionContext): Promise<Response> => {
-//     const url = new URL(request.url)
-//     const searchParams = url.searchParams
-//     const roomId = searchParams.get('room')
-//     if (roomId === null) {
-//       return new Response('Room ID is required', { status: 400 })
-//     }
-//     // This example will refer to the same Durable Object instance,
-//     // since the name "foo" is hardcoded.
-//     const id = env.WEBSOCKET_SERVER.idFromName(roomId)
-//     const durableObject = env.WEBSOCKET_SERVER.get(id)
-//     if (url.pathname.endsWith('/websocket')) {
-//       const upgradeHeader = request.headers.get('Upgrade')
-//       if (!upgradeHeader || upgradeHeader !== 'websocket') {
-//         return new Response('Durable Object expected Upgrade: websocket', { status: 426 })
-//       }
-//       return durableObject.fetch(request)
-//     }
-//     return new Response(null, {
-//       status: 400,
-//       statusText: 'Bad Request',
-//       headers: {
-//         'Content-Type': 'text/plain',
-//       },
-//     })
-//   },
-// }
-//# sourceMappingURL=index.js.map

package/dist/cf-worker/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/cf-worker/index.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,8BAA8B;;AAI9B,sCAAsC;AAEtC,mBAAmB;AACnB,8FAA8F;AAC9F,uCAAuC;AACvC,4CAA4C;AAC5C,8CAA8C;AAE9C,6BAA6B;AAC7B,oEAAoE;AACpE,QAAQ;AAER,sEAAsE;AACtE,4CAA4C;AAC5C,yDAAyD;AACzD,yDAAyD;AAEzD,iDAAiD;AACjD,6DAA6D;AAC7D,+DAA+D;AAC/D,6FAA6F;AAC7F,UAAU;AAEV,4CAA4C;AAC5C,QAAQ;AAER,kCAAkC;AAClC,qBAAqB;AACrB,mCAAmC;AACnC,mBAAmB;AACnB,wCAAwC;AACxC,WAAW;AACX,SAAS;AACT,OAAO;AACP,IAAI"}

package/dist/cf-worker/make-worker.d.ts

@@ -1,6 +0,0 @@
-import type { Env } from './durable-object.js';
-export type CFWorker = {
-    fetch: (request: Request, env: Env, ctx: ExecutionContext) => Promise<Response>;
-};
-export declare const makeWorker: () => CFWorker;
-//# sourceMappingURL=make-worker.d.ts.map

package/dist/cf-worker/make-worker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"make-worker.d.ts","sourceRoot":"","sources":["../../src/cf-worker/make-worker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,qBAAqB,CAAA;AAE9C,MAAM,MAAM,QAAQ,GAAG;IACrB,KAAK,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,gBAAgB,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;CAChF,CAAA;AAED,eAAO,MAAM,UAAU,QAAO,QAkC7B,CAAA"}