@thednp/rpc 0.2.1 → 0.3.1

package/dist/server/server.d.mts

@@ -1,15 +1,95 @@
-import { ResolvedConfig, ViteDevServer } from "vite";
+import { Connect, ResolvedConfig, ViteDevServer } from "vite";
 import "@thednp/rpc";
-import "express";
-import "hono";
+import { IncomingMessage, ServerResponse } from "node:http";
+import { NextFunction, Request, Response as Response$1 } from "express";
+import { MiddlewareHandler } from "hono";
 import "@hono/node-server";
 import "hono/utils/http-status";
 import "hono/factory";
-import "fastify";
+import { FastifyReply, FastifyRequest, HookHandlerDoneFunction } from "fastify";
 import "fastify-plugin";
-import "koa";
-import "h3";
+import { Context, Next } from "koa";
+import { Middleware } from "h3";
+//#region src/express/types.d.ts
+/**
+ * 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$1, next: Connect.NextFunction | NextFunction) => Promise<void>;
+}
+//#endregion
+//#region src/hono/types.d.ts
+/**
+ * Hono middleware handler signature used by the RPC middleware.
+ */
+interface HonoMiddlewareHooks {
+  /** Hono middleware handler */
+  handler: MiddlewareHandler;
+}
+//#endregion
+//#region src/fastify/types.d.ts
+/**
+ * Fastify middleware handler signature used by the RPC middleware.
+ */
+interface FastifyMiddlewareHooks {
+  /**
+   * The handler invoked for each matched request.
+   * @param req - Fastify request object
+   * @param res - Fastify reply object
+   * @param done - Fastify hook completion callback
+   */
+  handler: (req: FastifyRequest, res: FastifyReply, done: HookHandlerDoneFunction) => Promise<void>;
+}
+//#endregion
+//#region src/koa/types.d.ts
+/**
+ * Koa middleware handler signature used by the RPC middleware.
+ */
+interface KoaMiddlewareHooks {
+  /**
+   * The handler invoked for each matched request.
+   * @param ctx - Koa context object
+   * @param next - Koa next function
+   */
+  handler: (ctx: Context, next: Next) => Promise<void>;
+}
+//#endregion
+//#region src/h3/types.d.ts
+/**
+ * h3 middleware handler signature used by the RPC middleware.
+ */
+interface H3MiddlewareHooks {
+  /**
+   * The handler invoked for each matched request.
+   * @param event - h3 event object
+   * @param next - h3 next function
+   */
+  handler: Middleware;
+}
+//#endregion
 //#region src/types.d.ts
+/**
+ * Maps each supported framework adapter to its middleware hooks (handler signatures).
+ * Used to keep the middleware options type-safe per adapter.
+ */
+interface FrameworkHooks {
+  /** Express/Connect middleware handler signature */
+  express: ExpressMiddlewareHooks;
+  /** Hono middleware handler signature */
+  hono: HonoMiddlewareHooks;
+  /** Fastify middleware handler signature */
+  fastify: FastifyMiddlewareHooks;
+  /** Koa middleware handler signature */
+  koa: KoaMiddlewareHooks;
+  /** h3 middleware handler signature */
+  h3: H3MiddlewareHooks;
+}
 /**
  * Content types the RPC client modules send with each request.
  */
@@ -40,6 +120,11 @@ interface ServerFunctionOptions {
    * @default "POST"
    */
   method?: "GET" | "POST";
+  /**
+   * RPC endpoint prefix
+   * @default "__rpc"
+   */
+  rpcPrefix?: string;
 }
 // primitives and their compositions
 /**
@@ -98,12 +183,14 @@ interface RpcPluginOptionsInternal {
 /**
  * Partial Vite config used when scanning server files outside a running dev server.
  */
-type ScanConfig = Pick<ResolvedConfig, "base"> & {
+interface ScanConfig extends Pick<ResolvedConfig, "base"> {
   root?: string;
   server?: Partial<ResolvedConfig["server"]>;
   serverFiles?: "exact" | "glob";
   scanRoot?: string;
-};
+  /** Default rpcPrefix to register scanned functions under when a function does not declare its own. Defaults to `__rpc` for backward compatibility. */
+  rpcPrefix?: string;
+}
 /**
  * Entry in the server functions map: registered name, client handler,
  * optional per-function options, and the original export name.
@@ -158,8 +245,91 @@ interface RpcPluginOptions {
    */
   serverFiles?: "exact" | "glob";
 }
