arri 0.12.8 → 0.15.1

package/dist/cli.mjs

@@ -8,9 +8,10 @@ import { loadConfig } from 'c12';
 import consola, { createConsola } from 'consola';
 import * as esbuild from 'esbuild';
 import { build as build$1 } from 'esbuild';
+import { replace } from 'esbuild-plugin-replace';
 import path from 'pathe';
 import prettier from 'prettier';
-import { n as defaultConfig, m as isResolvedArriConfig, a as DEV_DEFINITION_ENDPOINT } from './shared/arri.4d91d9b0.mjs';
+import { n as defaultConfig, m as isResolvedArriConfig, a as DEV_DEFINITION_ENDPOINT } from './shared/arri.28516ef9.mjs';
 import { globby } from 'globby';
 import { camelCase, kebabCase } from 'scule';
 import { dartClientGenerator } from 'arri-codegen-dart';
@@ -21,10 +22,11 @@ import Degit from 'degit';
 import 'h3';
 import 'arri-validate';
 
-const DEFAULT_SERVER_ENTRY_FILE = "__default_arri_server.js";
-const DEFAULT_CODEGEN_FILE = "__default_arri_codegen.js";
-const SERVER_ENTRY_OUTPUT = "server.js";
-const CODEGEN_OUTPUT = "codegen.js";
+const GEN_APP_FILE = "__arri_app.js";
+const GEN_SERVER_ENTRY_FILE = "__arri_server.js";
+const OUT_APP_FILE = "app.js";
+const OUT_SERVER_ENTRY = "server.js";
+const OUT_CODEGEN = "codegen.js";
 async function setupWorkingDir(config) {
   const arriDir = path.resolve(config.rootDir, config.buildDir);
   const outDir = path.resolve(config.rootDir, ".output");
@@ -37,12 +39,15 @@ async function setupWorkingDir(config) {
   await fs.mkdir(arriDir);
   await fs.mkdir(outDir);
 }
-async function createRoutesModule(config) {
+async function createAppWithRoutesModule(config) {
+  const appModule = path.resolve(config.rootDir, config.srcDir, config.entry);
+  const appImportParts = path.relative(path.resolve(config.rootDir, config.srcDir), appModule).split(".");
+  appImportParts.pop();
   const routes = [];
   const existingRoutes = [];
   await Promise.all(
     config.procedureGlobPatterns.map(async (pattern) => {
-      const results = await getVirtualRouteBatch(pattern, config);
+      const results = await getFsRouteBatch(pattern, config);
       for (const result of results) {
         if (!existingRoutes.includes(result.name)) {
           routes.push(result);
@@ -53,22 +58,29 @@ async function createRoutesModule(config) {
   );
   routes.sort((a, b) => a.name < b.name ? -1 : 1);
   const module = await prettier.format(
-    `${routes.map(
+    `import app from './${appImportParts.join(".")}';
+        ${routes.map(
       (route) => `import ${route.importName} from '${route.importPath}';`
     ).join("\n")}
         const routes = [${routes.map(
       (route) => `{ id: '${route.name}', route: ${route.importName} }`
     ).join(",\n")}
         ];
-        export default routes`,
+        for(const route of routes) {
+            app.rpc({
+                name: route.id,
+                ...route.route,
+            });
+        }
+        export default app`,
     { parser: "typescript", tabWidth: 4 }
   );
   await fs.writeFile(
-    path.resolve(config.rootDir, config.buildDir, "routes.js"),
+    path.resolve(config.rootDir, config.buildDir, GEN_APP_FILE),
     module
   );
 }
-async function getVirtualRouteBatch(globPattern, config) {
+async function getFsRouteBatch(globPattern, config) {
   if (!config.procedureDir) {
     return [];
   }
@@ -174,19 +186,15 @@ async function startBuild(config, skipCodeGen = false) {
   logger$2.log("Bundling server....");
   await setupWorkingDir(config);
   await Promise.all([
-    createRoutesModule(config),
-    createBuildEntryModule(config),
-    createBuildCodegenModule(config)
+    createAppWithRoutesModule(config),
+    createServerEntryFile(config),
+    createCodegenEntryFile(config),
+    transpileFiles(config)
   ]);
-  await transpileFiles(config);
-  await bundleFiles(config);
+  await bundleAppEntry(config);
   logger$2.log("Finished bundling");
   const clientCount = config.clientGenerators.length;
-  const codegenModule = path.resolve(
-    config.rootDir,
-    ".output",
-    CODEGEN_OUTPUT
-  );
+  const codegenModule = path.resolve(config.rootDir, ".output", OUT_CODEGEN);
   if (!skipCodeGen) {
     logger$2.log("Generating Arri app definition (__definition.json)");
     execSync(`node ${codegenModule}`, { env: process.env });
@@ -213,48 +221,18 @@ async function startBuild(config, skipCodeGen = false) {
   logger$2.log("Cleaning up files");
   await fs.rm(codegenModule);
   logger$2.success(
-    `Build finished! You can start your server by running "node .output/${SERVER_ENTRY_OUTPUT}"`
+    `Build finished! You can start your server by running "node .output/${OUT_SERVER_ENTRY}"`
   );
 }
-async function bundleFiles(config, allowCodegen = true) {
-  if (allowCodegen) {
-    await build$1({
-      ...config.esbuild,
-      entryPoints: [
-        path.resolve(
-          config.rootDir,
-          config.buildDir,
-          DEFAULT_CODEGEN_FILE
-        )
-      ],
-      platform: config.esbuild.platform ?? "node",
-      target: config.esbuild.target ?? "node20",
-      packages: "external",
-      bundle: true,
-      format: "esm",
-      sourcemap: false,
-      minifyWhitespace: false,
-      banner: {
-        js: `import { createRequire as topLevelCreateRequire } from 'module';
-const require = topLevelCreateRequire(import.meta.url);`
-      },
-      outfile: path.resolve(config.rootDir, ".output", CODEGEN_OUTPUT)
-    });
-  }
-  let buildEntry = path.resolve(
+async function bundleAppEntry(config, allowCodegen = true) {
+  const appEntry = path.resolve(
     config.rootDir,
     config.buildDir,
-    DEFAULT_SERVER_ENTRY_FILE
+    GEN_APP_FILE
   );
-  if (config.buildEntry) {
-    const parts = config.buildEntry.split(".");
-    parts.pop();
-    const mergedParts = `${parts.join(".")}.js`;
-    buildEntry = path.resolve(config.rootDir, config.buildDir, mergedParts);
-  }
   await build$1({
     ...config.esbuild,
-    entryPoints: [buildEntry],
+    entryPoints: [appEntry],
     platform: config.esbuild.platform ?? "node",
     target: config.esbuild.target ?? "node20",
     bundle: true,
@@ -267,11 +245,34 @@ const require = topLevelCreateRequire(import.meta.url);`
 const require = topLevelCreateRequire(import.meta.url);`
     },
     allowOverwrite: true,
-    outfile: path.resolve(config.rootDir, ".output", SERVER_ENTRY_OUTPUT)
+    outfile: path.resolve(config.rootDir, ".output", OUT_APP_FILE)
   });
 }
-async function createBuildEntryModule(config) {
-  if (config.buildEntry) {
+async function createServerEntryFile(config) {
+  if (config.serverEntry) {
+    const buildEntry = path.resolve(
+      config.rootDir,
+      config.srcDir,
+      config.serverEntry
+    );
+    await build$1({
+      ...config.esbuild,
+      entryPoints: [buildEntry],
+      platform: config.esbuild.platform ?? "node",
+      target: config.esbuild.target ?? "node20",
+      bundle: false,
+      packages: "external",
+      format: "esm",
+      sourcemap: true,
+      minifyWhitespace: true,
+      banner: {
+        js: `import { createRequire as topLevelCreateRequire } from 'module';
+const require = topLevelCreateRequire(import.meta.url);`
+      },
+      plugins: [replace({ "virtual:arri/app": "./app.js" })],
+      allowOverwrite: true,
+      outfile: path.resolve(config.rootDir, ".output", OUT_SERVER_ENTRY)
+    });
     return;
   }
   const appModule = path.resolve(config.rootDir, config.srcDir, config.entry);
@@ -279,34 +280,18 @@ async function createBuildEntryModule(config) {
   appImportParts.pop();
   const virtualEntry = `import { toNodeListener } from 'arri';
 import { listen } from 'listhen';
-import routes from './routes.js';
-import app from './${appImportParts.join(".")}.js';
-
-for (const route of routes) {
-    app.rpc({
-        name: route.id,
-        method: route.route.method,
-        params: route.route.params,
-        response: route.route.response,
-        handler: route.route.handler,
-        postHandler: route.route.postHandler,
-    });
-}
+import app from './${OUT_APP_FILE}';
 
 void listen(toNodeListener(app.h3App), {
     port: process.env.PORT ?? ${config.port},
     public: true,
 });`;
   await fs.writeFile(
-    path.resolve(
-      config.rootDir,
-      config.buildDir,
-      DEFAULT_SERVER_ENTRY_FILE
-    ),
+    path.resolve(config.rootDir, ".output", GEN_SERVER_ENTRY_FILE),
     virtualEntry
   );
 }
-async function createBuildCodegenModule(config) {
+async function createCodegenEntryFile(config) {
   const appModule = path.resolve(config.rootDir, config.srcDir, config.entry);
   const appImportParts = path.relative(path.resolve(config.rootDir, config.srcDir), appModule).split(".");
   appImportParts.pop();
@@ -314,20 +299,7 @@ async function createBuildCodegenModule(config) {
     `
     import { writeFileSync } from 'node:fs';
     import path from 'pathe';
-    import app from './${appImportParts.join(".")}.js';
-    import routes from './routes.js';
-
-    for (const route of routes) {
-        app.rpc({
-            name: route.id,
-            method: route.route.method,
-            path: route.route.path,
-            params: route.route.params,
-            response: route.route.response,
-            handler: route.route.handler,
-            postHandler: route.route.postHandler,
-        });
-    }
+    import app from './${OUT_APP_FILE}';
 
     const __dirname = new URL(".", import.meta.url).pathname;
     const def = app.getAppDefinition();
@@ -338,7 +310,7 @@ async function createBuildCodegenModule(config) {
     { tabWidth: 4, parser: "typescript" }
   );
   await fs.writeFile(
-    path.resolve(config.rootDir, config.buildDir, DEFAULT_CODEGEN_FILE),
+    path.resolve(config.rootDir, ".output", OUT_CODEGEN),
     virtualModule
   );
 }
@@ -440,26 +412,26 @@ const dev = defineCommand({
     await startDevServer(config);
   }
 });
-const startListener = (config, showQr = false) => listenAndWatch(
-  path.resolve(config.rootDir, ".output", SERVER_ENTRY_OUTPUT),
-  {
-    public: true,
-    port: config.port,
-    logger: logger$1,
-    qr: showQr
-  }
-);
+const startListener = (config, showQr = false) => listenAndWatch(path.resolve(config.rootDir, ".output", OUT_SERVER_ENTRY), {
+  public: true,
+  port: config.port,
+  logger: logger$1,
+  qr: showQr
+});
 async function bundleFilesContext(config) {
+  const serverContent = `import app from './${OUT_APP_FILE}';
+
+export default app.h3App;`;
+  await fs.writeFile(
+    path.resolve(config.rootDir, ".output", OUT_SERVER_ENTRY),
+    serverContent
+  );
   return await esbuild.context({
     ...config.esbuild,
     entryPoints: [
-      path.resolve(
-        config.rootDir,
-        config.buildDir,
-        DEFAULT_SERVER_ENTRY_FILE
-      )
+      path.resolve(config.rootDir, config.buildDir, GEN_APP_FILE)
     ],
-    outfile: path.resolve(config.rootDir, ".output", SERVER_ENTRY_OUTPUT),
+    outfile: path.resolve(config.rootDir, ".output", OUT_APP_FILE),
     format: "esm",
     bundle: true,
     sourcemap: true,
@@ -471,8 +443,11 @@ async function bundleFilesContext(config) {
 async function startDevServer(config) {
   await setupWorkingDir(config);
   let fileWatcher;
-  await Promise.all([createRoutesModule(config), createEntryModule(config)]);
-  await transpileFiles(config);
+  await Promise.all([
+    createEntryModule(config),
+    createAppWithRoutesModule(config),
+    transpileFiles(config)
+  ]);
   const bundleFiles = await bundleFilesContext(config);
   await bundleFiles.rebuild();
   const listener = await startListener(config, true);
@@ -510,7 +485,7 @@ async function startDevServer(config) {
         if (event === "add" || event === "addDir") {
           return;
         }
-        await createRoutesModule(config);
+        await createAppWithRoutesModule(config);
         let bundleCreated = false;
         try {
           logger$1.log(
@@ -563,28 +538,11 @@ async function createEntryModule(config) {
   appImportParts.pop();
   const virtualEntry = `import { toNodeListener } from 'h3';
 import { listen } from 'listhen';
-import routes from './routes';
-import app from './${appImportParts.join(".")}';
-
-for (const route of routes) {
-    app.rpc({
-        name: route.id,
-        method: route.route.method,
-        path: route.route.path,
-        params: route.route.params,
-        response: route.route.response,
-        handler: route.route.handler,
-        postHandler: route.route.postHandler,
-    });
-}
+import app from './${GEN_APP_FILE}';
 
 export default app.h3App;`;
   await fs.writeFile(
-    path.resolve(
-      config.rootDir,
-      config.buildDir,
-      DEFAULT_SERVER_ENTRY_FILE
-    ),
+    path.resolve(config.rootDir, config.buildDir, GEN_SERVER_ENTRY_FILE),
     virtualEntry
   );
 }

package/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const config = require('./shared/arri.fa32b1ba.cjs');
+const config = require('./shared/arri.2eb37786.cjs');
 const h3 = require('h3');
 require('arri-validate');
 require('arri-codegen-utils');
@@ -13,24 +13,32 @@ exports.ArriRouter = config.ArriRouter;
 exports.DEV_DEFINITION_ENDPOINT = config.DEV_DEFINITION_ENDPOINT;
 exports.DEV_ENDPOINT_ROOT = config.DEV_ENDPOINT_ROOT;
 exports.ErrorResponse = config.ErrorResponse;
+exports.EventStreamConnection = config.EventStreamConnection;
 exports.createRpcDefinition = config.createRpcDefinition;
 exports.defaultConfig = config.defaultConfig;
 exports.defineConfig = config.defineConfig;
 exports.defineError = config.defineError;
+exports.defineEventStreamRpc = config.defineEventStreamRpc;
 exports.defineRoute = config.defineRoute;
 exports.defineRpc = config.defineRpc;
 exports.errorResponseFromValidationErrors = config.errorResponseFromValidationErrors;
+exports.formatSse = config.formatSse;
+exports.formatSseList = config.formatSseList;
 exports.getRpcParamName = config.getRpcParamName;
 exports.getRpcPath = config.getRpcPath;
 exports.getRpcResponseName = config.getRpcResponseName;
 exports.handleH3Error = config.handleH3Error;
 exports.handleRoute = config.handleRoute;
 exports.isArriConfig = config.isArriConfig;
+exports.isEventStreamRpc = config.isEventStreamRpc;
 exports.isResolvedArriConfig = config.isResolvedArriConfig;
 exports.isRpc = config.isRpc;
 exports.isRpcParamSchema = config.isRpcParamSchema;
+exports.registerEventStreamRpc = config.registerEventStreamRpc;
 exports.registerRoute = config.registerRoute;
 exports.registerRpc = config.registerRpc;
+exports.setSseHeaders = config.setSseHeaders;
+exports.validateRpcRequestInput = config.validateRpcRequestInput;
 exports.defineMiddleware = defineMiddleware;
 Object.keys(h3).forEach(function (k) {
     if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = h3[k];

package/dist/index.d.cts

@@ -1,6 +1,6 @@
-import { HttpMethod, RpcHttpMethod, RpcDefinition, AppDefinition, ClientGenerator } from 'arri-codegen-utils';
-import { AObjectSchema, ASchema, InferType, ARecordSchema, ADiscriminatorSchema, a, ValidationError } from 'arri-validate';
-import { H3EventContext, H3Event, Router, App, H3Error } from 'h3';
+import { HttpMethod, RpcHttpMethod, RpcDefinition, SchemaFormProperties, SchemaFormDiscriminator, SchemaFormValues, AppDefinition, ClientGenerator } from 'arri-codegen-utils';
+import { AObjectSchema, ASchema, InferType, a, ValidationError, ARecordSchema, ADiscriminatorSchema } from 'arri-validate';
+import { H3EventContext, H3Event, Router, H3Error, App } from 'h3';
 export * from 'h3';
 import { BuildOptions } from 'esbuild';
 
@@ -44,20 +44,103 @@ 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 const ErrorResponse: AObjectSchema<{
+    statusCode: number;
+    statusMessage: string;
+    stack?: string | undefined;
+    data?: any;
+}, false>;
+type ErrorResponse = a.infer<typeof ErrorResponse>;
+declare function defineError(statusCode: StatusCode, input?: Partial<Omit<ErrorResponse, "statusCode" | "stack">> & {
+    stack?: string;
+}): H3Error;
+declare function errorResponseFromValidationErrors(errors: ValidationError["errors"], prefixText?: string): H3Error;
+type StatusCode = number | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 419 | 420 | 421 | 422 | 423 | 424 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 507 | 511;
+declare function handleH3Error(err: unknown, event: H3Event, onError: ArriOptions["onError"]): Promise<void>;
+
+declare function setSseHeaders(event: H3Event): 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 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;
+    handler: EventStreamRpcHandler<TParams extends RpcParamSchema ? InferType<TParams> : undefined, TResponse extends RpcParamSchema ? InferType<TResponse> : undefined>;
+}
+type EventStreamRpcHandler<TParams, TResponse> = (context: EventStreamRpcHandlerContext<TParams, TResponse>, event: EventStreamRpcEvent<TParams, TResponse>) => void | Promise<void>;
+interface EventStreamRpcEvent<TParams, TResponse> extends RpcEvent<TParams> {
+    connection: EventStreamConnection<TResponse>;
+}
+interface EventStreamRpcHandlerContext<TParams = any, TResponse = any> extends RpcHandlerContext<TParams> {
+    connection: EventStreamConnection<TResponse>;
+}
+interface EventStreamConnectionOptions<TData> {
+    serializer: (input: TData) => string;
+    pingInterval?: number;
+}
+/**
+ * A server sent event
+ */
+interface Sse {
+    id?: string;
+    event?: string;
+    data: string;
+}
+declare function formatSse({ id, data, event }: Sse): string;
+declare function formatSseList(events: Sse[]): string;
+declare class EventStreamConnection<TData> {
+    lastEventId: string | undefined;
+    private readonly writable;
+    private readonly readable;
+    private readonly writer;
+    private readonly encoder;
+    private readonly serializer;
+    private readonly h3Event;
+    private pingInterval;
+    private readonly pingIntervalMs;
+    constructor(event: H3Event, opts: EventStreamConnectionOptions<TData>);
+    /**
+     * Start sending the event stream to the client
+     */
+    start(): void;
+    /**
+     * Publish a new event. Events published with this hook will trigger the `onData()` hooks of any connected clients.
+     */
+    push(data: TData[], eventId?: string): Promise<void>;
+    push(data: TData, eventId?: string): Promise<void>;
+    /**
+     * Publish an error event. This will trigger the `onError` hooks of any connected clients.
+     */
+    pushError(error: ErrorResponse, eventId?: string): Promise<void>;
+    private publishEvents;
+    private publishEvent;
+    private cleanup;
+    /**
+     * Tell clients that the stream has ended and close the connection.
+     */
+    end(): Promise<void>;
+    on(event: "disconnect", callback: () => any): void;
+    on(event: "end", callback: () => any): void;
+}
+declare function registerEventStreamRpc(router: Router, path: string, procedure: EventStreamRpc<any, any> & {
+    name: string;
+}, opts: RouteOptions): void;
+
 type RpcParamSchema<TObjectInner = any, TRecordInner extends ASchema = any, TDiscriminatorInner = any> = AObjectSchema<TObjectInner> | ARecordSchema<TRecordInner> | ADiscriminatorSchema<TDiscriminatorInner>;
 declare function isRpcParamSchema(input: unknown): input is RpcParamSchema;
-interface ArriProcedure<TParams extends RpcParamSchema | undefined, TResponse extends RpcParamSchema | undefined> {
-    description?: string;
+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> {
     method?: RpcHttpMethod;
     path?: string;
+    description?: string;
     params: TParams;
     response: TResponse;
-    handler: ArriProcedureHandler<TParams extends RpcParamSchema ? InferType<TParams> : undefined, TResponse extends RpcParamSchema ? InferType<TResponse> : void>;
-    postHandler?: ArriProcedurePostHandler<TParams extends RpcParamSchema ? InferType<TParams> : undefined, TResponse extends RpcParamSchema ? InferType<TResponse> : undefined>;
-}
-interface ArriNamedProcedure<TParams extends RpcParamSchema | undefined, TResponse extends RpcParamSchema | undefined> extends ArriProcedure<TParams, TResponse> {
-    name: string;
+    isEventStream?: TIsEventStream;
+    pingInterval?: TIsEventStream extends true ? number : undefined;
+    handler: TIsEventStream extends true ? EventStreamRpcHandler<TParams extends RpcParamSchema ? InferType<TParams> : undefined, TResponse extends RpcParamSchema ? InferType<TResponse> : undefined> : RpcHandler<TParams extends RpcParamSchema ? InferType<TParams> : undefined, TResponse extends RpcParamSchema ? InferType<TResponse> : void>;
+    postHandler?: TIsEventStream extends true ? undefined : RpcPostHandler<TParams extends RpcParamSchema ? InferType<TParams> : undefined, TResponse extends RpcParamSchema ? InferType<TResponse> : undefined>;
 }
+type HttpRpc<TParams extends RpcParamSchema | undefined, TResponse extends RpcParamSchema | undefined> = Omit<Rpc<false, TParams, TResponse>, "isEventStream">;
 type HandlerContext = Record<string, any>;
 interface RpcHandlerContext<TParams = undefined> extends HandlerContext, Omit<H3EventContext, "params"> {
     rpcName: string;
@@ -72,31 +155,37 @@ interface RpcEvent<TParams = undefined> extends Omit<H3Event, "context"> {
 interface RpcPostEvent<TParams = undefined, TResponse = undefined> extends Omit<H3Event, "context"> {
     context: RpcPostHandlerContext<TParams, TResponse>;
 }
-type ArriProcedureHandler<TParams, TResponse> = (context: RpcHandlerContext<TParams>, event: RpcEvent<TParams>) => TResponse | Promise<TResponse>;
-type ArriProcedurePostHandler<TParams, TResponse> = (context: RpcPostHandlerContext<TParams, TResponse>, event: RpcPostEvent<TParams, TResponse>) => any;
-declare function isRpc(input: any): input is ArriProcedure<any, any>;
-declare function defineRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined | never = undefined>(config: ArriProcedure<TParams, TResponse>): ArriProcedure<TParams, TResponse>;
-declare function createRpcDefinition(rpcName: string, httpPath: string, procedure: ArriProcedure<any, any>): RpcDefinition;
+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 createRpcDefinition(rpcName: string, httpPath: string, procedure: Rpc<any, any, any>): RpcDefinition;
 declare function getRpcPath(rpcName: string, prefix?: string): string;
-declare function getRpcParamName(rpcName: string, procedure: ArriProcedure<any, any>): string | undefined;
-declare function getRpcResponseName(rpcName: string, procedure: ArriProcedure<any, any>): string | undefined;
-declare function registerRpc(router: Router, path: string, procedure: ArriNamedProcedure<any, any>, opts: RouteOptions): void;
+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 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: <TParams extends AObjectSchema<any, any> | undefined, TResponse extends AObjectSchema<any, any> | undefined>(procedure: ArriNamedProcedure<TParams, TResponse>) => void;
+    rpc: <TIsEventStream extends boolean, TParams extends AObjectSchema<any, any> | undefined, TResponse extends AObjectSchema<any, any> | undefined>(procedure: NamedRpc<TIsEventStream, TParams, TResponse>) => 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;
 }
 declare class ArriRouter implements ArriRouterBase {
     private readonly procedures;
     private readonly routes;
-    rpc<TParams extends AObjectSchema<any, any> | undefined, TResponse extends AObjectSchema<any, any> | undefined>(procedure: ArriNamedProcedure<TParams, TResponse>): void;
+    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;
     route<TPath extends string, TQuery extends AObjectSchema<any, any> = any, TBody extends ASchema<any> = any, TResponse = any>(route: ArriRoute<TPath, TQuery, TBody, TResponse>): void;
-    getProcedures(): ArriNamedProcedure<any, any>[];
+    registerModels(models: ModelMap): void;
+    getProcedures(): NamedRpc<any, any, any>[];
     getRoutes(): ArriRoute<any, any, any, any>[];
+    getModels(): ModelMap;
 }
 
 declare const DEV_ENDPOINT_ROOT = "/__arri_dev__";
 declare const DEV_DEFINITION_ENDPOINT = "/__arri_dev__/__definition";
+type ModelMap = Record<string, SchemaFormProperties | SchemaFormDiscriminator | SchemaFormValues>;
 declare class ArriApp implements ArriRouterBase {
     __isArri__: boolean;
     readonly h3App: App;
@@ -113,8 +202,9 @@ declare class ArriApp implements ArriRouterBase {
     private readonly onError;
     constructor(opts?: ArriOptions);
     use(input: Middleware | ArriRouter): void;
-    rpc<TParams extends AObjectSchema<any, any> | undefined, TResponse extends AObjectSchema<any, any> | undefined>(procedure: ArriNamedProcedure<TParams, TResponse>): 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;
     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;
 }
 interface ArriOptions {
@@ -135,24 +225,10 @@ interface ArriOptions {
     onError?: (error: H3Error, event: MiddlewareEvent) => void | Promise<void>;
 }
 
-declare const ErrorResponse: AObjectSchema<{
-    statusCode: number;
-    statusMessage: string;
-    stack?: string | undefined;
-    data?: any;
-}, false>;
-type ErrorResponse = a.infer<typeof ErrorResponse>;
-declare function defineError(statusCode: StatusCode, input?: Partial<Omit<ErrorResponse, "statusCode" | "stack">> & {
-    stack?: string;
-}): H3Error;
-declare function errorResponseFromValidationErrors(errors: ValidationError["errors"], prefixText?: string): H3Error;
-type StatusCode = number | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 419 | 420 | 421 | 422 | 423 | 424 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 507 | 511;
-declare function handleH3Error(err: unknown, event: H3Event, onError: ArriOptions["onError"]): Promise<void>;
-
 interface ArriConfig {
     port: number;
     entry: string;
-    buildEntry?: string;
+    serverEntry?: string;
     rootDir?: string;
     srcDir?: string;
     procedureDir?: string | false;
@@ -170,4 +246,4 @@ type ResolvedArriConfig = Required<ArriConfig>;
 declare const defaultConfig: Required<ArriConfig>;
 declare function defineConfig(config: ArriConfig): ResolvedArriConfig;
 
-export { ArriApp, type ArriConfig, type ArriNamedProcedure, type ArriOptions, type ArriProcedure, type ArriProcedureHandler, type ArriProcedurePostHandler, type ArriRoute, ArriRouter, type ArriRouterBase, DEV_DEFINITION_ENDPOINT, DEV_ENDPOINT_ROOT, ErrorResponse, type ExtractParam, type ExtractParams, type HandlerContext, type Middleware, type MiddlewareEvent, type MiddlewareEventContext, type PostRouteEvent, type PostRouteEventContext, type ResolvedArriConfig, type RouteEvent, type RouteEventContext, type RouteOptions, type RpcEvent, type RpcHandlerContext, type RpcParamSchema, type RpcPostEvent, type RpcPostHandlerContext, type StatusCode, createRpcDefinition, defaultConfig, defineConfig, defineError, defineMiddleware, defineRoute, defineRpc, errorResponseFromValidationErrors, getRpcParamName, getRpcPath, getRpcResponseName, handleH3Error, handleRoute, isArriConfig, isResolvedArriConfig, isRpc, isRpcParamSchema, registerRoute, registerRpc };
+export { ArriApp, type ArriConfig, type ArriOptions, type ArriRoute, ArriRouter, type ArriRouterBase, DEV_DEFINITION_ENDPOINT, DEV_ENDPOINT_ROOT, ErrorResponse, EventStreamConnection, type EventStreamConnectionOptions, type EventStreamRpc, type EventStreamRpcEvent, 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 Sse, type StatusCode, createRpcDefinition, defaultConfig, defineConfig, defineError, defineEventStreamRpc, defineMiddleware, defineRoute, defineRpc, errorResponseFromValidationErrors, formatSse, formatSseList, getRpcParamName, getRpcPath, getRpcResponseName, handleH3Error, handleRoute, isArriConfig, isEventStreamRpc, isResolvedArriConfig, isRpc, isRpcParamSchema, registerEventStreamRpc, registerRoute, registerRpc, setSseHeaders, validateRpcRequestInput };