@fishenv/http 0.0.0-stage → 0.0.3

package/dist/ws/channels/protocol.js

@@ -0,0 +1,94 @@
+/**
+ * Wire protocol `fishenv.channels.v1` — JSON text frames.
+ *
+ * Client → server:
+ *   { t: "join",  ref?, ch, d? }
+ *   { t: "event", ref?, ch, ev, d? }
+ *   { t: "leave", ref?, ch }
+ *   { t: "presence_update", ref?, ch, d }
+ *
+ * Server → client:
+ *   { t: "reply", ref, ok: true, d? } | { t: "reply", ref, ok: false, err }
+ *   { t: "event", ch, ev, d }            — `seq` is reserved for replay
+ *   { t: "close", ch, reason }           — server-initiated leave
+ *   { t: "error", ch?, err }             — failure of a frame without `ref`
+ *   { t: "presence_state", ch, d }
+ *   { t: "presence_diff", ch, joins, leaves }
+ *
+ * Parsing reads only known keys and never merges client objects into
+ * server state, so `__proto__` & co. are inert.
+ */
+export { CHANNELS_PROTOCOL } from "../../contract/index.js";
+export const MAX_CHANNEL_NAME_LENGTH = 256;
+export const MAX_EVENT_NAME_LENGTH = 128;
+export const MAX_REF = 2 ** 31 - 1;
+/** Why a frame was rejected; `ref` is recovered when possible for the reply. */
+export class FrameError extends Error {
+    ref;
+    ch;
+    constructor(message, ref, ch) {
+        super(message);
+        this.name = "FrameError";
+        this.ref = ref;
+        this.ch = ch;
+    }
+}
+const TYPES = new Set(["join", "event", "leave", "presence_update"]);
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readRef(raw) {
+    const ref = raw.ref;
+    if (ref === undefined)
+        return undefined;
+    if (typeof ref === "number" &&
+        Number.isInteger(ref) &&
+        ref >= 0 &&
+        ref <= MAX_REF) {
+        return ref;
+    }
+    throw new FrameError("Invalid ref");
+}
+function readName(value, max) {
+    if (typeof value !== "string" || value === "" || value.length > max) {
+        return null;
+    }
+    // No control characters (incl. NUL) in names.
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: that's the point
+    if (/[\u0000-\u001f\u007f]/.test(value))
+        return null;
+    return value;
+}
+/** Validate an already-JSON-parsed client frame. Throws {@link FrameError}. */
+export function parseClientFrame(value) {
+    if (!isRecord(value))
+        throw new FrameError("Frame must be an object");
+    const ref = readRef(value);
+    const t = value.t;
+    if (typeof t !== "string" || !TYPES.has(t)) {
+        throw new FrameError("Unknown frame type", ref);
+    }
+    const ch = readName(value.ch, MAX_CHANNEL_NAME_LENGTH);
+    if (ch == null)
+        throw new FrameError("Invalid channel name", ref);
+    switch (t) {
+        case "join":
+            return { t, ref, ch, d: value.d };
+        case "leave":
+            return { t, ref, ch };
+        case "presence_update":
+            return { t, ref, ch, d: value.d };
+        default: {
+            const ev = readName(value.ev, MAX_EVENT_NAME_LENGTH);
+            if (ev == null)
+                throw new FrameError("Invalid event name", ref, ch);
+            return { t: "event", ref, ch, ev, d: value.d };
+        }
+    }
+}
+export function encodeFrame(frame) {
+    return JSON.stringify(frame);
+}
+export function eventFrame(ch, ev, d) {
+    return encodeFrame({ t: "event", ch, ev, d });
+}

