@velajs/cloudflare 1.5.0 → 1.8.0

package/dist/websocket/cf-ws-client.js

@@ -0,0 +1,83 @@
+const MAX_ATTACHMENT_BYTES = 16_384; // Cloudflare hibernation attachment limit (16 KiB).
+const encoder = new TextEncoder();
+const EMPTY = {
+    connId: '',
+    path: '',
+    rooms: [],
+    data: {}
+};
+/**
+ * Core `WsClient` over a native Cloudflare `WebSocket` inside a Durable Object.
+ * Per-connection state lives in the hibernation attachment (survives eviction),
+ * so a fresh `CfWsClient` is reconstructed per message with no in-memory state.
+ */ export class CfWsClient {
+    ctx;
+    ws;
+    attachment;
+    constructor(ctx, ws){
+        this.ctx = ctx;
+        this.ws = ws;
+        const raw = ws.deserializeAttachment();
+        this.attachment = raw ?? {
+            ...EMPTY,
+            data: {}
+        };
+    }
+    get id() {
+        return this.attachment.connId;
+    }
+    /** The gateway route path this socket connected on (used to route messages). */ get path() {
+        return this.attachment.path;
+    }
+    get rooms() {
+        return new Set(this.attachment.rooms);
+    }
+    get data() {
+        return this.attachment.data;
+    }
+    set data(value) {
+        this.attachment.data = value;
+    }
+    get raw() {
+        return this.ws;
+    }
+    send(event, data, id) {
+        this.ws.send(JSON.stringify(id !== undefined ? {
+            id,
+            event,
+            data
+        } : {
+            event,
+            data
+        }));
+    }
+    sendRaw(payload) {
+        this.ws.send(payload);
+    }
+    join(room) {
+        if (!this.attachment.rooms.includes(room)) {
+            this.attachment.rooms.push(room);
+            this.persist();
+        }
+    }
+    leave(room) {
+        const next = this.attachment.rooms.filter((r)=>r !== room);
+        if (next.length !== this.attachment.rooms.length) {
+            this.attachment.rooms = next;
+            this.persist();
+        }
+    }
+    /** Persist `data`/room mutations to the hibernation attachment. */ commit() {
+        this.persist();
+    }
+    close(code, reason) {
+        this.ws.close(code, reason);
+    }
+    persist() {
+        const serialized = JSON.stringify(this.attachment);
+        if (encoder.encode(serialized).length > MAX_ATTACHMENT_BYTES) {
+            throw new Error(`WebSocket attachment exceeds the 16 KiB Cloudflare limit. Store large ` + `per-connection state in Durable Object storage keyed by connId instead.`);
+        }
+        this.ws.serializeAttachment(this.attachment);
+    }
+}

package/dist/websocket/cloudflare-websocket.module.d.ts

@@ -0,0 +1,11 @@
+import type { DynamicModule } from '@velajs/vela';
+/**
+ * Cloudflare counterpart to the core `WebSocketModule.forRoot()`. Import this in
+ * your `AppModule` instead: it provides the gateway dispatcher plus a late-bound
+ * `WS_SERVER` (`WsServerHolder`) that the WebSocket Durable Object wires to a
+ * ctx-backed server per instance. `useClass` ensures a fresh holder per DI
+ * container so colocated DO instances never share a server.
+ */
+export declare class CloudflareWebSocketModule {
+    static forRoot(): DynamicModule;
+}

package/dist/websocket/cloudflare-websocket.module.js

@@ -0,0 +1,27 @@
+import { WsDispatcher, WS_SERVER } from "@velajs/vela/websocket";
+import { WsServerHolder } from "./ws-server-holder.js";
+/**
+ * Cloudflare counterpart to the core `WebSocketModule.forRoot()`. Import this in
+ * your `AppModule` instead: it provides the gateway dispatcher plus a late-bound
+ * `WS_SERVER` (`WsServerHolder`) that the WebSocket Durable Object wires to a
+ * ctx-backed server per instance. `useClass` ensures a fresh holder per DI
+ * container so colocated DO instances never share a server.
+ */ export class CloudflareWebSocketModule {
+    static forRoot() {
+        const providers = [
+            {
+                provide: WS_SERVER,
+                useClass: WsServerHolder
+            },
+            WsDispatcher
+        ];
+        return {
+            module: CloudflareWebSocketModule,
+            providers,
+            exports: [
+                WS_SERVER,
+                WsDispatcher
+            ]
+        };
+    }
+}

