@eleven-am/pondsocket-nest 0.0.136 → 0.0.138

package/dist/performers/errors.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performErrors = performErrors;
+exports.logHandlerError = logHandlerError;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const common_1 = require("@nestjs/common");
+const logger = new common_1.Logger('PondSocketHandler');
+function performErrors(error, response, lifecycle) {
+    var _a;
+    let message;
+    let data;
+    let status;
+    if (error instanceof common_1.HttpException) {
+        message = error.message;
+        status = error.getStatus();
+        data = (_a = error.getResponse()) === null || _a === void 0 ? void 0 : _a.message;
+    }
+    else if (error instanceof Error) {
+        message = error.message;
+        status = 500;
+    }
+    else {
+        message = 'An unknown error occurred';
+        status = 500;
+    }
+    logger.error(message, error instanceof Error ? error.stack : undefined);
+    if (lifecycle === 'event') {
+        return response.reply(pondsocket_common_1.ErrorTypes.INTERNAL_SERVER_ERROR, {
+            code: pondsocket_common_1.ErrorTypes.INTERNAL_SERVER_ERROR,
+            message,
+            data,
+            status,
+        });
+    }
+    const pendingResponse = response;
+    if (!pendingResponse.hasResponded) {
+        return pendingResponse.decline(message, status);
+    }
+}
+function logHandlerError(error, lifecycle, propertyKey) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`Error in ${lifecycle} handler "${String(propertyKey)}": ${message}`, error instanceof Error ? error.stack : undefined);
+}

package/dist/performers/response.d.ts

@@ -0,0 +1,5 @@
+import type { Channel, ConnectionContext, EventContext, JoinContext, LeaveEvent } from '@eleven-am/pondsocket/types';
+import { PondLifecycle, PondResponse } from '../types';
+type ResponseContext = JoinContext<string> | EventContext<string> | ConnectionContext<string> | LeaveEvent;
+export declare function performResponse(socketId: string, channel: Channel | null, data: PondResponse | null | undefined, context: ResponseContext, lifecycle: Exclude<PondLifecycle, 'outgoing'>): void;
+export {};

package/dist/performers/response.js

@@ -0,0 +1,65 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performResponse = performResponse;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+function isNotEmpty(value) {
+    if (value === null || value === undefined) {
+        return false;
+    }
+    if (typeof value === 'object') {
+        return Object.keys(value).length !== 0;
+    }
+    return value !== '';
+}
+function performResponse(socketId, channel, data, context, lifecycle) {
+    if (lifecycle === 'leave' || !isNotEmpty(data)) {
+        return;
+    }
+    if ((lifecycle === 'join' || lifecycle === 'connection') && context.hasResponded) {
+        return;
+    }
+    const { event, eventParams, presence, assigns, broadcast, broadcastFrom, broadcastTo, decline, payload: explicitPayload } = data, legacyPayload = __rest(data, ["event", "eventParams", "presence", "assigns", "broadcast", "broadcastFrom", "broadcastTo", "decline", "payload"]);
+    const responseContext = context;
+    if (decline && (lifecycle === 'join' || lifecycle === 'connection')) {
+        const options = typeof decline === 'string' ? { message: decline } : decline;
+        responseContext.decline(options.message, options.status);
+        return;
+    }
+    if (assigns !== undefined) {
+        responseContext.assign(assigns);
+    }
+    if (lifecycle === 'connection' || lifecycle === 'join') {
+        responseContext.accept();
+    }
+    const payload = explicitPayload !== null && explicitPayload !== void 0 ? explicitPayload : (isNotEmpty(legacyPayload) ? legacyPayload : {});
+    if (event) {
+        responseContext.reply(eventParams ? (0, pondsocket_common_1.buildPondRoute)(event, eventParams) : event, payload);
+    }
+    if (lifecycle === 'join' || lifecycle === 'event') {
+        const channelContext = responseContext;
+        if (broadcast) {
+            channelContext.broadcast(eventParams ? (0, pondsocket_common_1.buildPondRoute)(broadcast, eventParams) : broadcast, payload);
+        }
+        if (broadcastFrom) {
+            channelContext.broadcastFrom(eventParams ? (0, pondsocket_common_1.buildPondRoute)(broadcastFrom, eventParams) : broadcastFrom, payload);
+        }
+        if (broadcastTo) {
+            const broadcastEvent = eventParams ? (0, pondsocket_common_1.buildPondRoute)(broadcastTo.event, eventParams) : broadcastTo.event;
+            channelContext.broadcastTo(broadcastEvent, payload, broadcastTo.users);
+        }
+    }
+    if (channel && presence !== undefined) {
+        channel.upsertPresence(socketId, presence);
+    }
+}

