silgi 0.51.1 → 0.51.2

package/dist/adapters/_fetch-adapter.mjs

@@ -1,3 +1,4 @@
+import { analyticsTraceMap } from "../core/trace-map.mjs";
 import { createFetchHandler, wrapHandler } from "../core/handler.mjs";
 //#region src/adapters/_fetch-adapter.ts
 /**
@@ -26,7 +27,12 @@ function rewriteRequest(request, prefix) {
 function createFetchAdapter(router, options, defaultPrefix) {
 	const prefix = options.prefix ?? defaultPrefix;
 	const inner = createFetchHandler(router, options.context ?? (() => ({})));
-	return wrapHandler((request) => inner(rewriteRequest(request, prefix)), router, options);
+	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);
 }
 /**
 * Create a fetch-passthrough adapter for frameworks that pass an event object
@@ -45,8 +51,10 @@ function createEventFetchAdapter(router, options, defaultPrefix, extractRequest)
 		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);
+	}, router, options, prefix);
 	return (event) => {
 		const request = extractRequest(event);
 		requestEventMap.set(request, event);

package/dist/core/handler.mjs

@@ -72,7 +72,7 @@ function makeResponse(output, route, format, ctx) {
 * Returns a new handler that applies wrappers on first request (async import).
 * If no wrappers are needed, returns the original handler as-is.
 */
-function wrapHandler(handler, router, options) {
+function wrapHandler(handler, router, options, prefix) {
 	if (!options?.scalar && !options?.analytics) return handler;
 	let wrapped;
 	let initPromise;
@@ -81,7 +81,7 @@ function wrapHandler(handler, router, options) {
 		if (options.scalar) {
 			const { wrapWithScalar } = await import("../scalar.mjs");
 			const scalarOpts = typeof options.scalar === "object" ? options.scalar : {};
-			h = wrapWithScalar(h, router, scalarOpts);
+			h = wrapWithScalar(h, router, scalarOpts, prefix);
 		}
 		if (options.analytics) {
 			const { wrapWithAnalytics } = await import("../plugins/analytics.mjs");

package/dist/scalar.d.mts

@@ -43,7 +43,7 @@ interface ScalarOptions {
    */
   cdn?: 'cdn' | 'unpkg' | 'local' | (string & {});
 }
-declare function generateOpenAPI(router: RouterDef, options?: ScalarOptions): Record<string, unknown>;
+declare function generateOpenAPI(router: RouterDef, options?: ScalarOptions, basePath?: string): Record<string, unknown>;
 declare function scalarHTML(specUrl: string, options?: ScalarOptions): string;
 //#endregion
 export { ScalarOptions, generateOpenAPI, scalarHTML };

package/dist/scalar.mjs

@@ -24,12 +24,13 @@ function toOpenAPIPath(raw) {
 		pathParams
 	};
 }
-function generateOpenAPI(router, options = {}) {
+function generateOpenAPI(router, options = {}, basePath = "") {
 	const paths = {};
 	const tags = /* @__PURE__ */ new Map();
 	collectProcedures(router, [], (path, proc) => {
 		const route = proc.route;
-		const { httpPath, pathParams } = toOpenAPIPath(route?.path ?? "/" + path.join("/"));
+		const { httpPath: routePath, pathParams } = toOpenAPIPath(route?.path ?? "/" + path.join("/"));
+		const httpPath = basePath ? basePath.replace(/\/$/, "") + routePath : routePath;
 		const rawMethod = route?.method?.toLowerCase() ?? "post";
 		const methods = rawMethod === "*" ? [
 			"get",
@@ -293,17 +294,20 @@ function objectSchemaToParams(schema) {
 * Wrap a fetch handler to serve Scalar API Reference at /api/reference and /api/openapi.json.
 * Scalar routes are intercepted before the handler — zero overhead for normal requests.
 */
-function wrapWithScalar(handler, routerDef, options = {}) {
-	const specJson = JSON.stringify(generateOpenAPI(routerDef, options));
-	const specHtml = scalarHTML("/api/openapi.json", options);
+function wrapWithScalar(handler, routerDef, options = {}, prefix = "/api") {
+	const normPrefix = (prefix.startsWith("/") ? prefix : "/" + prefix).replace(/\/+$/, "");
+	const specJson = JSON.stringify(generateOpenAPI(routerDef, options, normPrefix));
+	const specHtml = scalarHTML(`${normPrefix}/openapi.json`, options);
+	const openapiMatch = `${normPrefix.slice(1)}/openapi.json`;
+	const referenceMatch = `${normPrefix.slice(1)}/reference`;
 	return (request) => {
 		const url = request.url;
 		const pathStart = url.indexOf("/", url.indexOf("//") + 2);
 		const qMark = url.indexOf("?", pathStart);
 		const fullPath = qMark === -1 ? url.slice(pathStart) : url.slice(pathStart, qMark);
 		const pathname = fullPath.length > 1 ? fullPath.slice(1) : "";
-		if (pathname === "api/openapi.json") return new Response(specJson, { headers: { "content-type": "application/json" } });
-		if (pathname === "api/reference") return new Response(specHtml, { headers: { "content-type": "text/html" } });
+		if (pathname === openapiMatch) return new Response(specJson, { headers: { "content-type": "application/json" } });
+		if (pathname === referenceMatch) return new Response(specHtml, { headers: { "content-type": "text/html" } });
 		return handler(request);
 	};
 }

package/package.json

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