package/dist/websocket/do-bootstrap.d.ts

@@ -0,0 +1,21 @@
+import type { Type } from '@velajs/vela';
+import { WsDispatcher } from '@velajs/vela/websocket';
+import type { WsServer } from '@velajs/vela/websocket';
+import { CfRoomRegistry } from './cf-room-registry';
+import type { DoStateLike } from './do-state';
+export interface DoRuntime {
+    dispatcher: WsDispatcher;
+    registry: CfRoomRegistry;
+    server: WsServer;
+    /** Gateway paths from `app.entrypoints.ofKind('websocket')` (discovery order). */
+    gatewayPaths: string[];
+    close(signal?: string): Promise<void>;
+}
+/**
+ * Slim DI bootstrap for the Durable Object isolate: wires the container and runs
+ * `OnModuleInit`/`OnApplicationBootstrap` (so `WsDispatcher` discovers gateways)
+ * WITHOUT building the Hono app/routes the DO never serves. Cloudflare binding
+ * refs are initialized straight from the DO's `env`, and the ctx-backed server
+ * is bound before bootstrap lifecycle so gateway `afterInit`/handlers see it.
+ */
+export declare function buildDoRuntime(rootModule: Type, ctx: DoStateLike, env: Record<string, unknown>): Promise<DoRuntime>;

package/dist/websocket/do-bootstrap.js

@@ -0,0 +1,50 @@
+import { bootstrap, VelaApplication } from "@velajs/vela";
+import { local, WsDispatcher, WsServerImpl, WS_SERVER } from "@velajs/vela/websocket";
+import { BindingRef } from "../binding-ref.js";
+import { EnvRef } from "../env-ref.js";
+import { CfRoomRegistry } from "./cf-room-registry.js";
+import { WsServerHolder } from "./ws-server-holder.js";
+/**
+ * Slim DI bootstrap for the Durable Object isolate: wires the container and runs
+ * `OnModuleInit`/`OnApplicationBootstrap` (so `WsDispatcher` discovers gateways)
+ * WITHOUT building the Hono app/routes the DO never serves. Cloudflare binding
+ * refs are initialized straight from the DO's `env`, and the ctx-backed server
+ * is bound before bootstrap lifecycle so gateway `afterInit`/handlers see it.
+ */ export async function buildDoRuntime(rootModule, ctx, env) {
+    const { container, routeManager, loader } = await bootstrap(rootModule);
+    // Init binding refs from env directly (no request middleware inside a DO).
+    // Enumerate per-instance useValue providers across ALL module buckets — two
+    // same-type binding modules share one token but live in distinct buckets, so
+    // resolving the token would return only the first and leave the rest uninitialized.
+    for (const value of container.getUseValues()){
+        if (value instanceof EnvRef) value._initialize(env);
+        else if (value instanceof BindingRef) value._initialize(env[value.bindingName]);
+    }
+    const registry = new CfRoomRegistry(ctx);
+    const driver = local();
+    driver.bind(registry);
+    const server = new WsServerImpl(driver);
+    try {
+        const holder = container.resolve(WS_SERVER);
+        if (holder instanceof WsServerHolder) holder.setTarget(server);
+    } catch  {
+    // CloudflareWebSocketModule not imported — gateways won't have a server.
+    }
+    const app = new VelaApplication(container, routeManager);
+    app.setInstances(await loader.resolveAllInstances());
+    await app.callOnModuleInit();
+    await app.callOnApplicationBootstrap();
+    // The entrypoint registry is the transport contract: one 'websocket' entry
+    // per discovered gateway ({ meta: { path, dispatcher } }). Built by
+    // callOnApplicationBootstrap(), so this slim no-routes path has it too.
+    const wsEntrypoints = app.entrypoints.ofKind('websocket');
+    return {
+        // Zero gateways still yields a live dispatcher (module imported, nothing
+        // decorated) — fall back to resolving it directly.
+        dispatcher: wsEntrypoints[0]?.meta.dispatcher ?? app.get(WsDispatcher),
+        registry,
+        server,
+        gatewayPaths: wsEntrypoints.map((ep)=>ep.meta.path),
+        close: (signal)=>app.close(signal)
+    };
+}

