silgi 0.51.6 → 0.51.8

package/dist/integrations/zod/index.d.mts

@@ -1,2 +1,29 @@
-import { CompositeSchemaConverter, ConvertOptions, JSONSchema, SchemaConverter, ZodSchemaConverter } from "./converter.mjs";
-export { CompositeSchemaConverter, type ConvertOptions, type JSONSchema, type SchemaConverter, ZodSchemaConverter };
+import { SchemaConverter } from "../../core/schema-converter.mjs";
+import { CompositeSchemaConverter, ConvertOptions, JSONSchema, ZodSchemaConverter } from "./converter.mjs";
+
+//#region src/integrations/zod/index.d.ts
+/**
+ * Pre-built Zod → JSON Schema converter for use with
+ * `silgi({ schemaConverters })`.
+ *
+ * @remarks
+ * Pass this to the `schemaConverters` option of `silgi()` to enable
+ * OpenAPI spec generation and analytics schema extraction for Zod
+ * schemas. Supports Zod v3 and v4.
+ *
+ * @example
+ * ```ts
+ * import { zodConverter } from 'silgi/zod'
+ * import { silgi } from 'silgi'
+ *
+ * const k = silgi({
+ *   context: (req) => ({ db: getDB() }),
+ *   schemaConverters: [zodConverter],
+ * })
+ * ```
+ *
+ * @category Schema
+ */
+declare const zodConverter: SchemaConverter;
+//#endregion
+export { CompositeSchemaConverter, type ConvertOptions, type JSONSchema, type SchemaConverter, ZodSchemaConverter, zodConverter };

package/dist/integrations/zod/index.mjs

@@ -1,2 +1,61 @@
 import { CompositeSchemaConverter, ZodSchemaConverter } from "./converter.mjs";
-export { CompositeSchemaConverter, ZodSchemaConverter };
+//#region src/integrations/zod/index.ts
+/**
+* Zod integration for Silgi — explicit injection model.
+*
+* @remarks
+* **Breaking change:** the old side-effect import (`import 'silgi/zod'`)
+* that auto-registered the Zod converter globally is removed. Import
+* {@link zodConverter} and pass it explicitly to
+* `silgi({ schemaConverters: [zodConverter] })`.
+*
+* Migration:
+* ```ts
+* // Before:
+* import 'silgi/zod'
+* const k = silgi({ context: ... })
+*
+* // After:
+* import { zodConverter } from 'silgi/zod'
+* const k = silgi({ context: ..., schemaConverters: [zodConverter] })
+* ```
+*
+* Note: Zod v4 schemas expose a native `jsonSchema.input()` fast path, so
+* most Zod v4 users do not strictly need this converter. Passing
+* `zodConverter` is still recommended as a safety net for schemas that
+* bypass the fast path.
+*
+* @category Schema
+*/
+const _zodConverterInstance = new ZodSchemaConverter();
+/**
+* Pre-built Zod → JSON Schema converter for use with
+* `silgi({ schemaConverters })`.
+*
+* @remarks
+* Pass this to the `schemaConverters` option of `silgi()` to enable
+* OpenAPI spec generation and analytics schema extraction for Zod
+* schemas. Supports Zod v3 and v4.
+*
+* @example
+* ```ts
+* import { zodConverter } from 'silgi/zod'
+* import { silgi } from 'silgi'
+*
+* const k = silgi({
+*   context: (req) => ({ db: getDB() }),
+*   schemaConverters: [zodConverter],
+* })
+* ```
+*
+* @category Schema
+*/
+const zodConverter = {
+	vendor: "zod",
+	toJsonSchema(schema, opts) {
+		const [, json] = _zodConverterInstance.convert(schema, opts);
+		return json;
+	}
+};
+//#endregion
+export { CompositeSchemaConverter, ZodSchemaConverter, zodConverter };

package/dist/lazy.d.mts

