@pluv/platform-node 0.0.0-experimental-20250527040415

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Shoubhit Dash
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,18 @@
+## `@pluv/platform-node`
+
+> Enables [@pluv/io](https://www.npmjs.com/package/@pluv/io) to run on [Node.js](https://nodejs.org/).
+
+**👉 See full documentation on [pluv.io](https://pluv.io/docs/introduction). 👈**
+
+## Installation
+
+```bash
+# npm
+npm install @pluv/platform-node ws @types/ws
+
+# yarn
+yarn add @pluv/platform-node ws @types/ws
+
+# pnpm
+pnpm add @pluv/platform-node ws @types/ws
+```

package/dist/index.d.mts

@@ -0,0 +1,134 @@
+import { WebSocket, WebSocketServer } from 'ws';
+export { WebSocket } from 'ws';
+import { AbstractWebSocket, WebSocketSession, WebSocketSerializedState, AbstractWebSocketConfig, AbstractEventMap, AbstractListener, AbstractPlatform, WebSocketRegistrationMode, AbstractPersistence, AbstractPubSub, ConvertWebSocketConfig, AbstractPlatformConfig, PluvServer, InferInitContextType, CreateIOParams, PluvIOAuthorize, PluvContext } from '@pluv/io';
+import { IOAuthorize, JsonObject, InferIOAuthorizeUser, Json, InferIOAuthorize, BaseUser, MaybePromise, Maybe, Id } from '@pluv/types';
+import { IncomingMessage, Server, ServerResponse } from 'node:http';
+
+type NodeWebSocketConfig = AbstractWebSocketConfig;
+declare class NodeWebSocket<TAuthorize extends IOAuthorize<any, any> | null = null> extends AbstractWebSocket<WebSocket> {
+    private _sessionId;
+    private _state;
+    private _user;
+    set presence(presence: JsonObject | null);
+    get readyState(): 0 | 1 | 2 | 3;
+    get session(): WebSocketSession<TAuthorize>;
+    get sessionId(): string;
+    get state(): WebSocketSerializedState;
+    set state(state: WebSocketSerializedState);
+    set user(user: InferIOAuthorizeUser<TAuthorize>);
+    constructor(webSocket: WebSocket, config: NodeWebSocketConfig);
+    addEventListener<TType extends keyof AbstractEventMap>(type: TType, handler: AbstractListener<TType>): void;
+    close(code?: number | undefined, reason?: string | undefined): void;
+    send(message: string | ArrayBuffer | ArrayBufferView): void;
+    terminate(): void;
+}
+
+type NodePlatformRoomContext<TMeta extends Record<string, Json>> = keyof TMeta extends never ? {
+    meta?: undefined;
+} : {
+    meta: TMeta;
+};
+type NodePlatformConfig<TMeta extends Record<string, Json>> = {
+    mode?: WebSocketRegistrationMode;
+} & ({
+    persistence?: undefined;
+    pubSub?: undefined;
+} | {
+    persistence: AbstractPersistence;
+    pubSub: AbstractPubSub;
+}) & {
+    roomContext?: NodePlatformRoomContext<TMeta>;
+};
+declare class NodePlatform<TAuthorize extends IOAuthorize<any, any> | null = null, TMeta extends Record<string, Json> = {}> extends AbstractPlatform<NodeWebSocket<TAuthorize>, {
+    req: IncomingMessage;
+}, NodePlatformRoomContext<TMeta>, {
+    authorize: {
+        secret: true;
+    };
+    handleMode: "io";
+    requireAuth: false;
+    registrationMode: WebSocketRegistrationMode;
+    listeners: {
+        onRoomDeleted: true;
+        onRoomMessage: true;
+        onStorageUpdated: true;
+        onUserConnected: true;
+        onUserDisconnected: true;
+    };
+    router: true;
+}> {
+    readonly id: `${string}-${string}-${string}-${string}-${string}`;
+    readonly _config: {
+        authorize: {
+            secret: true;
+        };
+        handleMode: "io";
+        registrationMode: WebSocketRegistrationMode;
+        requireAuth: false;
+        listeners: {
+            onRoomDeleted: true;
+            onRoomMessage: true;
+            onStorageUpdated: true;
+            onUserConnected: true;
+            onUserDisconnected: true;
+        };
+        router: true;
+    };
+    readonly _name = "platformNode";
+    constructor(config?: NodePlatformConfig<TMeta>);
+    acceptWebSocket(webSocket: NodeWebSocket<TAuthorize>): Promise<void>;
+    convertWebSocket(webSocket: WebSocket, config: ConvertWebSocketConfig): NodeWebSocket<TAuthorize>;
+    getLastPing(webSocket: NodeWebSocket<TAuthorize>): number | null;
+    getSerializedState(webSocket: WebSocket): WebSocketSerializedState | null;
+    getSessionId(webSocket: WebSocket): string | null;
+    getWebSockets(): readonly WebSocket[];
+    initialize(config: AbstractPlatformConfig<NodePlatformRoomContext<TMeta>>): this;
+    parseData(data: string | ArrayBuffer): Record<string, any>;
+    randomUUID(): string;
+    setSerializedState(webSocket: NodeWebSocket<TAuthorize>, state: WebSocketSerializedState): WebSocketSerializedState;
+}
+
+type AuthorizeFunctionContext<TPluvServer extends PluvServer<any, any, any, any>> = {
+    room: string;
+} & InferInitContextType<TPluvServer extends PluvServer<infer IPlatform, any, any, any> ? IPlatform : never>;
+type AuthorizeFunction<TPluvServer extends PluvServer<any, any, any, any>> = (ctx: AuthorizeFunctionContext<TPluvServer>) => MaybePromise<Maybe<InferIOAuthorizeUser<InferIOAuthorize<TPluvServer>>>>;
+type CreatePluvHandlerConfig<TPluvServer extends PluvServer<any, any, any, any>> = {
+    endpoint?: string;
+    io: TPluvServer;
+    server: Server;
+} & (InferIOAuthorizeUser<InferIOAuthorize<TPluvServer>> extends BaseUser ? {
+    authorize: AuthorizeFunction<TPluvServer>;
+} : {
+    authorize?: undefined;
+});
+type RequestHandler = (req: IncomingMessage, res: ServerResponse, next?: () => void) => void;
+interface WebSocketHandlerResult {
+    matched: boolean;
+}
+type WebSocketHandler = (ws: WebSocket, req: IncomingMessage) => Promise<WebSocketHandlerResult>;
+interface CreatePluvHandlerResult {
+    createWsServer: () => WebSocketServer;
+    handler: RequestHandler;
+    wsHandler: WebSocketHandler;
+}
+/**
+ * @deprecated Instructions will be provided on https://pluv.io on how to host this yourself instead.
+ * @date April 27, 2025
+ */
+declare const createPluvHandler: <TPluvServer extends PluvServer<NodePlatform<any>, any, any, any>>(config: CreatePluvHandlerConfig<TPluvServer>) => CreatePluvHandlerResult;
+
+declare const identity: <T extends unknown>(x: T) => T;
+
+type InferCallback<TMeta extends Record<string, Json> = {}> = (i: typeof identity) => {
+    meta?: (io: TMeta) => TMeta;
+};
+declare const infer: <TMeta extends Record<string, Json> = {}>(callback: InferCallback<TMeta>) => InferCallback<TMeta>;
+
+type PlatformNodeCreateIOParams<TMeta extends Record<string, Json> = {}, TContext extends Record<string, any> = {}, TUser extends BaseUser | null = null> = Id<NodePlatformConfig<TMeta> & Omit<CreateIOParams<NodePlatform<IOAuthorize<TUser, TContext>, TMeta>, TContext, TUser>, "authorize" | "context" | "platform"> & {
+    authorize?: PluvIOAuthorize<NodePlatform<IOAuthorize<TUser, TContext>, TMeta>, TUser, InferInitContextType<NodePlatform<IOAuthorize<TUser, TContext>, TMeta>>>;
+    context?: PluvContext<NodePlatform<IOAuthorize<TUser, any>, TMeta>, TContext>;
+    types?: InferCallback<TMeta>;
+}>;
+declare const platformNode: <TMeta extends Record<string, Json> = {}, TContext extends Record<string, any> = {}, TUser extends BaseUser | null = null>(config?: PlatformNodeCreateIOParams<TMeta, TContext, TUser>) => CreateIOParams<NodePlatform<IOAuthorize<TUser, TContext>, TMeta>, TContext, TUser>;
+
+export { type AuthorizeFunction, type AuthorizeFunctionContext, type CreatePluvHandlerConfig, type InferCallback, NodePlatform, type NodePlatformConfig, type PlatformNodeCreateIOParams, createPluvHandler, infer, platformNode };

package/dist/index.d.ts

@@ -0,0 +1,134 @@
+import { WebSocket, WebSocketServer } from 'ws';
+export { WebSocket } from 'ws';
+import { AbstractWebSocket, WebSocketSession, WebSocketSerializedState, AbstractWebSocketConfig, AbstractEventMap, AbstractListener, AbstractPlatform, WebSocketRegistrationMode, AbstractPersistence, AbstractPubSub, ConvertWebSocketConfig, AbstractPlatformConfig, PluvServer, InferInitContextType, CreateIOParams, PluvIOAuthorize, PluvContext } from '@pluv/io';
+import { IOAuthorize, JsonObject, InferIOAuthorizeUser, Json, InferIOAuthorize, BaseUser, MaybePromise, Maybe, Id } from '@pluv/types';
+import { IncomingMessage, Server, ServerResponse } from 'node:http';
+
+type NodeWebSocketConfig = AbstractWebSocketConfig;
+declare class NodeWebSocket<TAuthorize extends IOAuthorize<any, any> | null = null> extends AbstractWebSocket<WebSocket> {
+    private _sessionId;
+    private _state;
+    private _user;
+    set presence(presence: JsonObject | null);
+    get readyState(): 0 | 1 | 2 | 3;
+    get session(): WebSocketSession<TAuthorize>;
+    get sessionId(): string;
+    get state(): WebSocketSerializedState;
+    set state(state: WebSocketSerializedState);
+    set user(user: InferIOAuthorizeUser<TAuthorize>);
+    constructor(webSocket: WebSocket, config: NodeWebSocketConfig);
+    addEventListener<TType extends keyof AbstractEventMap>(type: TType, handler: AbstractListener<TType>): void;
+    close(code?: number | undefined, reason?: string | undefined): void;
+    send(message: string | ArrayBuffer | ArrayBufferView): void;
+    terminate(): void;
+}
+
+type NodePlatformRoomContext<TMeta extends Record<string, Json>> = keyof TMeta extends never ? {
+    meta?: undefined;
+} : {
+    meta: TMeta;
+};
+type NodePlatformConfig<TMeta extends Record<string, Json>> = {
+    mode?: WebSocketRegistrationMode;
+} & ({
+    persistence?: undefined;
+    pubSub?: undefined;
+} | {
+    persistence: AbstractPersistence;
+    pubSub: AbstractPubSub;
+}) & {
+    roomContext?: NodePlatformRoomContext<TMeta>;
+};
+declare class NodePlatform<TAuthorize extends IOAuthorize<any, any> | null = null, TMeta extends Record<string, Json> = {}> extends AbstractPlatform<NodeWebSocket<TAuthorize>, {
+    req: IncomingMessage;
+}, NodePlatformRoomContext<TMeta>, {
+    authorize: {
+        secret: true;
+    };
+    handleMode: "io";
+    requireAuth: false;
+    registrationMode: WebSocketRegistrationMode;
+    listeners: {
+        onRoomDeleted: true;
+        onRoomMessage: true;
+        onStorageUpdated: true;
+        onUserConnected: true;
+        onUserDisconnected: true;
+    };
+    router: true;
+}> {
+    readonly id: `${string}-${string}-${string}-${string}-${string}`;
+    readonly _config: {
+        authorize: {
+            secret: true;
+        };
+        handleMode: "io";
+        registrationMode: WebSocketRegistrationMode;
+        requireAuth: false;
+        listeners: {
+            onRoomDeleted: true;
+            onRoomMessage: true;
+            onStorageUpdated: true;
+            onUserConnected: true;
+            onUserDisconnected: true;
+        };
+        router: true;
+    };
+    readonly _name = "platformNode";
+    constructor(config?: NodePlatformConfig<TMeta>);
+    acceptWebSocket(webSocket: NodeWebSocket<TAuthorize>): Promise<void>;
+    convertWebSocket(webSocket: WebSocket, config: ConvertWebSocketConfig): NodeWebSocket<TAuthorize>;
+    getLastPing(webSocket: NodeWebSocket<TAuthorize>): number | null;
+    getSerializedState(webSocket: WebSocket): WebSocketSerializedState | null;
+    getSessionId(webSocket: WebSocket): string | null;
+    getWebSockets(): readonly WebSocket[];
+    initialize(config: AbstractPlatformConfig<NodePlatformRoomContext<TMeta>>): this;
+    parseData(data: string | ArrayBuffer): Record<string, any>;
+    randomUUID(): string;
+    setSerializedState(webSocket: NodeWebSocket<TAuthorize>, state: WebSocketSerializedState): WebSocketSerializedState;
+}
+
+type AuthorizeFunctionContext<TPluvServer extends PluvServer<any, any, any, any>> = {
+    room: string;
+} & InferInitContextType<TPluvServer extends PluvServer<infer IPlatform, any, any, any> ? IPlatform : never>;
+type AuthorizeFunction<TPluvServer extends PluvServer<any, any, any, any>> = (ctx: AuthorizeFunctionContext<TPluvServer>) => MaybePromise<Maybe<InferIOAuthorizeUser<InferIOAuthorize<TPluvServer>>>>;
+type CreatePluvHandlerConfig<TPluvServer extends PluvServer<any, any, any, any>> = {
+    endpoint?: string;
+    io: TPluvServer;
+    server: Server;
+} & (InferIOAuthorizeUser<InferIOAuthorize<TPluvServer>> extends BaseUser ? {
+    authorize: AuthorizeFunction<TPluvServer>;
+} : {
+    authorize?: undefined;
+});
+type RequestHandler = (req: IncomingMessage, res: ServerResponse, next?: () => void) => void;
+interface WebSocketHandlerResult {
+    matched: boolean;
+}
+type WebSocketHandler = (ws: WebSocket, req: IncomingMessage) => Promise<WebSocketHandlerResult>;
+interface CreatePluvHandlerResult {
+    createWsServer: () => WebSocketServer;
+    handler: RequestHandler;
+    wsHandler: WebSocketHandler;
+}
+/**
+ * @deprecated Instructions will be provided on https://pluv.io on how to host this yourself instead.
+ * @date April 27, 2025
+ */
+declare const createPluvHandler: <TPluvServer extends PluvServer<NodePlatform<any>, any, any, any>>(config: CreatePluvHandlerConfig<TPluvServer>) => CreatePluvHandlerResult;
+
+declare const identity: <T extends unknown>(x: T) => T;
+
+type InferCallback<TMeta extends Record<string, Json> = {}> = (i: typeof identity) => {
+    meta?: (io: TMeta) => TMeta;
+};
+declare const infer: <TMeta extends Record<string, Json> = {}>(callback: InferCallback<TMeta>) => InferCallback<TMeta>;
+
+type PlatformNodeCreateIOParams<TMeta extends Record<string, Json> = {}, TContext extends Record<string, any> = {}, TUser extends BaseUser | null = null> = Id<NodePlatformConfig<TMeta> & Omit<CreateIOParams<NodePlatform<IOAuthorize<TUser, TContext>, TMeta>, TContext, TUser>, "authorize" | "context" | "platform"> & {
+    authorize?: PluvIOAuthorize<NodePlatform<IOAuthorize<TUser, TContext>, TMeta>, TUser, InferInitContextType<NodePlatform<IOAuthorize<TUser, TContext>, TMeta>>>;
+    context?: PluvContext<NodePlatform<IOAuthorize<TUser, any>, TMeta>, TContext>;
+    types?: InferCallback<TMeta>;
+}>;
+declare const platformNode: <TMeta extends Record<string, Json> = {}, TContext extends Record<string, any> = {}, TUser extends BaseUser | null = null>(config?: PlatformNodeCreateIOParams<TMeta, TContext, TUser>) => CreateIOParams<NodePlatform<IOAuthorize<TUser, TContext>, TMeta>, TContext, TUser>;
+
+export { type AuthorizeFunction, type AuthorizeFunctionContext, type CreatePluvHandlerConfig, type InferCallback, NodePlatform, type NodePlatformConfig, type PlatformNodeCreateIOParams, createPluvHandler, infer, platformNode };

package/dist/index.js

@@ -0,0 +1,370 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createPluvHandler: () => createPluvHandler,
+  infer: () => infer,
+  platformNode: () => platformNode
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/createPluvHandler.ts
+var import_node_url = __toESM(require("url"));
+var import_path_to_regexp = require("path-to-regexp");
+var import_ws = require("ws");
+var handle = (ws) => ({
+  invalidEndpoint: () => {
+    ws.close(1003, "Invalid WebSocket endpoint");
+    return { matched: false };
+  },
+  invalidRoom: () => {
+    ws.close(1003, "Invalid room name");
+    return { matched: true };
+  },
+  invalidToken: () => {
+    ws.close(1003, "Invalid authentication token");
+    return { matched: true };
+  }
+});
+var createPluvHandler = (config) => {
+  const { authorize, endpoint = "/api/pluv", io, server } = config;
+  if (io._defs.platform._config.registrationMode === "detached") {
+    throw new Error("Cannot use createPluvHandler in detached mode for Node.js");
+  }
+  const wsServer = new import_ws.WebSocketServer({ server });
+  const rooms = /* @__PURE__ */ new Map();
+  const getRoom = (roomId) => {
+    Array.from(rooms.values()).forEach((room) => {
+      if (!room.getSize()) rooms.delete(room.id);
+    });
+    const existing = rooms.get(roomId);
+    if (existing) return existing;
+    const newRoom = io.createRoom(roomId, {
+      onDestroy: (event) => {
+        rooms.delete(event.room);
+      }
+    });
+    rooms.set(roomId, newRoom);
+    return newRoom;
+  };
+  const wsHandler = (ws, req) => __async(null, null, function* () {
+    var _a;
+    const url = req.url;
+    const onError = handle(ws);
+    if (!url) {
+      onError.invalidEndpoint();
+      return { matched: false };
+    }
+    const parsed = import_node_url.default.parse(url, true);
+    const { pathname } = parsed;
+    if (!pathname) return onError.invalidEndpoint();
+    const matcher = (0, import_path_to_regexp.match)(`${endpoint}/room/:roomId`);
+    const matched = matcher(pathname);
+    if (!matched) return onError.invalidEndpoint();
+    const { roomId } = matched.params;
+    if (!roomId) return onError.invalidRoom();
+    const token = ((_a = parsed.query) == null ? void 0 : _a.token) || void 0;
+    if (Array.isArray(token)) return onError.invalidToken();
+    const room = getRoom(roomId);
+    yield room.register(ws, { req, token });
+    return { matched: true };
+  });
+  const createWsServer = () => {
+    return wsServer.on("connection", (ws, req) => __async(null, null, function* () {
+      yield wsHandler(ws, req);
+    }));
+  };
+  const handler = (req, res, next) => __async(null, null, function* () {
+    var _a, _b, _c, _d, _e, _f;
+    if (!authorize) return (_a = next == null ? void 0 : next()) != null ? _a : null;
+    if (req.method !== "GET") return (_b = next == null ? void 0 : next()) != null ? _b : null;
+    const url = req.url;
+    if (!url) return (_c = next == null ? void 0 : next()) != null ? _c : null;
+    const parsed = import_node_url.default.parse(url, true);
+    const { pathname } = parsed;
+    if (!pathname) return (_d = next == null ? void 0 : next()) != null ? _d : null;
+    const matcher = (0, import_path_to_regexp.match)(`${endpoint}/authorize`);
+    const matched = matcher(pathname);
+    if (!matched) return (_e = next == null ? void 0 : next()) != null ? _e : null;
+    const room = ((_f = parsed.query) == null ? void 0 : _f.room) || void 0;
+    if (typeof room !== "string" || !room) {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      return res.end("Room does not exist");
+    }
+    try {
+      const user = yield authorize({ req, room });
+      if (!user) throw new Error();
+      const token = yield io.createToken({
+        req,
+        room,
+        user
+      });
+      res.writeHead(200, { "Content-Type": "text/plain" });
+      return res.end(token);
+    } catch (err) {
+      res.writeHead(403, { "Content-Type": "text/plain" });
+      return res.end(err instanceof Error ? err.message : "Unauthorized");
+    }
+  });
+  return {
+    createWsServer,
+    handler,
+    wsHandler
+  };
+};
+
+// src/infer.ts
+var infer = (callback) => callback;
+
+// src/NodePlatform.ts
+var import_io2 = require("@pluv/io");
+var import_node_crypto2 = __toESM(require("crypto"));
+var import_node_util = require("util");
+
+// src/NodeWebSocket.ts
+var import_io = require("@pluv/io");
+var import_node_crypto = __toESM(require("crypto"));
+var NodeWebSocket = class extends import_io.AbstractWebSocket {
+  constructor(webSocket, config) {
+    const { room } = config;
+    super(webSocket, config);
+    this._sessionId = null;
+    this._user = null;
+    this._state = {
+      presence: null,
+      quit: false,
+      room,
+      timers: {
+        ping: (/* @__PURE__ */ new Date()).getTime(),
+        presence: null
+      }
+    };
+  }
+  set presence(presence) {
+    this._state.presence = presence;
+  }
+  get readyState() {
+    return this.webSocket.readyState;
+  }
+  get session() {
+    const sessionId = this.sessionId;
+    const state = this._state;
+    const user = this._user;
+    return __spreadProps(__spreadValues({}, state), {
+      id: sessionId,
+      user,
+      webSocket: this
+    });
+  }
+  get sessionId() {
+    var _a;
+    if (this._sessionId) return this._sessionId;
+    const sessionId = (_a = this._sessionId) != null ? _a : `p_${import_node_crypto.default.randomUUID()}`;
+    this._sessionId = sessionId;
+    return sessionId;
+  }
+  get state() {
+    return this._state;
+  }
+  set state(state) {
+    this._state = state;
+  }
+  set user(user) {
+    this._user = user;
+  }
+  addEventListener(type, handler) {
+    switch (type) {
+      case "close":
+        this.webSocket.on("close", (code, buffer) => __async(this, null, function* () {
+          const reason = buffer.toString("utf-8");
+          yield Promise.resolve(handler({ code, reason }));
+        }));
+        return;
+      case "error":
+        this.webSocket.on("error", (error) => __async(this, null, function* () {
+          const message = error.message;
+          yield Promise.resolve(
+            handler({ error, message })
+          );
+        }));
+        return;
+      case "message":
+        this.webSocket.on("message", (data) => __async(this, null, function* () {
+          yield Promise.resolve(handler({ data }));
+        }));
+        return;
+      default:
+    }
+  }
+  close(code, reason) {
+    const canClose = [this.CONNECTING, this.OPEN].some(
+      (readyState) => readyState === this.readyState
+    );
+    if (!canClose) return;
+    this.webSocket.close(code, reason);
+  }
+  send(message) {
+    if (this.readyState !== this.OPEN) return;
+    this.webSocket.send(message, (error) => {
+      if (error) throw error;
+    });
+  }
+  terminate() {
+    this.webSocket.terminate();
+  }
+};
+
+// src/NodePlatform.ts
+var NodePlatform = class _NodePlatform extends import_io2.AbstractPlatform {
+  constructor(config = {}) {
+    const { roomContext, mode = "attached", persistence, pubSub } = config;
+    super(__spreadValues({
+      roomContext
+    }, persistence && pubSub ? { persistence, pubSub } : {}));
+    this.id = import_node_crypto2.default.randomUUID();
+    this._name = "platformNode";
+    this._config = {
+      authorize: {
+        secret: true
+      },
+      handleMode: "io",
+      registrationMode: mode,
+      requireAuth: false,
+      listeners: {
+        onRoomDeleted: true,
+        onRoomMessage: true,
+        onStorageUpdated: true,
+        onUserConnected: true,
+        onUserDisconnected: true
+      },
+      router: true
+    };
+  }
+  acceptWebSocket(webSocket) {
+    return Promise.resolve(void 0);
+  }
+  convertWebSocket(webSocket, config) {
+    const { room } = config;
+    return new NodeWebSocket(webSocket, {
+      persistence: this.persistence,
+      platform: this,
+      room
+    });
+  }
+  getLastPing(webSocket) {
+    return null;
+  }
+  getSerializedState(webSocket) {
+    return null;
+  }
+  getSessionId(webSocket) {
+    return null;
+  }
+  getWebSockets() {
+    return [];
+  }
+  initialize(config) {
+    return new _NodePlatform({
+      roomContext: config.roomContext,
+      mode: this._config.registrationMode,
+      persistence: this.persistence.initialize(config.roomContext),
+      pubSub: this.pubSub
+    })._initialize();
+  }
+  parseData(data) {
+    if (typeof data === "string") return JSON.parse(data);
+    const decoder = new import_node_util.TextDecoder("utf8");
+    return JSON.parse(decoder.decode(data));
+  }
+  randomUUID() {
+    return import_node_crypto2.default.randomUUID();
+  }
+  setSerializedState(webSocket, state) {
+    webSocket.state = state;
+    return webSocket.state;
+  }
+};
+
+// src/platformNode.ts
+var platformNode = (config = {}) => {
+  const { authorize, context, crdt, debug, limits } = config;
+  return {
+    authorize,
+    context,
+    crdt,
+    debug,
+    limits,
+    platform: () => new NodePlatform(config)
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPluvHandler,
+  infer,
+  platformNode
+});