package/dist/websocket/do-state.d.ts

@@ -0,0 +1,25 @@
+export interface WsLike {
+    send(message: string | ArrayBuffer): void;
+    close(code?: number, reason?: string): void;
+    serializeAttachment(value: unknown): void;
+    deserializeAttachment(): unknown;
+}
+export interface DoStateLike {
+    readonly id: {
+        toString(): string;
+        readonly name?: string | null;
+    };
+    acceptWebSocket(ws: WsLike, tags?: string[]): void;
+    getWebSockets(tag?: string): WsLike[];
+    setWebSocketAutoResponse?(pair: unknown): void;
+}
+/** Per-connection metadata persisted in the hibernation attachment (≤ 16 KiB). */
+export interface WsAttachment {
+    connId: string;
+    userId?: string;
+    /** The gateway route path this socket belongs to — used to route messages. */
+    path: string;
+    /** Dynamically-joined room names (the hub room is also a hibernation tag). */
+    rooms: string[];
+    data: Record<string, unknown>;
+}

package/dist/websocket/do-state.js

@@ -0,0 +1,4 @@
+// Minimal structural views of the Durable Object runtime, so the transport
+// logic is unit-testable in Node with fakes. Real `DurableObjectState` and
+// `WebSocket` (from @cloudflare/workers-types) satisfy these structurally.
+/** Per-connection metadata persisted in the hibernation attachment (≤ 16 KiB). */ export { };

package/dist/websocket/do-websocket-host.d.ts

@@ -0,0 +1,28 @@
+import type { BroadcastCommand, WsDispatcher } from '@velajs/vela/websocket';
+import type { CfRoomRegistry } from './cf-room-registry';
+import type { DoStateLike, WsLike } from './do-state';
+/**
+ * The socket lifecycle inside a WebSocket Durable Object, decoupled from the
+ * `cloudflare:workers` base class so it is unit-testable with fakes. The thin
+ * `VelaWebSocketDurableObject` shell forwards its hibernation callbacks here.
+ */
+export declare class DoWebSocketHost {
+    private readonly ctx;
+    private readonly dispatcher;
+    private readonly registry;
+    private readonly gatewayPaths;
+    constructor(ctx: DoStateLike, dispatcher: WsDispatcher, registry: CfRoomRegistry, gatewayPaths?: readonly string[]);
+    /** The single registered gateway's path — a fallback when the Worker didn't forward `x-vela-path`. */
+    defaultPath(): string | undefined;
+    /**
+     * Accept a hibernatable socket: tag it with its hub room + connection id,
+     * persist the attachment, then fire `OnGatewayConnection` WITHOUT blocking the
+     * 101 response (the caller returns it immediately).
+     */
+    accept(ws: WsLike, path: string, roomId: string, userId?: string): void;
+    onMessage(ws: WsLike, message: string | ArrayBuffer): Promise<void>;
+    onClose(ws: WsLike, code: number, reason: string): Promise<void>;
+    onError(ws: WsLike, err: unknown): Promise<void>;
+    /** Deliver a broadcast command to this DO's local sockets (RPC entry point). */
+    broadcast(cmd: BroadcastCommand): void;
+}

package/dist/websocket/do-websocket-host.js