package/{services → dist/services}/pondSocket.d.ts

@@ -1,7 +1,7 @@
+import { PondSocket } from '@eleven-am/pondsocket';
 import type { IDistributedBackend } from '@eleven-am/pondsocket/types';
-import { DiscoveryService } from '@golevelup/nestjs-discovery';
-import { OnModuleInit, OnModuleDestroy, PipeTransform } from '@nestjs/common';
-import { HttpAdapterHost, ModuleRef } from '@nestjs/core';
+import { OnModuleDestroy, OnModuleInit, PipeTransform } from '@nestjs/common';
+import { DiscoveryService, HttpAdapterHost, ModuleRef } from '@nestjs/core';
 import { CanActivate, Constructor } from '../types';
 export declare class PondSocketService implements OnModuleInit, OnModuleDestroy {
     private readonly moduleRef;
@@ -16,9 +16,17 @@ export declare class PondSocketService implements OnModuleInit, OnModuleDestroy
     private readonly logger;
     private socket;
     constructor(moduleRef: ModuleRef, discovery: DiscoveryService, adapterHost: HttpAdapterHost, globalGuards: Constructor<CanActivate>[], globalPipes: Constructor<PipeTransform>[], isExclusiveSocketServer: boolean, distributedBackend?: IDistributedBackend | undefined, maxMessageSize?: number | undefined, heartbeatInterval?: number | undefined);
+    get pondSocket(): PondSocket | null;
+    isHealthy(): boolean;
     onModuleInit(): Promise<void>;
-    onModuleDestroy(): void;
+    onModuleDestroy(): Promise<void>;
     private manageEndpoint;
     private manageChannel;
+    private getDefinitionHandlers;
+    private getSingleHandler;
+    private assertUniquePaths;
+    private getEndpointRegistration;
+    private getChannelRegistration;
+    private getProviders;
     private getGroupedInstances;
 }

package/dist/services/pondSocket.js

