@velajs/vela 1.19.0 → 1.19.1

package/dist/websocket/ws-dispatcher.js

@@ -1,343 +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;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { Container } from "../container/container.js";
-import { Inject, Injectable, Optional } from "../container/decorators.js";
-import { DiscoveryService } from "../discovery/discovery.service.js";
-import { resolveErrorReporter } from "../exceptions/reporter.js";
-import { instantiateMany } from "../http/instantiate.js";
-import { RouteManager } from "../http/route.manager.js";
-import { ComponentManager } from "../pipeline/component.manager.js";
-import { shouldFilterCatch } from "../pipeline/decorators.js";
-import { PipelineRunner } from "../pipeline/pipeline-runner.js";
-import { MetadataRegistry } from "../registry/metadata.registry.js";
-import { resolveWsArgs } from "./ws-argument-resolver.js";
-import { buildWsExecutionContext } from "./ws-execution-context.js";
-import { toErrorFrame, WsException } from "./ws-exception.js";
-import { RESERVED_WS_EVENT_PREFIX, WS_GATEWAY_METADATA, WS_RESERVED_METADATA, WS_SERVER, WS_SUBSCRIBE_METADATA } from "./websocket.tokens.js";
-function hasAfterInit(x) {
-    return typeof x?.afterInit === 'function';
-}
-function hasHandleConnection(x) {
-    return typeof x?.handleConnection === 'function';
-}
-function hasHandleDisconnect(x) {
-    return typeof x?.handleDisconnect === 'function';
-}
-function isWsResponse(x) {
-    return typeof x === 'object' && x !== null && typeof x.event === 'string';
-}
-export class WsDispatcher {
-    container;
-    discovery;
-    server;
-    routeManager;
-    gateways = new Map();
-    reserved = new Map();
-    constructor(container, discovery, server, routeManager){
-        this.container = container;
-        this.discovery = discovery;
-        this.server = server;
-        this.routeManager = routeManager;
-    }
-    /** Paths of every discovered `@WebSocketGateway` — used by transports to register routes. */ get gatewayPaths() {
-        return [
-            ...this.gateways.keys()
-        ];
-    }
-    async onApplicationBootstrap() {
-        // Reserved-event handlers first: modules claiming a `$…` event
-        // (@ReservedWsEvent) receive those frames across every gateway path.
-        for (const found of this.discovery.providersWithMeta(WS_RESERVED_METADATA)){
-            if (!found.instance) continue;
-            const event = found.meta.event;
-            if (this.reserved.has(event)) {
-                const msg = `[vela] duplicate @ReservedWsEvent('${event}') ` + `(${found.metatype.name}); keeping the first.`;
-                if (this.container.getDiagnostics() === 'throw') throw new Error(msg);
-                console.warn(msg);
-                continue;
-            }
-            this.reserved.set(event, found.instance);
-        }
-        for (const found of this.discovery.providersWithMeta(WS_GATEWAY_METADATA)){
-            if (!found.instance) continue;
-            const gatewayClass = found.metatype;
-            const instance = found.instance;
-            const entry = this.buildGatewayEntry(gatewayClass, found.meta, instance);
-            // Two gateways on the same path (or both defaulting to '') would silently
-            // overwrite each other in the routing Map — surface it instead.
-            if (this.gateways.has(entry.path)) {
-                const msg = `[vela] duplicate @WebSocketGateway path '${entry.path}' ` + `(${gatewayClass.name}); keeping the first. Give each gateway a distinct path.`;
-                if (this.container.getDiagnostics() === 'throw') throw new Error(msg);
-                console.warn(msg);
-                continue;
-            }
-            this.gateways.set(entry.path, entry);
-            if (this.server && hasAfterInit(instance)) {
-                try {
-                    await instance.afterInit(this.server);
-                } catch (err) {
-                    this.reportBootstrapError(gatewayClass.name, err);
-                }
-            }
-        }
-    }
-    /** One `'websocket'` entrypoint per discovered gateway (authoritative). */ collectEntrypoints() {
-        return [
-            ...this.gateways.values()
-        ].map((entry)=>({
-                kind: 'websocket',
-                token: entry.gatewayClass,
-                instance: entry.instance,
-                meta: {
-                    path: entry.path,
-                    dispatcher: this
-                }
-            }));
-    }
-    async handleOpen(path, client) {
-        const entry = this.gateways.get(path);
-        if (entry && hasHandleConnection(entry.instance)) {
-            await entry.instance.handleConnection(client);
-        }
-    }
-    async handleClose(path, client, _code, _reason) {
-        // Reserved handlers drop per-connection state first (isolated per handler)
-        // so a throwing gateway handleDisconnect can't leak live subscriptions.
-        for (const handler of this.reserved.values()){
-            try {
-                await handler.handleSocketClose?.(path, client);
-            } catch (err) {
-                await this.handleError(path, client, err);
-            }
-        }
-        const entry = this.gateways.get(path);
-        if (entry && hasHandleDisconnect(entry.instance)) {
-            await entry.instance.handleDisconnect(client);
-        }
-    }
-    async handleError(path, _client, err) {
-        // Connection-level and reserved-frame (`$…`) throws land here. Route them
-        // through the shared reporter so a custom APP_EXCEPTION_HANDLER observes
-        // them too — the default reporter console.errors and honors `'silent'`.
-        // No client frame is sent for this path, by design: reserved frames own
-        // their own client-facing responses, and there is no envelope id to reply to.
-        resolveErrorReporter(this.container).report(err, {
-            edge: 'ws',
-            source: path ? `reserved-frame ${path}` : 'reserved-frame'
-        });
-    }
-    async dispatchMessage(path, client, raw) {
-        const entry = this.gateways.get(path);
-        if (!entry) return;
-        let message;
-        try {
-            message = this.parse(raw);
-        } catch  {
-            this.trySend(client, 'exception', {
-                message: 'Invalid message'
-            });
-            return;
-        }
-        // Reserved namespace: `$…` frames route to @ReservedWsEvent handlers
-        // (after app-wide guards) and NEVER reach gateway handlers; an unclaimed
-        // reserved event is dropped like any unknown event.
-        if (message.event.startsWith(RESERVED_WS_EVENT_PREFIX)) {
-            await this.dispatchReserved(path, client, message);
-            return;
-        }
-        const handler = entry.handlers.get(message.event);
-        if (!handler) return; // unknown event — ignored (NestJS parity)
-        const ctx = buildWsExecutionContext(client, message.data, entry.gatewayClass, handler.methodName, message.event);
-        // App-wide global components (APP_* provider tokens + imperative
-        // app.useGlobalX()) run first, then controller/handler-tier — mirroring the
-        // HTTP HandlerExecutor so global guards/pipes/interceptors/filters protect
-        // gateway messages too. Read live so late registrations propagate.
-        const globals = this.routeManager?.getGlobalComponents();
-        const guards = [
-            ...instantiateMany(globals?.guards ?? [], this.container),
-            ...instantiateMany(handler.guards, this.container)
-        ];
-        const pipes = [
-            ...instantiateMany(globals?.pipes ?? [], this.container),
-            ...instantiateMany(handler.pipes, this.container)
-        ];
-        const interceptors = [
-            ...instantiateMany(globals?.interceptors ?? [], this.container),
-            ...instantiateMany(handler.interceptors, this.container)
-        ];
-        // Handler/controller filters first (closest), then global filters last.
-        const filters = [
-            ...instantiateMany(handler.filters, this.container),
-            ...instantiateMany(globals?.filters ?? [], this.container)
-        ];
-        try {
-            const method = entry.instance[handler.methodName];
-            // Guards → args + pipes → interceptor chain → handler, via the shared
-            // runner (WS keeps guards-first, unlike HTTP's args-before-guards).
-            const result = await PipelineRunner.run({
-                context: ctx,
-                guards,
-                interceptors,
-                resolveArgs: ()=>resolveWsArgs(handler.paramMeta, client, message.data, pipes, handler.paramTypes),
-                invoke: async (args)=>method.apply(entry.instance, args),
-                onGuardReject: ()=>new WsException('Forbidden')
-            });
-            this.reply(client, message, result);
-        } catch (error) {
-            const reporter = resolveErrorReporter(this.container);
-            const source = `${entry.gatewayClass.name}.${handler.methodName}`;
-            // Report FIRST, always — before any exception filter can claim (and thus
-            // hide) the error. Rendering is a separate concern (mirrors HandlerExecutor).
-            reporter.report(error, {
-                edge: 'ws',
-                source
-            });
-            await this.runFilters(client, message, error, filters, ctx, reporter, source);
-        }
-    }
-    /**
-   * Route a reserved (`$…`) frame to its claiming handler. App-wide (`APP_*` /
-   * `useGlobalGuards`) guards protect reserved frames exactly like gateway
-   * messages — guards-first, WS convention; handler/class-tier components are
-   * the claiming module's own concern (e.g. live resolvers run their scoped
-   * guards at subscribe).
-   */ async dispatchReserved(path, client, message) {
-        const handler = this.reserved.get(message.event);
-        if (!handler) return;
-        const ctx = buildWsExecutionContext(client, message.data, handler.constructor, 'handleReservedEvent', message.event);
-        const globals = this.routeManager?.getGlobalComponents();
-        const guards = instantiateMany(globals?.guards ?? [], this.container);
-        try {
-            for (const guard of guards){
-                if (!await guard.canActivate(ctx)) {
-                    const frame = toErrorFrame(new WsException('Forbidden'), resolveErrorReporter(this.container).catalog);
-                    this.trySend(client, frame.event, frame.data, message.id);
-                    return;
-                }
-            }
-            await handler.handleReservedEvent(path, client, message);
-        } catch (err) {
-            await this.handleError(path, client, err);
-        }
-    }
-    reply(client, message, result) {
-        if (result === undefined || result === null) return;
-        if (isWsResponse(result)) {
-            this.trySend(client, result.event, result.data, message.id);
-        } else {
-            this.trySend(client, message.event, result, message.id);
-        }
-    }
-    async runFilters(client, message, error, filters, ctx, reporter, source) {
-        for (const filter of filters){
-            if (shouldFilterCatch(filter, error)) {
-                try {
-                    const handled = await filter.catch(error, ctx);
-                    if (isWsResponse(handled)) {
-                        this.trySend(client, handled.event, handled.data, message.id);
-                    }
-                } catch (filterError) {
-                    // A throwing filter is itself a bug worth reporting — then fall back
-                    // to the default redacted frame (mirrors HandlerExecutor).
-                    reporter.report(filterError, {
-                        edge: 'ws',
-                        source,
-                        note: 'exception filter threw'
-                    });
-                    const frame = toErrorFrame(error, reporter.catalog);
-                    this.trySend(client, frame.event, frame.data, message.id);
-                }
-                return;
-            }
-        }
-        const errorFrame = toErrorFrame(error, reporter.catalog);
-        this.trySend(client, errorFrame.event, errorFrame.data, message.id);
-    }
-    // Outbound sends are best-effort: the socket may have closed mid-dispatch.
-    trySend(client, event, data, id) {
-        try {
-            client.send(event, data, id);
-        } catch  {
-        // socket closed — nothing to do
-        }
-    }
-    reportBootstrapError(name, err) {
-        const mode = this.container.getDiagnostics();
-        if (mode === 'throw') throw err;
-        if (mode === 'log') console.warn(`[vela] websocket gateway ${name} afterInit failed:`, err);
-    }
-    parse(raw) {
-        const text = typeof raw === 'string' ? raw : new TextDecoder().decode(raw);
-        const parsed = JSON.parse(text);
-        if (!parsed || typeof parsed !== 'object' || typeof parsed.event !== 'string') {
-            throw new Error('Invalid WebSocket message envelope');
-        }
-        return parsed;
-    }
-    buildGatewayEntry(gatewayClass, options, instance) {
-        const ctor = gatewayClass;
-        const subs = MetadataRegistry.getCustomClassMeta(ctor, WS_SUBSCRIBE_METADATA) ?? [];
-        const allParams = MetadataRegistry.getParameters(ctor);
-        const handlers = new Map();
-        for (const { event, methodName } of subs){
-            // The `$` namespace belongs to framework modules (@ReservedWsEvent) — an
-            // app gateway subscribing to it would never receive the frames anyway.
-            if (event.startsWith(RESERVED_WS_EVENT_PREFIX)) {
-                const msg = `[vela] @SubscribeMessage('${event}') on ${gatewayClass.name}: the ` + `'${RESERVED_WS_EVENT_PREFIX}' event prefix is reserved for framework modules — skipped.`;
-                if (this.container.getDiagnostics() === 'throw') throw new Error(msg);
-                console.warn(msg);
-                continue;
-            }
-            const paramMeta = [
-                ...allParams.get(methodName) ?? []
-            ].sort((a, b)=>a.index - b.index);
-            const paramTypes = Reflect.getMetadata('design:paramtypes', gatewayClass.prototype, methodName);
-            handlers.set(event, {
-                methodName,
-                paramMeta,
-                paramTypes,
-                guards: ComponentManager.getScopedComponents('guard', ctor, methodName),
-                pipes: ComponentManager.getScopedComponents('pipe', ctor, methodName),
-                interceptors: ComponentManager.getScopedComponents('interceptor', ctor, methodName),
-                // Handler → controller → global, so the closest filter runs first (mirrors HandlerExecutor).
-                filters: [
-                    ...ComponentManager.getScopedComponents('filter', ctor, methodName)
-                ].reverse()
-            });
-        }
-        return {
-            path: options.path ?? '',
-            instance,
-            gatewayClass,
-            handlers
-        };
-    }
-}
-WsDispatcher = _ts_decorate([
-    Injectable(),
-    _ts_param(0, Inject(Container)),
-    _ts_param(1, Inject(DiscoveryService)),
-    _ts_param(2, Optional()),
-    _ts_param(2, Inject(WS_SERVER)),
-    _ts_param(3, Optional()),
-    _ts_param(3, Inject(RouteManager)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Container === "undefined" ? Object : Container,
-        typeof DiscoveryService === "undefined" ? Object : DiscoveryService,
-        typeof WsServer === "undefined" ? Object : WsServer,
-        typeof RouteManager === "undefined" ? Object : RouteManager
-    ])
-], WsDispatcher);