@@ -0,0 +1,69 @@
+import { CfWsClient } from "./cf-ws-client.js";
+import { connTag, roomTag } from "./room-id.js";
+/**
+ * The socket lifecycle inside a WebSocket Durable Object, decoupled from the
+ * `cloudflare:workers` base class so it is unit-testable with fakes. The thin
+ * `VelaWebSocketDurableObject` shell forwards its hibernation callbacks here.
+ */ export class DoWebSocketHost {
+    ctx;
+    dispatcher;
+    registry;
+    gatewayPaths;
+    constructor(ctx, dispatcher, registry, gatewayPaths = []){
+        this.ctx = ctx;
+        this.dispatcher = dispatcher;
+        this.registry = registry;
+        this.gatewayPaths = gatewayPaths;
+    }
+    /** The single registered gateway's path — a fallback when the Worker didn't forward `x-vela-path`. */ defaultPath() {
+        return this.gatewayPaths[0];
+    }
+    /**
+   * Accept a hibernatable socket: tag it with its hub room + connection id,
+   * persist the attachment, then fire `OnGatewayConnection` WITHOUT blocking the
+   * 101 response (the caller returns it immediately).
+   */ accept(ws, path, roomId, userId) {
+        const connId = crypto.randomUUID();
+        this.ctx.acceptWebSocket(ws, [
+            roomTag(roomId),
+            connTag(connId)
+        ]);
+        const attachment = {
+            connId,
+            userId,
+            path,
+            rooms: [
+                roomId
+            ],
+            data: userId ? {
+                userId
+            } : {}
+        };
+        ws.serializeAttachment(attachment);
+        void Promise.resolve(this.dispatcher.handleOpen(path, new CfWsClient(this.ctx, ws))).catch((err)=>console.warn('[vela] websocket handleConnection failed:', err));
+    }
+    async onMessage(ws, message) {
+        const client = new CfWsClient(this.ctx, ws);
+        await this.dispatcher.dispatchMessage(client.path, client, message);
+    }
+    async onClose(ws, code, reason) {
+        const client = new CfWsClient(this.ctx, ws);
+        await this.dispatcher.handleClose(client.path, client, code, reason);
+        // Complete the closing handshake. Only 1000 and 3000-4999 are valid for
+        // close(); reserved/abnormal codes (1005/1006/1015, etc.) throw a RangeError,
+        // so fall back to a codeless close on those.
+        try {
+            if (code === 1000 || code >= 3000 && code <= 4999) ws.close(code, reason);
+            else ws.close();
+        } catch  {
+        // socket already closed
+        }
+    }
+    async onError(ws, err) {
+        const client = new CfWsClient(this.ctx, ws);
+        await this.dispatcher.handleError(client.path, client, err);
+    }
+    /** Deliver a broadcast command to this DO's local sockets (RPC entry point). */ broadcast(cmd) {
+        this.registry.deliverLocal(cmd);
+    }
+}

package/dist/websocket/index.d.ts

@@ -0,0 +1,13 @@
+export { VelaWebSocketDurableObject } from './websocket.durable-object';
+export { CloudflareWebSocketModule } from './cloudflare-websocket.module';
+export { broadcastToRoom } from './broadcast';
+export { CfWsClient } from './cf-ws-client';
+export { CfRoomRegistry } from './cf-room-registry';
+export { DoWebSocketHost } from './do-websocket-host';
+export { WsServerHolder } from './ws-server-holder';
+export { buildDoRuntime } from './do-bootstrap';
+export type { DoRuntime } from './do-bootstrap';
+export { registerWebSocketRoutes, collectWsGatewayRoutes } from './websocket-routing';
+export type { WsGatewayRoute } from './websocket-routing';
+export { roomTag, connTag, roomToDurableId } from './room-id';
+export type { DoStateLike, WsLike, WsAttachment } from './do-state';

package/dist/websocket/index.js

@@ -0,0 +1,13 @@
+// DO base class (imports `cloudflare:workers` — only runs in workerd).
+export { VelaWebSocketDurableObject } from "./websocket.durable-object.js";
+// Module + server-initiated emit helper
+export { CloudflareWebSocketModule } from "./cloudflare-websocket.module.js";
+export { broadcastToRoom } from "./broadcast.js";
+// Transport internals (advanced use / testing)
+export { CfWsClient } from "./cf-ws-client.js";
+export { CfRoomRegistry } from "./cf-room-registry.js";
+export { DoWebSocketHost } from "./do-websocket-host.js";
+export { WsServerHolder } from "./ws-server-holder.js";
+export { buildDoRuntime } from "./do-bootstrap.js";
+export { registerWebSocketRoutes, collectWsGatewayRoutes } from "./websocket-routing.js";
+export { roomTag, connTag, roomToDurableId } from "./room-id.js";

