silgi 0.51.2 → 0.51.3

package/dist/adapters/_fetch-adapter.mjs

@@ -1,4 +1,3 @@
-import { analyticsTraceMap } from "../core/trace-map.mjs";
 import { createFetchHandler, wrapHandler } from "../core/handler.mjs";
 //#region src/adapters/_fetch-adapter.ts
 /**
@@ -10,29 +9,13 @@ import { createFetchHandler, wrapHandler } from "../core/handler.mjs";
 * This module eliminates the duplication. Each adapter file becomes a thin
 * wrapper that extracts the framework-specific Request and calls this factory.
 */
-/** Strip prefix from request URL and create a rewritten Request. */
-function rewriteRequest(request, prefix) {
-	const url = new URL(request.url);
-	let pathname = url.pathname;
-	if (pathname.startsWith(prefix)) {
-		pathname = pathname.slice(prefix.length);
-		if (!pathname.startsWith("/")) pathname = "/" + pathname;
-	}
-	return new Request(new URL(pathname + url.search, url.origin), request);
-}
 /**
 * Create a fetch-passthrough adapter that strips a prefix and delegates to handler.
 * Used by adapters that receive a standard Request (Next.js, Astro, Remix).
 */
 function createFetchAdapter(router, options, defaultPrefix) {
 	const prefix = options.prefix ?? defaultPrefix;
-	const inner = createFetchHandler(router, options.context ?? (() => ({})));
-	return wrapHandler((request) => {
-		const rewritten = rewriteRequest(request, prefix);
-		const trace = analyticsTraceMap.get(request);
-		if (trace) analyticsTraceMap.set(rewritten, trace);
-		return inner(rewritten);
-	}, router, options, prefix);
+	return wrapHandler(createFetchHandler(router, options.context ?? (() => ({})), void 0, prefix), router, options, prefix);
 }
 /**
 * Create a fetch-passthrough adapter for frameworks that pass an event object
@@ -42,19 +25,11 @@ function createFetchAdapter(router, options, defaultPrefix) {
 function createEventFetchAdapter(router, options, defaultPrefix, extractRequest) {
 	const prefix = options.prefix ?? defaultPrefix;
 	const requestEventMap = /* @__PURE__ */ new WeakMap();
-	const inner = createFetchHandler(router, (_req) => {
+	const handler = wrapHandler(createFetchHandler(router, (_req) => {
 		const eventRef = requestEventMap.get(_req);
 		if (options.context && eventRef) return options.context(eventRef);
 		return {};
-	});
-	const handler = wrapHandler((request) => {
-		const rewritten = rewriteRequest(request, prefix);
-		const eventRef = requestEventMap.get(request);
-		if (eventRef) requestEventMap.set(rewritten, eventRef);
-		const trace = analyticsTraceMap.get(request);
-		if (trace) analyticsTraceMap.set(rewritten, trace);
-		return inner(rewritten);
-	}, router, options, prefix);
+	}, void 0, prefix), router, options, prefix);
 	return (event) => {
 		const request = extractRequest(event);
 		requestEventMap.set(request, event);

package/dist/core/handler.d.mts

@@ -7,6 +7,8 @@ type FetchHandler = (request: Request) => Response | Promise<Response>;
 interface WrapHandlerOptions {
   analytics?: boolean | AnalyticsOptions;
   scalar?: boolean | ScalarOptions;
+  /** URL path prefix for the handler (e.g. "/api"). Requests not matching this prefix return 404. */
+  basePath?: string;
 }
 //#endregion
 export { FetchHandler, WrapHandlerOptions };

package/dist/core/handler.mjs

@@ -96,12 +96,13 @@ function wrapHandler(handler, router, options, prefix) {
 		return initPromise.then(() => wrapped(request));
 	};
 }