@@ -9,14 +9,51 @@ interface LazyRouter {
 }
 /**
  * Wrap a dynamic import for lazy loading.
- * The module must export its router/procedure as `default`.
+ *
+ * @remarks
+ * The module must export its router or procedure as `default`. The
+ * returned handle is resolved on demand by {@link resolveLazy} and
+ * cached via module-local `WeakMap`s so concurrent resolutions share a
+ * single in-flight `Promise`.
+ *
+ * @param loader - A function returning `import('…')` — typically a
+ *   dynamic import expression pointing at a module whose default export
+ *   is a `RouterDef` or `ProcedureDef`.
+ * @returns A {@link LazyRouter} handle usable as a value inside
+ *   `silgi.router({ … })`.
+ *
+ * @example
+ * ```ts
+ * const appRouter = k.router({
+ *   users: lazy(() => import('./routes/users.ts')),
+ *   admin: lazy(() => import('./routes/admin.ts')),
+ * })
+ * ```
  */
 declare function lazy(loader: () => Promise<{
   default: RouterDef | ProcedureDef;
 }>): LazyRouter;
-/** Check if a value is a lazy router */
+/**
+ * Type guard: `true` when `value` is a {@link LazyRouter} produced by
+ * {@link lazy}.
+ *
+ * @param value - Any value.
+ * @returns `true` when `value` carries the `__lazy` brand.
+ */
 declare function isLazy(value: unknown): value is LazyRouter;
-/** Resolve a lazy router (cached after first load, race-safe) */
+/**
+ * Resolve a lazy router and cache the result.
+ *
+ * @remarks
+ * The resolved module is cached in a `WeakMap` keyed on the
+ * {@link LazyRouter} handle, so repeat calls return synchronously after
+ * the first. Concurrent calls share a single in-flight `Promise` to
+ * avoid duplicate imports — the race cache is cleared once the import
+ * settles.
+ *
+ * @param value - A handle returned by {@link lazy}.
+ * @returns The default export of the imported module.
+ */
 declare function resolveLazy(value: LazyRouter): Promise<RouterDef | ProcedureDef>;
 //#endregion
 export { LazyRouter, isLazy, lazy, resolveLazy };

package/dist/lazy.mjs