package/dist/ws/channels/target.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Server-side access to a concrete channel (`rooms/42`) from anywhere —
+ * use cases, jobs, webhooks — via the hub the channels are mounted with.
+ */
+import type { AnyChannelContract } from "../../contract/index.ts";
+import type { WsConnection } from "../connection.ts";
+import type { WsHub, WsRoomTarget } from "../hub.ts";
+import type { PresenceTopic } from "../presence.ts";
+import type { ServerEventName, ServerEventPayload } from "./channel.ts";
+/**
+ * Hub room backing a channel. The control-character prefix can't collide
+ * with client-supplied channel names (which reject control characters) or
+ * with ordinary server-side rooms.
+ */
+export declare function channelRoom(name: string): string;
+export declare class WsChannelTarget<C = AnyChannelContract> {
+    #private;
+    readonly name: string;
+    /** @internal Use `hub.channel(name)`. */
+    constructor(hub: WsHub, name: string, room?: WsRoomTarget);
+    /** Who is in this channel, cluster-wide (contracts with `.presence()`). */
+    get presence(): PresenceTopic;
+    /** Push an event to matching members on every node. Returns the local count. */
+    send<E extends ServerEventName<C>>(event: E, payload: ServerEventPayload<C, E>): number;
+    /** Only sockets registered under these hub keys (e.g. user ids). */
+    to(...keys: string[]): WsChannelTarget<C>;
+    except(...targets: (WsConnection | string)[]): WsChannelTarget<C>;
+    /**
+     * Remove matching members on every node. Their `.leave()` handlers run
+     * with reason `"kicked"` and the client receives `{ t: "close" }`.
+     */
+    kick(reason?: string): number;
+    /** Local matching member count. */
+    count(): number;
+    sockets(): WsConnection[];
+}

package/dist/ws/channels/target.js

@@ -0,0 +1,56 @@
+/**
+ * Server-side access to a concrete channel (`rooms/42`) from anywhere —
+ * use cases, jobs, webhooks — via the hub the channels are mounted with.
+ */
+import { eventFrame } from "./protocol.js";
+/**
+ * Hub room backing a channel. The control-character prefix can't collide
+ * with client-supplied channel names (which reject control characters) or
+ * with ordinary server-side rooms.
+ */
+export function channelRoom(name) {
+    return `\u0001ch:${name}`;
+}
+export class WsChannelTarget {
+    name;
+    #hub;
+    #room;
+    /** @internal Use `hub.channel(name)`. */
+    constructor(hub, name, room) {
+        this.name = name;
+        this.#hub = hub;
+        this.#room = room ?? hub.to(channelRoom(name));
+    }
+    /** Who is in this channel, cluster-wide (contracts with `.presence()`). */
+    get presence() {
+        return this.#hub.presence(channelRoom(this.name));
+    }
+    /** Push an event to matching members on every node. Returns the local count. */
+    send(event, payload) {
+        return this.#room.send(eventFrame(this.name, event, payload));
+    }
+    /** Only sockets registered under these hub keys (e.g. user ids). */
+    to(...keys) {
+        return this.#derive(this.#room.only(...keys));
+    }
+    except(...targets) {
+        return this.#derive(this.#room.except(...targets));
+    }
+    /**
+     * Remove matching members on every node. Their `.leave()` handlers run
+     * with reason `"kicked"` and the client receives `{ t: "close" }`.
+     */
+    kick(reason = "") {
+        return this.#room.kick(reason);
+    }
+    /** Local matching member count. */
+    count() {
+        return this.#room.count();
+    }
+    sockets() {
+        return this.#room.sockets();
+    }
+    #derive(room) {
+        return new WsChannelTarget(this.#hub, this.name, room);
+    }
+}

package/dist/ws/connection.d.ts