+interface MiddlewareOptions<A extends RpcPluginOptions["adapter"] = "express"> {
+  /**
+   * Name for the middleware (used for identification in Express stack)
+   */
+  name?: string;
+  /**
+   * Path pattern to match for middleware execution.
+   * Accepts string or RegExp to filter requests based on URL path.
+   *
+   * @example
+   * // String path
+   * path: "/api/v1"
+   *
+   * // RegExp pattern
+   * path: /^\/api\/v[0-9]+/
+   */
+  path?: string | RegExp;
+  /**
+   * RPC prefix without leading slash (e.g. "__rpc")
+   * Leading slash will be added automatically by the middleware.
+   * This prefix defines the base path for all RPC endpoints.
+   * @default string
+   * @example
+   * // Results in endpoints like: /api/rpc/myFunction
+   * rpcPrefix: "api/rpc"
+   */
+  rpcPrefix?: string | false;
+  /**
+   * Allowed request origin (e.g. "https://example.com").
+   * When set, any request carrying an `Origin` header that does not match
+   * is rejected with a 403 Forbidden response. Requests without an `Origin`
+   * header (curl, native clients) pass through unchecked.
+   * When unset (default), no origin validation is performed.
+   */
+  origin?: string;
+  /**
+   * Server file matching mode. Use `"exact"` for `server.ts|js|mjs|mts`
+   * names, or `"glob"` to match `**\/*.server.{ts,js,mjs,mts}` inside the
+   * scan root. Only used for the lazy production scan when the middleware
+   * populates its prefix map on first request.
+   * @default "exact"
+   */
+  serverFiles?: "exact" | "glob";
+  /**
+   * Root directory for scanning server files. Defaults to `<root>/src/api`.
+   * Only used for the lazy production scan.
+   */
+  scanRoot?: string;
+  /**
+   * Async handler for request processing.
+   * Core middleware function that processes incoming requests.
+   *
+   * @param req - The incoming request object
+   * @param res - The server response object
+   * @param next - Function to pass control to the next middleware
+   *
+   * @example
+   * handler: async (req, res, next) => {
+   *   // Process request
+   *   const data = await processRequest(req);
+   *
+   *   // Send response
+   *   sendResponse(res, { data }, 200);
+   * }
+   */
+  handler?: FrameworkHooks[A]["handler"];
+}
 //#endregion
 //#region src/functionsMap.d.ts
+/**
+ * Map of rpcPrefix -> Map of function names -> ServerFnEntry
+ * Enables multiple RPC instances with different prefixes to coexist
+ * without name collisions.
+ */
+declare const serverFunctionsByPrefix: Map<string, Map<string, ServerFnEntry>>;
+/**
+ * Gets or creates the function map for a specific prefix.
+ * @param prefix - The RPC prefix (e.g., "__rpc", "v1:rpc", "admin:rpc")
+ * @returns Map of function names to ServerFnEntry for that prefix
+ */
+declare const getFunctionsForPrefix: (prefix: string) => Map<string, ServerFnEntry>;
+/**
+ * Backward compatibility: default map for the default prefix.
+ * Legacy code can still use serverFunctionsMap.set(name, entry).
+ */
 declare const serverFunctionsMap: Map<string, ServerFnEntry>;
 //#endregion
 //#region src/scanForServerFiles.d.ts
