@pluv/platform-cloudflare 0.20.0 → 0.21.1

package/dist/index.mjs

@@ -1,3 +1,22 @@
+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) => {
@@ -25,14 +44,23 @@ var createPluvHandler = (config) => {
   const { authorize, binding, endpoint = "/api/pluv", modify, io } = config;
   const DurableObject = class {
     constructor(state, env) {
-      this._env = env;
-      this._io = io.getRoom(state.id.toString(), { env });
+      this._room = io.getRoom(state.id.toString(), { env, state });
     }
     webSocketClose(ws, code, reason, wasClean) {
+      if (io._registrationMode !== "detached") return;
+      const handler2 = this._room.onClose(ws);
+      handler2({ code, reason });
     }
     webSocketError(ws, error) {
+      if (io._registrationMode !== "detached") return;
+      const handler2 = this._room.onError(ws);
+      const eventError = error instanceof Error ? error : new Error("Internal Error");
+      handler2({ error: eventError, message: eventError.message });
     }
     webSocketMessage(ws, message) {
+      if (io._registrationMode !== "detached") return;
+      const handler2 = this._room.onMessage(ws);
+      handler2({ data: message });
     }
     fetch(request) {
       return __async(this, null, function* () {
@@ -42,11 +70,7 @@ var createPluvHandler = (config) => {
         }
         const { 0: client, 1: server } = new WebSocketPair();
         const token = new URL(request.url).searchParams.get("token");
-        yield this._io.register(server, {
-          env: this._env,
-          request,
-          token
-        });
+        yield this._room.register(server, { token });
         return new Response(null, { status: 101, webSocket: client });
       });
     }
@@ -133,13 +157,45 @@ import { AbstractPlatform } from "@pluv/io";
 // 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 sessionId() {
+    var _a, _b;
+    const deserialized = (_a = this.webSocket.deserializeAttachment()) != null ? _a : {};
+    const sessionId = (_b = deserialized.sessionId) != null ? _b : 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.state) != null ? _a : null;
+    if (!state) throw new Error("Could not get websocket state");
+    return state;
+  }
   constructor(webSocket, config) {
-    const { room, sessionId, userId } = config;
-    super({ room, sessionId, userId });
-    this.webSocket = webSocket;
+    const { room } = config;
+    super(webSocket, config);
+    const state = {
+      presence: null,
+      quit: false,
+      room,
+      timers: { ping: (/* @__PURE__ */ new Date()).getTime() }
+    };
+    webSocket.serializeAttachment(__spreadValues({
+      sessionId: this.sessionId,
+      state
+    }, webSocket.deserializeAttachment()));
   }
   addEventListener(type, handler) {
     this.webSocket.addEventListener(type, handler);
@@ -149,10 +205,6 @@ var CloudflareWebSocket = class extends AbstractWebSocket {
     if (!canClose) return;
     this.webSocket.close(code, reason);
   }
-  initialize() {
-    this.webSocket.accept();
-    return Promise.resolve(() => void 0);
-  }
   send(message) {
     if (this.readyState !== this.OPEN) return;
     this.webSocket.send(message);
@@ -162,10 +214,169 @@ var CloudflareWebSocket = class extends AbstractWebSocket {
   }
 };
 
+// src/PersistanceCloudflare.ts
+import { AbstractPersistance } from "@pluv/io";
+
+// src/utils/partitionByLength.ts
+var partitionByLength = (arr, length) => {
+  if (!arr.length) return [];
+  const head = arr.slice(0, length);
+  const tail = arr.slice(length);
+  return [head, ...partitionByLength(tail, length)];
+};
+
+// src/PersistanceCloudflare.ts
+var CLOUDFLARE_DELETE_BATCH_LIMIT = 128;
+var STORAGE_PREFIX = "$PLUV_STORAGE;";
+var USER_PREFIX = "$PLUV_USER";
+var PersistanceCloudflare = class extends AbstractPersistance {
+  constructor(config) {
+    super();
+    const { state } = config;
+    this._state = state;
+  }
+  addUser(room, connectionId, user) {
+    return __async(this, null, function* () {
+      yield this._state.storage.put(this._getUserKey(room, connectionId), user);
+    });
+  }
+  deleteStorageState(room) {
+    return __async(this, null, function* () {
+      yield this._state.storage.delete(this._getStorageKey(room));
+    });
+  }
+  deleteUser(room, connectionId) {
+    return __async(this, null, function* () {
+      yield this._state.storage.delete(this._getUserKey(room, connectionId));
+    });
+  }
+  deleteUsers(room) {
+    return __async(this, null, function* () {
+      const map = yield this._state.storage.list({
+        allowConcurrency: true,
+        noCache: true,
+        prefix: USER_PREFIX
+      });
+      const partitions = partitionByLength(Array.from(map.keys()), CLOUDFLARE_DELETE_BATCH_LIMIT);
+      yield this._state.storage.transaction((tx) => __async(this, null, function* () {
+        yield partitions.reduce((promise, partition) => __async(this, null, function* () {
+          return yield promise.then(() => __async(this, null, function* () {
+            yield tx.delete(partition);
+          }));
+        }), Promise.resolve());
+      }));
+    });
+  }
+  getSize(room) {
+    return __async(this, null, function* () {
+      const storage = yield this._state.storage.list({ prefix: USER_PREFIX });
+      return storage.size;
+    });
+  }
+  getStorageState(room) {
+    return __async(this, null, function* () {
+      const storage = yield this._state.storage.get(this._getStorageKey(room));
+      return storage != null ? storage : null;
+    });
+  }
+  getUser(room, connectionId) {
+    return __async(this, null, function* () {
+      const user = yield this._state.storage.get(this._getUserKey(room, connectionId));
+      return user != null ? user : null;
+    });
+  }
+  getUsers(room) {
+    return __async(this, null, function* () {
+      const storage = yield this._state.storage.list({
+        prefix: USER_PREFIX
+      });
+      return Array.from(storage.values());
+    });
+  }
+  setStorageState(room, state) {
+    return __async(this, null, function* () {
+      yield this._state.storage.put(this._getStorageKey(room), state, {
+        allowConcurrency: true
+      });
+    });
+  }
+  _getStorageKey(room) {
+    return `${STORAGE_PREFIX}::${room}`;
+  }
+  _getUserKey(room, connectionId) {
+    return `${USER_PREFIX}::${room}::${connectionId}`;
+  }
+};
+
+// src/constants.ts
+var DEFAULT_REGISTRATION_MODE = "attached";
+
 // src/CloudflarePlatform.ts
-var CloudflarePlatform = class extends AbstractPlatform {
+var CloudflarePlatform = class _CloudflarePlatform extends AbstractPlatform {
+  constructor(config = {}) {
+    var _a;
+    super(__spreadValues(__spreadValues({}, config), config.context && config.mode === "detached" ? { persistance: new PersistanceCloudflare(config.context) } : {}));
+    this._registrationMode = (_a = config.mode) != null ? _a : DEFAULT_REGISTRATION_MODE;
+    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) {
-    return new CloudflareWebSocket(webSocket, config);
+    const { room } = config;
+    return new CloudflareWebSocket(webSocket, { persistance: this.persistance, 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.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") {
+      throw new Error("This websocket was not registered");
+    }
+    return sessionId;
+  }
+  getWebSockets() {
+    var _a;
+    const detachedState = this._getDetachedState();
+    if (!detachedState) return [];
+    return (_a = detachedState.getWebSockets()) != null ? _a : [];
+  }
+  initialize(config) {
+    var _a;
+    const context = (_a = config.context) != null ? _a : __spreadValues(__spreadValues({}, this._ioContext), this._roomContext);
+    if (!context.env || !context.state) {
+      throw new Error("Could not derive platform context");
+    }
+    return new _CloudflarePlatform(__spreadProps(__spreadValues({
+      mode: this._registrationMode,
+      persistance: this.persistance,
+      pubSub: this.pubSub
+    }, config), {
+      context: { env: context.env, state: context.state }
+    }))._initialize();
   }
   parseData(data) {
     if (typeof data === "string") return JSON.parse(data);
@@ -175,11 +386,21 @@ var CloudflarePlatform = class extends AbstractPlatform {
   randomUUID() {
     return crypto.randomUUID();
   }
+  setSerializedState(webSocket, state) {
+    var _a;
+    const deserialized = (_a = webSocket.webSocket.deserializeAttachment()) != null ? _a : {};
+    webSocket.webSocket.serializeAttachment(__spreadProps(__spreadValues({}, deserialized), { state }));
+  }
+  _getDetachedState() {
+    var _a, _b;
+    if (this._registrationMode !== "detached") return null;
+    return (_b = (_a = this._roomContext) == null ? void 0 : _a.state) != null ? _b : null;
+  }
 };
 
 // src/platformCloudflare.ts
-var platformCloudflare = () => {
-  return new CloudflarePlatform();
+var platformCloudflare = (config = {}) => {
+  return new CloudflarePlatform(config);
 };
 export {
   createPluvHandler,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluv/platform-cloudflare",
-  "version": "0.20.0",
+  "version": "0.21.1",
   "description": "@pluv/io adapter for cloudflare workers",
   "author": "leedavidcs",
   "license": "MIT",
@@ -17,17 +17,17 @@
     "access": "public"
   },
   "dependencies": {
-    "path-to-regexp": "^7.0.0",
-    "@pluv/io": "^0.20.0",
-    "@pluv/types": "^0.20.0"
+    "path-to-regexp": "^7.1.0",
+    "@pluv/io": "^0.21.1",
+    "@pluv/types": "^0.21.1"
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20240620.0",
+    "@cloudflare/workers-types": "^4.20240806.0",
     "eslint": "^8.57.0",
-    "tsup": "^8.1.0",
-    "typescript": "^5.4.5",
-    "@pluv/tsconfig": "^0.20.0",
-    "eslint-config-pluv": "^0.20.0"
+    "tsup": "^8.2.4",
+    "typescript": "^5.5.4",
+    "@pluv/tsconfig": "^0.21.1",
+    "eslint-config-pluv": "^0.21.1"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",

package/src/CloudflarePlatform.ts

@@ -1,14 +1,112 @@
-import type { ConvertWebSocketConfig } from "@pluv/io";
+import type {
+    AbstractPlatformConfig,
+    ConvertWebSocketConfig,
+    WebSocketRegistrationMode,
+    WebSocketSerializedState,
+} from "@pluv/io";
 import { AbstractPlatform } from "@pluv/io";
 import { CloudflareWebSocket } from "./CloudflareWebSocket";
+import { PersistanceCloudflare } from "./PersistanceCloudflare";
+import { DEFAULT_REGISTRATION_MODE } from "./constants";
+
+export type CloudflarePlatformConfig<TEnv extends Record<string, any> = {}> = AbstractPlatformConfig<
+    { env: TEnv },
+    { state: DurableObjectState }
+> & { mode?: WebSocketRegistrationMode };
 
 export class CloudflarePlatform<TEnv extends Record<string, any> = {}> extends AbstractPlatform<
-    WebSocket,
+    CloudflareWebSocket,
     { env: TEnv },
-    { request: Request }
+    { state: DurableObjectState }
 > {
+    readonly _registrationMode: WebSocketRegistrationMode;
+
+    constructor(config: CloudflarePlatformConfig<TEnv> = {}) {
+        super({
+            ...config,
+            ...(config.context && config.mode === "detached"
+                ? { persistance: new PersistanceCloudflare(config.context) }
+                : {}),
+        });
+
+        this._registrationMode = config.mode ?? DEFAULT_REGISTRATION_MODE;
+
+        const detachedState = this._getDetachedState();
+
+        if (!detachedState) return;
+
+        detachedState.setWebSocketAutoResponse(
+            new WebSocketRequestResponsePair('{"type":"$PING","data":{}}', JSON.stringify({ type: "$PONG", data: {} })),
+        );
+    }
+
+    public async acceptWebSocket(webSocket: CloudflareWebSocket): Promise<void> {
+        const detachedState = this._getDetachedState();
+
+        if (!detachedState) {
+            webSocket.webSocket.accept();
+
+            return;
+        }
+
+        detachedState.acceptWebSocket(webSocket.webSocket);
+    }
+
     public convertWebSocket(webSocket: WebSocket, config: ConvertWebSocketConfig): CloudflareWebSocket {
-        return new CloudflareWebSocket(webSocket, config);
+        const { room } = config;
+
+        return new CloudflareWebSocket(webSocket, { persistance: this.persistance, room });
+    }
+
+    public getLastPing(webSocket: CloudflareWebSocket): number | null {
+        const detachedState = this._getDetachedState();
+
+        if (!detachedState) return null;
+
+        const timestamp = detachedState.getWebSocketAutoResponseTimestamp(webSocket.webSocket);
+
+        return timestamp?.getTime() ?? null;
+    }
+
+    public getSerializedState(webSocket: CloudflareWebSocket): WebSocketSerializedState | null {
+        const deserialized = webSocket.webSocket.deserializeAttachment();
+
+        return deserialized?.state ?? null;
+    }
+
+    public getSessionId(webSocket: WebSocket): string | null {
+        const deserialized = webSocket.deserializeAttachment() ?? {};
+        const sessionId = deserialized.sessionId;
+
+        if (typeof sessionId !== "string") {
+            throw new Error("This websocket was not registered");
+        }
+
+        return sessionId;
+    }
+
+    public getWebSockets(): readonly WebSocket[] {
+        const detachedState = this._getDetachedState();
+
+        if (!detachedState) return [];
+
+        return detachedState.getWebSockets() ?? [];
+    }
+
+    public initialize(config: AbstractPlatformConfig<{ env: TEnv }, { state: DurableObjectState }>): this {
+        const context = config.context ?? { ...this._ioContext, ...this._roomContext };
+
+        if (!context.env || !context.state) {
+            throw new Error("Could not derive platform context");
+        }
+
+        return new CloudflarePlatform<TEnv>({
+            mode: this._registrationMode,
+            persistance: this.persistance,
+            pubSub: this.pubSub,
+            ...config,
+            context: { env: context.env, state: context.state },
+        })._initialize() as this;
     }
 
     public parseData(data: string | ArrayBuffer): Record<string, any> {
@@ -22,4 +120,16 @@ export class CloudflarePlatform<TEnv extends Record<string, any> = {}> extends A
     public randomUUID(): string {
         return crypto.randomUUID();
     }
+
+    public setSerializedState(webSocket: CloudflareWebSocket, state: WebSocketSerializedState): void {
+        const deserialized = webSocket.webSocket.deserializeAttachment() ?? {};
+
+        webSocket.webSocket.serializeAttachment({ ...deserialized, state });
+    }
+
+    private _getDetachedState(): DurableObjectState | null {
+        if (this._registrationMode !== "detached") return null;
+
+        return this._roomContext?.state ?? null;
+    }
 }

package/src/CloudflareWebSocket.ts

@@ -1,4 +1,6 @@
-import { AbstractEventMap, AbstractListener, AbstractWebSocket, AbstractWebSocketConfig } from "@pluv/io";
+import type { AbstractEventMap, AbstractListener, AbstractWebSocketConfig, WebSocketSerializedState } from "@pluv/io";
+import { AbstractWebSocket } from "@pluv/io";
+import type { JsonObject } from "@pluv/types";
 
 export interface CloudflareWebSocketEventMap {
     close: CloseEvent;
@@ -9,19 +11,58 @@ export interface CloudflareWebSocketEventMap {
 
 export type CloudflareWebSocketConfig = AbstractWebSocketConfig;
 
-export class CloudflareWebSocket extends AbstractWebSocket {
-    public webSocket: WebSocket;
+export class CloudflareWebSocket extends AbstractWebSocket<WebSocket> {
+    public set presence(presence: JsonObject | null) {
+        const deserialized = this.webSocket.deserializeAttachment();
+        const state = deserialized.state;
+
+        this.webSocket.serializeAttachment({
+            ...this.webSocket.deserializeAttachment(),
+            state: { ...state, presence },
+        });
+    }
 
     public get readyState(): 0 | 1 | 2 | 3 {
         return this.webSocket.readyState as 0 | 1 | 2 | 3;
     }
 
-    constructor(webSocket: WebSocket, config: CloudflareWebSocketConfig) {
-        const { room, sessionId, userId } = config;
+    public get sessionId(): string {
+        const deserialized = this.webSocket.deserializeAttachment() ?? {};
+        const sessionId = deserialized.sessionId ?? crypto.randomUUID();
+
+        if (typeof deserialized.sessionId !== "string") {
+            this.webSocket.serializeAttachment({ ...deserialized, sessionId });
+        }
+
+        return sessionId;
+    }
+
+    public get state(): WebSocketSerializedState {
+        const deserialized = this.webSocket.deserializeAttachment();
+        const state = deserialized.state ?? null;
 
-        super({ room, sessionId, userId });
+        if (!state) throw new Error("Could not get websocket state");
 
-        this.webSocket = webSocket;
+        return state;
+    }
+
+    constructor(webSocket: WebSocket, config: CloudflareWebSocketConfig) {
+        const { room } = config;
+
+        super(webSocket, config);
+
+        const state: WebSocketSerializedState = {
+            presence: null,
+            quit: false,
+            room,
+            timers: { ping: new Date().getTime() },
+        };
+
+        webSocket.serializeAttachment({
+            sessionId: this.sessionId,
+            state,
+            ...webSocket.deserializeAttachment(),
+        });
     }
 
     public addEventListener<TType extends keyof AbstractEventMap>(type: TType, handler: AbstractListener<TType>) {
@@ -36,12 +77,6 @@ export class CloudflareWebSocket extends AbstractWebSocket {
         this.webSocket.close(code, reason);
     }
 
-    public initialize(): Promise<() => undefined> {
-        this.webSocket.accept();
-
-        return Promise.resolve(() => undefined);
-    }
-
     public send(message: string | ArrayBuffer | ArrayBufferView): void {
         if (this.readyState !== this.OPEN) return;
 

package/src/PersistanceCloudflare.ts

@@ -0,0 +1,100 @@
+import { AbstractPersistance } from "@pluv/io";
+import type { JsonObject } from "@pluv/types";
+import { partitionByLength } from "./utils";
+
+/**
+ * !HACK
+ * @description The max amount of keys a Cloudflare transactional storage may delete at once
+ * @see https://developers.cloudflare.com/durable-objects/api/transactional-storage-api/#delete
+ * @date July 8, 2024
+ */
+const CLOUDFLARE_DELETE_BATCH_LIMIT = 128;
+const STORAGE_PREFIX = "$PLUV_STORAGE;";
+const USER_PREFIX = "$PLUV_USER";
+
+export interface PersistanceCloudflareConfig<TEnv extends Record<string, any> = {}> {
+    env: TEnv;
+    state: DurableObjectState;
+}
+
+export class PersistanceCloudflare<TEnv extends Record<string, any> = {}> extends AbstractPersistance {
+    private _state: DurableObjectState;
+
+    constructor(config: PersistanceCloudflareConfig<TEnv>) {
+        super();
+
+        const { state } = config;
+
+        this._state = state;
+    }
+
+    public async addUser(room: string, connectionId: string, user: JsonObject | null): Promise<void> {
+        await this._state.storage.put(this._getUserKey(room, connectionId), user);
+    }
+
+    public async deleteStorageState(room: string): Promise<void> {
+        await this._state.storage.delete(this._getStorageKey(room));
+    }
+
+    public async deleteUser(room: string, connectionId: string): Promise<void> {
+        await this._state.storage.delete(this._getUserKey(room, connectionId));
+    }
+
+    public async deleteUsers(room: string): Promise<void> {
+        const map = await this._state.storage.list({
+            allowConcurrency: true,
+            noCache: true,
+            prefix: USER_PREFIX,
+        });
+
+        const partitions = partitionByLength(Array.from(map.keys()), CLOUDFLARE_DELETE_BATCH_LIMIT);
+
+        await this._state.storage.transaction(async (tx) => {
+            await partitions.reduce(async (promise, partition) => {
+                return await promise.then(async () => {
+                    await tx.delete(partition as string[]);
+                });
+            }, Promise.resolve());
+        });
+    }
+
+    public async getSize(room: string): Promise<number> {
+        const storage = await this._state.storage.list({ prefix: USER_PREFIX });
+
+        return storage.size;
+    }
+
+    public async getStorageState(room: string): Promise<string | null> {
+        const storage = await this._state.storage.get<string>(this._getStorageKey(room));
+
+        return storage ?? null;
+    }
+
+    public async getUser(room: string, connectionId: string): Promise<JsonObject | null> {
+        const user = await this._state.storage.get<JsonObject | null>(this._getUserKey(room, connectionId));
+
+        return user ?? null;
+    }
+
+    public async getUsers(room: string): Promise<readonly (JsonObject | null)[]> {
+        const storage = await this._state.storage.list({
+            prefix: USER_PREFIX,
+        });
+
+        return Array.from(storage.values()) as (JsonObject | null)[];
+    }
+
+    public async setStorageState(room: string, state: string): Promise<void> {
+        await this._state.storage.put(this._getStorageKey(room), state, {
+            allowConcurrency: true,
+        });
+    }
+
+    private _getStorageKey(room: string): string {
+        return `${STORAGE_PREFIX}::${room}`;
+    }
+
+    private _getUserKey(room: string, connectionId: string): string {
+        return `${USER_PREFIX}::${room}::${connectionId}`;
+    }
+}

package/src/constants.ts

@@ -0,0 +1,3 @@
+import type { WebSocketRegistrationMode } from "@pluv/io";
+
+export const DEFAULT_REGISTRATION_MODE: WebSocketRegistrationMode = "attached";