package/dist/websocket/ws-exception.d.ts

@@ -1,25 +0,0 @@
-import { type Catalog } from '@velajs/errors';
-/**
- * WebSocket analogue of `HttpException`. Thrown from guards/pipes/handlers to
- * signal a client-facing error; the dispatcher serializes it to an
- * `{ event: 'exception', data }` frame unless a matching exception filter
- * handles it first.
- */
-export declare class WsException extends Error {
-    private readonly err;
-    constructor(err: string | Record<string, unknown>);
-    getError(): string | Record<string, unknown>;
-}
-/**
- * Default serialization of an uncaught error into the outbound exception frame.
- *
- * A `WsException` ships its own payload verbatim (string → `{ message }`,
- * object → as-is). Every other error routes through `toErrorBody` — the single
- * wire-redaction seam shared with the HTTP edge — so unbranded/internal errors
- * are redacted to their catalog title and only branded `VelaError`s echo a
- * client-safe `{ code, message, ... }`.
- */
-export declare function toErrorFrame(error: unknown, catalog?: Catalog<string>): {
-    event: 'exception';
-    data: unknown;
-};

package/dist/websocket/ws-exception.js

@@ -1,42 +0,0 @@
-import { toErrorBody } from "@velajs/errors";
-/**
- * WebSocket analogue of `HttpException`. Thrown from guards/pipes/handlers to
- * signal a client-facing error; the dispatcher serializes it to an
- * `{ event: 'exception', data }` frame unless a matching exception filter
- * handles it first.
- */ export class WsException extends Error {
-    err;
-    constructor(err){
-        super(typeof err === 'string' ? err : String(err.message ?? 'WsException')), this.err = err;
-        this.name = 'WsException';
-    }
-    getError() {
-        return this.err;
-    }
-}
-/**
- * Default serialization of an uncaught error into the outbound exception frame.
- *
- * A `WsException` ships its own payload verbatim (string → `{ message }`,
- * object → as-is). Every other error routes through `toErrorBody` — the single
- * wire-redaction seam shared with the HTTP edge — so unbranded/internal errors
- * are redacted to their catalog title and only branded `VelaError`s echo a
- * client-safe `{ code, message, ... }`.
- */ export function toErrorFrame(error, catalog) {
-    if (error instanceof WsException) {
-        const e = error.getError();
-        return {
-            event: 'exception',
-            data: typeof e === 'string' ? {
-                message: e
-            } : e
-        };
-    }
-    const { body } = toErrorBody(error, {
-        catalog
-    });
-    return {
-        event: 'exception',
-        data: body.error
-    };
-}