package/dist/websocket/room-id.d.ts

@@ -0,0 +1,6 @@
+/** Hibernation tag marking a socket's hub room (set at accept; immutable after). */
+export declare function roomTag(roomId: string): string;
+/** Hibernation tag addressing one connection directly. */
+export declare function connTag(connId: string): string;
+/** One Durable Object instance per room, addressed by name. */
+export declare function roomToDurableId(ns: DurableObjectNamespace, roomId: string): DurableObjectId;

package/dist/websocket/room-id.js

@@ -0,0 +1,12 @@
+// Canonical room ↔ Durable Object mappings. The SAME functions are used by the
+// Worker upgrade route (to pick the DO) and by every server-initiated emit — so
+// a connection and a later broadcast always resolve to the same DO instance.
+/** Hibernation tag marking a socket's hub room (set at accept; immutable after). */ export function roomTag(roomId) {
+    return `room:${roomId}`;
+}
+/** Hibernation tag addressing one connection directly. */ export function connTag(connId) {
+    return `conn:${connId}`;
+}
+/** One Durable Object instance per room, addressed by name. */ export function roomToDurableId(ns, roomId) {
+    return ns.idFromName(roomId);
+}

package/dist/websocket/websocket-routing.d.ts

@@ -0,0 +1,14 @@
+import type { Hono } from 'hono';
+export interface WsGatewayRoute {
+    path: string;
+    binding: string;
+}
+/** Read `@WebSocketGateway({ path, binding })` off a resolved instance (CF-hosted gateways only). */
+export declare function collectWsGatewayRoutes(instance: object): WsGatewayRoute[];
+/**
+ * Registers the upgrade routes on the Worker's Hono app. Each route validates
+ * the `Upgrade` header, resolves the room's Durable Object, and forwards the raw
+ * request — injecting spoof-safe `x-vela-*` headers the DO reads. The DO returns
+ * the `101` with the client socket.
+ */
+export declare function registerWebSocketRoutes(hono: Hono, routes: WsGatewayRoute[]): void;

package/dist/websocket/websocket-routing.js

@@ -0,0 +1,45 @@
+import { getMetadata } from "@velajs/vela";
+import { WS_GATEWAY_METADATA } from "@velajs/vela/websocket";
+import { roomToDurableId } from "./room-id.js";
+/** Read `@WebSocketGateway({ path, binding })` off a resolved instance (CF-hosted gateways only). */ export function collectWsGatewayRoutes(instance) {
+    const options = getMetadata(WS_GATEWAY_METADATA, instance.constructor);
+    if (!options?.path || !options?.binding) return [];
+    return [
+        {
+            path: options.path,
+            binding: options.binding
+        }
+    ];
+}
+/**
+ * Registers the upgrade routes on the Worker's Hono app. Each route validates
+ * the `Upgrade` header, resolves the room's Durable Object, and forwards the raw
+ * request — injecting spoof-safe `x-vela-*` headers the DO reads. The DO returns
+ * the `101` with the client socket.
+ */ export function registerWebSocketRoutes(hono, routes) {
+    for (const route of routes){
+        hono.get(route.path, async (c)=>{
+            if (c.req.header('upgrade')?.toLowerCase() !== 'websocket') {
+                return c.text('Expected WebSocket upgrade', 426);
+            }
+            const ns = c.env[route.binding];
+            if (!ns) {
+                return c.text(`Durable Object binding '${route.binding}' is not configured`, 500);
+            }
+            const roomId = c.req.param('id') ?? route.path;
+            const stub = ns.get(roomToDurableId(ns, roomId));
+            // Strip any client-supplied x-vela-* (anti-spoof), then set server values.
+            const headers = new Headers(c.req.raw.headers);
+            headers.delete('x-vela-room');
+            headers.delete('x-vela-path');
+            headers.delete('x-vela-user');
+            headers.set('x-vela-room', roomId);
+            headers.set('x-vela-path', route.path);
+            const userId = c.get('userId');
+            if (userId) headers.set('x-vela-user', String(userId));
+            return stub.fetch(new Request(c.req.raw, {
+                headers
+            }));
+        });
+    }
+}