-function createFetchHandler(routerDef, contextFactory, hooks) {
+function createFetchHandler(routerDef, contextFactory, hooks, prefix) {
 	let compiledRouter = routerCache.get(routerDef);
 	if (!compiledRouter) {
 		compiledRouter = compileRouter(routerDef);
 		routerCache.set(routerDef, compiledRouter);
 	}
+	const prefixLen = prefix ? prefix.length : 0;
 	const jsonHeaders = { "content-type": "application/json" };
 	const notFoundBody = JSON.stringify({
 		code: "NOT_FOUND",
@@ -117,7 +118,14 @@ function createFetchHandler(routerDef, contextFactory, hooks) {
 	}
 	return async function handleRequest(request) {
 		const url = request.url;
-		const fullPath = parseUrlPath(url);
+		let fullPath = parseUrlPath(url);
+		if (prefix) {
+			if (!fullPath.startsWith(prefix)) return new Response(notFoundBody, {
+				status: 404,
+				headers: jsonHeaders
+			});
+			fullPath = fullPath.slice(prefixLen) || "/";
+		}
 		const pathname = fullPath.length > 1 ? fullPath.slice(1) : "";
 		const qMark = url.indexOf("?", url.indexOf("/", url.indexOf("//") + 2));
 		const match = compiledRouter(request.method, fullPath);

package/dist/core/serve.d.mts

@@ -20,6 +20,8 @@ interface SilgiServer {
   close(forceCloseConnections?: boolean): Promise<void>;
 }
 interface ServeOptions {
+  /** URL path prefix (e.g. "/api"). Only requests matching this prefix are handled; others return 404. */
+  basePath?: string;
   port?: number;
   hostname?: string;
   /** Enable Scalar API Reference UI at /api/reference and /api/openapi.json */

package/dist/core/serve.mjs

@@ -1,3 +1,4 @@
+import { normalizePrefix } from "./url.mjs";
 import { createFetchHandler, wrapHandler } from "./handler.mjs";
 import { _createWSHooks } from "../ws.mjs";
 import { serve } from "srvx";
@@ -16,7 +17,8 @@ function routerHasSubscription(def) {
 async function createServeHandler(routerDef, contextFactory, hooks, options) {
 	const port = options?.port ?? 3e3;
 	const hostname = options?.hostname ?? "127.0.0.1";
-	const httpHandler = wrapHandler(createFetchHandler(routerDef, contextFactory, hooks), routerDef, options);
+	const prefix = options?.basePath ? normalizePrefix(options.basePath) : void 0;
+	const httpHandler = wrapHandler(createFetchHandler(routerDef, contextFactory, hooks, prefix), routerDef, options, prefix);
 	const shutdownOpt = options?.gracefulShutdown ?? true;
 	let gracefulShutdown;
 	if (typeof shutdownOpt === "object") gracefulShutdown = {

package/dist/core/url.mjs

@@ -24,5 +24,11 @@ function parseUrlPathname(url) {
 	const fullPath = parseUrlPath(url);
 	return fullPath.length > 1 ? fullPath.slice(1) : "";
 }
+/** Normalize a basePath: ensure leading slash, strip trailing slash. */
+function normalizePrefix(basePath) {
+	let p = basePath.startsWith("/") ? basePath : "/" + basePath;
+	if (p.endsWith("/")) p = p.slice(0, -1);
+	return p;
+}
 //#endregion
-export { parseUrlPath, parseUrlPathname };
+export { normalizePrefix, parseUrlPath, parseUrlPathname };

package/dist/silgi.d.mts

@@ -95,7 +95,8 @@ interface SilgiInstance<TBaseCtx extends Record<string, unknown>> {
   router: <T extends RouterDef>(def: T) => T;
   /** Create a Fetch API handler: (Request) => Response */
   handler: (router: RouterDef, options?: {
-    /** Enable Scalar API Reference UI at /api/reference and /api/openapi.json */scalar?: boolean | ScalarOptions; /** Enable analytics dashboard at /api/analytics */
+    /** URL path prefix (e.g. "/api"). Only requests matching this prefix are handled; others return 404. */basePath?: string; /** Enable Scalar API Reference UI at /api/reference and /api/openapi.json */
+    scalar?: boolean | ScalarOptions; /** Enable analytics dashboard at /api/analytics */
     analytics?: boolean | AnalyticsOptions;
   }) => (request: Request) => Response | Promise<Response>;
   /** Create a direct caller — call procedures without HTTP. For testing and server-side usage. */

package/dist/silgi.mjs

@@ -3,6 +3,7 @@ import { createProcedureBuilder } from "./builder.mjs";
 import { assignPaths, routerCache } from "./core/router-utils.mjs";
 import { compileRouter } from "./compile.mjs";
 import { createCaller } from "./caller.mjs";
+import { normalizePrefix } from "./core/url.mjs";
 import { createFetchHandler, wrapHandler } from "./core/handler.mjs";
 import { createHooks } from "hookable";
 //#region src/silgi.ts
@@ -113,7 +114,8 @@ function silgi(config) {
 			return createCaller(routerDef, contextFactory, options);
 		},
 		handler: (routerDef, options) => {
-			const fetchHandler = wrapHandler(createFetchHandler(routerDef, contextFactory, hooks), routerDef, options);
+			const prefix = options?.basePath ? normalizePrefix(options.basePath) : void 0;
+			const fetchHandler = wrapHandler(createFetchHandler(routerDef, contextFactory, hooks, prefix), routerDef, options, prefix);
 			if (!(function checkWs(def) {
 				if (!def || typeof def !== "object") return false;
 				if (def.type === "subscription") return true;
@@ -126,8 +128,9 @@ function silgi(config) {
 				const { _createWSHooks } = await import("./ws.mjs");
 				wsHooks = _createWSHooks(routerDef);
 			}
+			const wsPath = prefix ? `${prefix}/_ws` : "/_ws";
 			return async (request) => {
-				if (new URL(request.url).pathname === "/_ws") {
+				if (new URL(request.url).pathname === wsPath) {
 					if (!wsHooks) {
 						wsInitPromise ??= initWsHooks();
 						await wsInitPromise;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "silgi",
-  "version": "0.51.2",
+  "version": "0.51.3",
   "private": false,
   "description": "The fastest end-to-end type-safe RPC framework for TypeScript — compiled pipelines, single package, every runtime",
   "keywords": [