silgi 0.51.2 → 0.51.4

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

@@ -86,7 +86,7 @@ function wrapHandler(handler, router, options, prefix) {
 		if (options.analytics) {
 			const { wrapWithAnalytics } = await import("../plugins/analytics.mjs");
 			const analyticsOpts = typeof options.analytics === "object" ? options.analytics : {};
-			h = wrapWithAnalytics(h, analyticsOpts);
+			h = wrapWithAnalytics(h, router, analyticsOpts);
 		}
 		wrapped = h;
 	}
@@ -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/integrations/better-auth/index.mjs

@@ -151,7 +151,7 @@ function tracing(config) {
 				try {
 					const request = ctx.request;
 					if (!request) return;
-					const silgiCtx = request.__silgiCtx;
+					const silgiCtx = request.__silgiCtx ?? getCtx();
 					if (!silgiCtx) return;
 					const reqTrace = silgiCtx.__analyticsTrace;
 					if (!reqTrace) return;

package/dist/plugins/analytics/collector.d.mts

@@ -16,6 +16,11 @@ declare class AnalyticsCollector {
   /** Cost tracker */
   costTracker: CostTracker;
   constructor(options?: AnalyticsOptions);
+  /** Set procedure schemas extracted from router definition. */
+  setProcedureSchemas(schemas: Map<string, {
+    input?: Record<string, unknown>;
+    output?: Record<string, unknown>;
+  }>): void;
   /** Check if a path is server-side ignored (from config). */
   isIgnored(pathname: string): boolean;
   /** Check if a path is hidden in the dashboard (from runtime API). */

package/dist/plugins/analytics/collector.mjs

@@ -38,6 +38,8 @@ var AnalyticsCollector = class {
 	#ignorePaths;
 	/** Client-side hide — from dashboard, filters display only */
 	#hiddenPaths = /* @__PURE__ */ new Set();
+	/** Procedure input/output JSON schemas (set once from router) */
+	#procedureSchemas = null;
 	/** SSE hub for real-time streaming */
 	sseHub;
 	/** Multi-tier time-series aggregation */
@@ -71,6 +73,10 @@ var AnalyticsCollector = class {
 			for (const p of paths) this.#hiddenPaths.add(p);
 		});
 	}
+	/** Set procedure schemas extracted from router definition. */
+	setProcedureSchemas(schemas) {
+		this.#procedureSchemas = schemas;
+	}
 	/** Check if a path is server-side ignored (from config). */
 	isIgnored(pathname) {
 		if (this.#ignorePaths.size === 0) return false;
@@ -222,7 +228,7 @@ var AnalyticsCollector = class {
 		let totalLatencyCount = 0;
 		for (const [path, entry] of this.#procedures) {
 			const avg = entry.latencies.avg();
-			procedures[path] = {
+			const snapshot = {
 				count: entry.count,
 				errors: entry.errors,
 				errorRate: entry.count > 0 ? round(entry.errors / entry.count * 100) : 0,
@@ -235,6 +241,10 @@ var AnalyticsCollector = class {
 				lastError: entry.lastError,
 				lastErrorTime: entry.lastErrorTime || null
 			};
+			const schemaInfo = this.#procedureSchemas?.get(path);
+			if (schemaInfo?.input) snapshot.inputSchema = schemaInfo.input;
+			if (schemaInfo?.output) snapshot.outputSchema = schemaInfo.output;
+			procedures[path] = snapshot;
 			totalLatencySum += avg * entry.latencies.count;
 			totalLatencyCount += entry.latencies.count;
 		}

package/dist/plugins/analytics/types.d.mts

@@ -119,6 +119,8 @@ interface ProcedureSnapshot {
   };
   lastError: string | null;
   lastErrorTime: number | null;
+  inputSchema?: Record<string, unknown>;
+  outputSchema?: Record<string, unknown>;
 }
 interface TaskSnapshot {
   totalRuns: number;

package/dist/plugins/analytics.d.mts

@@ -1,3 +1,4 @@
+import { RouterDef } from "../types.mjs";
 import { AnalyticsOptions, AnalyticsSnapshot, ErrorEntry, ProcedureCall, ProcedureSnapshot, RequestEntry, SpanKind, TaskExecution, TaskSnapshot, TraceSpan } from "./analytics/types.mjs";
 import { AnalyticsCollector } from "./analytics/collector.mjs";
 import { RequestTrace, trace } from "./analytics/trace.mjs";
@@ -9,10 +10,14 @@ import { analyticsTraceMap } from "../core/trace-map.mjs";
 import { FetchHandler } from "../core/handler.mjs";
 
 //#region src/plugins/analytics.d.ts
+interface ProcedureSchemaInfo {
+  input?: Record<string, unknown>;
+  output?: Record<string, unknown>;
+}
 /**
  * Wrap a fetch handler with analytics collection.
  * Intercepts analytics dashboard routes and instruments every request.
  */
-declare function wrapWithAnalytics(handler: FetchHandler, options?: AnalyticsOptions): FetchHandler;
+declare function wrapWithAnalytics(handler: FetchHandler, router: RouterDef | undefined, options?: AnalyticsOptions): FetchHandler;
 //#endregion
-export { AnalyticsCollector, type AnalyticsOptions, type AnalyticsSnapshot, type ErrorEntry, type ProcedureCall, type ProcedureSnapshot, RequestAccumulator, type RequestEntry, RequestTrace, type SpanKind, type TaskExecution, type TaskSnapshot, type TraceSpan, analyticsAuthResponse, analyticsHTML, analyticsTraceMap, checkAnalyticsAuth, errorToMarkdown, requestToMarkdown, sanitizeHeaders, serveAnalyticsRoute, trace, wrapWithAnalytics };
+export { AnalyticsCollector, type AnalyticsOptions, type AnalyticsSnapshot, type ErrorEntry, type ProcedureCall, ProcedureSchemaInfo, type ProcedureSnapshot, RequestAccumulator, type RequestEntry, RequestTrace, type SpanKind, type TaskExecution, type TaskSnapshot, type TraceSpan, analyticsAuthResponse, analyticsHTML, analyticsTraceMap, checkAnalyticsAuth, errorToMarkdown, requestToMarkdown, sanitizeHeaders, serveAnalyticsRoute, trace, wrapWithAnalytics };

package/dist/plugins/analytics.mjs

@@ -2,6 +2,7 @@ import { ValidationError } from "../core/schema.mjs";
 import { SilgiError, toSilgiError } from "../core/error.mjs";
 import { analyticsTraceMap } from "../core/trace-map.mjs";
 import { parseUrlPathname } from "../core/url.mjs";
+import { ZodSchemaConverter } from "../integrations/zod/converter.mjs";
 import { generateRequestId } from "./analytics/request-id.mjs";
 import { isTrackedRequestPath, normalizeAnalyticsPath, round, sanitizeHeaders } from "./analytics/utils.mjs";
 import { RequestAccumulator } from "./analytics/accumulator.mjs";
@@ -80,12 +81,48 @@ function extractResponseError(output, status, fallback) {
 		message: `Request failed with status ${status}`
 	};
 }
+function isProcedureDef(value) {
+	return typeof value === "object" && value !== null && "type" in value && "resolve" in value && typeof value.resolve === "function";
+}
+const _zodConverter = new ZodSchemaConverter();
+function schemaToJson(schema, strategy) {
+	if (!schema) return void 0;
+	const std = schema["~standard"];
+	if (std?.jsonSchema?.input) try {
+		const result = std.jsonSchema.input({ target: "draft-2020-12" });
+		if (result && typeof result === "object") {
+			const { $schema: _, ...rest } = result;
+			return rest;
+		}
+	} catch {}
+	if (_zodConverter.condition(schema)) try {
+		const [, json] = _zodConverter.convert(schema, { strategy });
+		return json;
+	} catch {}
+}
+function extractProcedureSchemas(router) {
+	const schemas = /* @__PURE__ */ new Map();
+	function walk(node, path) {
+		if (isProcedureDef(node)) {
+			const info = {};
+			if (node.input) info.input = schemaToJson(node.input, "input");
+			if (node.output) info.output = schemaToJson(node.output, "output");
+			if (info.input || info.output) schemas.set(path.join("/"), info);
+			return;
+		}
+		if (typeof node === "object" && node !== null) for (const [key, child] of Object.entries(node)) walk(child, [...path, key]);
+	}
+	walk(router, []);
+	return schemas;
+}
 /**
 * Wrap a fetch handler with analytics collection.
 * Intercepts analytics dashboard routes and instruments every request.
 */
-function wrapWithAnalytics(handler, options = {}) {
+function wrapWithAnalytics(handler, router, options = {}) {
 	const collector = new AnalyticsCollector(options);
+	const procedureSchemas = router ? extractProcedureSchemas(router) : void 0;
+	if (procedureSchemas) collector.setProcedureSchemas(procedureSchemas);
 	const dashboardHtml = analyticsHTML();
 	const auth = options.auth;
 	import("../core/task.mjs").then(({ setTaskAnalytics }) => {

package/dist/scalar.mjs

@@ -1,5 +1,12 @@
+import { ZodSchemaConverter } from "./integrations/zod/converter.mjs";
 //#region src/scalar.ts
 /**
+* Scalar API Reference — v2 OpenAPI integration.
+*
+* Generates OpenAPI 3.1.0 spec from v2 RouterDef and serves
+* Scalar UI at /api/reference + spec at /api/openapi.json.
+*/
+/**
 * Generate OpenAPI 3.1.0 document from a v2 RouterDef.
 */
 /**
@@ -67,7 +74,7 @@ function generateOpenAPI(router, options = {}, basePath = "") {
 		if (route?.security === false) operation.security = [];
 		else if (route?.security) operation.security = route.security.map((s) => ({ [s]: [] }));
 		else if (options.security) operation.security = [{ auth: [] }];
-		const inputSchema = proc.input ? schemaToJsonSchema(proc.input) : null;
+		const inputSchema = proc.input ? schemaToJsonSchema(proc.input, "input") : null;
 		const successStatus = route?.successStatus ?? 200;
 		const successDesc = route?.successDescription ?? "Successful response";
 		const guards = (proc.use ?? []).filter((m) => m.kind === "guard" && m.errors);
@@ -100,7 +107,7 @@ function generateOpenAPI(router, options = {}, basePath = "") {
 			};
 			if (params.length > 0) op.parameters = params;
 			if (proc.type === "subscription") {
-				const outputSchema = proc.output ? schemaToJsonSchema(proc.output) : { type: "string" };
+				const outputSchema = proc.output ? schemaToJsonSchema(proc.output, "output") : { type: "string" };
 				op.responses[String(successStatus)] = {
 					description: "SSE event stream",
 					content: { "text/event-stream": { schema: {
@@ -110,7 +117,7 @@ function generateOpenAPI(router, options = {}, basePath = "") {
 				};
 			} else if (proc.output) op.responses[String(successStatus)] = {
 				description: successDesc,
-				content: { "application/json": { schema: schemaToJsonSchema(proc.output) } }
+				content: { "application/json": { schema: schemaToJsonSchema(proc.output, "output") } }
 			};
 			else op.responses[String(successStatus)] = { description: successDesc };
 			if (proc.input) op.responses["400"] = {
@@ -263,20 +270,25 @@ function collectProcedures(node, path, cb) {
 	if (typeof node === "object" && node !== null) for (const [key, child] of Object.entries(node)) collectProcedures(child, [...path, key], cb);
 }
 /**
-* Convert a Standard Schema to JSON Schema via `~standard.jsonSchema.input()`.
+* Convert a Standard Schema to JSON Schema.
 *
-* Works with Zod v4, Valibot, ArkType — any validator implementing Standard Schema v1.
+* Fast path: `~standard.jsonSchema.input()` (StandardJSONSchemaV1 implementors).
+* Fallback: vendor-specific converters (Zod v4 via ZodSchemaConverter).
 */
-function schemaToJsonSchema(schema) {
+const _zodConverter = new ZodSchemaConverter();
+function schemaToJsonSchema(schema, strategy = "input") {
 	const std = schema["~standard"];
-	if (!std?.jsonSchema?.input) return {};
-	try {
+	if (std?.jsonSchema?.input) try {
 		const result = std.jsonSchema.input({ target: "draft-2020-12" });
 		if (result && typeof result === "object") {
 			const { $schema: _, ...rest } = result;
 			return rest;
 		}
 	} catch {}
+	if (_zodConverter.condition(schema)) try {
+		const [, jsonSchema] = _zodConverter.convert(schema, { strategy });
+		return jsonSchema;
+	} catch {}
 	return {};
 }
 function objectSchemaToParams(schema) {

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;