@pluv/io 0.17.2 → 0.18.0

package/src/PluvProcedure.ts

@@ -0,0 +1,203 @@
+import type { EventRecord, IOAuthorize, InputZodLike, JsonObject } from "@pluv/types";
+import type { AbstractPlatform, InferPlatformEventContextType, InferPlatformRoomContextType } from "./AbstractPlatform";
+import type { EventResolver, MergeEventRecords } from "./types";
+
+export interface PluvProcedureConfig<
+    TPlatform extends AbstractPlatform<any>,
+    TAuthorize extends IOAuthorize<any, any, InferPlatformRoomContextType<TPlatform>>,
+    TContext extends JsonObject,
+    TInput extends JsonObject = {},
+    TOutput extends EventRecord<string, any> = {},
+> {
+    broadcast?: EventResolver<
+        TPlatform,
+        TAuthorize,
+        TContext & InferPlatformRoomContextType<TPlatform> & InferPlatformEventContextType<TPlatform>,
+        TInput,
+        Partial<TOutput>
+    > | null;
+    input?: InputZodLike<TInput>;
+    self?: EventResolver<
+        TPlatform,
+        TAuthorize,
+        TContext & InferPlatformRoomContextType<TPlatform> & InferPlatformEventContextType<TPlatform>,
+        TInput,
+        Partial<TOutput>
+    > | null;
+    sync?: EventResolver<TPlatform, TAuthorize, TContext, TInput, Partial<TOutput>> | null;
+}
+
+export class PluvProcedure<
+    TPlatform extends AbstractPlatform<any>,
+    TAuthorize extends IOAuthorize<any, any, InferPlatformRoomContextType<TPlatform>>,
+    TContext extends JsonObject,
+    TInput extends JsonObject = {},
+    TOutput extends EventRecord<string, any> = {},
+    TFilled extends "input" | "broadcast" | "self" | "sync" | "" = "",
+> {
+    private _broadcast: EventResolver<
+        TPlatform,
+        TAuthorize,
+        TContext & InferPlatformRoomContextType<TPlatform> & InferPlatformEventContextType<TPlatform>,
+        TInput,
+        Partial<TOutput>
+    > | null = null;
+    private _input: InputZodLike<TInput> | null = null;
+    private _self: EventResolver<
+        TPlatform,
+        TAuthorize,
+        TContext & InferPlatformRoomContextType<TPlatform> & InferPlatformEventContextType<TPlatform>,
+        TInput,
+        Partial<TOutput>
+    > | null = null;
+    private _sync: EventResolver<TPlatform, TAuthorize, TContext, TInput, Partial<TOutput>> | null = null;
+
+    public get config() {
+        return {
+            broadcast: this._broadcast?.bind(this) ?? null,
+            input: this._input ?? null,
+            resolver: this._resolver,
+            self: this._self?.bind(this) ?? null,
+            sync: this._sync?.bind(this) ?? null,
+        };
+    }
+
+    constructor(config: PluvProcedureConfig<TPlatform, TAuthorize, TContext, TInput, TOutput> = {}) {
+        const { broadcast, input, self, sync } = config;
+
+        this._broadcast = broadcast ?? null;
+        this._input = input ?? null;
+        this._self = self ?? null;
+        this._sync = sync ?? null;
+    }
+
+    public broadcast<TResult extends EventRecord<string, any> = {}>(
+        resolver: EventResolver<
+            TPlatform,
+            TAuthorize,
+            TContext & InferPlatformRoomContextType<TPlatform> & InferPlatformEventContextType<TPlatform>,
+            TInput,
+            TResult
+        >,
+    ): Omit<
+        PluvProcedure<
+            TPlatform,
+            TAuthorize,
+            TContext,
+            TInput,
+            MergeEventRecords<[TOutput, TResult]>,
+            TFilled | "input" | "broadcast"
+        >,
+        TFilled | "input" | "broadcast"
+    > {
+        const { broadcast } = this.config;
+
+        if (!!broadcast) throw new Error("Broadcast was already defined for this procedure");
+
+        return new PluvProcedure<
+            TPlatform,
+            TAuthorize,
+            TContext,
+            TInput,
+            MergeEventRecords<[TOutput, TResult]>,
+            TFilled | "input" | "broadcast"
+        >({
+            ...(this.config as any),
+            broadcast: resolver as any,
+        });
+    }
+
+    public input<TData extends JsonObject>(
+        input: InputZodLike<TData>,
+    ): Omit<PluvProcedure<TPlatform, TAuthorize, TContext, TData, {}, TFilled | "input">, TFilled | "input"> {
+        return new PluvProcedure<TPlatform, TAuthorize, TContext, TData, {}, TFilled | "input">({ input });
+    }
+
+    public self<TResult extends EventRecord<string, any> = {}>(
+        resolver: EventResolver<
+            TPlatform,
+            TAuthorize,
+            TContext & InferPlatformRoomContextType<TPlatform> & InferPlatformEventContextType<TPlatform>,
+            TInput,
+            TResult
+        >,
+    ): Omit<
+        PluvProcedure<
+            TPlatform,
+            TAuthorize,
+            TContext,
+            TInput,
+            MergeEventRecords<[TOutput, TResult]>,
+            TFilled | "input" | "self"
+        >,
+        TFilled | "input" | "self"
+    > {
+        const { self } = this.config;
+
+        if (!!self) throw new Error("Self was already defined for this procedure");
+
+        return new PluvProcedure<
+            TPlatform,
+            TAuthorize,
+            TContext,
+            TInput,
+            MergeEventRecords<[TOutput, TResult]>,
+            TFilled | "input" | "self"
+        >({
+            ...(this.config as any),
+            self: resolver as any,
+        });
+    }
+
+    public sync<TResult extends EventRecord<string, any> = {}>(
+        resolver: EventResolver<
+            TPlatform,
+            TAuthorize,
+            TContext & InferPlatformRoomContextType<TPlatform> & InferPlatformEventContextType<TPlatform>,
+            TInput,
+            TResult
+        >,
+    ): Omit<
+        PluvProcedure<
+            TPlatform,
+            TAuthorize,
+            TContext,
+            TInput,
+            MergeEventRecords<[TOutput, TResult]>,
+            TFilled | "input" | "sync"
+        >,
+        TFilled | "input" | "sync"
+    > {
+        const { sync } = this.config;
+
+        if (!!sync) throw new Error("Sync was already defined for this procedure");
+
+        return new PluvProcedure<
+            TPlatform,
+            TAuthorize,
+            TContext,
+            TInput,
+            MergeEventRecords<[TOutput, TResult]>,
+            TFilled | "input" | "sync"
+        >({
+            ...(this.config as any),
+            sync: resolver as any,
+        });
+    }
+
+    private _resolver(): EventResolver<
+        TPlatform,
+        TAuthorize,
+        TContext & InferPlatformRoomContextType<TPlatform> & InferPlatformEventContextType<TPlatform>,
+        TInput,
+        TOutput
+    > {
+        return (data, context) => {
+            return {
+                ...this._broadcast?.(data, context),
+                ...this._self?.(data, context),
+                ...this._sync?.(data, context),
+            } as TOutput;
+        };
+    }
+}

