arri 0.36.0 → 0.37.0

package/dist/index.d.ts

@@ -1,8 +1,9 @@
-import { HttpMethod, RpcHttpMethod, HttpRpcDefinition, SchemaFormProperties, SchemaFormDiscriminator, SchemaFormValues, AppDefinition, ClientGenerator } from 'arri-codegen-utils';
-import { AObjectSchema, a, ValidationError, ASchema, InferType, ValueError, ADiscriminatorSchema } from 'arri-validate';
+import { HttpMethod, WsRpcDefinition, RpcHttpMethod, HttpRpcDefinition, SchemaFormProperties, SchemaFormDiscriminator, SchemaFormValues, AppDefinition, ClientGenerator } from 'arri-codegen-utils';
+import { AObjectSchema, a, ValidationError, ASchema, InferType, ValueError, CompiledValidator, ADiscriminatorSchema } from 'arri-validate';
 import { H3Error, H3Event, H3EventContext, Router, App } from 'h3';
 export * from 'h3';
 import { EventStream } from 'h3-sse';
+import { Peer, WSError } from 'crossws';
 import { BuildOptions } from 'esbuild';
 
 declare class ArriServerError extends Error {
@@ -67,7 +68,7 @@ type RouteOptions = Pick<ArriOptions, "onAfterResponse" | "onBeforeResponse" | "
 declare function registerRoute(router: Router, route: ArriRoute<any>, opts: RouteOptions): void;
 declare function handleRoute(router: Router, method: HttpMethod, route: ArriRoute<any>, opts: RouteOptions): void;
 
-declare function defineEventStreamRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined | never = undefined>(config: Omit<EventStreamRpc<TParams, TResponse>, "isEventStream">): EventStreamRpc<TParams, TResponse>;
+declare function defineEventStreamRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined | never = undefined>(config: Omit<EventStreamRpc<TParams, TResponse>, "isEventStream" | "transport">): EventStreamRpc<TParams, TResponse>;
 declare function isEventStreamRpc(input: unknown): input is EventStreamRpc<any, any>;
 interface EventStreamRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> extends Omit<Rpc<true, TParams, TResponse>, "handler" | "postHandler"> {
     isEventStream: true;
@@ -116,12 +117,62 @@ declare function registerEventStreamRpc(router: Router, path: string, procedure:
     name: string;
 }, opts: RouteOptions): void;
 
+interface NamedWebsocketRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> extends WebsocketRpc<TParams, TResponse> {
+    name: string;
+}
+interface WebsocketRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> {
+    transport: "ws";
+    description?: string;
+    path?: string;
+    isDeprecated?: boolean;
+    params: TParams;
+    response: TResponse;
+    pingInterval?: boolean;
+    handler: WebSocketRpcHandler<TParams extends RpcParamSchema ? InferType<TParams> : undefined, TResponse extends RpcParamSchema ? InferType<TResponse> : undefined>;
+}
+interface WsPeerOpts<TResponse> {
+    validator?: CompiledValidator<ASchema<TResponse>>;
+    context: WsPeerContext;
+}
+interface WsPeerContext extends Record<string, any> {
+    rpcName: string;
+    queryParams?: Record<string, string>;
+    clientAddress?: string;
+}
+declare class WsPeer<TResponse> {
+    private readonly _peer;
+    private readonly _validator?;
+    context: WsPeerContext;
+    url: string;
+    constructor(peer: Peer, opts: WsPeerOpts<TResponse>);
+    send(data: TResponse): number | undefined;
+    sendError(err: ArriServerErrorResponse): number;
+    close(): void;
+    subscribe(channel: string): void;
+    unsubscribe(channel: string): void;
+    publish(channel: string, message: TResponse): void;
+    readyState(): (0 | 1 | 2 | 3) | -1;
+}
+interface WebSocketRpcHandler<TParams, TResponse> {
+    onOpen: (peer: WsPeer<TResponse>) => void;
+    onMessage: (peer: WsPeer<TResponse>, message: TParams) => void;
+    onClose: (peer: WsPeer<TResponse>, details: {
+        code?: number;
+        reason?: string;
+    }) => void;
+    onError: (peer: WsPeer<TResponse>, error: WSError) => void;
+}
+declare function defineWebsocketRpc<TParams extends RpcParamSchema | undefined, TResponse extends RpcParamSchema | undefined>(def: Omit<WebsocketRpc<TParams, TResponse>, "transport">): WebsocketRpc<TParams, TResponse>;
+declare function registerWebsocketRpc(router: Router, path: string, rpc: NamedWebsocketRpc<any, any>): void;
+declare function createWsRpcDefinition(rpcName: string, path: string, rpc: NamedWebsocketRpc<any, any>): WsRpcDefinition;
+
 type RpcParamSchema<TObjectInner = any, TDiscriminatorInner = any> = AObjectSchema<TObjectInner> | ADiscriminatorSchema<TDiscriminatorInner>;
 declare function isRpcParamSchema(input: unknown): input is RpcParamSchema;
 interface NamedRpc<TIsEventStream extends boolean = false, TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> extends Rpc<TIsEventStream, TParams, TResponse> {
     name: string;
 }
 interface Rpc<TIsEventStream extends boolean = false, TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> {
+    transport: "http";
     method?: RpcHttpMethod;
     path?: string;
     description?: string;
@@ -151,16 +202,17 @@ interface RpcPostEvent<TParams = undefined, TResponse = undefined> extends Omit<
 type RpcHandler<TParams, TResponse> = (context: RpcHandlerContext<TParams>, event: RpcEvent<TParams>) => TResponse | Promise<TResponse>;
 type RpcPostHandler<TParams, TResponse> = (context: RpcPostHandlerContext<TParams, TResponse>, event: RpcPostEvent<TParams, TResponse>) => any;
 declare function isRpc(input: unknown): input is Rpc<any, any>;
-declare function defineRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined | never = undefined>(config: HttpRpc<TParams, TResponse>): Rpc<false, TParams, TResponse>;
+declare function defineRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined | never = undefined>(config: Omit<HttpRpc<TParams, TResponse>, "transport">): Rpc<false, TParams, TResponse>;
 declare function createHttpRpcDefinition(rpcName: string, httpPath: string, procedure: Rpc<any, any, any>): HttpRpcDefinition;
 declare function getRpcPath(rpcName: string, prefix?: string): string;
-declare function getRpcParamName(rpcName: string, procedure: Rpc<any, any, any>): string | undefined;
-declare function getRpcResponseName(rpcName: string, procedure: Rpc<any, any, any>): string | undefined;
+declare function getRpcParamName(rpcName: string, procedure: Rpc<any, any, any> | WebsocketRpc<any, any>): string | undefined;
+declare function getRpcResponseName(rpcName: string, procedure: Rpc<any, any, any> | WebsocketRpc<any, any>): string | undefined;
 declare function registerRpc(router: Router, path: string, procedure: NamedRpc<any, any, any>, opts: RouteOptions): void;
 declare function validateRpcRequestInput(event: H3Event, httpMethod: RpcHttpMethod, schema: ASchema): Promise<void>;
 
 interface ArriRouterBase {
-    rpc: <TIsEventStream extends boolean, TParams extends AObjectSchema<any, any> | undefined, TResponse extends AObjectSchema<any, any> | undefined>(procedure: NamedRpc<TIsEventStream, TParams, TResponse>) => void;
+    rpc: <TIsEventStream extends boolean, TParams extends AObjectSchema<any, any> | undefined, TResponse extends AObjectSchema<any, any> | undefined>(procedure: Omit<NamedRpc<TIsEventStream, TParams, TResponse>, "transport">) => void;
+    wsRpc: <TParams extends RpcParamSchema | undefined, TResponse extends RpcParamSchema | undefined>(procedure: Omit<NamedWebsocketRpc<TParams, TResponse>, "transport">) => void;
     route: <TPath extends string, TQuery extends AObjectSchema<any, any> = any, TBody extends ASchema<any> = any, TResponse = any>(route: ArriRoute<TPath, TQuery, TBody, TResponse>) => void;
     registerModels: (models: ModelMap) => void;
 }
@@ -168,10 +220,11 @@ declare class ArriRouter implements ArriRouterBase {
     private readonly procedures;
     private readonly routes;
     private readonly models;
-    rpc<TIsEventStream extends boolean = false, TParams extends AObjectSchema<any, any> | undefined = undefined, TResponse extends AObjectSchema<any, any> | undefined = undefined>(procedure: NamedRpc<TIsEventStream, TParams, TResponse>): void;
+    rpc<TIsEventStream extends boolean = false, TParams extends AObjectSchema<any, any> | undefined = undefined, TResponse extends AObjectSchema<any, any> | undefined = undefined>(procedure: Omit<NamedRpc<TIsEventStream, TParams, TResponse>, "transport">): void;
+    wsRpc<TParams extends RpcParamSchema | undefined, TResponse extends RpcParamSchema | undefined>(procedure: Omit<NamedWebsocketRpc<TParams, TResponse>, "transport">): void;
     route<TPath extends string, TQuery extends AObjectSchema<any, any> = any, TBody extends ASchema<any> = any, TResponse = any>(route: ArriRoute<TPath, TQuery, TBody, TResponse>): void;
     registerModels(models: ModelMap): void;
-    getProcedures(): NamedRpc<any, any, any>[];
+    getProcedures(): (NamedWebsocketRpc<any, any> | NamedRpc<any, any, any>)[];
     getRoutes(): ArriRoute<any, any, any, any>[];
     getModels(): ModelMap;
 }
@@ -195,9 +248,11 @@ declare class ArriApp implements ArriRouterBase {
     private readonly _onBeforeResponse;
     private readonly _onError;
     private readonly _debug;
+    readonly definitionPath: string;
     constructor(opts?: ArriOptions);
     use(input: Middleware | ArriRouter): void;
-    rpc<TIsEventStream extends boolean = false, TParams extends AObjectSchema<any, any> | undefined = undefined, TResponse extends AObjectSchema<any, any> | undefined = undefined>(procedure: NamedRpc<TIsEventStream, TParams, TResponse>): void;
+    rpc<TIsEventStream extends boolean = false, TParams extends AObjectSchema<any, any> | undefined = undefined, TResponse extends AObjectSchema<any, any> | undefined = undefined>(procedure: Omit<NamedRpc<TIsEventStream, TParams, TResponse>, "transport">): void;
+    wsRpc<TParams extends RpcParamSchema | undefined, TResponse extends RpcParamSchema | undefined>(procedure: Omit<NamedWebsocketRpc<TParams, TResponse>, "transport">): void;
     route<TPath extends string, TQuery extends AObjectSchema<any, any>, TBody extends ASchema<any>, TResponse = any>(route: ArriRoute<TPath, TQuery, TBody, TResponse>): void;
     registerModels(models: ModelMap): void;
     getAppDefinition(): AppDefinition;
@@ -247,4 +302,4 @@ type ResolvedArriConfig = Required<ArriConfig>;
 declare const defaultConfig: Required<ArriConfig>;
 declare function defineConfig(config: ArriConfig): ResolvedArriConfig;
 
-export { ArriApp, type ArriConfig, type ArriOptions, type ArriRoute, ArriRouter, type ArriRouterBase, ArriServerError, ArriServerErrorResponse, DEV_DEFINITION_ENDPOINT, DEV_ENDPOINT_ROOT, EventStreamConnection, type EventStreamConnectionOptions, type EventStreamRpc, type EventStreamRpcHandler, type EventStreamRpcHandlerContext, type ExtractParam, type ExtractParams, type HandlerContext, type HttpRpc, type Middleware, type MiddlewareEvent, type MiddlewareEventContext, type ModelMap, type NamedRpc, type PostRouteEvent, type PostRouteEventContext, type ResolvedArriConfig, type RouteEvent, type RouteEventContext, type RouteOptions, type Rpc, type RpcEvent, type RpcHandler, type RpcHandlerContext, type RpcParamSchema, type RpcPostEvent, type RpcPostHandler, type RpcPostHandlerContext, type StatusCode, createAppDefinition, createHttpRpcDefinition, defaultConfig, defineConfig, defineError, defineEventStreamRpc, defineMiddleware, defineRoute, defineRpc, errorResponseFromValidationErrors, getRpcParamName, getRpcPath, getRpcResponseName, handleH3Error, handleRoute, isArriConfig, isEventStreamRpc, isResolvedArriConfig, isRpc, isRpcParamSchema, registerEventStreamRpc, registerRoute, registerRpc, validateRpcRequestInput };
+export { ArriApp, type ArriConfig, type ArriOptions, type ArriRoute, ArriRouter, type ArriRouterBase, ArriServerError, ArriServerErrorResponse, DEV_DEFINITION_ENDPOINT, DEV_ENDPOINT_ROOT, EventStreamConnection, type EventStreamConnectionOptions, type EventStreamRpc, type EventStreamRpcHandler, type EventStreamRpcHandlerContext, type ExtractParam, type ExtractParams, type HandlerContext, type HttpRpc, type Middleware, type MiddlewareEvent, type MiddlewareEventContext, type ModelMap, type NamedRpc, type NamedWebsocketRpc, type PostRouteEvent, type PostRouteEventContext, type ResolvedArriConfig, type RouteEvent, type RouteEventContext, type RouteOptions, type Rpc, type RpcEvent, type RpcHandler, type RpcHandlerContext, type RpcParamSchema, type RpcPostEvent, type RpcPostHandler, type RpcPostHandlerContext, type StatusCode, type WebSocketRpcHandler, type WebsocketRpc, WsPeer, type WsPeerContext, createAppDefinition, createHttpRpcDefinition, createWsRpcDefinition, defaultConfig, defineConfig, defineError, defineEventStreamRpc, defineMiddleware, defineRoute, defineRpc, defineWebsocketRpc, errorResponseFromValidationErrors, getRpcParamName, getRpcPath, getRpcResponseName, handleH3Error, handleRoute, isArriConfig, isEventStreamRpc, isResolvedArriConfig, isRpc, isRpcParamSchema, registerEventStreamRpc, registerRoute, registerRpc, registerWebsocketRpc, validateRpcRequestInput };

package/dist/index.mjs

@@ -1,6 +1,7 @@
-export { A as ArriApp, t as ArriRouter, j as ArriServerError, k as ArriServerErrorResponse, a as DEV_DEFINITION_ENDPOINT, D as DEV_ENDPOINT_ROOT, E as EventStreamConnection, c as createAppDefinition, e as createHttpRpcDefinition, q as defaultConfig, s as defineConfig, l as defineError, y as defineEventStreamRpc, u as defineRoute, d as defineRpc, m as errorResponseFromValidationErrors, f as getRpcParamName, g as getRpcPath, h as getRpcResponseName, n as handleH3Error, x as handleRoute, o as isArriConfig, z as isEventStreamRpc, p as isResolvedArriConfig, b as isRpc, i as isRpcParamSchema, B as registerEventStreamRpc, w as registerRoute, r as registerRpc, v as validateRpcRequestInput } from './shared/arri.b0950dad.mjs';
+export { A as ArriApp, t as ArriRouter, j as ArriServerError, k as ArriServerErrorResponse, a as DEV_DEFINITION_ENDPOINT, D as DEV_ENDPOINT_ROOT, E as EventStreamConnection, W as WsPeer, c as createAppDefinition, e as createHttpRpcDefinition, G as createWsRpcDefinition, q as defaultConfig, s as defineConfig, l as defineError, y as defineEventStreamRpc, u as defineRoute, d as defineRpc, C as defineWebsocketRpc, m as errorResponseFromValidationErrors, f as getRpcParamName, g as getRpcPath, h as getRpcResponseName, n as handleH3Error, x as handleRoute, o as isArriConfig, z as isEventStreamRpc, p as isResolvedArriConfig, b as isRpc, i as isRpcParamSchema, B as registerEventStreamRpc, w as registerRoute, r as registerRpc, F as registerWebsocketRpc, v as validateRpcRequestInput } from './shared/arri.90dd1716.mjs';
 export * from 'h3';
 import 'arri-codegen-utils';
+import 'consola';
 import 'arri-validate';
 import 'h3-sse';
 import 'scule';

package/dist/shared/{arri.087dabd0.cjs → arri.1ce0fa20.cjs}

@@ -1,22 +1,27 @@
 'use strict';
 
 const arriCodegenUtils = require('arri-codegen-utils');
+const consola = require('consola');
 const h3 = require('h3');
 const arriValidate = require('arri-validate');
 const h3Sse = require('h3-sse');
 const scule = require('scule');
 
-var __defProp$3 = Object.defineProperty;
-var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$3 = (obj, key, value) => {
-  __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const consola__default = /*#__PURE__*/_interopDefaultCompat(consola);
+
+var __defProp$4 = Object.defineProperty;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$4 = (obj, key, value) => {
+  __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 class ArriServerError extends Error {
   constructor(err) {
     super(err.message);
-    __publicField$3(this, "code");
-    __publicField$3(this, "data");
+    __publicField$4(this, "code");
+    __publicField$4(this, "data");
     this.code = err.code;
     this.data = err.data;
     if (err.stack) {
@@ -262,6 +267,7 @@ function isRpc(input) {
   return typeof input === "object" && input !== null && "method" in input && arriCodegenUtils.isRpcHttpMethod(input.method) && "handler" in input && typeof input.handler === "function";
 }
 function defineRpc(config) {
+  config.transport = "http";
   return config;
 }
 function createHttpRpcDefinition(rpcName, httpPath, procedure) {
@@ -473,17 +479,18 @@ async function validateRpcRequestInput(event, httpMethod, schema) {
   }
 }
 
-var __defProp$2 = Object.defineProperty;
-var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$2 = (obj, key, value) => {
-  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => {
+  __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 function defineEventStreamRpc(config) {
   return {
     ...config,
     method: config.method ?? "get",
-    isEventStream: true
+    isEventStream: true,
+    transport: "http"
   };
 }
 function isEventStreamRpc(input) {
@@ -491,14 +498,14 @@ function isEventStreamRpc(input) {
 }
 class EventStreamConnection {
   constructor(event, opts) {
-    __publicField$2(this, "lastEventId");
-    __publicField$2(this, "validationErrors");
-    __publicField$2(this, "validator");
-    __publicField$2(this, "serializer");
+    __publicField$3(this, "lastEventId");
+    __publicField$3(this, "validationErrors");
+    __publicField$3(this, "validator");
+    __publicField$3(this, "serializer");
     // for some reason Rollup cannot output DTS when this is set to NodeJS.Timeout
-    __publicField$2(this, "pingInterval");
-    __publicField$2(this, "pingIntervalMs");
-    __publicField$2(this, "eventStream");
+    __publicField$3(this, "pingInterval");
+    __publicField$3(this, "pingIntervalMs");
+    __publicField$3(this, "eventStream");
     this.eventStream = h3Sse.createEventStream(event);
     this.lastEventId = this.eventStream.lastEventId;
     this.pingIntervalMs = opts.pingInterval ?? 6e4;
@@ -812,19 +819,24 @@ function handleRoute(router, method, route, opts) {
   }
 }
 
-var __defProp$1 = Object.defineProperty;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$1 = (obj, key, value) => {
-  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => {
+  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 class ArriRouter {
   constructor() {
-    __publicField$1(this, "procedures", []);
-    __publicField$1(this, "routes", []);
-    __publicField$1(this, "models", {});
+    __publicField$2(this, "procedures", []);
+    __publicField$2(this, "routes", []);
+    __publicField$2(this, "models", {});
   }
   rpc(procedure) {
+    procedure.transport = "http";
+    this.procedures.push(procedure);
+  }
+  wsRpc(procedure) {
+    procedure.transport = "ws";
     this.procedures.push(procedure);
   }
   route(route) {
@@ -846,6 +858,145 @@ class ArriRouter {
   }
 }
 
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class WsPeer {
+  constructor(peer, opts) {
+    __publicField$1(this, "_peer");
+    __publicField$1(this, "_validator");
+    __publicField$1(this, "context");
+    __publicField$1(this, "url");
+    this._peer = peer;
+    this._validator = opts.validator;
+    this.url = peer.url;
+    this.context = opts.context;
+  }
+  send(data) {
+    if (!this._validator) {
+      return;
+    }
+    if (!this._validator.validate(data)) {
+      return;
+    }
+    const payload = this._validator.serialize(data);
+    return this._peer.send(`type: message
+data: ${payload}`);
+  }
+  sendError(err) {
+    return this._peer.send(`type: error
+data: ${JSON.stringify(err)}`);
+  }
+  close() {
+    throw new Error("close() is not yet implemented on WsPeer");
+  }
+  subscribe(channel) {
+    this._peer.subscribe(channel);
+  }
+  unsubscribe(channel) {
+    this._peer.unsubscribe(channel);
+  }
+  publish(channel, message) {
+    if (!this._validator) {
+      return;
+    }
+    if (!this._validator.validate(message)) {
+      const err = {
+        code: 500,
+        message: `Error serializing message on server. The payload doesn't match the specified schema.`,
+        data: {
+          payload: message
+        }
+      };
+      this.sendError(err);
+      return;
+    }
+    const payload = this._validator.serialize(message);
+    this._peer.publish(channel, payload);
+  }
+  readyState() {
+    return this._peer.readyState;
+  }
+}
+function defineWebsocketRpc(def) {
+  def.transport = "ws";
+  return def;
+}
+function registerWebsocketRpc(router, path, rpc) {
+  let responseValidator;
+  let paramValidator;
+  try {
+    responseValidator = rpc.response ? arriValidate.a.compile(rpc.response) : void 0;
+  } catch (err) {
+    console.error("ERROR COMPILING VALIDATOR", err);
+  }
+  try {
+    paramValidator = rpc.params ? arriValidate.a.compile(rpc.params) : void 0;
+  } catch (err) {
+    console.error("ERROR COMPILING PARAMS", err);
+  }
+  const handler = h3.defineWebSocketHandler({
+    upgrade(req) {
+    },
+    open(peer) {
+      const urlParts = peer.url.split("?");
+      const context = {
+        rpcName: rpc.name,
+        clientAddress: peer.addr
+      };
+      if (urlParts.length > 1) {
+        urlParts.shift();
+        const queryStr = new URLSearchParams(urlParts.join("?"));
+        const query = {};
+        for (const [key, val] of queryStr.entries()) {
+          query[key] = val;
+        }
+        context.queryParams = query;
+      }
+      const wsPeer = new WsPeer(peer, {
+        validator: responseValidator,
+        context
+      });
+      peer.ctx.__wsPeer = wsPeer;
+      rpc.handler.onOpen(peer.ctx.__wsPeer);
+    },
+    message(peer, message) {
+      if (!paramValidator) {
+        return;
+      }
+      const data = paramValidator.safeParse(message.text());
+      if (!data.success) {
+        const errorResponse = {
+          code: 400,
+          message: data.error.message,
+          data: data.error.errors,
+          stack: data.error.stack?.split("\n")
+        };
+        peer.ctx.__wsPeer.sendError(errorResponse);
+        return;
+      }
+      rpc.handler.onMessage(peer.ctx.__wsPeer, data.value);
+    },
+    close(peer, details) {
+      rpc.handler.onClose(peer.ctx.__wsPeer, details);
+    }
+  });
+  router.use(path, handler);
+}
+function createWsRpcDefinition(rpcName, path, rpc) {
+  return {
+    transport: "ws",
+    path,
+    params: getRpcParamName(rpcName, rpc),
+    response: getRpcResponseName(rpcName, rpc),
+    isDeprecated: rpc.isDeprecated,
+    description: rpc.description
+  };
+}
+
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => {
@@ -871,6 +1022,7 @@ class ArriApp {
     __publicField(this, "_onBeforeResponse");
     __publicField(this, "_onError");
     __publicField(this, "_debug");
+    __publicField(this, "definitionPath");
     this.appInfo = opts?.appInfo;
     this.h3App = h3.createApp({
       debug: opts?.debug
@@ -883,11 +1035,15 @@ class ArriApp {
     this._rpcRoutePrefix = opts?.rpcRoutePrefix ?? "";
     this._rpcDefinitionPath = opts?.rpcDefinitionPath ?? "__definition";
     this.h3App.use(this.h3Router);
+    this.definitionPath = this._rpcRoutePrefix ? `/${this._rpcRoutePrefix}/${this._rpcDefinitionPath}`.split("//").join("/") : `/${this._rpcDefinitionPath}`;
     this.h3Router.get(
-      this._rpcRoutePrefix ? `/${this._rpcRoutePrefix}/${this._rpcDefinitionPath}`.split("//").join("/") : `/${this._rpcDefinitionPath}`,
+      this.definitionPath,
       h3.eventHandler(() => this.getAppDefinition())
     );
     if (process.env.ARRI_DEV_MODE === "true") {
+      consola__default.info(
+        `Arri definition available at \`http://<host>${this.definitionPath}\``
+      );
       this.h3Router.get(
         DEV_DEFINITION_ENDPOINT,
         h3.eventHandler(() => this.getAppDefinition())
@@ -918,7 +1074,11 @@ class ArriApp {
         this.route(route);
       }
       for (const rpc of input.getProcedures()) {
-        this.rpc(rpc);
+        if (rpc.transport === "http") {
+          this.rpc(rpc);
+        } else {
+          this.wsRpc(rpc);
+        }
       }
       this.registerModels(input.getModels());
       return;
@@ -926,26 +1086,24 @@ class ArriApp {
     this._middlewares.push(input);
   }
   rpc(procedure) {
-    const path = procedure.path ?? getRpcPath(procedure.name, this._rpcRoutePrefix);
-    this._procedures[procedure.name] = createHttpRpcDefinition(
-      procedure.name,
-      path,
-      procedure
-    );
-    if (isRpcParamSchema(procedure.params)) {
-      const paramName = getRpcParamName(procedure.name, procedure);
+    procedure.transport = "http";
+    const p = procedure;
+    const path = p.path ?? getRpcPath(p.name, this._rpcRoutePrefix);
+    this._procedures[p.name] = createHttpRpcDefinition(p.name, path, p);
+    if (isRpcParamSchema(p.params)) {
+      const paramName = getRpcParamName(p.name, p);
       if (paramName) {
-        this._models[paramName] = procedure.params;
+        this._models[paramName] = p.params;
       }
     }
-    if (isRpcParamSchema(procedure.response)) {
-      const responseName = getRpcResponseName(procedure.name, procedure);
+    if (isRpcParamSchema(p.response)) {
+      const responseName = getRpcResponseName(p.name, p);
       if (responseName) {
-        this._models[responseName] = procedure.response;
+        this._models[responseName] = p.response;
       }
     }
-    if (isEventStreamRpc(procedure)) {
-      registerEventStreamRpc(this.h3Router, path, procedure, {
+    if (isEventStreamRpc(p)) {
+      registerEventStreamRpc(this.h3Router, path, p, {
         middleware: this._middlewares,
         onRequest: this._onRequest,
         onError: this._onError,
@@ -955,7 +1113,7 @@ class ArriApp {
       });
       return;
     }
-    registerRpc(this.h3Router, path, procedure, {
+    registerRpc(this.h3Router, path, p, {
       middleware: this._middlewares,
       onRequest: this._onRequest,
       onError: this._onError,
@@ -964,6 +1122,29 @@ class ArriApp {
       debug: this._debug
     });
   }
+  wsRpc(procedure) {
+    procedure.transport = "ws";
+    const p = procedure;
+    const path = procedure.path ?? getRpcPath(procedure.name, this._rpcRoutePrefix);
+    this._procedures[procedure.name] = createWsRpcDefinition(
+      procedure.name,
+      path,
+      p
+    );
+    if (isRpcParamSchema(procedure.params)) {
+      const paramName = getRpcParamName(procedure.name, p);
+      if (paramName) {
+        this._models[paramName] = procedure.params;
+      }
+    }
+    if (isRpcParamSchema(procedure.response)) {
+      const responseName = getRpcResponseName(procedure.name, p);
+      if (responseName) {
+        this._models[responseName] = procedure.response;
+      }
+    }
+    registerWebsocketRpc(this.h3Router, path, p);
+  }
   route(route) {
     registerRoute(this.h3Router, route, {
       middleware: this._middlewares,
@@ -1060,14 +1241,17 @@ exports.ArriServerErrorResponse = ArriServerErrorResponse;
 exports.DEV_DEFINITION_ENDPOINT = DEV_DEFINITION_ENDPOINT;
 exports.DEV_ENDPOINT_ROOT = DEV_ENDPOINT_ROOT;
 exports.EventStreamConnection = EventStreamConnection;
+exports.WsPeer = WsPeer;
 exports.createAppDefinition = createAppDefinition;
 exports.createHttpRpcDefinition = createHttpRpcDefinition;
+exports.createWsRpcDefinition = createWsRpcDefinition;
 exports.defaultConfig = defaultConfig;
 exports.defineConfig = defineConfig;
 exports.defineError = defineError;
 exports.defineEventStreamRpc = defineEventStreamRpc;
 exports.defineRoute = defineRoute;
 exports.defineRpc = defineRpc;
+exports.defineWebsocketRpc = defineWebsocketRpc;
 exports.errorResponseFromValidationErrors = errorResponseFromValidationErrors;
 exports.getRpcParamName = getRpcParamName;
 exports.getRpcPath = getRpcPath;
@@ -1082,4 +1266,5 @@ exports.isRpcParamSchema = isRpcParamSchema;
 exports.registerEventStreamRpc = registerEventStreamRpc;
 exports.registerRoute = registerRoute;
 exports.registerRpc = registerRpc;
+exports.registerWebsocketRpc = registerWebsocketRpc;
 exports.validateRpcRequestInput = validateRpcRequestInput;