@@ -0,0 +1,56 @@
+/** A single live WebSocket, usable beyond the lifetime of its route handler. */
+import type { UpgradedSocket } from "../core/index.ts";
+import type { WsMessage } from "./message.ts";
+import { type WsCleanupFn, type WsSendable, type WsSendResult } from "./types.ts";
+export type WsMessageListener = (message: WsMessage) => unknown;
+export type WsCloseListener = (code: number, reason: string) => unknown;
+/**
+ * Wraps Bun's `ServerWebSocket`. Every method is a no-op once the connection
+ * is closed (or closing), so a stale reference held by a service or hub can
+ * never throw.
+ */
+export declare class WsConnection {
+    #private;
+    /** Unique per connection; a user may hold several (one per tab/device). */
+    readonly id: string;
+    /** The upgrade request (headers, URL). */
+    readonly req: Request;
+    /** Negotiated subprotocol, if any. */
+    readonly protocol: string | null;
+    /** Free-form per-connection state for the application. */
+    data: Record<string, unknown>;
+    /** @internal Created by the ws route lifecycle. */
+    constructor(ws: UpgradedSocket, req: Request, protocol: string | null, onError: (err: unknown) => void);
+    /** `true` once `close()` was called or the peer disconnected. */
+    get closed(): boolean;
+    get remoteAddress(): string;
+    /** Bytes queued but not yet flushed to the socket. */
+    get bufferedBytes(): number;
+    /** Escape hatch to Bun's socket. Native topics used here aren't namespaced. */
+    get raw(): UpgradedSocket;
+    send(data: WsSendable): WsSendResult;
+    /** `JSON.stringify` + send. Throws on non-serializable values. */
+    sendJson(value: unknown): WsSendResult;
+    /** Graceful close. The reason is truncated to 123 bytes. */
+    close(code?: number, reason?: string): void;
+    /**
+     * Close with `4001 Session expired` at `when` (a `Date` or epoch ms) —
+     * align it with the token/session lifetime so sockets don't outlive auth.
+     * Calling again replaces the previous deadline.
+     */
+    expireAt(when: Date | number): void;
+    /** Returns an unsubscribe fn. */
+    onMessage(fn: WsMessageListener): () => void;
+    /** Runs exactly once, immediately if already closed. */
+    onClose(fn: WsCloseListener | WsCleanupFn): void;
+    /** Fires when a backpressured socket's buffer drains. */
+    onDrain(fn: () => void): () => void;
+    /** @internal */
+    _deliver(message: WsMessage): void;
+    /** @internal */
+    _drained(): void;
+    /** @internal Bun reported the socket closed. */
+    _closed(code: number, reason: string): void;
+}
+/** Run a user callback; sync throws and rejections both go to `onError`. */
+export declare function runCallback(fn: () => unknown, onError: (err: unknown) => void): void;

package/dist/ws/connection.js