package/src/PluvRouter.ts

@@ -0,0 +1,46 @@
+import type { BaseIOAuthorize, IOAuthorize, IORouterLike, JsonObject } from "@pluv/types";
+import type { AbstractPlatform, InferPlatformRoomContextType } from "./AbstractPlatform";
+import type { PluvProcedure } from "./PluvProcedure";
+
+export type PluvRouterEventConfig<
+    TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
+    TAuthorize extends IOAuthorize<any, any, InferPlatformRoomContextType<TPlatform>> = BaseIOAuthorize,
+    TContext extends JsonObject = {},
+> = {
+    [P: string]: Pick<PluvProcedure<TPlatform, TAuthorize, TContext, any, any>, "config">;
+};
+
+export type MergedRouter<
+    TRouters extends PluvRouter<TPlatform, TAuthorize, TContext, any>[] = [],
+    TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
+    TAuthorize extends IOAuthorize<any, any, InferPlatformRoomContextType<TPlatform>> = BaseIOAuthorize,
+    TContext extends JsonObject = {},
+    TRoot extends TRouters[0]["_events"] = {},
+> = TRouters extends [
+    infer IHead extends PluvRouter<TPlatform, TAuthorize, TContext, any>,
+    ...infer ITail extends PluvRouter<TPlatform, TAuthorize, TContext, any>[],
+]
+    ? MergedRouter<ITail, TPlatform, TAuthorize, TContext, TRoot & IHead["_events"]>
+    : PluvRouter<TPlatform, TAuthorize, TContext, TRoot>;
+
+export class PluvRouter<
+    TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
+    TAuthorize extends IOAuthorize<any, any, InferPlatformRoomContextType<TPlatform>> = BaseIOAuthorize,
+    TContext extends JsonObject = {},
+    TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext> = {},
+> implements IORouterLike<TEvents>
+{
+    readonly _events: TEvents = {} as TEvents;
+
+    constructor(events: TEvents) {
+        this._events = events;
+    }
+
+    public static merge<TRouters extends PluvRouter<any, any, any, any>[]>(
+        ...routers: TRouters
+    ): MergedRouter<TRouters> {
+        const events = Object.assign(Object.create(null), ...routers.map((router) => router._events));
+
+        return new PluvRouter<any, any, any, any>(events) as MergedRouter<TRouters>;
+    }
+}

