@thednp/rpc 0.0.1 → 0.0.5

package/AGENTS.md

@@ -81,7 +81,7 @@ The tsdown.config.ts produces multiple entries:
 
 ## Important Notes
 
-- In dev mode, **only** the Vite dev server and Express/Connect middleware are available
+- In dev mode, **only** the Vite dev server and Express/Connect middleware are available, which means adapters don't work in DEV mode
 - Uses `deno` for linting and formatting (not eslint/prettier)
 - Uses `tsdown` for bundling (not rollup/vite directly)
 - Uses `vitest` for testing with `istanbul` coverage
@@ -97,11 +97,11 @@ The tsdown.config.ts produces multiple entries:
 
 ## Security & Hardening
 
-- **Prefix boundary check**: All adapters use `new RegExp(\`^/${escapeRegExp(rpcPreffix)}/\`)` instead of `startsWith` to prevent path segment bypassing (e.g., `/__rpc-evil/foo` no longer matches prefix `"__rpc"`)
-- **Prefix regex injection prevention**: `rpcPreffix` config string is escaped via `escapeRegExp()` before being embedded in the boundary regex, preventing ReDoS or unintended matching from metacharacters in the prefix
+- **Prefix boundary check**: All adapters use `new RegExp(\`^/${escapeRegExp(rpcPrefix)}/\`)` instead of `startsWith` to prevent path segment bypassing (e.g., `/__rpc-evil/foo` no longer matches prefix `"__rpc"`)
+- **Prefix regex injection prevention**: `rpcPrefix` config string is escaped via `escapeRegExp()` before being embedded in the boundary regex, preventing ReDoS or unintended matching from metacharacters in the prefix
 - **Regex compilation hoisted**: All prefix/path regexes are compiled once at middleware creation time (not per-request), eliminating per-request regex overhead
 - **Koa URL normalization**: Koa adapter parses `ctx.url` through `new URL()` to strip query strings and normalize encoding before prefix checking
-- **Code injection prevention in client module generation**: `getClientModules.ts` validates all interpolated identifiers (`fnName`, `fnEntry`, `rpcPreffix`) against `/^[A-Za-z_$][A-Za-z0-9_$]*$/` (and a path-safe variant allowing `/`) before interpolating into the generated client bundle. This prevents code injection via malicious export names or prefixes containing template literal interpolations (`${...}`), backticks, or `</script>` sequences.
+- **Code injection prevention in client module generation**: `getClientModules.ts` validates all interpolated identifiers (`fnName`, `fnEntry`, `rpcPrefix`) against `/^[A-Za-z_$][A-Za-z0-9_$]*$/` (and a path-safe variant allowing `/`) before interpolating into the generated client bundle. This prevents code injection via malicious export names or prefixes containing template literal interpolations (`${...}`), backticks, or `</script>` sequences.
 - **Body size limits**: Host frameworks cap parsed JSON bodies — Express (`express.json({ limit })`), Fastify (`bodyLimit`), Koa (`koa-body`), Hono (`hono/body-limit`). Rely on your framework's body parser middleware for size limits (see wiki/best-practices.md). The raw stream path in `readBody` does not impose a built-in limit — use framework middleware or a custom body limit handler for defense-in-depth.
 - **Generic 404 responses**: Error messages no longer echo the requested function name, preventing function enumeration
 - **Auth is middleware's responsibility**: Authentication should be handled by middleware registered before `createRPCMiddleware()`. The middleware chain naturally composes — no built-in auth hook is needed.
@@ -113,7 +113,7 @@ The framework's security boundary is the **RPC prefix-gated HTTP endpoint**. Inp
 
 | Input                 | Source                        | Trust Level         | Hardening Applied                                                        |
 | -----------------------| -------------------------------| ---------------------| --------------------------------------------------------------------------|