@@ -167,7 +337,7 @@ declare const serverFunctionsMap: Map<string, ServerFnEntry>;
 declare const scannedServerFiles: Set<string>;
 /**
  * Scans `src/api/` (or an explicit `scanRoot`) for server function files
- * and populates the global `serverFunctionsMap` with their exported functions.
+ * and populates the server functions map (scoped by rpcPrefix) with their exported functions.
  * Uses Vite's SSR module loading to resolve and execute each file.
  *
  * Supports two matching modes via `config.serverFiles`:
@@ -179,22 +349,49 @@ declare const scannedServerFiles: Set<string>;
 declare const scanForServerFiles: (initialCfg?: ScanConfig, devServer?: ViteDevServer) => Promise<void>;
 //#endregion
 //#region src/createFunction.d.ts
+/**
+ * Extended options for createServerFunction, including rpcPrefix for multi-instance support.
+ */
+interface CreateServerFunctionOptions extends Partial<ServerFunctionOptions> {
+  /**
+   * RPC prefix for this function. Enables multiple RPC instances with different prefixes.
+   * When using multi-prefix setup, functions with the same name but different prefixes
+   * can coexist without collision.
+   * @default "__rpc"
+   * @example
+   * // v1 API
+   * export const login = createServerFunction(
+   *   "login",
+   *   async (signal, email, password) => ({...}),
+   *   { rpcPrefix: "v1:rpc" },
+   * );
+   *
+   * // v2 API - same function name, different prefix
+   * export const login = createServerFunction(
+   *   "login",
+   *   async (signal, credentials) => ({...}),
+   *   { rpcPrefix: "v2:rpc" },
+   * );
+   */
+  rpcPrefix?: string;
+}
 /**
  * Creates a server-side RPC function.
- * Registers the function in the server functions map and returns a client-compatible
- * wrapper that exposes `data` (Promise) and `cancel` (function) for request lifecycle control.
+ * Registers the function in the server functions map (scoped by rpcPrefix) and returns
+ * a client-compatible wrapper that exposes `data` (Promise) and `cancel` (function)
+ * for request lifecycle control.
  * @param name - Unique identifier used by the RPC router to dispatch requests
  * @param handler - The actual implementation receiving an AbortSignal followed by JSON-serializable arguments
- * @param fnOptions - Optional contentType and credentials settings
+ * @param fnOptions - Optional contentType, credentials, and rpcPrefix settings
  * @returns A client stub with `data` promise and `cancel` method, auto-registered in the server map
  */
-declare function createServerFunction<TArgs extends JsonArray = JsonArray, TResult extends JsonValue = JsonValue>(name: string, handler: ServerFunctionInit<TArgs, TResult>, fnOptions?: Partial<ServerFunctionOptions>): ClientFunction<TArgs, TResult>;
+declare function createServerFunction<TArgs extends JsonArray = JsonArray, TResult extends JsonValue = JsonValue>(name: string, handler: ServerFunctionInit<TArgs, TResult>, fnOptions?: CreateServerFunctionOptions): ClientFunction<TArgs, TResult>;
 //#endregion
 //#region src/getClientModules.d.ts
 /**
  * Generates the complete client-side module bundle by iterating all registered server functions
- * and producing fetch-based stubs for each. The result is transformed by Vite (or Oxc) during
- * the dev server or production build.
+ * for a specific prefix and producing fetch-based stubs for each. The result is transformed by Vite
+ * (or Oxc) during the dev server or production build.
  * @param initialOptions - Plugin options containing rpcPrefix and optional adapter
  * @returns A string of JavaScript code with all client RPC modules and their import dependencies
  */
@@ -267,6 +464,9 @@ declare function escapeRegExp(s: string): string;
  * @returns A URL object; never throws
  */
 declare const safeURL: (rawUrl: string, base?: string) => URL;