@@ -0,0 +1,288 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PondSocketService = void 0;
+const pondsocket_1 = require("@eleven-am/pondsocket");
+const common_1 = require("@nestjs/common");
+const channel_1 = require("../managers/channel");
+const channelInstance_1 = require("../managers/channelInstance");
+const connection_1 = require("../managers/connection");
+const endpoint_1 = require("../managers/endpoint");
+const endpointInstance_1 = require("../managers/endpointInstance");
+const event_1 = require("../managers/event");
+const join_1 = require("../managers/join");
+const leave_1 = require("../managers/leave");
+const outgoingEvent_1 = require("../managers/outgoingEvent");
+const action_1 = require("../performers/action");
+const errors_1 = require("../performers/errors");
+class PondSocketService {
+    constructor(moduleRef, discovery, adapterHost, globalGuards, globalPipes, isExclusiveSocketServer, distributedBackend, maxMessageSize, heartbeatInterval) {
+        this.moduleRef = moduleRef;
+        this.discovery = discovery;
+        this.adapterHost = adapterHost;
+        this.globalGuards = globalGuards;
+        this.globalPipes = globalPipes;
+        this.isExclusiveSocketServer = isExclusiveSocketServer;
+        this.distributedBackend = distributedBackend;
+        this.maxMessageSize = maxMessageSize;
+        this.heartbeatInterval = heartbeatInterval;
+        this.logger = new common_1.Logger(PondSocketService.name);
+        this.socket = null;
+    }
+    get pondSocket() {
+        return this.socket;
+    }
+    isHealthy() {
+        var _a, _b;
+        return (_b = (_a = this.socket) === null || _a === void 0 ? void 0 : _a.isHealthy()) !== null && _b !== void 0 ? _b : false;
+    }
+    onModuleInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const instances = this.getGroupedInstances();
+            this.socket = new pondsocket_1.PondSocket({
+                server: this.adapterHost.httpAdapter.getHttpServer(),
+                closeHttpServerOnShutdown: false,
+                exclusiveServer: this.isExclusiveSocketServer,
+                distributedBackend: this.distributedBackend,
+                maxMessageSize: this.maxMessageSize,
+                heartbeatInterval: this.heartbeatInterval,
+            });
+            yield this.socket.ready();
+            instances.forEach((instance) => this.manageEndpoint(this.socket, instance));
+        });
+    }
+    onModuleDestroy() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const socket = this.socket;
+            this.socket = null;
+            yield (socket === null || socket === void 0 ? void 0 : socket.closeAsync());
+        });
+    }
+    manageEndpoint(socket, groupedInstance) {
+        const instance = groupedInstance.endpoint.instance;
+        const registration = this.getEndpointRegistration(groupedInstance.endpoint);
+        const { set: setEndpoint } = (0, endpointInstance_1.manageEndpointInstance)(instance);
+        if (!registration) {
+            return;
+        }
+        const handlers = [
+            ...(0, connection_1.manageConnection)(instance).get(),
+            ...this.getDefinitionHandlers(instance, registration, 'connection'),
+        ];
+        const handler = this.getSingleHandler(handlers, 'connection', groupedInstance.endpoint.name);
+        const endpoint = socket.createEndpoint(registration, (context) => __awaiter(this, void 0, void 0, function* () {
+            if (handler) {
+                yield handler.value(instance, this.moduleRef, this.globalGuards, this.globalPipes, context);
+            }
+            else {
+                context.accept();
+            }
+        }));
+        const endpointPath = typeof registration === 'string' ? registration : registration.path;
+        this.logger.log(`${groupedInstance.endpoint.name} {${endpointPath}}`);
+        if (handler) {
+            this.logger.log(`Mapped {${endpointPath}, CONNECTION}`);
+        }
+        setEndpoint(endpoint);
+        groupedInstance.channels.forEach((channel) => this.manageChannel(channel, endpoint, endpointPath));
+    }
+    manageChannel(provider, endpoint, endpointPath) {
+        const instance = provider.instance;
+        const registration = this.getChannelRegistration(provider);
+        if (!registration) {
+            return;
+        }
+        const { set: setChannel } = (0, channelInstance_1.manageChannelInstance)(instance);
+        const joinHandlers = [
+            ...(0, join_1.manageJoin)(instance).get(),
+            ...this.getDefinitionHandlers(instance, registration, 'join'),
+        ];
+        const joinHandler = this.getSingleHandler(joinHandlers, 'join', provider.name);
+        const channelInstance = endpoint.createChannel(registration, (context) => __awaiter(this, void 0, void 0, function* () {
+            if (joinHandler) {
+                yield joinHandler.value(instance, this.moduleRef, this.globalGuards, this.globalPipes, context);
+            }
+            else {
+                context.accept();
+            }
+        }));
+        const path = typeof registration === 'string' ? registration : registration.path;
+        const fullPath = `${endpointPath}/${path}`.replace(/\/+/g, '/');
+        this.logger.log(`${provider.name} {${fullPath}}`);
+        if (joinHandler) {
+            this.logger.log(`Mapped {${fullPath}, JOIN}`);
+        }
+        setChannel(channelInstance);
+        const eventHandlers = [
+            ...(0, event_1.manageEvent)(instance).get(),
+            ...this.getDefinitionHandlers(instance, registration, 'event'),
+        ];
+        this.assertUniquePaths(eventHandlers, 'event', provider.name);
+        eventHandlers.forEach((handler) => {
+            channelInstance.onEvent(handler.path, (context) => __awaiter(this, void 0, void 0, function* () {
+                yield handler.value(instance, this.moduleRef, this.globalGuards, this.globalPipes, context);
+            }));
+            this.logger.log(`Mapped {${fullPath}/${handler.path}, EVENT}`);
+        });
+        const outgoingHandlers = [
+            ...(0, outgoingEvent_1.manageOutgoingEvent)(instance).get(),
+            ...this.getDefinitionHandlers(instance, registration, 'outgoing'),
+        ];
+        this.assertUniquePaths(outgoingHandlers, 'outgoing event', provider.name);
+        outgoingHandlers.forEach((handler) => {
+            channelInstance.handleOutgoingEvent(handler.path, (context) => __awaiter(this, void 0, void 0, function* () {
+                yield handler.value(instance, this.moduleRef, this.globalGuards, this.globalPipes, context);
+            }));
+            this.logger.log(`Mapped {${fullPath}/${handler.path}, OUTGOING}`);
+        });
+        const leaveHandlers = [
+            ...(0, leave_1.manageLeave)(instance).get(),
+            ...this.getDefinitionHandlers(instance, registration, 'leave'),
+        ];
+        const leaveHandler = this.getSingleHandler(leaveHandlers, 'leave', provider.name);
+        if (leaveHandler) {
+            channelInstance.onLeave((event) => leaveHandler.value(instance, this.moduleRef, this.globalGuards, this.globalPipes, event));
+            this.logger.log(`Mapped {${fullPath}, LEAVE}`);
+        }
+    }
+    getDefinitionHandlers(instance, registration, lifecycle) {
+        var _a;
+        if (typeof registration === 'string') {
+            return [];
+        }
+        const definitions = (_a = (0, pondsocket_1.getPondMetadata)(instance, pondsocket_1.pondHandlerMetadataKey)) !== null && _a !== void 0 ? _a : [];
+        return definitions
+            .filter((definition) => definition.definition === registration && definition.lifecycle === lifecycle)
+            .map((definition) => {
+            var _a;
+            return ({
+                path: (_a = definition.event) !== null && _a !== void 0 ? _a : '',
+                value: (target, moduleRef, guards, pipes, input) => __awaiter(this, void 0, void 0, function* () {
+                    const typedTarget = target;
+                    const method = typedTarget[definition.propertyKey];
+                    if (typeof method !== 'function') {
+                        throw new Error(`${typedTarget.constructor.name}.${String(definition.propertyKey)} is not a method`);
+                    }
+                    try {
+                        return yield (0, action_1.performAction)(typedTarget, moduleRef, guards, pipes, method, String(definition.propertyKey), input, lifecycle, definition.definition);
+                    }
+                    catch (error) {
+                        if (lifecycle === 'connection' || lifecycle === 'join' || lifecycle === 'event') {
+                            return (0, errors_1.performErrors)(error, input, lifecycle);
+                        }
+                        (0, errors_1.logHandlerError)(error, lifecycle, definition.propertyKey);
+                        if (lifecycle === 'outgoing') {
+                            input.block();
+                        }
+                    }
+                }),
+            });
+        });
+    }
+    getSingleHandler(handlers, lifecycle, providerName) {
+        if (handlers.length > 1) {
+            throw new Error(`${providerName} declares multiple ${lifecycle} handlers; exactly one is allowed`);
+        }
+        return handlers[0];
+    }
+    assertUniquePaths(handlers, lifecycle, providerName) {
+        const paths = new Set();
+        handlers.forEach(({ path }) => {
+            if (paths.has(path)) {
+                throw new Error(`${providerName} declares duplicate ${lifecycle} handler "${path}"`);
+            }
+            paths.add(path);
+        });
+    }
+    getEndpointRegistration(provider) {
+        var _a;
+        const metadata = (0, pondsocket_1.getPondMetadata)(provider.metatype, pondsocket_1.pondEndpointMetadataKey);
+        return (_a = metadata === null || metadata === void 0 ? void 0 : metadata.definition) !== null && _a !== void 0 ? _a : (0, endpoint_1.manageEndpoint)(provider.metatype).get();
+    }
+    getChannelRegistration(provider) {
+        var _a;
+        const metadata = (0, pondsocket_1.getPondMetadata)(provider.metatype, pondsocket_1.pondChannelMetadataKey);
+        return (_a = metadata === null || metadata === void 0 ? void 0 : metadata.definition) !== null && _a !== void 0 ? _a : (0, channel_1.manageChannel)(provider.metatype).get();
+    }
+    getProviders() {
+        const wrappers = [...this.discovery.getProviders(), ...this.discovery.getControllers()];
+        const providers = new Map();
+        wrappers.forEach((wrapper) => {
+            var _a;
+            if (wrapper.instance && typeof wrapper.metatype === 'function') {
+                providers.set(wrapper.metatype, {
+                    host: wrapper.host,
+                    instance: wrapper.instance,
+                    metatype: wrapper.metatype,
+                    name: String((_a = wrapper.name) !== null && _a !== void 0 ? _a : wrapper.metatype.name),
+                });
+            }
+        });
+        return [...providers.values()];
+    }
+    getGroupedInstances() {
+        const providers = this.getProviders();
+        const endpoints = providers.filter((provider) => this.getEndpointRegistration(provider));
+        const channels = providers.filter((provider) => this.getChannelRegistration(provider));
+        if (channels.length > 0 && endpoints.length === 0) {
+            throw new Error('PondSocket channels were discovered, but no endpoint is registered');
+        }
+        const endpointByType = new Map(endpoints.map((endpoint) => [endpoint.metatype, endpoint]));
+        const grouped = new Map(endpoints.map((endpoint) => [endpoint, []]));
+        const endpointPaths = new Set();
+        endpoints.forEach((endpoint) => {
+            const registration = this.getEndpointRegistration(endpoint);
+            const path = typeof registration === 'string' ? registration : registration.path;
+            if (endpointPaths.has(path)) {
+                throw new Error(`Multiple PondSocket endpoints declare the path "${path}"`);
+            }
+            endpointPaths.add(path);
+        });
+        channels.forEach((channel) => {
+            const metadata = (0, pondsocket_1.getPondMetadata)(channel.metatype, pondsocket_1.pondChannelMetadataKey);
+            const reference = metadata === null || metadata === void 0 ? void 0 : metadata.options.endpoint;
+            let endpoint;
+            if (reference) {
+                let endpointType = reference;
+                if (!endpointByType.has(endpointType)) {
+                    try {
+                        endpointType = reference();
+                    }
+                    catch (_a) {
+                        throw new Error(`${channel.name} references an invalid PondSocket endpoint`);
+                    }
+                }
+                endpoint = endpointByType.get(endpointType);
+                if (!endpoint) {
+                    throw new Error(`${channel.name} references endpoint ${endpointType.name}, but it is not registered as a Nest provider`);
+                }
+            }
+            else if (endpoints.length === 1) {
+                endpoint = endpoints[0];
+            }
+            else {
+                const localEndpoints = endpoints.filter((candidate) => candidate.host === channel.host);
+                if (localEndpoints.length === 1) {
+                    endpoint = localEndpoints[0];
+                }
+            }
+            if (!endpoint) {
+                throw new Error(`${channel.name} cannot be associated with an endpoint. Pass { endpoint: EndpointClass } to Channel().`);
+            }
+            grouped.get(endpoint).push(channel);
+        });
+        return [...grouped].map(([endpoint, groupedChannels]) => ({
+            endpoint,
+            channels: groupedChannels,
+        }));
+    }
+}
+exports.PondSocketService = PondSocketService;