package/src/PluvServer.ts

@@ -0,0 +1,182 @@
+import type { AbstractCrdtDocFactory } from "@pluv/crdt";
+import { noop } from "@pluv/crdt";
+import type {
+    BaseIOAuthorize,
+    IOAuthorize,
+    IORouterLike,
+    InferIOAuthorize,
+    InferIOAuthorizeUser,
+    JsonObject,
+} from "@pluv/types";
+import colors from "kleur";
+import type { AbstractPlatform, InferPlatformRoomContextType } from "./AbstractPlatform";
+import { IORoom } from "./IORoom";
+import type { PluvRouterEventConfig } from "./PluvRouter";
+import { PluvRouter } from "./PluvRouter";
+import type { JWTEncodeParams } from "./authorize";
+import { authorize } from "./authorize";
+import type { IORoomListenerEvent, PluvIOListeners } from "./types";
+import { __PLUV_VERSION } from "./version";
+
+export type InferIORoom<TServer extends PluvServer<any, any, any, any>> =
+    TServer extends PluvServer<infer IPlatform, infer IAuthorize, infer IContext, infer IEvents>
+        ? IORoom<IPlatform, IAuthorize, IContext, IEvents>
+        : never;
+
+export type PluvServerConfig<
+    TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
+    TAuthorize extends IOAuthorize<any, any, InferPlatformRoomContextType<TPlatform>> = BaseIOAuthorize,
+    TContext extends JsonObject = {},
+    TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext> = {},
+> = Partial<PluvIOListeners<TPlatform>> & {
+    authorize?: TAuthorize;
+    context?: TContext;
+    crdt?: { doc: (value: any) => AbstractCrdtDocFactory<any> };
+    debug?: boolean;
+    platform: TPlatform;
+    router?: PluvRouter<TPlatform, TAuthorize, TContext, TEvents>;
+};
+
+export type GetRoomOptions<TPlatform extends AbstractPlatform> = {
+    debug?: boolean;
+} & InferPlatformRoomContextType<TPlatform>;
+
+export class PluvServer<
+    TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
+    TAuthorize extends IOAuthorize<any, any, InferPlatformRoomContextType<TPlatform>> = BaseIOAuthorize,
+    TContext extends JsonObject = {},
+    TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext> = {},
+> implements IORouterLike<TEvents>
+{
+    private _rooms = new Map<string, IORoom<TPlatform, TAuthorize, TContext, TEvents>>();
+
+    readonly _authorize: TAuthorize | null = null;
+    readonly _context: TContext = {} as TContext;
+    readonly _crdt: { doc: (value: any) => AbstractCrdtDocFactory<any> };
+    readonly _debug: boolean;
+    readonly _listeners: PluvIOListeners<TPlatform>;
+    readonly _platform: TPlatform;
+    readonly _router: PluvRouter<TPlatform, TAuthorize, TContext, TEvents>;
+    readonly _version: string = __PLUV_VERSION as any;
+
+    public get _events() {
+        return this._router._events;
+    }
+
+    constructor(options: PluvServerConfig<TPlatform, TAuthorize, TContext, TEvents>) {
+        const {
+            authorize,
+            context,
+            crdt = noop,
+            debug = false,
+            onRoomDeleted,
+            onStorageUpdated,
+            platform,
+            router = new PluvRouter<TPlatform, TAuthorize, TContext, TEvents>({} as TEvents),
+        } = options;
+
+        this._crdt = crdt;
+        this._debug = debug;
+        this._platform = platform;
+        this._router = router ?? null;
+
+        if (authorize) this._authorize = authorize;
+        if (context) this._context = context;
+
+        this._listeners = {
+            onRoomDeleted: (event) => onRoomDeleted?.(event),
+            onStorageUpdated: (event) => onStorageUpdated?.(event),
+        };
+    }
+
+    public async createToken(
+        params: JWTEncodeParams<InferIOAuthorizeUser<InferIOAuthorize<this>>, TPlatform>,
+    ): Promise<string> {
+        if (!this._authorize) {
+            throw new Error("IO does not specify authorize during initialization.");
+        }
+
+        const ioAuthorize =
+            typeof this._authorize === "function" ? this._authorize(params) : (this._authorize as { secret: string });
+
+        const secret = ioAuthorize.secret;
+
+        return await authorize({
+            platform: this._platform,
+            secret,
+        }).encode(params);
+    }
+
+    public getRoom(room: string, options: GetRoomOptions<TPlatform>): IORoom<TPlatform, TAuthorize, TContext, TEvents> {
+        const { debug, ...platformRoomContext } = options;
+
+        this._purgeEmptyRooms();
+
+        if (!/^[a-z0-9]+[a-z0-9\-_]+[a-z0-9]+$/i.test(room)) {
+            throw new Error("Unsupported room name");
+        }
+
+        const platform = this._platform;
+        const oldRoom = this._rooms.get(room);
+
+        if (oldRoom) return oldRoom;
+
+        const roomContext = {
+            ...this._context,
+            ...platformRoomContext,
+        } as TContext & InferPlatformRoomContextType<TPlatform>;
+
+        const newRoom = new IORoom<TPlatform, TAuthorize, TContext, TEvents>(room, {
+            authorize: this._authorize ?? undefined,
+            context: roomContext,
+            crdt: this._crdt,
+            debug: debug ?? this._debug,
+            onDestroy: ({ encodedState, room }) => {
+                this._logDebug(`${colors.blue("Deleting empty room:")} ${room}`);
+
+                const roomContext = {
+                    room,
+                    encodedState,
+                    ...platformRoomContext,
+                } as IORoomListenerEvent<TPlatform> & InferPlatformRoomContextType<TPlatform>;
+
+                this._rooms.delete(room);
+                this._listeners.onRoomDeleted(roomContext);
+
+                if (this._debug) {
+                    const rooms = Array.from(this._rooms.keys());
+
+                    this._logDebug(`${colors.blue("Deleted room:")} ${room}`);
+                    this._logDebug(`${colors.blue("Rooms available:")} ${rooms.join(", ")}`);
+                }
+            },
+            platform,
+            router: this._router,
+        });
+
+        this._rooms.set(room, newRoom);
+
+        if (this._debug) {
+            const rooms = Array.from(this._rooms.keys());
+
+            this._logDebug(`${colors.blue("Created room:")} ${room}`);
+            this._logDebug(`${colors.blue("Rooms available:")} ${rooms.join(", ")}`);
+        }
+
+        return newRoom;
+    }
+
+    private _logDebug(...data: any[]): void {
+        this._debug && console.log(...data);
+    }
+
+    private _purgeEmptyRooms(): void {
+        const rooms = Array.from(this._rooms.entries());
+
+        rooms.forEach(([id, room]) => {
+            if (room.getSize()) return;
+
+            this._rooms.delete(id);
+        });
+    }
+}

