@velajs/cloudflare 1.10.0 → 1.10.1

package/dist/websocket/do-live.js

@@ -1,197 +0,0 @@
-import { LIVE_CURSOR_LOG, LIVE_DRIVER, readPersistedLiveSubscriptions } from "@velajs/vela/live";
-import { CfWsClient } from "./cf-ws-client.js";
-import { roomToDurableId } from "./room-id.js";
-const DEFAULT_ROOM = 'default';
-const DEFAULT_MAX_LOG_ROWS = 4096;
-/**
- * The durable `CursorLog`: an append-only tag-invalidation log in the DO's
- * SQLite (`__vela_live_log`, AUTOINCREMENT seq = cursor) plus an epoch UUID in
- * `__vela_live_meta`. Because the cursor survives hibernation AND trims (it is
- * read from `sqlite_sequence`, lunora's `ctx-db-cdc.ts` trick), a reconnecting
- * client whose gap the log still covers gets a tiny `resume` instead of a
- * re-run — the real-resume half of the live protocol.
- *
- * Constructed un-initialized at module-composition time (the same app module
- * bootstraps in the Worker AND in each DO); `initDoLive` wires the SQLite
- * handle inside the DO. In the Worker isolate it stays un-initialized — and is
- * never consulted there, because `durableObjectLive()` routes every
- * invalidation to the room DO's log (one log scope per room, exactly the
- * protocol's model).
- */ export class DoCursorLog {
-    maxRows;
-    sql;
-    epoch;
-    constructor(maxRows = DEFAULT_MAX_LOG_ROWS){
-        this.maxRows = maxRows;
-    }
-    /** @internal — called by `initDoLive` with the DO's `ctx.storage.sql`. */ _initialize(sql) {
-        this.sql = sql;
-        sql.exec('CREATE TABLE IF NOT EXISTS __vela_live_log (seq INTEGER PRIMARY KEY AUTOINCREMENT, ts REAL NOT NULL, tags TEXT NOT NULL)');
-        sql.exec('CREATE TABLE IF NOT EXISTS __vela_live_meta (k TEXT PRIMARY KEY, v TEXT NOT NULL)');
-        const row = sql.exec("SELECT v FROM __vela_live_meta WHERE k = 'epoch'").toArray()[0];
-        if (row && typeof row.v === 'string') {
-            this.epoch = row.v;
-        } else {
-            this.epoch = crypto.randomUUID();
-            sql.exec("INSERT INTO __vela_live_meta (k, v) VALUES ('epoch', ?)", this.epoch);
-        }
-    }
-    append(tags) {
-        const sql = this.assertReady();
-        sql.exec('INSERT INTO __vela_live_log (ts, tags) VALUES (?, ?)', Date.now(), JSON.stringify(tags));
-        const stamp = this.current();
-        // Bounded retention: trimmed gaps degrade to snapshot-on-reconnect.
-        if (stamp.cursor > this.maxRows) {
-            sql.exec('DELETE FROM __vela_live_log WHERE seq <= ?', stamp.cursor - this.maxRows);
-        }
-        return stamp;
-    }
-    current() {
-        const sql = this.assertReady();
-        // sqlite_sequence survives DELETE-based trims, so the cursor never
-        // rewinds. The table itself only materializes on the first AUTOINCREMENT
-        // insert — before that the log is empty and the cursor is 0.
-        let cursor = 0;
-        try {
-            const row = sql.exec("SELECT seq FROM sqlite_sequence WHERE name = '__vela_live_log'").toArray()[0];
-            cursor = typeof row?.seq === 'number' ? row.seq : Number(row?.seq ?? 0);
-        } catch  {
-            cursor = 0;
-        }
-        return {
-            cursor,
-            epoch: this.epoch
-        };
-    }
-    evaluateResume(sinceCursor, sinceEpoch, subscriptionTags) {
-        const sql = this.assertReady();
-        const { cursor, epoch } = this.current();
-        if (sinceEpoch !== epoch) return 'snapshot'; // forked timeline (reset/recreated DO)
-        if (sinceCursor > cursor) return 'snapshot'; // rollback guard
-        if (sinceCursor === cursor) return 'resume';
-        const minRow = sql.exec('SELECT MIN(seq) AS m FROM __vela_live_log').toArray()[0];
-        const min = minRow?.m == null ? undefined : Number(minRow.m);
-        // The log must still cover (sinceCursor, cursor] — a trimmed gap cannot be reasoned about.
-        if (min === undefined || min > sinceCursor + 1) return 'snapshot';
-        const subTags = new Set(subscriptionTags);
-        for (const row of sql.exec('SELECT tags FROM __vela_live_log WHERE seq > ?', sinceCursor).toArray()){
-            let tags;
-            try {
-                tags = JSON.parse(String(row.tags));
-            } catch  {
-                return 'snapshot';
-            }
-            if (Array.isArray(tags) && tags.some((tag)=>subTags.has(tag))) return 'rerun';
-        }
-        return 'resume';
-    }
-    assertReady() {
-        if (!this.sql) {
-            throw new Error('DoCursorLog is not initialized. It only runs inside a SQLite-backed Durable Object ' + '(wrangler: new_sqlite_classes) — Worker-side invalidations must go through durableObjectLive(), ' + "which routes them to the room DO's log.");
-        }
-        return this.sql;
-    }
-}
-/**
- * The Cloudflare `LiveDriver`. Dual-mode, because the SAME app module
- * bootstraps in both isolates:
- *
- * - **Worker** (HTTP mutations, queue consumers, crons): route the command to
- *   the room's Durable Object over the `invalidate` RPC — the same canonical
- *   `roomToDurableId` mapping the upgrade route and `broadcastToRoom` use —
- *   and return THAT log scope's commit stamp (what `Vela-Commit-Cursor`
- *   must carry).
- * - **DO** (writes issued from inside the object): apply to the local engine.
- */ export function durableObjectLive(options) {
-    let sink;
-    let env;
-    let localMode = false;
-    return {
-        kind: 'durable-object',
-        bind (boundSink) {
-            sink = boundSink;
-        },
-        _initializeEnv (capturedEnv) {
-            env = capturedEnv;
-        },
-        _setLocalMode () {
-            localMode = true;
-        },
-        dispatch (cmd) {
-            if (localMode) return sink?.applyInvalidation(cmd);
-            const namespace = env?.[options.binding];
-            if (!namespace) {
-                throw new Error(`durableObjectLive: binding '${options.binding}' is not available. In a Worker, ` + 'createCloudflareApp() captures env on the first request; check the wrangler binding name.');
-            }
-            const room = cmd.room ?? options.defaultRoom ?? DEFAULT_ROOM;
-            const stub = namespace.get(roomToDurableId(namespace, room));
-            return stub.invalidate({
-                ...cmd,
-                room
-            });
-        }
-    };
-}
-const isCfLiveDriver = (value)=>typeof value === 'object' && value !== null && typeof value._setLocalMode === 'function' && typeof value._initializeEnv === 'function';
-/** Worker-side wiring, called from `cloudflareAdapter`'s first-request middleware. */ export function initializeWorkerLive(container, env) {
-    let driver;
-    try {
-        driver = container.resolve(LIVE_DRIVER);
-    } catch  {
-        return; // LiveModule not imported
-    }
-    if (isCfLiveDriver(driver)) driver._initializeEnv(env);
-}
-/**
- * DO-side wiring, called from `buildDoRuntime`: initialize the SQLite cursor
- * log, flip the driver to local mode, and replay every hibernation-persisted
- * subscription into the (fresh) engine so an eviction is invisible to
- * subscribers. Returns the engine for the `invalidate` RPC, or undefined when
- * the app doesn't use LiveModule.
- */ export function initDoLive(app, container, ctx) {
-    const entry = app.entrypoints.ofKind('live')[0];
-    if (!entry) return undefined;
-    const engine = entry.meta.engine;
-    try {
-        const log = container.resolve(LIVE_CURSOR_LOG);
-        if (log instanceof DoCursorLog) {
-            const sql = ctx.storage?.sql;
-            if (!sql) {
-                throw new Error('DoCursorLog requires a SQLite-backed Durable Object: add this class to ' + "wrangler's `migrations[].new_sqlite_classes`. Falling back is not possible — " + 'either enable SQLite or drop the `log: durableObjectCursorLog()` option ' + '(snapshot-on-reconnect semantics).');
-            }
-            log._initialize(sql);
-        }
-    } catch (err) {
-        // Surface misconfiguration loudly — a silently un-initialized log would
-        // throw on the first subscribe instead.
-        if (err instanceof Error && err.message.includes('new_sqlite_classes')) throw err;
-    }
-    try {
-        const driver = container.resolve(LIVE_DRIVER);
-        if (isCfLiveDriver(driver)) driver._setLocalMode();
-    } catch  {
-    // LiveModule always provides LIVE_DRIVER when the engine exists; defensive only.
-    }
-    // Wake-time replay: subscriptions ride the hibernation attachments.
-    for (const ws of ctx.getWebSockets()){
-        const client = new CfWsClient(ctx, ws);
-        for (const record of readPersistedLiveSubscriptions(client)){
-            engine.restoreSubscription(client.path, client, record);
-        }
-    }
-    return engine;
-}
-/** Ergonomic alias: the log option for `LiveModule.forRoot` on Cloudflare. */ export function durableObjectCursorLog(maxRows) {
-    return new DoCursorLog(maxRows);
-}
-/**
- * Invalidate live tags in a room from a Worker (controller / cron / queue
- * consumer) — the live sibling of `broadcastToRoom`. Returns the room log
- * scope's commit stamp for `Vela-Commit-Cursor` stamping.
- */ export async function liveInvalidateToRoom(ns, room, tags) {
-    const stub = ns.get(roomToDurableId(ns, room));
-    return stub.invalidate({
-        room,
-        tags
-    });
-}

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

