silgi 0.51.3 → 0.51.4

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;
 	}

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) {