+/** Global rpcPrefix from the last loaded config / middleware — fallback for functions without explicit prefix. */
+declare const getGlobalPrefix: () => string | undefined;
+declare const setGlobalPrefix: (prefix: string | undefined) => void;
 //#endregion
 //#region src/context.d.ts
 /**
@@ -404,17 +604,10 @@ interface RequestMeta {
 declare const getRequestMeta: (event: RequestEvent) => RequestMeta;
 //#endregion
 //#region src/options.d.ts
-declare const defaultServerFnOptions: {
-  contentType: "application/json";
-  credentials: "same-origin";
-  method: "POST";
-};
+declare const defaultServerFnOptions: ServerFunctionOptions;
+declare const defaultPrefix = "__rpc";
 declare const defaultRPCOptions: RpcPluginOptions;
-declare const defaultMiddlewareOptions: {
-  rpcPrefix: undefined;
-  path: undefined;
-  origin: undefined;
-};
+declare const defaultMiddlewareOptions: MiddlewareOptions;
 //#endregion
-export { RPCError, RequestEvent, RequestMeta, createServerFunction, defaultMiddlewareOptions, defaultRPCOptions, defaultServerFnOptions, escapeRegExp, formatError, getClientModules, getRequestContext, getRequestMeta, hasContentTypeMismatch, isFormContentType, provideRequestContext, redirect, safeURL, scanForServerFiles, scannedServerFiles, sendResponse, serverFunctionsMap, walkGlobFiles };
+export { CreateServerFunctionOptions, RPCError, RequestEvent, RequestMeta, createServerFunction, defaultMiddlewareOptions, defaultPrefix, defaultRPCOptions, defaultServerFnOptions, escapeRegExp, formatError, getClientModules, getFunctionsForPrefix, getGlobalPrefix, getRequestContext, getRequestMeta, hasContentTypeMismatch, isFormContentType, provideRequestContext, redirect, safeURL, scanForServerFiles, scannedServerFiles, sendResponse, serverFunctionsByPrefix, serverFunctionsMap, setGlobalPrefix, walkGlobFiles };
 //# sourceMappingURL=server.d.mts.map

package/dist/server/server.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.mts","names":[],"sources":["../../src/types.d.ts","../../src/functionsMap.ts","../../src/scanForServerFiles.ts","../../src/createFunction.ts","../../src/getClientModules.ts","../../src/server-helpers.ts","../../src/context.ts","../../src/options.ts"],"mappings":";;;;;;;;;;;;;;;KAkEY;;;;KASA;;;;;UAkBK;;;;;EAKf,aAAa;;;;;EAKb,cAAc;;;;;;;EAOd;;;;;;KAOU;;;;KAIA;GAAgB,cAAc,YAAY;;;;;KAI1C,aAAa,WAAW;;;;KAIxB,YAAY,gBAAgB,YAAY;;;;;KAsCxC,mBACV,cAAc,WAAW,YAAY,WACrC,gBAAgB,YAAY,cACzB,QAAQ,gBAAgB,MAAM,UAAU,QAAQ;;;;;;KAOzC,eACV,cAAc,YAAY,WAC1B,gBAAgB,YAAY,iBACtB,MAAM;;EAEZ,MAAM,QAAQ;;EAEd,SAAS;;;;;;KAOC,4BAA4B;;EAEtC;;EAEA,UAAU;;;;;UAMK;;EAEf;;EAEA;;;;;KAMU,aAAa,KAAK;EAC5B;EACA,SAAS,QAAQ;EACjB;EACA;;;;;;UAOe;;EAEf;;EAEA,SAAS;;EAET,UAAU;;EAEV;;;;;;;;UASe;;;;;;;;;;;EAWf;;;;;;;EAQA;;;;;;;EAQA;;;;;;;EAQA;;;;cChRW,oBAAoB,YAAY;;;;cCehC,oBAAoB;;;;;;;;;;;;cAepB,qBAAkB,aAChB,YAAU,YACX,kBACX;;;;;;;;;;;;iBCda,qBACd,cAAc,YAAY,WAC1B,gBAAgB,YAAY,WAE5B,cACA,SAAS,mBAAmB,OAAO,UACnC,YAAW,QAAQ,yBAClB,eAAe,OAAO;;;;;;;;;;cCgEZ,mBAAgB,gBACX;;;;;;;cChFL,gBAAa,gBAAwB;;;;;;cA4BrC,iBAAiB;;EAE5B;;EAEA,OAAO;EACP,YAAY,iBAAiB,eAAmB,OAAO;;;;;;;;;;cAgB5C,cAAW,cACV,0BAEX;;;;;;;cAqBU,oBAAiB;;;;;;;;;;;cAcjB,yBAAsB,UACvB,aAAW;;;;;;;;iBAqBP,aAAa;;;;;;;;;;;;;;cAmBhB,UAAO,gBAAkB,kBAAyB;;;;;;;;;;;;;;;;;;UC/G9C;;EAEf;;EAEA;;EAEA;;;;;;;EAOA,WAAW,kBAAkB;;;;;EAK7B;IAAe;IAAkB;;;;;;;;;;;EAUjC,OACE,gBACA,MAAM,WACN,UAAU;;;;;EAMZ;IAAS;IAAgB,MAAM;IAAW,UAAU;;;;;;EAKpD;;EAEA,QAAQ;GACP;;;;;;;;;cAiBU,wBAAyB,GAAC,MAC/B,cAAY,UACR,MACT;;;;;;cAOU,yBAAwB;;;;;;;;;cAgBxB,WAAQ,kBAAoB;;;;;;;;;;;;cAe5B,eAAY,gBACT,MACR,WAAS,UACL;;;;;;;UAWK;;EAEf;;EAEA;;EAEA;;EAEA,cAAc;;EAEd,SAAS;;EAET;;EAEA;;EAEA;;;;;;;;;;cAsCW,iBAAc,OAAW,iBAAe;;;cCnMxC;;;;;cAMA,mBAAmB;cAOnB"}
+{"version":3,"file":"server.d.mts","names":[],"sources":["../../src/express/types.d.ts","../../src/hono/types.d.ts","../../src/fastify/types.d.ts","../../src/koa/types.d.ts","../../src/h3/types.d.ts","../../src/types.d.ts","../../src/functionsMap.ts","../../src/scanForServerFiles.ts","../../src/createFunction.ts","../../src/getClientModules.ts","../../src/server-helpers.ts","../../src/context.ts","../../src/options.ts"],"mappings":"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"}

package/dist/server/server.mjs

@@ -2,8 +2,69 @@ import { readdir } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import process from "node:process";
 import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/options.ts
+const defaultServerFnOptions = {
+	contentType: "application/json",
+	credentials: "same-origin",
+	method: "POST"
+};
+const defaultPrefix = "__rpc";
+const defaultRPCOptions = {
+	rpcPrefix: defaultPrefix,
+	adapter: "express",
+	serverFiles: "exact",
+	scanRoot: void 0
+};
+const defaultMiddlewareOptions = {
+	rpcPrefix: void 0,
+	path: void 0,
+	origin: void 0
+};
+//#endregion
 //#region src/functionsMap.ts
-const serverFunctionsMap = /* @__PURE__ */ new Map();
+/**
+* Global symbol under which the shared `serverFunctionsByPrefix` map is stored
+* on `globalThis`. Keeping it on a `Symbol.for` key makes it instance-stable
+* across the bundled entry copies (`index.mjs`, `server.mjs`, `express.mjs`,
+* ...) and dev-server hot reloads, exactly like the request-context storage in
+* `context.ts`. Without this, `scanForServerFiles` (bundled into the plugin)
+* would populate a map copy the adapter middleware could not read.
+*/
+const functionsMapSymbol = Symbol.for("thednp.rpc.functionsMap");
+/**
+* Map of rpcPrefix -> Map of function names -> ServerFnEntry
+* Enables multiple RPC instances with different prefixes to coexist
+* without name collisions.
+*/
+const serverFunctionsByPrefix = globalThis[functionsMapSymbol] ??= /* @__PURE__ */ new Map();
+/**
+* Gets or creates the function map for a specific prefix.
+* @param prefix - The RPC prefix (e.g., "__rpc", "v1:rpc", "admin:rpc")
+* @returns Map of function names to ServerFnEntry for that prefix
+*/
+const getFunctionsForPrefix = (prefix) => {
+	if (!serverFunctionsByPrefix.has(prefix)) serverFunctionsByPrefix.set(prefix, /* @__PURE__ */ new Map());
+	return serverFunctionsByPrefix.get(prefix);
+};
+/**
+* Backward compatibility: default map for the default prefix.
+* Legacy code can still use serverFunctionsMap.set(name, entry).
+*/
+const serverFunctionsMap = {
+	get: (key) => getFunctionsForPrefix(defaultPrefix).get(key),
+	set: (key, value) => getFunctionsForPrefix(defaultPrefix).set(key, value),
+	has: (key) => getFunctionsForPrefix(defaultPrefix).has(key),
+	delete: (key) => getFunctionsForPrefix(defaultPrefix).delete(key),
+	clear: () => getFunctionsForPrefix(defaultPrefix).clear(),
+	get size() {
+		return getFunctionsForPrefix(defaultPrefix).size;
+	},
+	entries: () => getFunctionsForPrefix(defaultPrefix).entries(),
+	keys: () => getFunctionsForPrefix(defaultPrefix).keys(),
+	values: () => getFunctionsForPrefix(defaultPrefix).values(),
+	forEach: (callback) => getFunctionsForPrefix(defaultPrefix).forEach(callback),
+	[Symbol.iterator]: () => getFunctionsForPrefix(defaultPrefix)[Symbol.iterator]()
+};
 //#endregion
 //#region src/constants.ts
 const OPERATION_ABORTED = "Operation aborted";