-| `rpcPreffix` (config) | `rpc.config.ts` / dev options | Developer-trusted   | Escaped before regex; validated before code gen                          |
+| `rpcPrefix` (config) | `rpc.config.ts` / dev options | Developer-trusted   | Escaped before regex; validated before code gen                          |
 | Function export name  | `src/api/server.ts` exports   | Developer-trusted   | Validated against identifier regex before client codegen                 |
 | HTTP request URL      | Untrusted client              | Boundary-filtered   | Prefix regex (escaped, anchored, hoisted); Koa URL normalization         |
 | HTTP request body | Untrusted client | Capped by framework | Framework body parsers cap JSON and raw bodies |

package/CLAUDE.md

@@ -0,0 +1 @@
+AGENTS.md

package/README.md

@@ -1,66 +1,146 @@
 # @thednp/rpc
 
-[![Coverage Status](https://coveralls.io/repos/github/thednp/rpcv/badge.svg)](https://coveralls.io/github/thednp/rpcv)
-[![ci](https://github.com/thednp/rpcv/actions/workflows/ci.yml/badge.svg)](https://github.com/thednp/rpcv/actions/workflows/ci.yml)
+[![Coverage Status](https://coveralls.io/repos/github/thednp/rpc/badge.svg)](https://coveralls.io/github/thednp/rpc)
+[![ci](https://github.com/thednp/rpc/actions/workflows/ci.yml/badge.svg)](https://github.com/thednp/rpc/actions/workflows/ci.yml)
 [![NPM Version](https://img.shields.io/npm/v/@thednp/rpc.svg)](https://www.npmjs.com/package/@thednp/rpc)
+[![JSR Version](https://img.shields.io/jsr/v/@thednp/rpc.svg)](https://jsr.io/@thednp/rpc)
 [![NPM Downloads](https://img.shields.io/npm/dm/@thednp/rpc.svg)](http://npm-stat.com/charts.html?package=@thednp/rpc)
 
-A Vite plugin for automatic RPC generation that is simple, framework agnostic and very simple to use.
+A Vite plugin for automatic RPC generation — simple, framework agnostic, and easy to use.
 
-* Server functions defined in `src/api/server.ts` are auto-scanned, with client modules generated at build time.
-* Typed client `fetch` based modules are generated and available via the RPC plugin.
+## Isomorphic Design
 
-The name stands for RPC via Vite, because that's exactly what it is. No more, no less.
+Server functions defined in `src/api/server.ts` run exclusively on the server. The plugin transforms their imports into client-side fetch stubs, so calling a server function from the client looks and feels like a local call — but the actual execution stays on the server.
+
+The server functions run **isomorphically** within any Vite powered runtime.
 
 ## Why this exists
 
-Most RPC solutions ask you to adopt a new way of thinking. You learn a complex API, you organize your code into a specific structure, for sure they are powerful, they work well and provide excelent DX, but complexity comes with its own drawbacks.
+Most RPC solutions ask you to adopt a new way of thinking, require learning a complex API, some are vendor locked, some even allow you to blend in with your client code (via `"use server"` directive), for sure they are powerful and work well, they provide excellent DX, but complexity always comes with its own drawbacks.
+
+`@thednp/rpc` carves out the niche that wants to do RPC **without the weight of an entire framework**. If your app is a Vite site, a static SPA, or a small server powered by a single middleware — but you still want typed, cancellable, server-only functions callable from the client — you shouldn't have to adopt a full meta-framework, a full-stack router, or a build-time convention just to bridge the two. This plugin gives you that bridge alone: no framework to learn, no runtime to adopt, no vendor to sign up with.
+
+### Simplicity is best
+
+`@thednp/rpc` takes simplicity very seriously:
+<details>
+<summary><b>Server functions should just be functions</b></summary>
+
+You define them in a file, import and call them where you need them. The plugin handles everything in between — system wide configuration, scanning, type inference, client stub generation, middleware registration, request cancellation — without asking you to restructure your codebase.
+</details>
+
+<details>
+<summary><b>The architecture is clean and minimal</b></summary>
+
+* `createFunction.ts` — server-side definition (wrapped handler with `AbortController`)
+* `getClientModules.ts` — build-time code generation (string template with validation)
+* `helpers.ts` — client-side runtime (thin `fetch` based modules)
+* `scanForServerFiles.ts` — file discovery
+* **Adapters** — thin middleware wrappers
+</details>
+
+### Sound mental model
+
+* **Query Engine** — The Brain (something like `@tanstack/react-query` that handles caching, lifecycles, deduplication).
+* **@thednp/rpc** — The Nervous System (isomorphic transport, serialization, client/server bridge, request cancellation).
+* **UI Framework** — The Muscle (Reactive DOM updates).
+
+## What you get
+
+<details>
+<summary><b>File-level server isolation, without directives</b></summary>
+
+Your server code lives in `src/api/server.ts`. The plugin knows it's server code because of where it lives, not because you annotated it. There's no `'use server'` string to forget, no build error when you accidentally leave it out. The boundary is **the file**. That's it.
+</details>
+
+<details>
+<summary><b>One config file for everything</b></summary>
+
+The plugin options live in `rpc.config.ts` at your project root. Adapter choice, URL prefix, middleware hooks — it's all in one place. You set it up once and then you don't think about it again.
+
+You can access config system wide by calling `loadRPCConfig()` within your project server-side code.
+</details>
+
 
-`@thednp/rpc` takes the opposite bet: your **server functions should just be functions**. You define them in a file, import and call them where you need them. The plugin handles everything in between — system wide configuration, scanning, type inference, client stub generation, middleware registration, request cancellation — without asking you to restructure your codebase or learn a new DSL (Domain-Specific Language).
+<details>
+<summary><b>Typed client modules, generated at build time</b></summary>
 
-### The Mental model
-* **Query Engine** The Brain (something like `@tanstack/react-query` that handles caching, lifecycles, deduplication).
-* **@thednp/rpc** The Nervous System (transport, serialization, client/server bridge, request cancellation).
-* **UI Framework** = The Muscle (Reactive DOM updates).
+When you import a server function on the client, the plugin generates a stub that matches your function's exact signature. Change an argument type on the server, and the client types update on the next build. There's no separate codegen command to run, no generated files to commit, no drift between your server and client types.
+</details>
 
-## Features
+<details>
+<summary><b>Cancellation should be easy</b></summary>
 
-- Framework-agnostic core with adapters for **Express**, **Fastify**, **Hono**, and **Koa**
-- Automatic RPC generation — server functions are auto-scanned; client `fetch` based modules are generated at build time
-- File-level server code isolation (no `'use server'` directives required)
-- System-wide configuration via `rpc.config.ts`
-- `AbortController` based request cancellation (via `.cancel()` on the returned handle)
-- TypeScript support with generic type inference
+Every server function call returns a handle with a `cancel()` helper. Under the hood, it's an `AbortController` wired into the fetch request. You don't have to create the controller, pass the signal, or clean up listeners. You just call `cancel()` and the request dies. The server function receives the `AbortSignal` as its first argument, so you can bail out of expensive work early if the client has already moved on.
+</details>
+
+<details>
+<summary><b>Your server framework is your business</b></summary>
+
+The core plugin doesn't care whether you're running Express, Fastify, Hono, or Koa. Adapters for all four are bundled with the package — you import the one you need, register it as middleware, and you're done. If you're building a plain SPA with no server framework at all, the Vite dev server handles RPC requests directly in development. No adapter needed.
+</details>
+
+<details>
+<summary><b>TypeScript throughout</b></summary>
+
+Generic type inference flows from your server function's arguments and return type all the way to the client stub. You get autocomplete for function names, argument types, and return types without writing a single type annotation on the client side.
+</details>
 
 ## Demos
 
-| Example         | Source Code                                                                     | Try online                                                                                |
-| -----------------| ---------------------------------------------------------------------------------| -------------------------------------------------------------------------------------------|
-| SPA - node:http | [examples/spa](https://github.com/thednp/rpcv/tree/master/examples/spa)         | [StackBlitz](https://stackblitz.com/fork/github/thednp/rpcv/tree/master/examples/spa)     |
-| SSR - node:http | [examples/ssr](https://github.com/thednp/rpcv/tree/master/examples/ssr)         | [StackBlitz](https://stackblitz.com/fork/github/thednp/rpcv/tree/master/examples/ssr)     |
-| Express         | [examples/express](https://github.com/thednp/rpcv/tree/master/examples/express) | [StackBlitz](https://stackblitz.com/fork/github/thednp/rpcv/tree/master/examples/express) |
-| Fastify         | [examples/fastify](https://github.com/thednp/rpcv/tree/master/examples/fastify) | [StackBlitz](https://stackblitz.com/fork/github/thednp/rpcv/tree/master/examples/fastify) |
-| Hono            | [examples/hono](https://github.com/thednp/rpcv/tree/master/examples/hono)       | [StackBlitz](https://stackblitz.com/fork/github/thednp/rpcv/tree/master/examples/hono)    |
-| Koa             | [examples/koa](https://github.com/thednp/rpcv/tree/master/examples/koa)         | [StackBlitz](https://stackblitz.com/fork/github/thednp/rpcv/tree/master/examples/koa)     |
+| Example         | Source Code                                                                    | Try online                                                                               |
+| -----------------| --------------------------------------------------------------------------------| ------------------------------------------------------------------------------------------|
+| SPA - node:http | [examples/spa](https://github.com/thednp/rpc/tree/master/examples/spa)         | [StackBlitz](https://stackblitz.com/fork/github/thednp/rpc/tree/master/examples/spa)     |
+| SSR - node:http | [examples/ssr](https://github.com/thednp/rpc/tree/master/examples/ssr)         | [StackBlitz](https://stackblitz.com/fork/github/thednp/rpc/tree/master/examples/ssr)     |
+| Express         | [examples/express](https://github.com/thednp/rpc/tree/master/examples/express) | [StackBlitz](https://stackblitz.com/fork/github/thednp/rpc/tree/master/examples/express) |
+| Fastify         | [examples/fastify](https://github.com/thednp/rpc/tree/master/examples/fastify) | [StackBlitz](https://stackblitz.com/fork/github/thednp/rpc/tree/master/examples/fastify) |
+| Hono            | [examples/hono](https://github.com/thednp/rpc/tree/master/examples/hono)       | [StackBlitz](https://stackblitz.com/fork/github/thednp/rpc/tree/master/examples/hono)    |
+| Koa             | [examples/koa](https://github.com/thednp/rpc/tree/master/examples/koa)         | [StackBlitz](https://stackblitz.com/fork/github/thednp/rpc/tree/master/examples/koa)     |
 
+> **NOTE**: Stackblitz is currently working on upgrading their platform. Demos may not work properly. 
 
 ## Examples
 
-| Example | Adapter                                       | Type | Run Command        |
-| ---------| -----------------------------------------------| ------| --------------------|
-| spa     | Vite dev server (Connect, Express-compatible) | SPA  | `pnpm dev`         |
-| express | Express                                       | SSR  | `pnpm dev:express` |
-| fastify | Fastify                                       | SSR  | `pnpm dev:fastify` |
-| hono    | Hono                                          | SSR  | `pnpm dev:hono`    |
-| koa     | Koa                                           | SSR  | `pnpm dev:koa`     |
-| ssr     | Custom `node:http` (Express-compatible)       | SSR  | `pnpm dev:ssr`     |
+| Example | Adapter                                       | Type | Run Command        | RPC Approach                       |
+| ---------| -----------------------------------------------| ------| --------------------| ------------------------------------|
+| spa     | Vite dev server (Connect, Express-compatible) | SPA  | `pnpm dev`         | Client stubs only                  |
+| express | Express                                       | SSR  | `pnpm dev:express` | Direct import (SSR) + client stubs |
+| fastify | Fastify                                       | SSR  | `pnpm dev:fastify` | Direct import (SSR) + client stubs |
+| hono    | Hono                                          | SSR  | `pnpm dev:hono`    | Direct import (SSR) + client stubs |
+| koa     | Koa                                           | SSR  | `pnpm dev:koa`     | Direct import (SSR) + client stubs |
+| ssr     | Custom `node:http` (Express-compatible)       | SSR  | `pnpm dev:ssr`     | Direct import (SSR) + client stubs |
+
+SSR examples demonstrate isomorphic usage: server functions are imported directly during server-side rendering (`entry-server.ts`) and also called from the client via auto-generated fetch stubs. The SPA example uses only the client-side stubs.
 
 ## Quick Start
 
 ### 1. Installation
 
 ```bash
-pnpm add @thednp/rpc@latest
+// npm/pnpm and jsr
+pnpm add jsr:@thednp/rpc
+// OR
+npx jsr add @thednp/rpc
+```
+
+```bash
+// deno and jsr
+deno add jsr:@thednp/rpc
+```
+
+```bash
+// pnpm/npm/bun from the npm registry
+pnpm add @thednp/rpc
+```
+
+```bash
+// npm
+npm i @thednp/rpc
+```
+
+```bash
+// bun
+bun add @thednp/rpc
 ```
 
 ### 2. Configuration
@@ -72,7 +152,7 @@ import { defineConfig } from "@thednp/rpc";
 
 export default defineConfig({
   adapter: "express",
-  rpcPreffix: "__rpc",
+  rpcPrefix: "__rpc",
 });
 ```
 
@@ -88,6 +168,8 @@ export default defineConfig({
 
 ```
 
+Check [Configuration Guide](wiki/configuration.md) for details.
+
 ### 3. Define a server function
 
 Create `src/api/server.ts`:
@@ -112,9 +194,11 @@ Create `src/api/index.ts`:
 export * from "./server";
 ```
 
-### 4. Call it from the client
+Check [Server Functions Guide](./wiki/server-functions.md) for details.
+
+### 4. Call it in your code
 
-Import the generated client module in any client-side file:
+Import the function in any client-side or server-side file:
 
 ```ts
 // src/app.ts
@@ -122,12 +206,25 @@ import { greet } from "./api";
 
 const { data, cancel } = greet("World");
 const result = await data; // "Hello, World!"
-cancel(); // AbortController-based cancellation
+cancel("Client aborted"); // AbortController-based cancellation
 ```
 
 ### 5. Register the RPC middleware on the server
 
-Import and use the middleware from your chosen adapter package. See the [Adapters guide](./wiki/adapters.md) for full snippets for each framework.
+Import and use the middleware from your chosen adapter package.
+
+```ts
+// Express
+import express from "express";
+import { createRPCMiddleware } from "@thednp/rpc/express";
+
+const app = express();
+app.use(createRPCMiddleware());
+
+app.listen(3000);
+```
+
+See the [Adapters guide](./wiki/adapters.md) for full snippets for each framework.
 
 ## Testing
 
@@ -153,14 +250,65 @@ These tests check the following:
 * check if there is any issue generating the HTML
 * check if server functions work properly
 
+## Contributing
+
+Contributions are welcome. This project uses:
+
+- **pnpm** for package management
+- **deno** for linting and formatting
+- **tsdown** for bundling
+- **vitest** with **istanbul** for testing
+- **TypeScript** for type checking
+
+### Development
+
+```bash
+pnpm lint         # deno lint + tsc -noEmit
+pnpm format       # deno fmt src
+pnpm test         # Run tests with coverage
+pnpm test-ui      # Run tests with interactive UI 
+pnpm build        # Bundle with tsdown
+```
+
+All changes should pass `pnpm lint && pnpm format && pnpm test` before submitting. See [AGENTS.md](./AGENTS.md) for the full command reference and project conventions.
+
 ## Security
 
-- Prefix boundary check via anchored regex — prevents `/__rpc-evil/foo` bypass
-- Body size limit: `readBody` caps raw text/plain streams at 1 MiB by default
-- Code injection prevention: all interpolated identifiers are validated before client module generation
-- Generic error responses — no stack traces or internal details exposed to the client
+RPC endpoints are, by definition, public surface area. Anything reachable over HTTP can be prodded, poked, and abused. We've tried to close the obvious doors:
+
+<details>
+<summary><b>Prefix boundary checking</b></summary>
+
+The URL prefix is validated with an anchored regex, not a simple `startsWith` check. This means a request to `/__rpc-evil/foo` won't accidentally match the `/__rpc` prefix and slip through to your server functions. It sounds like a small thing, but prefix bypass bugs are one of the most common mistakes in middleware-based routing, and they're the kind of thing that only shows up in a security audit at 2am.
+</details>
+
+<details>
+<summary><b>Code injection prevention</b></summary>
+
+When the plugin generates client modules, it interpolates your function names and type signatures into the generated code. Every identifier is validated before it's written into the output. A server function named `greet; drop table users` won't make it through the generator — it'll fail at build time with a clear error, rather than producing a client module with arbitrary code in it.
+</details>
+
+<details>
+<summary><b>Generic error responses</b></summary>
+
+When a server function throws, the client receives a clean, generic error message. Stack traces, file paths, database connection strings, and other internal details stay on the server, where they belong. Your server logs get the full error. The client gets `"Internal Server Error"` and nothing more.
+</details>
+
+<details>
+<summary><b>Body size limits</b></summary>
+
+The `readBody` utility of each adapter doesn't cap raw request bodies by default. You need to use the middleware provided by your server framework of choice.
+</details>
+
+<details>
+<summary><b>Method restriction (GET/POST only)</b></summary>
+
+Server functions only support `GET` and `POST` (default `POST`). RPC dispatch is not REST — `PUT`/`PATCH`/`DELETE` carry resource semantics that don't apply to function calls, and `OPTIONS` must stay reserved for CORS preflight. Every accepted method is another dispatch path to validate; keeping the surface minimal (and defaulting to `POST`) reduces CSRF and parsing attack surface. See [Server Functions Guide](./wiki/server-functions.md) for details.
+</details>
+
+---
+The full threat model, including edge cases and configuration options for tightening things further, is documented in [Security](./wiki/security.md).
 
-See [Security](./wiki/security.md) for full details.
 
 ## Documentation
 
@@ -175,4 +323,4 @@ See [Security](./wiki/security.md) for full details.
 
 ## License
 
-Released under [MIT](LICENSE).
+Released under [MIT](./LICENSE).

package/dist/express/express.d.mts

@@ -1,39 +1,133 @@
 import { Connect, ViteDevServer } from "vite";
 import { BodyResult, JsonValue, MiddlewareOptions, RpcPluginOptions } from "@thednp/rpc";
-import { IncomingMessage, ServerResponse } from "node:http";
+import { IncomingHttpHeaders, IncomingMessage, ServerResponse } from "node:http";
 import { Express, NextFunction, Request, Response } from "express";
 //#region src/express/types.d.ts
+/**
+ * Express-specific middleware options, constrained to the `"express"` adapter.
+ */
 type ExpressMiddlewareOptions = MiddlewareOptions<"express">;
+/**
+ * Express middleware factory: takes optional initial options and returns
+ * the Express/Connect-compatible handler.
+ */
 type ExpressMiddlewareFn = <A extends RpcPluginOptions["adapter"] = "express">(initialOptions?: Partial<ExpressMiddlewareOptions>) => ExpressMiddlewareHooks["handler"];
+/**
+ * Express/Connect middleware handler signature used by the RPC middleware.
+ */
 interface ExpressMiddlewareHooks {
+  /**
+   * The handler invoked for each matched request.
+   * @param req - Node or Express request object
+   * @param res - Node or Express response object
+   * @param next - Connect or Express next function
+   */
   handler: (req: IncomingMessage | Request, res: ServerResponse | Response, next: Connect.NextFunction | NextFunction) => Promise<void>;
 }
+/**
+ * Wraps a server response to normalize status, header, and send operations
+ * across Node `ServerResponse` and Express `Response` objects.
+ */
+type ResponseDetails = {
+  /** Whether the response was already sent */
+  isResponseSent: boolean;
+  /** Sets a response header */
+  setHeader: (name: string, value: string) => void;
+  /** Current response status code */
+  statusCode: number;
+  /** Sets the response status code */
+  setStatusCode: (code: number) => void;
+  /** Sends a JSON response with the given status code and output */
+  sendResponse: (code: number, output: Record<string, JsonValue>) => void;
+};
+/**
+ * Normalized view of an incoming request: URL parts, headers, and method.
+ */
+type RequestDetails = {
+  /** Full request URL (path + query string) */
+  url: string;
+  /** Query string including the leading `?` */
+  search: string;
+  /** Parsed query string parameters */
+  searchParams: URLSearchParams;
+  /** Raw request headers */
+  headers: IncomingHttpHeaders;
+  /** HTTP method (GET, POST, etc.) */
+  method: string | undefined;
+};
 //#endregion
 //#region src/express/createMiddleware.d.ts
+/**
+ * Creates an Express middleware with optional path and rpcPrefix filtering.
+ * Middleware names are deduplicated — reusing a name throws an error.
+ * Prefix and path regexes are compiled once at creation time (hoisted) for performance.
+ * @param initialOptions - Options for rpcPrefix, path matching, and the handler function
+ * @returns An Express middleware function
+ */
 declare const createMiddleware: ExpressMiddlewareFn;
+/**
+ * Creates the Express RPC middleware that routes incoming requests to registered server functions.
+ * Reads the request body, dispatches to the matching function via serverFunctionsMap,
+ * and sends the JSON-serialized result. Handles client disconnection via abort signals.
+ * @param initialOptions - Options including rpcPrefix for URL routing
+ * @returns An Express middleware function
+ */
 declare const createRPCMiddleware: ExpressMiddlewareFn;
 //#endregion
 //#region src/express/helpers.d.ts
+/**
+ * Convenience function to load RPC config and attach the RPC middleware to an Express app.
+ * Dynamically imports loadRPCConfig and creates the middleware with loaded options.
+ * @param app - Express application instance
+ */
 declare function attachRPC(app: Express): Promise<void>;
+/**
+ * Attaches Vite's dev server middlewares to an Express app for development mode.
+ * @param app - Express application instance
+ * @param vite - Running Vite dev server
+ */
 declare function attachVite(app: Express, vite: ViteDevServer): void;
+/**
+ * Reads and parses the HTTP request body from an Express or Node IncomingMessage.
+ * If a body parser middleware (e.g. express.json()) already consumed the stream,
+ * uses the pre-parsed body from `req.body`.
+ * @param req - Express or Node.js IncomingMessage
+ * @returns A promise resolving to the parsed body with its content type
+ */
 declare const readBody: (req: Request | IncomingMessage) => Promise<BodyResult>;
+/**
+ * Type guard that checks whether a request is an Express Request (has `originalUrl`).
+ * @param req - A Node IncomingMessage or Express Request
+ * @returns True if the request is an Express Request
+ */
 declare const isExpressRequest: (req: IncomingMessage | Request) => req is Request;
+/**
+ * Type guard that checks whether a response is an Express Response (has `json` and `send` methods).
+ * @param res - A Node ServerResponse or Express Response
+ * @returns True if the response is an Express Response
+ */
 declare const isExpressResponse: (res: ServerResponse | Response) => res is Response;
+/**
+ * Type guard that checks whether a request has a pre-parsed body (`body` property).
+ * Used to detect if a body-parser middleware already consumed the stream.
+ * @param req - A Node IncomingMessage or Express Request
+ * @returns True if the request has a body property
+ */
 declare const hasPreParsedBody: (req: IncomingMessage | Request) => req is Request;
-declare const getRequestDetails: (request: Request | IncomingMessage) => {
-  url: string;
-  search: string;
-  searchParams: URLSearchParams;
-  headers: import("node:http").IncomingHttpHeaders;
-  method: string | undefined;
-};
-declare const getResponseDetails: (response: Response | ServerResponse) => {
-  isResponseSent: boolean;
-  setHeader: (name: string, value: string) => void;
-  statusCode: number;
-  setStatusCode: (code: number) => void;
-  sendResponse: (code: number, output: Record<string, JsonValue>) => void;
-};
+/**
+ * Extracts normalized request details from an Express or Node IncomingMessage.
+ * Parses the URL to extract pathname, search string, and search params.
+ * @param request - Express or Node.js request object
+ * @returns Normalized request details including URL, headers, and method
+ */
+declare const getRequestDetails: (request: Request | IncomingMessage) => RequestDetails;
+/**
+ * Wraps an Express or Node ServerResponse with a uniform API for setting headers,
+ * status codes, and sending JSON responses. Handles the Express vs raw Node API differences.
+ * @param response - Express or Node.js server response object
+ * @returns A ResponseDetails object with setHeader, setStatusCode, and sendResponse helpers
+ */
+declare const getResponseDetails: (response: Response | ServerResponse) => ResponseDetails;
 //#endregion
-export { type ExpressMiddlewareFn, type ExpressMiddlewareHooks, type ExpressMiddlewareOptions, attachRPC, attachVite, createMiddleware, createRPCMiddleware, getRequestDetails, getResponseDetails, hasPreParsedBody, isExpressRequest, isExpressResponse, readBody };
+export { type ExpressMiddlewareFn, type ExpressMiddlewareHooks, type ExpressMiddlewareOptions, type RequestDetails, type ResponseDetails, attachRPC, attachVite, createMiddleware, createRPCMiddleware, getRequestDetails, getResponseDetails, hasPreParsedBody, isExpressRequest, isExpressResponse, readBody };
 //# sourceMappingURL=express.d.mts.map

package/dist/express/express.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"express.d.mts","names":[],"sources":["../../src/express/types.d.ts","../../src/express/createMiddleware.ts","../../src/express/helpers.ts"],"mappings":";;;;;KAKY,2BAA2B;KAE3B,uBACV,UAAU,yCAEV,iBAAiB,QAAQ,8BACtB;UAEY;EACf,UACE,KAAK,kBAAkB,SACvB,KAAK,iBAAiB,UACtB,MAAM,QAAQ,eAAe,iBAC1B;;;;cCGM,kBAAkB;cAmElB,qBAAqB;;;iBC5EZ,UAAU,KAAK,UAAO;iBAM5B,WAAW,KAAK,SAAS,MAAM;cAKlC,WAAQ,KACd,UAAiB,oBACrB,QAAQ;cAsDE,mBAAgB,KACtB,kBAAkB,YACtB,OAAO;cAIG,oBAAiB,KACvB,iBAAiB,aACrB,OAAO;cAIG,mBAAgB,KACtB,kBAAkB,YACtB,OAAO;cAIG,oBAAiB,SACnB,UAAiB;EAQxB;EACA;EACA,cAAY;EACZ,6BAAO;EACP;;cAIS,qBAAkB,UACnB,WAAkB;;EAIH,YAAA,cAAM;;EAQF,gBAAA;EAQD,eAAA,cAAM,QAAU,eAAe"}
+{"version":3,"file":"express.d.mts","names":[],"sources":["../../src/express/types.d.ts","../../src/express/createMiddleware.ts","../../src/express/helpers.ts"],"mappings":";;;;;;;;KAgBY,2BAA2B;;;;;KAM3B,uBACV,UAAU,yCAEV,iBAAiB,QAAQ,8BACtB;;;;UAKY;;;;;;;EAOf,UACE,KAAK,kBAAkB,SACvB,KAAK,iBAAiB,UACtB,MAAM,QAAQ,eAAe,iBAC1B;;;;;;KAOK;;EAEV;;EAEA,YAAY,cAAc;;EAE1B;;EAEA,gBAAgB;;EAEhB,eAAe,cAAc,QAAQ,eAAe;;;;;KAM1C;;EAEV;;EAEA;;EAEA,cAAc;;EAEd,SAAS;;EAET;;;;;;;;;;;cCtCW,kBAAkB;;;;;;;;cAyElB,qBAAqB;;;;;;;;iBC5FZ,UAAU,KAAK,UAAO;;;;;;iBAW5B,WAAW,KAAK,SAAS,MAAM;;;;;;;;cAWlC,WAAQ,KACd,UAAiB,oBACrB,QAAQ;;;;;;cA2DE,mBAAgB,KACtB,kBAAkB,YACtB,OAAO;;;;;;cASG,oBAAiB,KACvB,iBAAiB,aACrB,OAAO;;;;;;;cAUG,mBAAgB,KACtB,kBAAkB,YACtB,OAAO;;;;;;;cAUG,oBAAiB,SACnB,UAAiB,oBACzB;;;;;;;cAqBU,qBAAkB,UACnB,WAAkB,mBAC3B"}