@@ -3,7 +3,26 @@ const resolved = /* @__PURE__ */ new WeakMap();
 const loading = /* @__PURE__ */ new WeakMap();
 /**
 * Wrap a dynamic import for lazy loading.
-* The module must export its router/procedure as `default`.
+*
+* @remarks
+* The module must export its router or procedure as `default`. The
+* returned handle is resolved on demand by {@link resolveLazy} and
+* cached via module-local `WeakMap`s so concurrent resolutions share a
+* single in-flight `Promise`.
+*
+* @param loader - A function returning `import('…')` — typically a
+*   dynamic import expression pointing at a module whose default export
+*   is a `RouterDef` or `ProcedureDef`.
+* @returns A {@link LazyRouter} handle usable as a value inside
+*   `silgi.router({ … })`.
+*
+* @example
+* ```ts
+* const appRouter = k.router({
+*   users: lazy(() => import('./routes/users.ts')),
+*   admin: lazy(() => import('./routes/admin.ts')),
+* })
+* ```
 */
 function lazy(loader) {
 	return {
@@ -11,11 +30,29 @@ function lazy(loader) {
 		load: loader
 	};
 }
-/** Check if a value is a lazy router */
+/**
+* Type guard: `true` when `value` is a {@link LazyRouter} produced by
+* {@link lazy}.
+*
+* @param value - Any value.
+* @returns `true` when `value` carries the `__lazy` brand.
+*/
 function isLazy(value) {
 	return typeof value === "object" && value !== null && value.__lazy === true;
 }
-/** Resolve a lazy router (cached after first load, race-safe) */
+/**
+* Resolve a lazy router and cache the result.
+*
+* @remarks
+* The resolved module is cached in a `WeakMap` keyed on the
+* {@link LazyRouter} handle, so repeat calls return synchronously after
+* the first. Concurrent calls share a single in-flight `Promise` to
+* avoid duplicate imports — the race cache is cleared once the import
+* settles.
+*
+* @param value - A handle returned by {@link lazy}.
+* @returns The default export of the imported module.
+*/
 async function resolveLazy(value) {
 	const cached = resolved.get(value);
 	if (cached) return cached;

package/dist/map-input.mjs

@@ -1,4 +1,4 @@
-import { RAW_INPUT } from "./compile.mjs";
+import { RAW_INPUT } from "./core/ctx-symbols.mjs";
 //#region src/map-input.ts
 /**
 * mapInput — transform the input shape before a procedure runs.

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

@@ -15,7 +15,7 @@ declare class AnalyticsCollector {
   alertEngine: AlertEngine | null;
   /** Cost tracker */
   costTracker: CostTracker;
-  constructor(options?: AnalyticsOptions);
+  constructor(options?: Omit<AnalyticsOptions, 'auth'>);
   /** Set procedure schemas extracted from router definition. */
   setProcedureSchemas(schemas: Map<string, {
     input?: Record<string, unknown>;

package/dist/plugins/analytics/trace.mjs

@@ -75,7 +75,7 @@ function guessKind(name) {
 * ```
 */
 async function trace(ctx, name, fn, opts) {
-	const reqTrace = ctx.__analyticsTrace;
+	const reqTrace = ctx.trace;
 	if (reqTrace) return reqTrace.trace(name, fn, opts);
 	return fn();
 }

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

@@ -90,12 +90,12 @@ interface AnalyticsOptions {
   /** Time-series history in seconds (default: 120) */
   historySeconds?: number;
   /**
-   * Protect dashboard access.
+   * Protect dashboard access. **Required** — the analytics dashboard exposes
+   * request bodies, headers, and stack traces, so authentication is mandatory.
    * - `string` — secret token checked against `Authorization: Bearer <token>` header or `?token=` query param
    * - `(req: Request) => boolean | Promise<boolean>` — custom auth function
-   * - `undefined` — no auth (open access, NOT recommended in production)
    */
-  auth?: string | ((req: Request) => boolean | Promise<boolean>);
+  auth: string | ((req: Request) => boolean | Promise<boolean>);
   /** Interval in ms between storage flushes (default: 5000) */
   flushInterval?: number;
   /** Days to retain entries in storage (default: 30). Entries older than this are pruned on flush. */

package/dist/plugins/analytics/utils.mjs

@@ -13,11 +13,8 @@ const SENSITIVE_HEADER_KEYS = new Set([
 	"x-auth-token",
 	"proxy-authorization"
 ]);
-function shouldRedactSensitiveData() {
-	return process.env.NODE_ENV === "production";
-}
 function redactHeaderValue(key, value) {
-	return shouldRedactSensitiveData() && SENSITIVE_HEADER_KEYS.has(key.toLowerCase()) ? REDACTED : value;
+	return SENSITIVE_HEADER_KEYS.has(key.toLowerCase()) ? REDACTED : value;
 }
 function round(n) {
 	return Math.round(n * 100) / 100;

package/dist/plugins/analytics.d.mts

@@ -1,13 +1,15 @@
 import { RouterDef } from "../types.mjs";
 import { AnalyticsOptions, AnalyticsSnapshot, ErrorEntry, ProcedureCall, ProcedureSnapshot, RequestEntry, SpanKind, TaskExecution, TaskSnapshot, TraceSpan } from "./analytics/types.mjs";
+import { SchemaRegistry } from "../core/schema-converter.mjs";
 import { AnalyticsCollector } from "./analytics/collector.mjs";
 import { RequestTrace, trace } from "./analytics/trace.mjs";
 import { analyticsAuthResponse, analyticsHTML, checkAnalyticsAuth, serveAnalyticsRoute } from "./analytics/routes.mjs";
 import { errorToMarkdown, requestToMarkdown } from "./analytics/export.mjs";
 import { sanitizeHeaders } from "./analytics/utils.mjs";
 import { RequestAccumulator } from "./analytics/accumulator.mjs";
-import { analyticsTraceMap } from "../core/trace-map.mjs";
+import { SilgiHooks } from "../silgi.mjs";
 import { FetchHandler } from "../core/handler.mjs";
+import { Hookable } from "hookable";
 
 //#region src/plugins/analytics.d.ts
 interface ProcedureSchemaInfo {
@@ -18,6 +20,6 @@ interface ProcedureSchemaInfo {
  * Wrap a fetch handler with analytics collection.
  * Intercepts analytics dashboard routes and instruments every request.
  */
-declare function wrapWithAnalytics(handler: FetchHandler, router: RouterDef | undefined, options?: AnalyticsOptions): FetchHandler;
+declare function wrapWithAnalytics(handler: FetchHandler, router: RouterDef | undefined, options: AnalyticsOptions, registry?: SchemaRegistry, hooks?: Hookable<SilgiHooks>): FetchHandler;
 //#endregion
-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 };
+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, checkAnalyticsAuth, errorToMarkdown, requestToMarkdown, sanitizeHeaders, serveAnalyticsRoute, trace, wrapWithAnalytics };

package/dist/plugins/analytics.mjs

@@ -1,8 +1,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 { schemaToJsonSchema } from "../core/schema-converter.mjs";
 import { generateRequestId } from "./analytics/request-id.mjs";
 import { isTrackedRequestPath, normalizeAnalyticsPath, round, sanitizeHeaders } from "./analytics/utils.mjs";
 import { RequestAccumulator } from "./analytics/accumulator.mjs";
@@ -84,29 +83,18 @@ function extractResponseError(output, status, fallback) {
 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) {
+function schemaToJson(schema, strategy, registry) {
 	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 {}
+	const json = schemaToJsonSchema(schema, strategy, registry);
+	return Object.keys(json).length > 0 ? json : void 0;
 }
-function extractProcedureSchemas(router) {
+function extractProcedureSchemas(router, registry) {
 	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 (node.input) info.input = schemaToJson(node.input, "input", registry);
+			if (node.output) info.output = schemaToJson(node.output, "output", registry);
 			if (info.input || info.output) schemas.set(path.join("/"), info);
 			return;
 		}
@@ -119,12 +107,13 @@ function extractProcedureSchemas(router) {
 * Wrap a fetch handler with analytics collection.
 * Intercepts analytics dashboard routes and instruments every request.
 */
-function wrapWithAnalytics(handler, router, options = {}) {
+function wrapWithAnalytics(handler, router, options, registry, hooks) {
 	const collector = new AnalyticsCollector(options);
-	const procedureSchemas = router ? extractProcedureSchemas(router) : void 0;
+	const procedureSchemas = router ? extractProcedureSchemas(router, registry) : void 0;
 	if (procedureSchemas) collector.setProcedureSchemas(procedureSchemas);
 	const dashboardHtml = analyticsHTML();
 	const auth = options.auth;
+	if (!auth) throw new Error("[silgi analytics] `options.auth` is required. The analytics dashboard exposes request bodies, headers, and stack traces. Provide an auth token via `analytics: { auth: \"your-secret-token\" }` to protect it.");
 	import("../core/task.mjs").then(({ setTaskAnalytics }) => {
 		setTaskAnalytics((entry) => collector.recordTask({
 			...entry,
@@ -136,10 +125,8 @@ function wrapWithAnalytics(handler, router, options = {}) {
 		const analyticsSub = normalizeAnalyticsPath(pathname);
 		if (analyticsSub !== null) {
 			const canonical = analyticsSub === "" ? "api/analytics" : `api/analytics/${analyticsSub}`;
-			if (auth) {
-				const authResult = checkAnalyticsAuth(request, auth);
-				if (!(authResult instanceof Promise ? await authResult : authResult)) return analyticsAuthResponse(canonical);
-			}
+			const authResult = checkAnalyticsAuth(request, auth);
+			if (!(authResult instanceof Promise ? await authResult : authResult)) return analyticsAuthResponse(canonical);
 			return serveAnalyticsRoute(canonical, request, collector, dashboardHtml);
 		}
 		if (!isTrackedRequestPath(pathname) || collector.isIgnored(pathname)) return handler(request);
@@ -149,7 +136,9 @@ function wrapWithAnalytics(handler, router, options = {}) {
 		const acc = new RequestAccumulator(request, collector, traceId, parentRequestId ?? void 0);
 		const reqTrace = new RequestTrace();
 		const t0 = performance.now();
-		analyticsTraceMap.set(request, reqTrace);
+		if (hooks) hooks.hookOnce("request:prepare", (event) => {
+			if (event.request === request) event.ctx.trace = reqTrace;
+		});
 		let response;
 		try {
 			response = await handler(request);
@@ -206,8 +195,6 @@ function wrapWithAnalytics(handler, router, options = {}) {
 				spans: reqTrace.spans ?? []
 			});
 			throw error;
-		} finally {
-			analyticsTraceMap.delete(request);
 		}
 		const headers = new Headers(response.headers);
 		headers.set("x-request-id", acc.requestId);
@@ -224,4 +211,4 @@ function wrapWithAnalytics(handler, router, options = {}) {
 	};
 }
 //#endregion
-export { AnalyticsCollector, RequestAccumulator, RequestTrace, analyticsAuthResponse, analyticsHTML, analyticsTraceMap, checkAnalyticsAuth, errorToMarkdown, requestToMarkdown, sanitizeHeaders, serveAnalyticsRoute, trace, wrapWithAnalytics };
+export { AnalyticsCollector, RequestAccumulator, RequestTrace, analyticsAuthResponse, analyticsHTML, checkAnalyticsAuth, errorToMarkdown, requestToMarkdown, sanitizeHeaders, serveAnalyticsRoute, trace, wrapWithAnalytics };

package/dist/plugins/cache.mjs

@@ -1,4 +1,4 @@
-import { RAW_INPUT } from "../compile.mjs";
+import { RAW_INPUT } from "../core/ctx-symbols.mjs";
 import { useStorage as useStorage$1 } from "../core/storage.mjs";
 import { defineCachedFunction, setStorage, useStorage } from "ocache";
 import { hash } from "ohash";

package/dist/plugins/coerce.mjs

@@ -1,4 +1,4 @@
-import { RAW_INPUT } from "../compile.mjs";
+import { RAW_INPUT } from "../core/ctx-symbols.mjs";
 //#region src/plugins/coerce.ts
 /**
 * Smart coercion — convert string query parameters to proper types.

package/dist/scalar.d.mts

@@ -1,4 +1,5 @@
 import { RouterDef } from "./types.mjs";
+import { SchemaRegistry } from "./core/schema-converter.mjs";
 //#region src/scalar.d.ts
 interface ScalarOptions {
   title?: string;
@@ -43,7 +44,7 @@ interface ScalarOptions {
    */
   cdn?: 'cdn' | 'unpkg' | 'local' | (string & {});
 }
-declare function generateOpenAPI(router: RouterDef, options?: ScalarOptions, basePath?: string): Record<string, unknown>;
+declare function generateOpenAPI(router: RouterDef, options?: ScalarOptions, basePath?: string, registry?: SchemaRegistry): Record<string, unknown>;
 declare function scalarHTML(specUrl: string, options?: ScalarOptions): string;
 //#endregion
 export { ScalarOptions, generateOpenAPI, scalarHTML };

package/dist/scalar.mjs

@@ -1,4 +1,4 @@
-import { ZodSchemaConverter } from "./integrations/zod/converter.mjs";
+import { schemaToJsonSchema } from "./core/schema-converter.mjs";
 //#region src/scalar.ts
 /**
 * Scalar API Reference — v2 OpenAPI integration.
@@ -31,7 +31,8 @@ function toOpenAPIPath(raw) {
 		pathParams
 	};
 }
-function generateOpenAPI(router, options = {}, basePath = "") {
+function generateOpenAPI(router, options = {}, basePath = "", registry) {
+	const schemaToJsonSchema$1 = (schema, strategy = "input") => schemaToJsonSchema(schema, strategy, registry);
 	const paths = {};
 	const tags = /* @__PURE__ */ new Map();
 	collectProcedures(router, [], (path, proc) => {
@@ -74,7 +75,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, "input") : null;
+		const inputSchema = proc.input ? schemaToJsonSchema$1(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);
@@ -107,7 +108,7 @@ function generateOpenAPI(router, options = {}, basePath = "") {
 			};
 			if (params.length > 0) op.parameters = params;
 			if (proc.type === "subscription") {
-				const outputSchema = proc.output ? schemaToJsonSchema(proc.output, "output") : { type: "string" };
+				const outputSchema = proc.output ? schemaToJsonSchema$1(proc.output, "output") : { type: "string" };
 				op.responses[String(successStatus)] = {
 					description: "SSE event stream",
 					content: { "text/event-stream": { schema: {
@@ -117,7 +118,7 @@ function generateOpenAPI(router, options = {}, basePath = "") {
 				};
 			} else if (proc.output) op.responses[String(successStatus)] = {
 				description: successDesc,
-				content: { "application/json": { schema: schemaToJsonSchema(proc.output, "output") } }
+				content: { "application/json": { schema: schemaToJsonSchema$1(proc.output, "output") } }
 			};
 			else op.responses[String(successStatus)] = { description: successDesc };
 			if (proc.input) op.responses["400"] = {
@@ -154,7 +155,7 @@ function generateOpenAPI(router, options = {}, basePath = "") {
 					const entry = { code };
 					if (typeof def === "object") {
 						if (def.message) entry.message = def.message;
-						if (def.data) entry.schema = schemaToJsonSchema(def.data);
+						if (def.data) entry.schema = schemaToJsonSchema$1(def.data);
 					}
 					byStatus.get(status).push(entry);
 				}
@@ -269,28 +270,6 @@ 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.
-*
-* Fast path: `~standard.jsonSchema.input()` (StandardJSONSchemaV1 implementors).
-* Fallback: vendor-specific converters (Zod v4 via ZodSchemaConverter).
-*/
-const _zodConverter = new ZodSchemaConverter();
-function schemaToJsonSchema(schema, strategy = "input") {
-	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 [, jsonSchema] = _zodConverter.convert(schema, { strategy });
-		return jsonSchema;
-	} catch {}
-	return {};
-}
 function objectSchemaToParams(schema) {
 	if (schema.type !== "object" || !schema.properties) return [];
 	const required = new Set(schema.required ?? []);
@@ -306,9 +285,9 @@ 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 = {}, prefix = "/api") {
+function wrapWithScalar(handler, routerDef, options = {}, prefix = "/api", registry) {
 	const normPrefix = (prefix.startsWith("/") ? prefix : "/" + prefix).replace(/\/+$/, "");
-	const specJson = JSON.stringify(generateOpenAPI(routerDef, options, normPrefix));
+	const specJson = JSON.stringify(generateOpenAPI(routerDef, options, normPrefix, registry));
 	const specHtml = scalarHTML(`${normPrefix}/openapi.json`, options);
 	const openapiMatch = `${normPrefix.slice(1)}/openapi.json`;
 	const referenceMatch = `${normPrefix.slice(1)}/reference`;