@@ -13,7 +74,7 @@ const INTERNAL_SERVER_ERROR = "Internal Server Error";
 /** Error message when a value fails the safe-identifier validation. @param label - What kind of value was being validated. @param name - The rejected value */
 const INVALID_IDENTIFIER = (label, name) => `Invalid ${label}: "${name}" must match /^[A-Za-z_$][A-Za-z0-9_$]*$/`;
 /** Error message when a value fails the safe-path-segment validation. @param label - What kind of value was being validated. @param segment - The rejected value */
-const INVALID_PATH_SEGMENT = (label, segment) => `Invalid ${label}: "${segment}" must match /^[A-Za-z0-9_$][A-Za-z0-9_$/-]*$/`;
+const INVALID_PATH_SEGMENT = (label, segment) => `Invalid ${label}: "${segment}" must match /^[A-Za-z0-9_$@:][A-Za-z0-9_$@:/-]*$/`;
 /** Error template for duplicate server function names across files. @param name - The duplicate registered name */
 const DUPLICATE_FUNCTION_NAME = (name) => `Duplicate server function "${name}" detected. Each server function must have a unique name. Remove or rename the duplicate.`;
 //#endregion
@@ -133,6 +194,13 @@ const safeURL = (rawUrl, base = SAFE_URL_BASE) => {
 		return new URL("/", base);
 	}
 };