package/dist/websocket/websocket.durable-object.d.ts

@@ -0,0 +1,15 @@
+import { DurableObject } from 'cloudflare:workers';
+import type { Type } from '@velajs/vela';
+/**
+ * Base class for the WebSocket Durable Object. The user exports a named subclass
+ * (matching their `wrangler.toml` `class_name`) built from their `AppModule`:
+ *
+ * ```ts
+ * export class ChatRoom extends VelaWebSocketDurableObject(AppModule) {}
+ * ```
+ *
+ * It owns the raw hibernation socket lifecycle (Hono's `upgradeWebSocket` cannot
+ * bridge DO hibernation) and forwards every event into the runtime-agnostic
+ * `WsDispatcher` via {@link DoWebSocketHost}.
+ */
+export declare function VelaWebSocketDurableObject(rootModule: Type): new (ctx: DurableObjectState, env: Record<string, unknown>) => DurableObject<Record<string, unknown>>;

package/dist/websocket/websocket.durable-object.js

@@ -0,0 +1,72 @@
+import { DurableObject } from "cloudflare:workers";
+import { buildDoRuntime } from "./do-bootstrap.js";
+import { DoWebSocketHost } from "./do-websocket-host.js";
+const PING = '{"event":"ping"}';
+const PONG = '{"event":"pong"}';
+/**
+ * Base class for the WebSocket Durable Object. The user exports a named subclass
+ * (matching their `wrangler.toml` `class_name`) built from their `AppModule`:
+ *
+ * ```ts
+ * export class ChatRoom extends VelaWebSocketDurableObject(AppModule) {}
+ * ```
+ *
+ * It owns the raw hibernation socket lifecycle (Hono's `upgradeWebSocket` cannot
+ * bridge DO hibernation) and forwards every event into the runtime-agnostic
+ * `WsDispatcher` via {@link DoWebSocketHost}.
+ */ export function VelaWebSocketDurableObject(rootModule) {
+    return class VelaWsDurableObject extends DurableObject {
+        host;
+        ready;
+        constructor(ctx, env){
+            super(ctx, env);
+            // Application-level ping/pong answered WITHOUT waking a hibernated DO.
+            try {
+                ctx.setWebSocketAutoResponse(new WebSocketRequestResponsePair(PING, PONG));
+            } catch  {
+            // Older runtimes without auto-response — fine, protocol pings still work.
+            }
+            this.ready = ctx.blockConcurrencyWhile(async ()=>{
+                const runtime = await buildDoRuntime(rootModule, ctx, env);
+                this.host = new DoWebSocketHost(ctx, runtime.dispatcher, runtime.registry, runtime.gatewayPaths);
+            });
+        }
+        async fetch(request) {
+            await this.ready;
+            if (request.headers.get('upgrade')?.toLowerCase() !== 'websocket') {
+                return new Response('Expected WebSocket upgrade', {
+                    status: 426
+                });
+            }
+            const { 0: client, 1: server } = new WebSocketPair();
+            const url = new URL(request.url);
+            // Headers are primary (carry auth + multi-gateway routing); fall back to the
+            // DO's own name (set via idFromName(room)) and the single gateway path so a
+            // plain `stub.fetch(request)` forward still works.
+            const roomId = request.headers.get('x-vela-room') ?? this.ctx.id.name ?? url.pathname;
+            const path = request.headers.get('x-vela-path') ?? this.host.defaultPath() ?? url.pathname;
+            const userId = request.headers.get('x-vela-user') || undefined;
+            this.host.accept(server, path, roomId, userId);
+            return new Response(null, {
+                status: 101,
+                webSocket: client
+            });
+        }
+        async webSocketMessage(ws, message) {
+            await this.ready;
+            await this.host.onMessage(ws, message);
+        }
+        async webSocketClose(ws, code, reason) {
+            await this.ready;
+            await this.host.onClose(ws, code, reason);
+        }
+        async webSocketError(ws, error) {
+            await this.ready;
+            await this.host.onError(ws, error);
+        }
+        /** DO RPC — server-initiated broadcast forwarded from a Worker (see `broadcastToRoom`). */ async broadcast(cmd) {
+            await this.ready;
+            this.host.broadcast(cmd);
+        }
+    };
+}