@@ -1,35 +0,0 @@
-export interface WsLike {
-    send(message: string | ArrayBuffer): void;
-    close(code?: number, reason?: string): void;
-    serializeAttachment(value: unknown): void;
-    deserializeAttachment(): unknown;
-}
-/** Structural view of the DO's SQLite handle (`ctx.storage.sql`, requires `new_sqlite_classes`). */
-export interface SqlStorageLike {
-    exec(query: string, ...bindings: unknown[]): {
-        toArray(): Record<string, 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;
-    /** Present on SQLite-backed DOs — the live cursor log lives here. */
-    readonly storage?: {
-        sql?: SqlStorageLike;
-    };
-}
-/** 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

@@ -1,4 +0,0 @@
-// 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

@@ -1,28 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,15 +0,0 @@
-export { VelaWebSocketDurableObject } from './websocket.durable-object';
-export { CloudflareWebSocketModule } from './cloudflare-websocket.module';
-export { broadcastToRoom } from './broadcast';
-export { DoCursorLog, durableObjectCursorLog, durableObjectLive, initDoLive, initializeWorkerLive, liveInvalidateToRoom, } from './do-live';
-export type { CfLiveDriver, DurableObjectLiveOptions } from './do-live';
-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, SqlStorageLike, WsLike, WsAttachment } from './do-state';

package/dist/websocket/index.js

@@ -1,15 +0,0 @@
-// 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";
-// Live queries: durable cursor log + DO-routed invalidation driver
-export { DoCursorLog, durableObjectCursorLog, durableObjectLive, initDoLive, initializeWorkerLive, liveInvalidateToRoom } from "./do-live.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

@@ -1,6 +0,0 @@
-/** 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

@@ -1,12 +0,0 @@
-// 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

@@ -1,14 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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;
-        liveEngine;
-        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);
-                this.liveEngine = runtime.live;
-            });
-        }
-        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);
-        }
-        /**
-     * DO RPC — live tag invalidation forwarded from a Worker (durableObjectLive /
-     * liveInvalidateToRoom). Appends to THIS log scope's cursor log and returns
-     * the commit stamp (what `Vela-Commit-Cursor` carries); the subscription
-     * refreshes fan out asynchronously.
-     */ async invalidate(cmd) {
-            await this.ready;
-            return this.liveEngine?.applyInvalidation(cmd);
-        }
-    };
-}

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

@@ -1,16 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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);