@@ -0,0 +1,172 @@
+/** A single live WebSocket, usable beyond the lifetime of its route handler. */
+import { truncateReason, WsCloseCode, } from "./types.js";
+/** setTimeout's max delay; longer expiries are chained. */
+const MAX_TIMEOUT = 2 ** 31 - 1;
+/**
+ * Wraps Bun's `ServerWebSocket`. Every method is a no-op once the connection
+ * is closed (or closing), so a stale reference held by a service or hub can
+ * never throw.
+ */
+export class WsConnection {
+    /** Unique per connection; a user may hold several (one per tab/device). */
+    id = crypto.randomUUID();
+    /** The upgrade request (headers, URL). */
+    req;
+    /** Negotiated subprotocol, if any. */
+    protocol;
+    /** Free-form per-connection state for the application. */
+    data = {};
+    #ws;
+    #onError;
+    #state = "open";
+    #closeInfo = null;
+    #messageListeners = new Set();
+    #drainListeners = new Set();
+    #closeListeners = [];
+    #expiry;
+    /** @internal Created by the ws route lifecycle. */
+    constructor(ws, req, protocol, onError) {
+        this.#ws = ws;
+        this.req = req;
+        this.protocol = protocol;
+        this.#onError = onError;
+    }
+    /** `true` once `close()` was called or the peer disconnected. */
+    get closed() {
+        return this.#state !== "open";
+    }
+    get remoteAddress() {
+        return this.#ws.remoteAddress;
+    }
+    /** Bytes queued but not yet flushed to the socket. */
+    get bufferedBytes() {
+        return this.#state === "closed" ? 0 : this.#ws.getBufferedAmount();
+    }
+    /** Escape hatch to Bun's socket. Native topics used here aren't namespaced. */
+    get raw() {
+        return this.#ws;
+    }
+    send(data) {
+        if (this.closed)
+            return "closed";
+        let status;
+        try {
+            status = this.#ws.send(data);
+        }
+        catch {
+            return "closed";
+        }
+        if (status === -1)
+            return "backpressure";
+        if (status === 0)
+            return "dropped";
+        return "sent";
+    }
+    /** `JSON.stringify` + send. Throws on non-serializable values. */
+    sendJson(value) {
+        return this.send(JSON.stringify(value));
+    }
+    /** Graceful close. The reason is truncated to 123 bytes. */
+    close(code = WsCloseCode.Normal, reason = "") {
+        if (this.closed)
+            return;
+        this.#state = "closing";
+        this.#clearExpiry();
+        try {
+            this.#ws.close(code, truncateReason(reason));
+        }
+        catch {
+            // Invalid code or already torn down — make sure it really goes away.
+            this.#ws.terminate();
+        }
+    }
+    /**
+     * Close with `4001 Session expired` at `when` (a `Date` or epoch ms) —
+     * align it with the token/session lifetime so sockets don't outlive auth.
+     * Calling again replaces the previous deadline.
+     */
+    expireAt(when) {
+        if (this.closed)
+            return;
+        this.#clearExpiry();
+        const deadline = typeof when === "number" ? when : when.getTime();
+        const arm = () => {
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) {
+                this.close(WsCloseCode.SessionExpired, "Session expired");
+                return;
+            }
+            this.#expiry = setTimeout(arm, Math.min(remaining, MAX_TIMEOUT));
+        };
+        arm();
+    }
+    /** Returns an unsubscribe fn. */
+    onMessage(fn) {
+        if (this.#state === "closed")
+            return () => { };
+        this.#messageListeners.add(fn);
+        return () => this.#messageListeners.delete(fn);
+    }
+    /** Runs exactly once, immediately if already closed. */
+    onClose(fn) {
+        if (this.#state === "closed") {
+            const info = this.#closeInfo;
+            runCallback(() => fn(info.code, info.reason), this.#onError);
+            return;
+        }
+        this.#closeListeners.push(fn);
+    }
+    /** Fires when a backpressured socket's buffer drains. */
+    onDrain(fn) {
+        if (this.#state === "closed")
+            return () => { };
+        this.#drainListeners.add(fn);
+        return () => this.#drainListeners.delete(fn);
+    }
+    // ── Lifecycle hooks (driven by the route lifecycle) ─────────────────
+    /** @internal */
+    _deliver(message) {
+        for (const listener of [...this.#messageListeners]) {
+            if (this.closed)
+                return;
+            runCallback(() => listener(message), this.#onError);
+        }
+    }
+    /** @internal */
+    _drained() {
+        for (const listener of [...this.#drainListeners]) {
+            runCallback(listener, this.#onError);
+        }
+    }
+    /** @internal Bun reported the socket closed. */
+    _closed(code, reason) {
+        if (this.#state === "closed")
+            return;
+        this.#state = "closed";
+        this.#closeInfo = { code, reason };
+        this.#clearExpiry();
+        this.#messageListeners.clear();
+        this.#drainListeners.clear();
+        const listeners = this.#closeListeners;
+        this.#closeListeners = [];
+        for (const fn of listeners) {
+            runCallback(() => fn(code, reason), this.#onError);
+        }
+    }
+    #clearExpiry() {
+        if (this.#expiry !== undefined)
+            clearTimeout(this.#expiry);
+        this.#expiry = undefined;
+    }
+}
+/** Run a user callback; sync throws and rejections both go to `onError`. */
+export function runCallback(fn, onError) {
+    try {
+        const result = fn();
+        if (result instanceof Promise)
+            result.catch(onError);
+    }
+    catch (err) {
+        onError(err);
+    }
+}

package/dist/ws/helpers.d.ts

@@ -0,0 +1,17 @@
+/** Handshake helpers usable from custom handlers and middleware. */
+import { HttpError } from "../core/index.ts";
+/** `426 Upgrade Required`, advertising the websocket upgrade. */
+export declare class UpgradeRequiredError extends HttpError {
+    constructor(message?: string);
+    get code(): string;
+    toResponse(development?: boolean): Response;
+}
+/** RFC 6455 §4.2.1 opening-handshake checks. */
+export declare function isWebSocketUpgrade(req: Request): boolean;
+/** Subprotocols the client offered, in its order. */
+export declare function requestedProtocols(req: Request): string[];
+/**
+ * Pick the first of the server's `supported` protocols (server preference
+ * order) that the client offered; `null` if none match.
+ */
+export declare function negotiateProtocol(req: Request, supported: readonly string[]): string | null;

package/dist/ws/helpers.js

@@ -0,0 +1,48 @@
+/** Handshake helpers usable from custom handlers and middleware. */
+import { HttpError } from "../core/index.js";
+/** `426 Upgrade Required`, advertising the websocket upgrade. */
+export class UpgradeRequiredError extends HttpError {
+    constructor(message = "Upgrade Required") {
+        super(426, message);
+    }
+    get code() {
+        return "upgrade_required";
+    }
+    toResponse(development = false) {
+        const res = super.toResponse(development);
+        res.headers.set("Upgrade", "websocket");
+        res.headers.set("Connection", "Upgrade");
+        return res;
+    }
+}
+function hasToken(header, token) {
+    if (header == null)
+        return false;
+    return header.split(",").some((part) => part.trim().toLowerCase() === token);
+}
+/** RFC 6455 §4.2.1 opening-handshake checks. */
+export function isWebSocketUpgrade(req) {
+    return (req.method === "GET" &&
+        hasToken(req.headers.get("upgrade"), "websocket") &&
+        hasToken(req.headers.get("connection"), "upgrade") &&
+        req.headers.get("sec-websocket-version") === "13" &&
+        (req.headers.get("sec-websocket-key") ?? "") !== "");
+}
+/** Subprotocols the client offered, in its order. */
+export function requestedProtocols(req) {
+    const header = req.headers.get("sec-websocket-protocol");
+    if (header == null)
+        return [];
+    return header
+        .split(",")
+        .map((p) => p.trim())
+        .filter((p) => p !== "");
+}
+/**
+ * Pick the first of the server's `supported` protocols (server preference
+ * order) that the client offered; `null` if none match.
+ */
+export function negotiateProtocol(req, supported) {
+    const offered = new Set(requestedProtocols(req));
+    return supported.find((p) => offered.has(p)) ?? null;
+}

package/dist/ws/hub.d.ts

@@ -0,0 +1,172 @@
+/**
+ * Keyed registry of live sockets plus server-side rooms — the seam for
+ * targeted (non-broadcast) sends from anywhere in the application.
+ */
+import type { AnyChannelContract } from "../contract/index.ts";
+import { type Transport, type TransportEnvelope } from "../core/index.ts";
+import { WsChannelTarget } from "./channels/target.ts";
+import type { WsConnection } from "./connection.ts";
+import { type PresenceOptions, PresenceRegistry, PresenceTopic } from "./presence.ts";
+/** Anything a hub can deliver: text and binary go out as-is, the rest as JSON. */
+export type WsHubPayload = unknown;
+/** Serializable form of a {@link RoomFilter}. */
+export interface WireFilter {
+    exceptIds?: string[];
+    exceptKeys?: string[];
+    onlyKeys?: string[];
+}
+/**
+ * Cross-process envelope for hub operations. One transport instance can be
+ * shared by every hub: messages carry the hub name.
+ */
+export type WsTransportMessage = TransportEnvelope & {
+    hub: string;
+} & ({
+    kind: "send";
+    key: string | null;
+    payload: WirePayload;
+} | {
+    kind: "room";
+    room: string;
+    payload: WirePayload;
+    filter?: WireFilter;
+} | {
+    kind: "close";
+    key: string;
+    code: number;
+    reason: string;
+} | {
+    kind: "kick";
+    room: string;
+    filter?: WireFilter;
+    reason: string;
+} | {
+    kind: "presence";
+    body: unknown;
+});
+/** A pre-encoded payload: text, or base64 for binary frames. */
+export interface WirePayload {
+    text?: string;
+    base64?: string;
+}
+export interface WsHubOptions {
+    /**
+     * Namespaces native topics and transport messages. Defaults to the class
+     * name — set it explicitly if your build minifies class names.
+     */
+    name?: string;
+    transport?: Transport<WsTransportMessage>;
+    /** Presence tuning (batching, heartbeats, limits). */
+    presence?: PresenceOptions;
+}
+type Frame = string | Uint8Array;
+/** Which room members a send/kick applies to. */
+export interface RoomFilter {
+    exceptIds: ReadonlySet<string>;
+    exceptKeys: ReadonlySet<string>;
+    /** `null` = every key. */
+    onlyKeys: ReadonlySet<string> | null;
+}
+/** A fan-out target: a room, optionally narrowed to/away from sockets or keys. */
+export declare class WsRoomTarget {
+    #private;
+    /** @internal Use `hub.to(room)`. */
+    constructor(hub: WsHub, room: string, filter?: RoomFilter);
+    /** Exclude a socket (e.g. the sender) or every socket of a key. */
+    except(...targets: (WsConnection | string)[]): WsRoomTarget;
+    /** Only members registered under one of `keys`. */
+    only(...keys: string[]): WsRoomTarget;
+    /** Deliver to matching members on every node. Returns the local delivery count. */
+    send(data: WsHubPayload): number;
+    /**
+     * Remove matching members from the room on every node, running any leave
+     * hook registered for them (channels use this to notify the client).
+     */
+    kick(reason?: string): number;
+    /** Local matching member count. */
+    count(): number;
+    /** Local matching members. */
+    sockets(): WsConnection[];
+}
+/**
+ * Sockets keyed by an application identity (user id, tenant id, device…),
+ * plus server-side **rooms** — groupings the server assigns; clients can't
+ * ask to join one. One key maps to many sockets (tabs); one socket has at
+ * most one key and any number of rooms.
+ *
+ * Subclass it to get a DI token:
+ * ```ts
+ * class ChatSockets extends WsHub {}
+ * ```
+ */
+export declare class WsHub {
+    #private;
+    readonly name: string;
+    constructor(options?: WsHubOptions);
+    /** Random id of this hub instance on the transport. */
+    get nodeId(): string;
+    /**
+     * Register a socket under `key`. Returns an unregister fn; also
+     * auto-removes (keys and rooms) on close. Re-adding moves the socket.
+     */
+    add(key: string, socket: WsConnection): () => void;
+    /** The key a socket was registered under, if any. */
+    keyOf(socket: WsConnection): string | undefined;
+    /** Put a socket in a room (idempotent). Server-side only. */
+    join(socket: WsConnection, room: string): void;
+    /** Remove a socket from a room. Does *not* run leave hooks. */
+    leave(socket: WsConnection, room: string): void;
+    /** Rooms a socket is in. */
+    rooms(socket: WsConnection): string[];
+    /** Every room with at least one local member. */
+    roomNames(): string[];
+    to(room: string): WsRoomTarget;
+    /**
+     * A concrete channel of a `channels()` handler mounted with this hub.
+     * Pass the contract for typed server events: `hub.channel(room, "rooms/42")`.
+     */
+    channel(name: string): WsChannelTarget;
+    channel<C extends AnyChannelContract>(contract: C, name: string): WsChannelTarget<C>;
+    /** Send to every socket of `key` on every node. Returns local delivery count. */
+    send(key: string, data: WsHubPayload): number;
+    sendMany(keys: Iterable<string>, data: WsHubPayload): number;
+    /** Send to every keyed socket in this hub, on every node. */
+    broadcast(data: WsHubPayload): number;
+    /**
+     * Close every socket of `key` on every node — e.g. on logout or when
+     * permissions are revoked. Returns the local count.
+     */
+    close(key: string, code?: number, reason?: string): number;
+    /** Close every local socket and detach from the transport. */
+    closeAll(code?: number, reason?: string): void;
+    /**
+     * Presence for a topic — who is "in" it, by key, across every node.
+     * Channels with contract presence use `hub.channel(name).presence`.
+     */
+    presence<M = unknown>(topic: string): PresenceTopic<M>;
+    /** @internal The hub's presence registry (created on first use). */
+    _presenceRegistry(): PresenceRegistry;
+    has(key: string): boolean;
+    /** Socket count for `key`, or every keyed socket when omitted. */
+    count(key?: string): number;
+    keys(): string[];
+    connections(key: string): WsConnection[];
+    /**
+     * @internal Run `hook` when `socket` is kicked from `room` (locally or by
+     * another node). The hook is responsible for calling `leave()`.
+     */
+    _onLeave(socket: WsConnection, room: string, hook: (reason: string) => void): void;
+    /** @internal Receive transport messages of an extension (e.g. presence). */
+    _registerExtension(kind: "presence", onRemote: (body: unknown) => void): void;
+    /** @internal Publish an extension message to other nodes. */
+    _publishExtension(kind: "presence", body: unknown): void;
+    /** @internal */
+    _members(room: string, filter?: RoomFilter): WsConnection[];
+    /** @internal */
+    _sendRoom(room: string, frame: Frame, filter: RoomFilter, publish: boolean): number;
+    /** @internal */
+    _kick(room: string, filter: RoomFilter, reason: string, publish: boolean): number;
+}
+/** Text and binary frames go out as-is; everything else as JSON. */
+export declare function encodeFrame(data: WsHubPayload): Frame;
+export {};