package/dist/websocket/ws-execution-context.d.ts

@@ -1,9 +0,0 @@
-import type { Type } from '../container/types';
-import type { WsClient, WsExecutionContext } from './websocket.types';
-/**
- * WebSocket sibling of `buildExecutionContext` (`http/execution-context.ts`).
- * Guards/pipes/interceptors/filters that read `getClass()`/`getHandler()` or
- * call `switchToWs()` reuse unchanged; the HTTP-only accessors throw rather
- * than fabricate a fake `Request`.
- */
-export declare function buildWsExecutionContext(client: WsClient, data: unknown, controller: Type, handlerName: string | symbol, pattern: string): WsExecutionContext;

package/dist/websocket/ws-execution-context.js

@@ -1,24 +0,0 @@
-const HTTP_ON_WS = (accessor)=>()=>{
-        throw new Error(`${accessor} called on a WebSocket ExecutionContext. This handler runs over a gateway message, not HTTP — use switchToWs().`);
-    };
-/**
- * WebSocket sibling of `buildExecutionContext` (`http/execution-context.ts`).
- * Guards/pipes/interceptors/filters that read `getClass()`/`getHandler()` or
- * call `switchToWs()` reuse unchanged; the HTTP-only accessors throw rather
- * than fabricate a fake `Request`.
- */ export function buildWsExecutionContext(client, data, controller, handlerName, pattern) {
-    const host = {
-        getClient: ()=>client,
-        getData: ()=>data,
-        getPattern: ()=>pattern
-    };
-    return {
-        getType: ()=>'ws',
-        getClass: ()=>controller,
-        getHandler: ()=>handlerName,
-        getContext: HTTP_ON_WS('getContext()'),
-        getRequest: HTTP_ON_WS('getRequest()'),
-        switchToHttp: HTTP_ON_WS('switchToHttp()'),
-        switchToWs: ()=>host
-    };
-}

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