+const globalPrefixSymbol = Symbol.for("thednp.rpc.globalPrefix");
+/** Global rpcPrefix from the last loaded config / middleware — fallback for functions without explicit prefix. */
+const getGlobalPrefix = () => globalThis[globalPrefixSymbol];
+const setGlobalPrefix = (prefix) => {
+	if (prefix) globalThis[globalPrefixSymbol] = prefix;
+	else delete globalThis[globalPrefixSymbol];
+};
 //#endregion
 //#region src/scanForServerFiles.ts
 let isScanned = false;
@@ -146,7 +214,7 @@ const EXACT_NAMES = [
 ];
 /**
 * Scans `src/api/` (or an explicit `scanRoot`) for server function files
-* and populates the global `serverFunctionsMap` with their exported functions.
+* and populates the server functions map (scoped by rpcPrefix) with their exported functions.
 * Uses Vite's SSR module loading to resolve and execute each file.
 *
 * Supports two matching modes via `config.serverFiles`:
@@ -157,7 +225,13 @@ const EXACT_NAMES = [
 */
 const scanForServerFiles = async (initialCfg, devServer) => {
 	if (isScanned && !devServer) return;
-	const { createServer, normalizePath } = await import("vite");
+	let createServer;
+	let normalizePath;
+	try {
+		({createServer, normalizePath} = await import("vite"));
+	} catch {
+		return;
+	}
 	const config = !initialCfg && !devServer || !initialCfg ? {
 		root: process.cwd(),
 		base: process.env.BASE || "/",
@@ -204,16 +278,21 @@ const scanForServerFiles = async (initialCfg, devServer) => {
 			}
 			for (const [exportName, exportValue] of moduleEntries) {
 				const registeredName = exportValue.name;
-				if (seenNames.has(registeredName)) {
+				const prefix = exportValue.options?.rpcPrefix || config.rpcPrefix || "__rpc";
+				const seenKey = `${prefix}:${registeredName}`;
+				if (seenNames.has(seenKey)) {
 					if (process.env.NODE_ENV !== "production") throw new Error(DUPLICATE_FUNCTION_NAME(registeredName));
 					console.warn(DUPLICATE_FUNCTION_NAME(registeredName));
 					continue;
 				}
-				seenNames.add(registeredName);
-				serverFunctionsMap.set(registeredName, {
+				seenNames.add(seenKey);
+				const prefixMap = getFunctionsForPrefix(prefix);
+				const existing = prefixMap.get(registeredName);
+				if (existing) existing.exportName = exportName;
+				else prefixMap.set(registeredName, {
 					name: registeredName,
 					handler: exportValue,
-					options: exportValue?.options,
+					options: exportValue.options,
 					exportName
 				});
 			}
@@ -224,36 +303,20 @@ const scanForServerFiles = async (initialCfg, devServer) => {
 	}
 };
 //#endregion
-//#region src/options.ts
-const defaultServerFnOptions = {
-	contentType: "application/json",
-	credentials: "same-origin",
-	method: "POST"
-};
-const defaultRPCOptions = {
-	rpcPrefix: "__rpc",
-	adapter: "express",
-	serverFiles: "exact",
-	scanRoot: void 0
-};
-const defaultMiddlewareOptions = {
-	rpcPrefix: void 0,
-	path: void 0,
-	origin: void 0
-};
-//#endregion
 //#region src/createFunction.ts
 /**
 * Creates a server-side RPC function.
-* Registers the function in the server functions map and returns a client-compatible
-* wrapper that exposes `data` (Promise) and `cancel` (function) for request lifecycle control.
+* Registers the function in the server functions map (scoped by rpcPrefix) and returns
+* a client-compatible wrapper that exposes `data` (Promise) and `cancel` (function)
+* for request lifecycle control.
 * @param name - Unique identifier used by the RPC router to dispatch requests
 * @param handler - The actual implementation receiving an AbortSignal followed by JSON-serializable arguments
-* @param fnOptions - Optional contentType and credentials settings
+* @param fnOptions - Optional contentType, credentials, and rpcPrefix settings
 * @returns A client stub with `data` promise and `cancel` method, auto-registered in the server map
 */
 function createServerFunction(name, handler, fnOptions = {}) {
 	const options = Object.assign({}, defaultServerFnOptions, fnOptions);
+	const rpcPrefix = fnOptions.rpcPrefix || getGlobalPrefix() || "__rpc";
 	const wrappedFunction = (...args) => {
 		const controller = new AbortController();
 		const cancel = (reason) => controller.abort(reason);
@@ -278,7 +341,7 @@ function createServerFunction(name, handler, fnOptions = {}) {
 			configurable: false
 		}
 	});
-	serverFunctionsMap.set(name, {
+	getFunctionsForPrefix(rpcPrefix).set(name, {
 		name,
 		handler: wrappedFunction,
 		options
@@ -288,7 +351,7 @@ function createServerFunction(name, handler, fnOptions = {}) {
 //#endregion
 //#region src/validate.ts
 const SAFE_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-const SAFE_PATH_SEGMENT = /^[A-Za-z0-9_$@][A-Za-z0-9_$@/-]*$/;
+const SAFE_PATH_SEGMENT = /^[A-Za-z0-9_$@:][A-Za-z0-9_$@:/-]*$/;
 const CREDENTIALS_VALUES = [
 	"same-origin",
 	"include",
@@ -308,7 +371,8 @@ function validateIdentifier(name, label) {
 }
 /**
 * Validates that a string is a safe path segment for RPC routing.
-* Allows alphanumeric characters, underscores, dollar signs, at signs, hyphens, and forward slashes.
+* Allows alphanumeric characters, underscores, dollar signs, at signs,
+* colons, hyphens, and forward slashes.
 * @param segment - The string to validate
 * @param label - Human-readable label for error messages (e.g. "rpcPrefix")
 * @returns The validated segment if it passes
@@ -358,53 +422,28 @@ const getModule = (fnName, fnEntry, options) => {
 	const safePrefix = validatePathSegment(options.rpcPrefix, "rpcPrefix");
 	const credentials = validateCredentials(options.credentials);
 	const method = validateMethod(options.method);
-	let body = "";
-	let headers = "{}";
-	switch (options.contentType) {
-		case "text/plain":
-			body = `args[0]`;
-			headers = `{ 'Content-Type': 'text/plain' }`;
-			break;
-		case "application/x-www-form-urlencoded":
-			body = `new URLSearchParams(args[0]).toString()`;
-			headers = `{ 'Content-Type': 'application/x-www-form-urlencoded' }`;
-			break;
-		case "multipart/form-data":
-			body = `args[0]`;
-			headers = `{}`;
-			break;
-		default:
-			body = `JSON.stringify(args)`;
-			headers = `{ 'Content-Type': 'application/json' }`;
-	}
-	if (method === "GET") {
-		body = `JSON.stringify(args)`;
-		headers = `{}`;
-	}
+	const contentType = options.contentType ?? "application/json";
+	const opts = [];
+	if (method !== "POST") opts.push(`method: "${method}"`);
+	if (credentials !== "same-origin") opts.push(`credentials: "${credentials}"`);
+	if (contentType !== "application/json") opts.push(`contentType: "${contentType}"`);
 	return `
-export const ${safeFnEntry} = (...args) => {
-  const body = ${body};
-  const headers = ${headers};
-  const prefix = "${safePrefix}";
-  const name = "${safeFnName}";
-  const credentials = "${credentials}";
-  const method = "${method}";
-  return innerModule(body, headers, credentials, prefix, name, method);
-}`.trim();
+ export const ${safeFnEntry} = getClientStub("${safePrefix}", "${safeFnName}"${opts.length ? `, { ${opts.join(", ")} }` : ""});`.trim();
 };
 /**
 * Generates the complete client-side module bundle by iterating all registered server functions
-* and producing fetch-based stubs for each. The result is transformed by Vite (or Oxc) during
-* the dev server or production build.
+* for a specific prefix and producing fetch-based stubs for each. The result is transformed by Vite
+* (or Oxc) during the dev server or production build.
 * @param initialOptions - Plugin options containing rpcPrefix and optional adapter
 * @returns A string of JavaScript code with all client RPC modules and their import dependencies
 */
 const getClientModules = (initialOptions) => {
 	validatePathSegment(initialOptions.rpcPrefix, "rpcPrefix");
+	const prefixMap = getFunctionsForPrefix(initialOptions.rpcPrefix);
 	return `
 
-import { innerModule } from "@thednp/rpc/helpers";
-${Array.from(serverFunctionsMap.entries()).filter(([, entry]) => entry.exportName).map(([registeredName, entry]) => getModule(registeredName, entry.exportName, {
+import { getClientStub } from "@thednp/rpc/helpers";
+${Array.from(prefixMap.entries()).filter(([, entry]) => entry.exportName).map(([registeredName, entry]) => getModule(registeredName, entry.exportName, {
 		...initialOptions,
 		...entry.options || {}
 	})).join("\n")}`.trim();
@@ -507,6 +546,6 @@ const getRequestMeta = (event) => {
 	};
 };
 //#endregion
-export { RPCError, createServerFunction, defaultMiddlewareOptions, defaultRPCOptions, defaultServerFnOptions, escapeRegExp, formatError, getClientModules, getRequestContext, getRequestMeta, hasContentTypeMismatch, isFormContentType, provideRequestContext, redirect, safeURL, scanForServerFiles, scannedServerFiles, sendResponse, serverFunctionsMap, walkGlobFiles };
+export { RPCError, createServerFunction, defaultMiddlewareOptions, defaultPrefix, defaultRPCOptions, defaultServerFnOptions, escapeRegExp, formatError, getClientModules, getFunctionsForPrefix, getGlobalPrefix, getRequestContext, getRequestMeta, hasContentTypeMismatch, isFormContentType, provideRequestContext, redirect, safeURL, scanForServerFiles, scannedServerFiles, sendResponse, serverFunctionsByPrefix, serverFunctionsMap, setGlobalPrefix, walkGlobFiles };
 
 //# sourceMappingURL=server.mjs.map