package/dist/types.d.ts

@@ -0,0 +1,113 @@
+import type { AnyPondChannelDefinition, AnyPondSchema, AssignsOf, ConnectionContext, EventContext as CoreEventContext, EventPayload, EventReplyPayload, EventsOf, IDistributedBackend, JoinContext as CoreJoinContext, LeaveEvent, OutgoingContext as CoreOutgoingContext, OutgoingPayload, PathOf, Params, PondAssigns, PondHandlerLifecycle, PondEndpointDefinition, PondMessage, PondPresence, PresenceOf, SchemaOf, ServerActions } from '@eleven-am/pondsocket/types';
+import type { ModuleMetadata, PipeTransform, Type } from '@nestjs/common';
+import type { ModuleRef } from '@nestjs/core';
+import type { Context } from './context/context';
+export interface NestContext<Schema extends AnyPondSchema = AnyPondSchema, Path extends string = string, EventName extends Extract<keyof EventsOf<Schema>, string> = Extract<keyof EventsOf<Schema>, string>> {
+    connection?: ConnectionContext<Path>;
+    join?: CoreJoinContext<Path, Schema>;
+    event?: CoreEventContext<Path, Schema, EventName>;
+    outgoing?: CoreOutgoingContext<Path, Schema, EventName>;
+    leave?: LeaveEvent;
+}
+export type ParamDecoratorCallback<Input> = (data: Input, context: Context, type: unknown) => unknown | Promise<unknown>;
+export interface ParamDecoratorMetadata {
+    index: number;
+    callback: (context: Context, globalPipes: Constructor<PipeTransform>[], moduleRef: ModuleRef) => Promise<unknown>;
+}
+export type HandlerFunction<Context> = (instance: unknown, moduleRef: ModuleRef, globalGuards: Constructor<CanActivate>[], globalPipes: Constructor<PipeTransform>[], ctx: Context) => Promise<unknown>;
+export type HandlerData<Context> = {
+    path: string;
+    value: HandlerFunction<Context>;
+};
+export type Constructor<T, Parameters extends any[] = any[]> = new (...args: Parameters) => T;
+export interface CanActivate {
+    /**
+     * @desc Whether the client can continue with the request
+     * @param context - The context of the request
+     */
+    canActivate(context: Context): boolean | Promise<boolean>;
+}
+export type GroupedInstances = {
+    endpoint: PondProvider;
+    channels: PondProvider[];
+};
+export interface PondProvider {
+    host?: {
+        metatype?: Type;
+    };
+    instance: any;
+    metatype: Type;
+    name: string;
+}
+export interface Metadata extends Omit<ModuleMetadata, 'controllers'> {
+    guards?: Constructor<CanActivate>[];
+    pipes?: Constructor<PipeTransform>[];
+    isExclusiveSocketServer?: boolean;
+    backend?: IDistributedBackend;
+    maxMessageSize?: number;
+    heartbeatInterval?: number;
+    isGlobal?: boolean;
+}
+export interface AsyncFactoryResult {
+    backend?: IDistributedBackend;
+    maxMessageSize?: number;
+    heartbeatInterval?: number;
+}
+export interface AsyncMetadata extends Omit<Metadata, 'backend' | 'maxMessageSize' | 'heartbeatInterval'> {
+    isGlobal?: boolean;
+    inject?: any[];
+    imports?: any[];
+    useFactory: (...args: any[]) => Promise<AsyncFactoryResult> | AsyncFactoryResult;
+}
+export type PondResponse<Event extends string = string, Payload extends PondMessage = PondMessage, Presence extends PondPresence = PondPresence, Assigns extends PondAssigns = PondAssigns> = {
+    event?: Event;
+    eventParams?: Params<Event>;
+    broadcast?: Event;
+    broadcastFrom?: Event;
+    assigns?: Partial<Assigns>;
+    presence?: Partial<Presence>;
+    broadcastTo?: {
+        event: Event;
+        users: string[];
+    };
+    decline?: string | {
+        message?: string;
+        status?: number;
+    };
+    payload?: Payload;
+} & Partial<Payload>;
+export type PondLifecycle = PondHandlerLifecycle;
+type EndpointPathOf<Definition extends PondEndpointDefinition> = Definition extends PondEndpointDefinition<infer Path> ? Path : never;
+export type PondConnectionContext<Definition extends PondEndpointDefinition> = Omit<Context<AnyPondSchema, EndpointPathOf<Definition>>, 'block' | 'broadcast' | 'broadcastFrom' | 'broadcastTo' | 'channel' | 'eventContext' | 'evictUser' | 'joinContext' | 'joinParams' | 'leaveEvent' | 'outgoingContext' | 'payload' | 'presence' | 'removePresence' | 'trackPresence' | 'transform' | 'updatePresence'> & {
+    readonly connectionContext: ConnectionContext<EndpointPathOf<Definition>>;
+    readonly params: Params<EndpointPathOf<Definition>>;
+};
+export type PondJoinContext<Definition extends AnyPondChannelDefinition> = Omit<Context<SchemaOf<Definition>, PathOf<Definition>>, 'block' | 'connectionContext' | 'eventContext' | 'evictUser' | 'leaveEvent' | 'outgoingContext' | 'payload' | 'removePresence' | 'transform' | 'updatePresence'> & {
+    readonly joinContext: CoreJoinContext<PathOf<Definition>, SchemaOf<Definition>>;
+    readonly joinParams: SchemaOf<Definition>['joinParams'];
+};
+export type PondEventContext<Definition extends AnyPondChannelDefinition, Event extends Extract<keyof EventsOf<SchemaOf<Definition>>, string>> = Omit<Context<SchemaOf<Definition>, Event, Event>, 'accept' | 'block' | 'connectionContext' | 'decline' | 'joinContext' | 'joinParams' | 'leaveEvent' | 'outgoingContext' | 'reply' | 'transform'> & {
+    readonly eventContext: CoreEventContext<Event, SchemaOf<Definition>, Event>;
+    readonly event: CoreEventContext<Event, SchemaOf<Definition>, Event>['event'];
+    readonly payload: EventPayload<EventsOf<SchemaOf<Definition>>, Event>;
+    reply(payload: EventReplyPayload<EventsOf<SchemaOf<Definition>>, Event>): PondEventContext<Definition, Event>;
+};
+type PondOutgoingContextForAction<Definition extends AnyPondChannelDefinition, Event extends Extract<keyof EventsOf<SchemaOf<Definition>>, string>, Action extends ServerActions.BROADCAST | ServerActions.SYSTEM> = Omit<Context<SchemaOf<Definition>, Event, Event>, 'accept' | 'action' | 'assign' | 'broadcast' | 'broadcastFrom' | 'broadcastTo' | 'connectionContext' | 'decline' | 'eventContext' | 'evictUser' | 'joinContext' | 'joinParams' | 'leaveEvent' | 'removePresence' | 'reply' | 'event' | 'outgoingContext' | 'payload' | 'trackPresence' | 'transform' | 'updatePresence'> & {
+    readonly action: Action;
+    readonly outgoingContext: CoreOutgoingContext<Event, SchemaOf<Definition>, Event, Action>;
+    readonly event: CoreOutgoingContext<Event, SchemaOf<Definition>, Event, Action>['event'];
+    readonly payload: OutgoingPayload<SchemaOf<Definition>, Event, Action>;
+    transform(payload: OutgoingPayload<SchemaOf<Definition>, Event, Action>): PondOutgoingContextForAction<Definition, Event, Action>;
+};
+export type PondOutgoingContext<Definition extends AnyPondChannelDefinition, Event extends Extract<keyof EventsOf<SchemaOf<Definition>>, string>> = PondOutgoingContextForAction<Definition, Event, ServerActions.BROADCAST> | PondOutgoingContextForAction<Definition, Event, ServerActions.SYSTEM>;
+export type PondCoreJoinContext<Definition extends AnyPondChannelDefinition> = CoreJoinContext<PathOf<Definition>, SchemaOf<Definition>>;
+export type PondCoreEventContext<Definition extends AnyPondChannelDefinition, Event extends Extract<keyof EventsOf<SchemaOf<Definition>>, string>> = CoreEventContext<Event, SchemaOf<Definition>, Event>;
+export type PondCoreOutgoingContext<Definition extends AnyPondChannelDefinition, Event extends Extract<keyof EventsOf<SchemaOf<Definition>>, string>> = CoreOutgoingContext<Event, SchemaOf<Definition>, Event, ServerActions.BROADCAST> | CoreOutgoingContext<Event, SchemaOf<Definition>, Event, ServerActions.SYSTEM>;
+export type PondEventPayload<Definition extends AnyPondChannelDefinition, Event extends Extract<keyof EventsOf<SchemaOf<Definition>>, string>> = EventPayload<EventsOf<SchemaOf<Definition>>, Event>;
+export type PondSchemaPresence<Definition extends AnyPondChannelDefinition> = PresenceOf<SchemaOf<Definition>>;
+export type PondSchemaAssigns<Definition extends AnyPondChannelDefinition> = AssignsOf<SchemaOf<Definition>>;
+export type PondResponseFor<Definition extends AnyPondChannelDefinition, Event extends Extract<keyof EventsOf<SchemaOf<Definition>>, string>> = Omit<PondResponse<Event, EventReplyPayload<EventsOf<SchemaOf<Definition>>, Event>, PresenceOf<SchemaOf<Definition>>, AssignsOf<SchemaOf<Definition>>>, 'eventParams'> & {
+    eventParams?: Params<Event>;
+};
+export type PondEventHandler<Definition extends AnyPondChannelDefinition, Event extends Extract<keyof EventsOf<SchemaOf<Definition>>, string>> = (context: PondEventContext<Definition, Event>) => PondResponseFor<Definition, Event> | null | undefined | Promise<PondResponseFor<Definition, Event> | null | undefined>;
+export {};