@@ -1,31 +0,0 @@
-import type { SyncDriver } from './ws-sync';
-import type { BroadcastOperator, WsServer } from './websocket.types';
-/**
- * Accumulates `{ rooms, exceptRooms, exceptIds }` across a fluent chain and, on
- * `.emit()`, produces a serializable `BroadcastCommand` handed to the active
- * `SyncDriver`. The driver decides local-vs-remote delivery.
- */
-export declare class BroadcastOperatorImpl implements BroadcastOperator {
-    private readonly driver;
-    private readonly rooms;
-    private readonly exceptRooms;
-    private readonly exceptIds;
-    constructor(driver: SyncDriver, rooms?: Set<string>, exceptRooms?: Set<string>, exceptIds?: Set<string>);
-    to(room: string): this;
-    in(room: string): this;
-    except(room: string): this;
-    emit(event: string, data?: unknown): void | Promise<void>;
-}
-/**
- * The `@WebSocketServer()`-injected handle. Server-origin broadcasts never
- * pre-exclude anyone (a client-origin `client.to()` seeds `exceptIds` with the
- * sender — that lives in the transport's client, not here).
- */
-export declare class WsServerImpl implements WsServer {
-    private readonly driver;
-    constructor(driver: SyncDriver);
-    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.js

@@ -1,74 +0,0 @@
-/**
- * Accumulates `{ rooms, exceptRooms, exceptIds }` across a fluent chain and, on
- * `.emit()`, produces a serializable `BroadcastCommand` handed to the active
- * `SyncDriver`. The driver decides local-vs-remote delivery.
- */ export class BroadcastOperatorImpl {
-    driver;
-    rooms;
-    exceptRooms;
-    exceptIds;
-    constructor(driver, rooms = new Set(), exceptRooms = new Set(), exceptIds = new Set()){
-        this.driver = driver;
-        this.rooms = rooms;
-        this.exceptRooms = exceptRooms;
-        this.exceptIds = exceptIds;
-    }
-    to(room) {
-        this.rooms.add(room);
-        return this;
-    }
-    in(room) {
-        return this.to(room);
-    }
-    except(room) {
-        this.exceptRooms.add(room);
-        return this;
-    }
-    emit(event, data) {
-        const cmd = {
-            rooms: [
-                ...this.rooms
-            ],
-            exceptRooms: this.exceptRooms.size ? [
-                ...this.exceptRooms
-            ] : undefined,
-            exceptIds: this.exceptIds.size ? [
-                ...this.exceptIds
-            ] : undefined,
-            frame: JSON.stringify({
-                event,
-                data
-            })
-        };
-        return this.driver.dispatch(cmd);
-    }
-}
-/**
- * The `@WebSocketServer()`-injected handle. Server-origin broadcasts never
- * pre-exclude anyone (a client-origin `client.to()` seeds `exceptIds` with the
- * sender — that lives in the transport's client, not here).
- */ export class WsServerImpl {
-    driver;
-    constructor(driver){
-        this.driver = driver;
-    }
-    emit(event, data) {
-        // Empty `rooms` means GLOBAL.
-        return this.driver.dispatch({
-            rooms: [],
-            frame: JSON.stringify({
-                event,
-                data
-            })
-        });
-    }
-    to(room) {
-        return new BroadcastOperatorImpl(this.driver).to(room);
-    }
-    in(room) {
-        return this.to(room);
-    }
-    except(room) {
-        return new BroadcastOperatorImpl(this.driver).except(room);
-    }
-}

package/dist/websocket/ws-sync.d.ts

@@ -1,47 +0,0 @@
-import type { BroadcastCommand, WsClient } from './websocket.types';
-/**
- * Owns LOCAL room membership and local fan-out for the connections a single
- * node/isolate holds. The Cloudflare transport backs this with hibernation
- * tags + attachment; node/bun/deno back it with the in-memory implementation
- * below. Always edge-safe (no `node:*`).
- */
-export interface RoomRegistry {
-    /** Register a connection (called on connect) so global broadcasts can reach it. */
-    register(client: WsClient): void;
-    join(client: WsClient, room: string): void | Promise<void>;
-    leave(client: WsClient, room: string): void | Promise<void>;
-    /** Remove a connection and all its room memberships (called on disconnect). */
-    leaveAll(client: WsClient): void | Promise<void>;
-    /** Deliver a command to the sockets THIS node holds, applying every exclusion. */
-    deliverLocal(cmd: BroadcastCommand): void | Promise<void>;
-    localIdsInRoom(room: string): string[];
-}
-/**
- * Pluggable cross-instance transport for broadcast commands. `local()` is the
- * zero-config single-instance default; `durableObject()` (Cloudflare) and
- * `redis()` (node) are additive and chosen at the composition root.
- */
-export interface SyncDriver {
-    readonly kind: string;
-    /** Wire the local registry so the driver can deliver to locally-held sockets. */
-    bind(registry: RoomRegistry): void;
-    /** Route a command so every node that may hold a matching socket delivers it. */
-    dispatch(cmd: BroadcastCommand): void | Promise<void>;
-    countRoom?(room: string): Promise<number>;
-    start?(): void | Promise<void>;
-    stop?(): void | Promise<void>;
-}
-/** Single-instance default: deliver straight to the local registry, no cross-node hop. */
-export declare function local(): SyncDriver;
-/** In-memory `RoomRegistry` for node/bun/deno and tests. Edge-safe (plain Maps). */
-export declare class InMemoryRoomRegistry implements RoomRegistry {
-    private readonly rooms;
-    private readonly clientRooms;
-    private readonly clients;
-    register(client: WsClient): void;
-    join(client: WsClient, room: string): void;
-    leave(client: WsClient, room: string): void;
-    leaveAll(client: WsClient): void;
-    localIdsInRoom(room: string): string[];
-    deliverLocal(cmd: BroadcastCommand): void;
-}

package/dist/websocket/ws-sync.js

@@ -1,74 +0,0 @@
-/** Single-instance default: deliver straight to the local registry, no cross-node hop. */ export function local() {
-    let registry;
-    return {
-        kind: 'local',
-        bind (r) {
-            registry = r;
-        },
-        dispatch (cmd) {
-            return registry?.deliverLocal(cmd);
-        }
-    };
-}
-/** In-memory `RoomRegistry` for node/bun/deno and tests. Edge-safe (plain Maps). */ export class InMemoryRoomRegistry {
-    rooms = new Map();
-    clientRooms = new Map();
-    clients = new Map();
-    register(client) {
-        this.clients.set(client.id, client);
-    }
-    join(client, room) {
-        this.register(client);
-        let members = this.rooms.get(room);
-        if (!members) {
-            members = new Set();
-            this.rooms.set(room, members);
-        }
-        members.add(client);
-        let joined = this.clientRooms.get(client.id);
-        if (!joined) {
-            joined = new Set();
-            this.clientRooms.set(client.id, joined);
-        }
-        joined.add(room);
-    }
-    leave(client, room) {
-        const members = this.rooms.get(room);
-        members?.delete(client);
-        if (members && members.size === 0) this.rooms.delete(room);
-        this.clientRooms.get(client.id)?.delete(room);
-    }
-    leaveAll(client) {
-        for (const room of this.clientRooms.get(client.id) ?? []){
-            const members = this.rooms.get(room);
-            members?.delete(client);
-            if (members && members.size === 0) this.rooms.delete(room);
-        }
-        this.clientRooms.delete(client.id);
-        this.clients.delete(client.id);
-    }
-    localIdsInRoom(room) {
-        return [
-            ...this.rooms.get(room) ?? []
-        ].map((c)=>c.id);
-    }
-    deliverLocal(cmd) {
-        const excludeIds = new Set(cmd.exceptIds ?? []);
-        const excludeRooms = cmd.exceptRooms ?? [];
-        // Empty `rooms` => GLOBAL: every registered connection. Otherwise the union
-        // of the targeted rooms' members (deduped per connection).
-        const candidates = cmd.rooms.length === 0 ? new Set(this.clients.values()) : (()=>{
-            const set = new Set();
-            for (const room of cmd.rooms){
-                for (const client of this.rooms.get(room) ?? [])set.add(client);
-            }
-            return set;
-        })();
-        for (const client of candidates){
-            if (excludeIds.has(client.id)) continue;
-            const joined = this.clientRooms.get(client.id);
-            if (excludeRooms.some((room)=>joined?.has(room))) continue;
-            client.sendRaw(cmd.frame);
-        }
-    }
-}