package/dist/websocket/ws-server-holder.d.ts

@@ -0,0 +1,16 @@
+import type { BroadcastOperator, WsServer } from '@velajs/vela/websocket';
+/**
+ * Late-bound `WsServer`. Provided as `WS_SERVER` (one per DI container, i.e. per
+ * Durable Object instance), then pointed at the ctx-backed server once the DO
+ * builds. Gateways inject it via `@WebSocketServer()`; it throws if used before
+ * a runtime binds it (e.g. from the stateless Worker isolate).
+ */
+export declare class WsServerHolder implements WsServer {
+    private target?;
+    setTarget(server: WsServer): void;
+    private get resolved();
+    emit(event: string, data?: unknown): void | Promise<void>;
+    to(room: string): BroadcastOperator;
+    in(room: string): BroadcastOperator;
+    except(room: string): BroadcastOperator;
+}

package/dist/websocket/ws-server-holder.js

@@ -0,0 +1,34 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { Injectable } from "@velajs/vela";
+export class WsServerHolder {
+    target;
+    setTarget(server) {
+        this.target = server;
+    }
+    get resolved() {
+        if (!this.target) {
+            throw new Error('WebSocket server is only available inside a WebSocket Durable Object. To ' + 'push from a Worker HTTP handler, use broadcastToRoom(namespace, room, ...).');
+        }
+        return this.target;
+    }
+    emit(event, data) {
+        return this.resolved.emit(event, data);
+    }
+    to(room) {
+        return this.resolved.to(room);
+    }
+    in(room) {
+        return this.resolved.in(room);
+    }
+    except(room) {
+        return this.resolved.except(room);
+    }
+}
+WsServerHolder = _ts_decorate([
+    Injectable()
+], WsServerHolder);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velajs/cloudflare",
-  "version": "1.5.0",
+  "version": "1.8.0",
   "description": "Cloudflare Workers integration for Vela framework",
   "type": "module",
   "main": "./dist/index.js",
@@ -17,13 +17,6 @@
     "LICENSE",
     "CHANGELOG.md"
   ],
-  "scripts": {
-    "build": "rm -rf dist && swc src -d dist --strip-leading-paths && tsc --emitDeclarationOnly",
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit",
-    "prepare": "swc src -d dist --strip-leading-paths && tsc --emitDeclarationOnly",
-    "prepublishOnly": "pnpm run typecheck && pnpm test"
-  },
   "sideEffects": false,
   "keywords": [
     "vela",
@@ -52,24 +45,22 @@
   },
   "peerDependencies": {
     "@cloudflare/workers-types": ">=4",
-    "@velajs/vela": ">=1.8.5",
+    "@velajs/vela": ">=1.11.0",
     "hono": ">=4"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20260624.1",
     "@swc/cli": "^0.8.1",
     "@swc/core": "^1.15.43",
-    "@velajs/vela": "^1.8.5",
+    "@velajs/vela": "^1.12.0",
     "hono": "^4.12.27",
     "typescript": "^6.0.3",
     "unplugin-swc": "^1.5.9",
     "vitest": "^4.1.9"
   },
-  "packageManager": "pnpm@10.20.0",
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "@swc/core",
-      "esbuild"
-    ]
+  "scripts": {
+    "build": "rm -rf dist && swc src -d dist --strip-leading-paths && tsc --emitDeclarationOnly",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
   }
-}
+}