@pluv/platform-cloudflare 0.0.0-experimental-20250527040415

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Shoubhit Dash
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,18 @@
+## `@pluv/platform-cloudflare`
+
+> Enables [@pluv/io](https://www.npmjs.com/package/@pluv/io) to run on [Cloudflare Workers](https://workers.cloudflare.com/).
+
+**👉 See full documentation on [pluv.io](https://pluv.io/docs/introduction). 👈**
+
+## Installation
+
+```bash
+# npm
+npm install @pluv/platform-cloudflare
+
+# yarn
+yarn add @pluv/platform-cloudflare
+
+# pnpm
+pnpm add @pluv/platform-cloudflare
+```

package/dist/index.d.mts

@@ -0,0 +1,127 @@
+import { AbstractWebSocket, WebSocketSession, WebSocketSerializedState, AbstractWebSocketConfig, AbstractEventMap, AbstractListener, AbstractPlatform, WebSocketRegistrationMode, AbstractPlatformConfig, ConvertWebSocketConfig, PluvServer, InferInitContextType, CreateIOParams, PluvIOAuthorize, PluvContext } from '@pluv/io';
+import { IOAuthorize, JsonObject, InferIOAuthorizeUser, Json, MaybePromise, InferIOAuthorize, BaseUser, Maybe, Id } from '@pluv/types';
+import { DurableObject } from 'cloudflare:workers';
+
+type CloudflareWebSocketConfig = AbstractWebSocketConfig;
+declare class CloudflareWebSocket<TAuthorize extends IOAuthorize<any, any> | null = null> extends AbstractWebSocket<WebSocket, TAuthorize> {
+    set presence(presence: JsonObject | null);
+    get readyState(): 0 | 1 | 2 | 3;
+    get session(): WebSocketSession<TAuthorize>;
+    get sessionId(): string;
+    get state(): WebSocketSerializedState;
+    set state(state: WebSocketSerializedState);
+    set user(user: InferIOAuthorizeUser<TAuthorize>);
+    constructor(webSocket: WebSocket, config: CloudflareWebSocketConfig);
+    addEventListener<TType extends keyof AbstractEventMap>(type: TType, handler: AbstractListener<TType>): void;
+    close(code?: number | undefined, reason?: string | undefined): void;
+    send(message: string | ArrayBuffer | ArrayBufferView): void;
+    terminate(code?: number): void;
+}
+
+type CloudflarePlatformRoomContext<TEnv extends Record<string, any>, TMeta extends Record<string, Json>> = {
+    env: TEnv;
+    state: DurableObjectState;
+} & (keyof TMeta extends never ? {
+    meta?: undefined;
+} : {
+    meta: TMeta;
+});
+type CloudflarePlatformConfig<TEnv extends Record<string, any> = {}, TMeta extends Record<string, Json> = {}> = AbstractPlatformConfig<CloudflarePlatformRoomContext<TEnv, TMeta>> & {
+    mode?: WebSocketRegistrationMode;
+};
+declare class CloudflarePlatform<TAuthorize extends IOAuthorize<any, any> | null = null, TEnv extends Record<string, any> = {}, TMeta extends Record<string, Json> = {}> extends AbstractPlatform<CloudflareWebSocket<TAuthorize>, {
+    env: TEnv;
+    request: Request;
+}, CloudflarePlatformRoomContext<TEnv, TMeta>, {
+    authorize: {
+        secret: true;
+    };
+    handleMode: "io";
+    requireAuth: false;
+    registrationMode: WebSocketRegistrationMode;
+    listeners: {
+        onRoomDeleted: true;
+        onRoomMessage: true;
+        onStorageUpdated: true;
+        onUserConnected: true;
+        onUserDisconnected: true;
+    };
+    router: true;
+}> {
+    readonly id: string;
+    readonly _config: {
+        authorize: {
+            secret: true;
+        };
+        handleMode: "io";
+        registrationMode: WebSocketRegistrationMode;
+        requireAuth: false;
+        listeners: {
+            onRoomDeleted: true;
+            onRoomMessage: true;
+            onStorageUpdated: true;
+            onUserConnected: true;
+            onUserDisconnected: true;
+        };
+        router: true;
+    };
+    readonly _name = "platformCloudflare";
+    constructor(config: CloudflarePlatformConfig<TEnv, TMeta>);
+    acceptWebSocket(webSocket: CloudflareWebSocket<TAuthorize>): Promise<void>;
+    convertWebSocket(webSocket: WebSocket, config: ConvertWebSocketConfig): CloudflareWebSocket<TAuthorize>;
+    getLastPing(webSocket: CloudflareWebSocket<TAuthorize>): number | null;
+    getSerializedState(webSocket: WebSocket): WebSocketSerializedState | null;
+    getSessionId(webSocket: WebSocket): string | null;
+    getWebSockets(): readonly WebSocket[];
+    initialize(config: AbstractPlatformConfig<CloudflarePlatformRoomContext<TEnv, TMeta>>): this;
+    parseData(data: string | ArrayBuffer): Record<string, any>;
+    randomUUID(): string;
+    setSerializedState(webSocket: CloudflareWebSocket<TAuthorize>, state: WebSocketSerializedState): WebSocketSerializedState;
+    private _getDetachedState;
+}
+
+type AuthorizeFunctionContext<TPluvServer extends PluvServer<any, any, any, any>> = {
+    room: string;
+} & InferInitContextType<TPluvServer extends PluvServer<infer IPlatform, any, any, any> ? IPlatform : never>;
+type AuthorizeFunction<TPluvServer extends PluvServer<any, any, any, any>> = (ctx: AuthorizeFunctionContext<TPluvServer>) => MaybePromise<Maybe<InferIOAuthorizeUser<InferIOAuthorize<TPluvServer>>>>;
+type CreatePluvHandlerConfig<TPluvServer extends PluvServer<any, any, any, any>, TEnv extends Record<string, any>> = {
+    binding: string;
+    endpoint?: string;
+    modify?: (request: Request, response: Response, env: TEnv) => MaybePromise<Response>;
+    io: TPluvServer;
+} & (InferIOAuthorizeUser<InferIOAuthorize<TPluvServer>> extends BaseUser ? {
+    authorize: AuthorizeFunction<TPluvServer>;
+} : {
+    authorize?: undefined;
+});
+type PluvHandlerFetch<TEnv extends Record<string, any> = {}> = (request: Request, env: TEnv) => Promise<Response | null>;
+interface CreatePluvHandlerResult<TEnv extends Record<string, any> = {}> {
+    DurableObject: {
+        new (state: DurableObjectState, env: TEnv): DurableObject<TEnv>;
+    };
+    fetch: PluvHandlerFetch<TEnv>;
+    handler: ExportedHandler<TEnv>;
+}
+type InferCloudflarePluvHandlerEnv<TPluvServer extends PluvServer<CloudflarePlatform<any, any>, any, any, any>> = TPluvServer extends PluvServer<CloudflarePlatform<any, infer IEnv>, any, any, any> ? IEnv : {};
+/**
+ * @deprecated Instructions will be provided on https://pluv.io on how to host this yourself instead.
+ * @date April 27, 2025
+ */
+declare const createPluvHandler: <TPluvServer extends PluvServer<CloudflarePlatform<any, any>, any, any, any>>(config: CreatePluvHandlerConfig<TPluvServer, Id<InferCloudflarePluvHandlerEnv<TPluvServer>>>) => CreatePluvHandlerResult<Id<InferCloudflarePluvHandlerEnv<TPluvServer>>>;
+
+declare const identity: <T extends unknown>(x: T) => T;
+
+type InferCallback<TEnv extends Record<string, any> = {}, TMeta extends Record<string, Json> = {}> = (i: typeof identity) => {
+    env?: (io: TEnv) => TEnv;
+    meta?: (io: TMeta) => TMeta;
+};
+declare const infer: <TEnv extends Record<string, any> = {}, TMeta extends Record<string, Json> = {}>(callback: InferCallback<TEnv, TMeta>) => InferCallback<TEnv, TMeta>;
+
+type PlatformCloudflareCreateIOParams<TEnv extends Record<string, any> = {}, TMeta extends Record<string, Json> = {}, TContext extends Record<string, any> = {}, TUser extends BaseUser | null = null> = Id<CloudflarePlatformConfig<TEnv, TMeta> & Omit<CreateIOParams<CloudflarePlatform<IOAuthorize<TUser, TContext>, TEnv, TMeta>, TContext, TUser>, "authorize" | "context" | "platform"> & {
+    authorize?: PluvIOAuthorize<CloudflarePlatform<IOAuthorize<TUser, TContext>, TEnv, TMeta>, TUser, InferInitContextType<CloudflarePlatform<IOAuthorize<TUser, TContext>, TEnv, TMeta>>>;
+    context?: PluvContext<CloudflarePlatform<IOAuthorize<TUser, any>, TEnv, TMeta>, TContext>;
+    types?: InferCallback<TEnv, TMeta>;
+}>;
+declare const platformCloudflare: <TEnv extends Record<string, any> = {}, TMeta extends Record<string, Json> = {}, TContext extends Record<string, any> = {}, TUser extends BaseUser | null = null>(config?: PlatformCloudflareCreateIOParams<TEnv, TMeta, TContext, TUser>) => CreateIOParams<CloudflarePlatform<IOAuthorize<TUser, TContext>, TEnv, TMeta>, TContext, TUser>;
+
+export { type AuthorizeFunction, type AuthorizeFunctionContext, CloudflarePlatform, type CloudflarePlatformConfig, type CreatePluvHandlerConfig, type CreatePluvHandlerResult, type InferCallback, type PlatformCloudflareCreateIOParams, type PluvHandlerFetch, createPluvHandler, infer, platformCloudflare };

package/dist/index.mjs

@@ -0,0 +1,412 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/createPluvHandler.ts
+import { DurableObject as BaseDurableObject } from "cloudflare:workers";
+import { match } from "path-to-regexp";
+
+// src/constants.ts
+var DEFAULT_REGISTRATION_MODE = "detached";
+var GARBAGE_COLLECT_INTERVAL_MS = 6e4;
+
+// src/createPluvHandler.ts
+var createPluvHandler = (config) => {
+  const { authorize, binding, endpoint = "/api/pluv", modify, io } = config;
+  const DurableObject = class extends BaseDurableObject {
+    constructor(state, env) {
+      super(state, env);
+      this._room = io.createRoom(state.id.toString(), { env, state });
+    }
+    webSocketClose(ws, code, reason, wasClean) {
+      return __async(this, null, function* () {
+        if (io._defs.platform._config.registrationMode !== "detached") return;
+        const onCloseHandler = this._room.onClose(ws);
+        yield onCloseHandler({ code, reason });
+      });
+    }
+    webSocketError(ws, error) {
+      return __async(this, null, function* () {
+        if (io._defs.platform._config.registrationMode !== "detached") return;
+        const onErrorHandler = this._room.onError(ws);
+        const eventError = error instanceof Error ? error : new Error("Internal Error");
+        yield onErrorHandler({ error: eventError, message: eventError.message });
+      });
+    }
+    webSocketMessage(ws, message) {
+      return __async(this, null, function* () {
+        if (io._defs.platform._config.registrationMode !== "detached") return;
+        const onMessageHandler = this._room.onMessage(ws);
+        yield onMessageHandler({ data: message });
+      });
+    }
+    fetch(request) {
+      return __async(this, null, function* () {
+        const isWSRequest = request.headers.get("Upgrade") === "websocket";
+        if (!isWSRequest) return new Response("Expected websocket", { status: 400 });
+        const { 0: client, 1: server } = new WebSocketPair();
+        const token = new URL(request.url).searchParams.get("token");
+        const alarm = yield this.ctx.storage.getAlarm();
+        if (alarm !== null)
+          yield this.ctx.storage.setAlarm(Date.now() + GARBAGE_COLLECT_INTERVAL_MS);
+        yield this._room.register(server, { env: this.env, request, token });
+        return new Response(null, { status: 101, webSocket: client });
+      });
+    }
+    alarm(alarmInfo) {
+      return __async(this, null, function* () {
+        yield this._room.garbageCollect();
+        yield this.ctx.storage.setAlarm(Date.now() + GARBAGE_COLLECT_INTERVAL_MS);
+      });
+    }
+  };
+  const getDurableObjectNamespace = (env) => {
+    const namespace = env[binding];
+    if (!namespace) {
+      throw new Error(`Could not find DurableObject binding: ${binding}`);
+    }
+    return namespace;
+  };
+  const authHandler = (request, env) => __async(null, null, function* () {
+    if (!authorize) return null;
+    const { pathname, searchParams } = new URL(request.url);
+    const matcher = match(`${endpoint}/authorize`);
+    const matched = matcher(pathname);
+    if (!matched) return null;
+    const room = searchParams.get("room");
+    if (!room) {
+      return new Response("Not found", {
+        headers: { "Content-Type": "text/plain" },
+        status: 404
+      });
+    }
+    try {
+      const user = yield authorize({
+        env,
+        request,
+        room
+      });
+      if (!user) throw new Error();
+      const namespace = getDurableObjectNamespace(env);
+      const durableObjectId = namespace.idFromName(room);
+      const token = yield io.createToken({
+        env,
+        room: durableObjectId.toString(),
+        user,
+        request
+      });
+      return new Response(token, {
+        headers: { "Content-Type": "text/plain" },
+        status: 200
+      });
+    } catch (err) {
+      return new Response(err instanceof Error ? err.message : "Unauthorized", {
+        headers: { "Content-Type": "text/plain" },
+        status: 403
+      });
+    }
+  });
+  const roomHandler = (request, env) => __async(null, null, function* () {
+    const { pathname } = new URL(request.url);
+    const matcher = match(`${endpoint}/room/:roomId`);
+    const matched = matcher(pathname);
+    if (!matched) return null;
+    const { roomId } = matched.params;
+    if (!roomId) {
+      return new Response("Not found", {
+        headers: { "Content-Type": "text/plain" },
+        status: 404
+      });
+    }
+    const namespace = getDurableObjectNamespace(env);
+    const durableObjectId = namespace.idFromName(roomId);
+    const room = namespace.get(durableObjectId);
+    return room.fetch(request);
+  });
+  const handlerFetch = (request, env) => __async(null, null, function* () {
+    return [authHandler, roomHandler].reduce((promise, current) => __async(null, null, function* () {
+      return yield promise.then((value) => __async(null, null, function* () {
+        return value != null ? value : yield current(request, env);
+      }));
+    }), Promise.resolve(null));
+  });
+  const handler = {
+    fetch: (request, env) => __async(null, null, function* () {
+      var _a, _b;
+      const response = (_a = yield handlerFetch(request, env)) != null ? _a : new Response("Not Found", {
+        headers: { "Content-Type": "text/plain" },
+        status: 404
+      });
+      return (_b = modify == null ? void 0 : modify(request, response, env)) != null ? _b : response;
+    })
+  };
+  return { fetch: handlerFetch, DurableObject, handler };
+};
+
+// src/infer.ts
+var infer = (callback) => callback;
+
+// src/CloudflarePlatform.ts
+import { AbstractPlatform } from "@pluv/io";
+import { PersistenceCloudflareTransactionalStorage } from "@pluv/persistence-cloudflare-transactional-storage";
+
+// src/CloudflareWebSocket.ts
+import { AbstractWebSocket } from "@pluv/io";
+var CloudflareWebSocket = class extends AbstractWebSocket {
+  set presence(presence) {
+    const deserialized = this.webSocket.deserializeAttachment();
+    const state = deserialized.state;
+    this.webSocket.serializeAttachment(__spreadProps(__spreadValues({}, this.webSocket.deserializeAttachment()), {
+      state: __spreadProps(__spreadValues({}, state), { presence })
+    }));
+  }
+  get readyState() {
+    return this.webSocket.readyState;
+  }
+  get session() {
+    var _a;
+    const deserialized = this.webSocket.deserializeAttachment();
+    const sessionId = deserialized.sessionId;
+    const state = this.state;
+    const user = (_a = deserialized.user) != null ? _a : null;
+    return __spreadProps(__spreadValues({}, state), {
+      id: sessionId,
+      user,
+      webSocket: this
+    });
+  }
+  get sessionId() {
+    var _a, _b;
+    const deserialized = (_a = this.webSocket.deserializeAttachment()) != null ? _a : {};
+    const sessionId = (_b = deserialized.sessionId) != null ? _b : `p_${crypto.randomUUID()}`;
+    if (typeof deserialized.sessionId !== "string") {
+      this.webSocket.serializeAttachment(__spreadProps(__spreadValues({}, deserialized), { sessionId }));
+    }
+    return sessionId;
+  }
+  get state() {
+    var _a;
+    const deserialized = this.webSocket.deserializeAttachment();
+    const state = (_a = deserialized == null ? void 0 : deserialized.state) != null ? _a : null;
+    if (!state) throw new Error("Could not get websocket state");
+    const currentPing = state.timers.ping;
+    const lastPing = this._platform.getLastPing(this);
+    if (!lastPing) return state;
+    if (currentPing >= lastPing) return state;
+    const newState = __spreadProps(__spreadValues({}, state), {
+      timers: __spreadProps(__spreadValues({}, state.timers), { ping: lastPing })
+    });
+    return this._platform.setSerializedState(this, newState);
+  }
+  set state(state) {
+    const deserialized = this.webSocket.deserializeAttachment();
+    this.webSocket.serializeAttachment(__spreadProps(__spreadValues({}, deserialized), { state }));
+  }
+  set user(user) {
+    const deserialized = this.webSocket.deserializeAttachment();
+    this.webSocket.serializeAttachment(__spreadProps(__spreadValues({}, deserialized), { user }));
+  }
+  constructor(webSocket, config) {
+    const { room } = config;
+    super(webSocket, config);
+    const state = {
+      presence: null,
+      quit: false,
+      room,
+      timers: {
+        ping: (/* @__PURE__ */ new Date()).getTime(),
+        presence: null
+      }
+    };
+    webSocket.serializeAttachment(__spreadValues({
+      state
+    }, webSocket.deserializeAttachment()));
+  }
+  addEventListener(type, handler) {
+    this.webSocket.addEventListener(type, handler);
+  }
+  close(code, reason) {
+    const canClose = [this.CONNECTING, this.OPEN].some(
+      (readyState) => readyState === this.readyState
+    );
+    if (!canClose) return;
+    this.webSocket.close(code, reason);
+  }
+  send(message) {
+    if (this.readyState !== this.OPEN) return;
+    this.webSocket.send(message);
+  }
+  terminate(code = 1011) {
+    return this.webSocket.close(code, "Terminated");
+  }
+};
+
+// src/CloudflarePlatform.ts
+var CloudflarePlatform = class _CloudflarePlatform extends AbstractPlatform {
+  constructor(config) {
+    var _a, _b;
+    super(__spreadValues(__spreadValues({}, config), config.roomContext && config.mode === "detached" ? {
+      persistence: (_a = config.persistence) != null ? _a : new PersistenceCloudflareTransactionalStorage({ mode: "sqlite" })
+    } : {}));
+    this.id = crypto.randomUUID();
+    this._name = "platformCloudflare";
+    this._config = {
+      authorize: {
+        secret: true
+      },
+      handleMode: "io",
+      registrationMode: (_b = config.mode) != null ? _b : DEFAULT_REGISTRATION_MODE,
+      requireAuth: false,
+      listeners: {
+        onRoomDeleted: true,
+        onRoomMessage: true,
+        onStorageUpdated: true,
+        onUserConnected: true,
+        onUserDisconnected: true
+      },
+      router: true
+    };
+    const detachedState = this._getDetachedState();
+    if (!detachedState) return;
+    detachedState.setWebSocketAutoResponse(
+      new WebSocketRequestResponsePair(
+        '{"type":"$ping","data":{}}',
+        JSON.stringify({ type: "$pong", data: {} })
+      )
+    );
+  }
+  acceptWebSocket(webSocket) {
+    return __async(this, null, function* () {
+      const detachedState = this._getDetachedState();
+      if (!detachedState) {
+        webSocket.webSocket.accept();
+        return;
+      }
+      detachedState.acceptWebSocket(webSocket.webSocket);
+    });
+  }
+  convertWebSocket(webSocket, config) {
+    const { room } = config;
+    return new CloudflareWebSocket(webSocket, {
+      persistence: this.persistence,
+      platform: this,
+      room
+    });
+  }
+  getLastPing(webSocket) {
+    var _a;
+    const detachedState = this._getDetachedState();
+    if (!detachedState) return null;
+    const timestamp = detachedState.getWebSocketAutoResponseTimestamp(webSocket.webSocket);
+    return (_a = timestamp == null ? void 0 : timestamp.getTime()) != null ? _a : null;
+  }
+  getSerializedState(webSocket) {
+    var _a;
+    const deserialized = webSocket.deserializeAttachment();
+    return (_a = deserialized == null ? void 0 : deserialized.state) != null ? _a : null;
+  }
+  getSessionId(webSocket) {
+    var _a;
+    const deserialized = (_a = webSocket.deserializeAttachment()) != null ? _a : {};
+    const sessionId = deserialized.sessionId;
+    if (typeof sessionId !== "string") return null;
+    return sessionId;
+  }
+  getWebSockets() {
+    var _a;
+    const detachedState = this._getDetachedState();
+    if (!detachedState) return [];
+    const webSockets = (_a = detachedState.getWebSockets()) != null ? _a : [];
+    return webSockets;
+  }
+  initialize(config) {
+    var _a;
+    const ctx = (_a = config.roomContext) != null ? _a : __spreadValues({}, this._roomContext);
+    if (!ctx.env || !ctx.state) throw new Error("Could not derive platform roomContext");
+    const roomContext = {
+      env: ctx.env,
+      meta: ctx.meta,
+      state: ctx.state
+    };
+    return new _CloudflarePlatform({
+      roomContext,
+      mode: this._config.registrationMode,
+      persistence: this.persistence.initialize(roomContext),
+      pubSub: this.pubSub
+    })._initialize();
+  }
+  parseData(data) {
+    if (typeof data === "string") return JSON.parse(data);
+    const decoder = new TextDecoder("utf8");
+    return JSON.parse(decoder.decode(data));
+  }
+  randomUUID() {
+    return crypto.randomUUID();
+  }
+  setSerializedState(webSocket, state) {
+    var _a;
+    const deserialized = (_a = webSocket.webSocket.deserializeAttachment()) != null ? _a : {};
+    webSocket.webSocket.serializeAttachment(__spreadProps(__spreadValues({}, deserialized), { state }));
+    return state;
+  }
+  _getDetachedState() {
+    var _a, _b;
+    if (this._config.registrationMode !== "detached") return null;
+    const detachedState = (_b = (_a = this._roomContext) == null ? void 0 : _a.state) != null ? _b : null;
+    return detachedState;
+  }
+};
+
+// src/platformCloudflare.ts
+var platformCloudflare = (config = {}) => {
+  const { authorize, context, crdt, debug, limits } = config;
+  return {
+    authorize,
+    context,
+    crdt,
+    debug,
+    limits,
+    platform: () => new CloudflarePlatform(config)
+  };
+};
+export {
+  createPluvHandler,
+  infer,
+  platformCloudflare
+};

package/eslint.config.mjs

@@ -0,0 +1,4 @@
+import { config } from "eslint-config-pluv/base";
+
+/** @type {import("eslint").Linter.Config} */
+export default config;

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@pluv/platform-cloudflare",
+  "version": "0.0.0-experimental-20250527040415",
+  "description": "@pluv/io adapter for cloudflare workers",
+  "author": "leedavidcs",
+  "license": "MIT",
+  "homepage": "https://github.com/pluv-io/pluv",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pluv-io/pluv.git",
+    "directory": "packages/platform-cloudflare"
+  },
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "path-to-regexp": "^8.2.0",
+    "@pluv/io": "^0.0.0-experimental-20250527040415",
+    "@pluv/persistence-cloudflare-transactional-storage": "^0.0.0-experimental-20250527040415",
+    "@pluv/types": "^0.0.0-experimental-20250527040415"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20250521.0",
+    "eslint": "^9.27.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3",
+    "@pluv/tsconfig": "^0.0.0-experimental-20250527040415",
+    "eslint-config-pluv": "^0.0.0-experimental-20250527040415"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts",
+    "lint": "eslint \"src/**/*.ts*\" --fix --max-warnings 0",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  }
+}