package/src/PubSub.ts

@@ -10,15 +10,9 @@ export class PubSub extends AbstractPubSub {
     // Map of roomName to subscription ids
     private _subscriptionsRefs = new Map<string, readonly number[]>();
     // Map of
-    private _unsubscriptions = new Map<
-        number,
-        [roomName: string, unsubscribe: () => void]
-    >();
-
-    public async publish(
-        roomName: string,
-        payload: IOPubSubEventMessage<any>,
-    ): Promise<void> {
+    private _unsubscriptions = new Map<number, [roomName: string, unsubscribe: () => void]>();
+
+    public async publish(roomName: string, payload: IOPubSubEventMessage<any>): Promise<void> {
         const subject = this._subjects.get(roomName);
 
         if (!subject) return;
@@ -26,10 +20,7 @@ export class PubSub extends AbstractPubSub {
         Promise.resolve(subject.next(payload));
     }
 
-    public subscribe(
-        roomName: string,
-        onMessage: (message: IOPubSubEventMessage<any>) => void,
-    ): Promise<number> {
+    public subscribe(roomName: string, onMessage: (message: IOPubSubEventMessage<any>) => void): Promise<number> {
         const id = this._currentSubscriptionId++;
         const refs = this._subscriptionsRefs.get(roomName) ?? [];
 
@@ -46,8 +37,7 @@ export class PubSub extends AbstractPubSub {
     }
 
     public unsubscribe(subscriptionId: number): void {
-        const [roomName, unsubscribe] =
-            this._unsubscriptions.get(subscriptionId) ?? [];
+        const [roomName, unsubscribe] = this._unsubscriptions.get(subscriptionId) ?? [];
 
         if (!roomName || !unsubscribe) return;
 
@@ -67,9 +57,7 @@ export class PubSub extends AbstractPubSub {
 
         this._subscriptionsRefs.set(
             roomName,
-            index === -1
-                ? refs
-                : [...refs.slice(0, index), ...refs.slice(index + 1)],
+            index === -1 ? refs : [...refs.slice(0, index), ...refs.slice(index + 1)],
         );
 
         unsubscribe();

package/src/authorize.ts

@@ -1,21 +1,12 @@
 import hkdf from "@panva/hkdf";
 import type { BaseUser } from "@pluv/types";
 import { EncryptJWT, jwtDecrypt } from "jose";
-import type {
-    AbstractPlatform,
-    InferPlatformRoomContextType,
-} from "./AbstractPlatform";
+import type { AbstractPlatform, InferPlatformRoomContextType } from "./AbstractPlatform";
 
 const DEFAULT_MAX_AGE_MS = 60_000;
 
 export const getEncryptionKey = async (secret: string): Promise<Uint8Array> => {
-    return await hkdf(
-        "sha256",
-        secret,
-        "",
-        "Pluv.io Generated Encryption Key",
-        32,
-    );
+    return await hkdf("sha256", secret, "", "Pluv.io Generated Encryption Key", 32);
 };
 
 export interface JWT<TUser extends BaseUser> {
@@ -24,10 +15,7 @@ export interface JWT<TUser extends BaseUser> {
     user: TUser;
 }
 
-export type JWTEncodeParams<
-    TUser extends BaseUser,
-    TPlatform extends AbstractPlatform,
-> = {
+export type JWTEncodeParams<TUser extends BaseUser, TPlatform extends AbstractPlatform> = {
     maxAge?: number;
     room: string;
     user: TUser;
@@ -50,10 +38,7 @@ const now = () => (Date.now() / 1_000) | 0;
 export const authorize = (params: AuthorizeParams) => {
     const { platform, secret } = params;
 
-    const encode = async <
-        TUser extends BaseUser,
-        TPlatform extends AbstractPlatform,
-    >(
+    const encode = async <TUser extends BaseUser, TPlatform extends AbstractPlatform>(
         encodeParams: JWTEncodeParams<TUser, TPlatform>,
     ): Promise<string> => {
         const { maxAge = DEFAULT_MAX_AGE_MS, room, user } = encodeParams;
@@ -74,9 +59,7 @@ export const authorize = (params: AuthorizeParams) => {
         return token.toString();
     };
 
-    const decode = async <TUser extends BaseUser>(
-        jwt: string,
-    ): Promise<JWT<TUser> | null> => {
+    const decode = async <TUser extends BaseUser>(jwt: string): Promise<JWT<TUser> | null> => {
         const encryptionSecret = await getEncryptionKey(secret);
 
         const { payload } = await jwtDecrypt(jwt, encryptionSecret, {

package/src/createIO.ts

@@ -1,17 +1,8 @@
 import type { AbstractCrdtDocFactory } from "@pluv/crdt";
-import type {
-    BaseClientEventRecord,
-    BaseIOEventRecord,
-    BaseUser,
-    IOAuthorize,
-    JsonObject,
-} from "@pluv/types";
-import type {
-    AbstractPlatform,
-    InferPlatformRoomContextType,
-} from "./AbstractPlatform";
-import type { GetInitialStorageFn, PluvIOListeners } from "./PluvIO";
+import type { BaseUser, IOAuthorize, JsonObject } from "@pluv/types";
+import type { AbstractPlatform, InferPlatformRoomContextType } from "./AbstractPlatform";
 import { PluvIO } from "./PluvIO";
+import type { GetInitialStorageFn, PluvIOListeners } from "./types";
 
 export type CreateIOParams<
     TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
@@ -19,11 +10,7 @@ export type CreateIOParams<
     TAuthorizeUser extends BaseUser = BaseUser,
     TAuthorizeRequired extends boolean = false,
 > = Partial<PluvIOListeners<TPlatform>> & {
-    authorize?: IOAuthorize<
-        TAuthorizeUser,
-        TAuthorizeRequired,
-        InferPlatformRoomContextType<TPlatform>
-    >;
+    authorize?: IOAuthorize<TAuthorizeUser, TAuthorizeRequired, InferPlatformRoomContextType<TPlatform>>;
     context?: TContext;
     crdt?: { doc: (value: any) => AbstractCrdtDocFactory<any> };
     debug?: boolean;
@@ -37,44 +24,18 @@ export const createIO = <
     TAuthorizeUser extends BaseUser = BaseUser,
     TAuthorizeRequired extends boolean = false,
 >(
-    params: CreateIOParams<
-        TPlatform,
-        TContext,
-        TAuthorizeUser,
-        TAuthorizeRequired
-    >,
+    params: CreateIOParams<TPlatform, TContext, TAuthorizeUser, TAuthorizeRequired>,
 ): PluvIO<
     TPlatform,
-    IOAuthorize<
-        TAuthorizeUser,
-        TAuthorizeRequired,
-        InferPlatformRoomContextType<TPlatform>
-    >,
-    TContext,
-    BaseClientEventRecord,
-    BaseIOEventRecord<IOAuthorize<TAuthorizeUser, TAuthorizeRequired>>
+    IOAuthorize<TAuthorizeUser, TAuthorizeRequired, InferPlatformRoomContextType<TPlatform>>,
+    TContext
 > => {
-    const {
-        authorize,
-        context,
-        crdt,
-        debug,
-        getInitialStorage,
-        onRoomDeleted,
-        onStorageUpdated,
-        platform,
-    } = params;
+    const { authorize, context, crdt, debug, getInitialStorage, onRoomDeleted, onStorageUpdated, platform } = params;
 
     return new PluvIO<
         TPlatform,
-        IOAuthorize<
-            TAuthorizeUser,
-            TAuthorizeRequired,
-            InferPlatformRoomContextType<TPlatform>
-        >,
-        TContext,
-        BaseClientEventRecord,
-        BaseIOEventRecord<IOAuthorize<TAuthorizeUser, TAuthorizeRequired>>
+        IOAuthorize<TAuthorizeUser, TAuthorizeRequired, InferPlatformRoomContextType<TPlatform>>,
+        TContext
     >({
         authorize,
         context,

package/src/index.ts

@@ -1,9 +1,4 @@
-export type {
-    BaseUser,
-    EventMessage,
-    EventRecord,
-    IOEventMessage,
-} from "@pluv/types";
+export type { BaseUser, EventMessage, EventRecord, IOEventMessage } from "@pluv/types";
 export { AbstractPersistance } from "./AbstractPersistance";
 export { AbstractPlatform } from "./AbstractPlatform";
 export type {
@@ -28,12 +23,13 @@ export type {
 } from "./AbstractWebSocket";
 export type { IORoom } from "./IORoom";
 export { PluvIO } from "./PluvIO";
-export type { GetRoomOptions, InferIORoom, PluvIOConfig } from "./PluvIO";
-export type {
-    AuthorizeModule,
-    AuthorizeParams,
-    JWT,
-    JWTEncodeParams,
-} from "./authorize";
+export type { PluvIOConfig, ServerConfig } from "./PluvIO";
+export { PluvProcedure } from "./PluvProcedure";
+export type { PluvProcedureConfig } from "./PluvProcedure";
+export { PluvRouter } from "./PluvRouter";
+export type { MergedRouter, PluvRouterEventConfig } from "./PluvRouter";
+export { PluvServer } from "./PluvServer";
+export type { GetRoomOptions, InferIORoom, PluvServerConfig } from "./PluvServer";
+export type { AuthorizeModule, AuthorizeParams, JWT, JWTEncodeParams } from "./authorize";
 export { createIO } from "./createIO";
 export type { CreateIOParams } from "./createIO";