silgi 0.52.2 → 0.53.1

package/dist/core/handler.mjs

@@ -1,5 +1,5 @@
 import { routerCache } from "./router-utils.mjs";
-import { compileRouter, createContext, detachContext, releaseContext } from "../compile.mjs";
+import { compileRouter } from "../compile.mjs";
 import { applyContext } from "./dispatch.mjs";
 import { detectResponseFormat, encodeResponse, makeErrorResponse } from "./codec.mjs";
 import { parseInput } from "./input.mjs";
@@ -7,58 +7,45 @@ import { iteratorToEventStream } from "./sse.mjs";
 import { parseUrlPath } from "./url.mjs";
 //#region src/core/handler.ts
 /**
-* Fetch API handler — single unified request handler.
+* Fetch API handler
+* -------------------
 *
-* Orchestrates: routing → context → input parsing → pipeline → response encoding.
-* Each concern lives in its own module (codec.ts, input.ts, sse.ts).
+* Every adapter that speaks the Fetch API (Next.js App Router, SvelteKit,
+* srvx, Bun, Cloudflare Workers, Deno) ends up calling the handler built
+* here. It is the single place that turns a `Request` into a `Response`
+* by running the compiled pipeline produced by `compileRouter`.
 *
-* Analytics / Scalar are NOT here — they wrap the handler externally
-* (see wrapWithAnalytics / wrapWithScalar in their respective modules).
+* Responsibilities, in order:
+*
+*   1. URL parsing and `basePath` stripping.
+*   2. Route lookup + HTTP method enforcement.
+*   3. Context construction (factory + optional `AsyncLocalStorage` bridge).
+*   4. `request:prepare` hook so plugins (analytics, etc.) can seed `ctx`.
+*   5. Input parsing (body / query / URL params).
+*   6. Pipeline execution — the compiled handler from `compileProcedure`.
+*   7. Response encoding (JSON, msgpack, stream, SSE, raw `Response`).
+*
+* Analytics and the Scalar UI are layered on top via `wrapHandler` — they
+* do not live inside the hot path.
 */
-/** Wrap a stream to release pooled context on completion or cancellation. */
-function wrapStreamWithRelease(source, ctx) {
-	let released = false;
-	const release = () => {
-		if (!released) {
-			released = true;
-			releaseContext(ctx);
-		}
-	};
-	const reader = source.getReader();
-	return new ReadableStream({
-		async pull(controller) {
-			try {
-				const { done, value } = await reader.read();
-				if (done) {
-					release();
-					controller.close();
-				} else controller.enqueue(value);
-			} catch (err) {
-				release();
-				controller.error(err);
-			}
-		},
-		cancel() {
-			release();
-			reader.cancel();
-		}
-	});
-}
 /**
-* Build the Response for a handler's output. The pooled `ctx` is released
-* by the caller's `using` scope; for streaming outputs we detach `ctx` first
-* so the stream becomes the sole owner (releases on stream end/cancel).
+* Convert a pipeline output into an HTTP `Response`.
+*
+* We handle four shapes:
+*   - `Response` — user returned one directly; pass through.
+*   - `ReadableStream` — wrap in a binary response.
+*   - Async iterator — render as Server-Sent Events.
+*   - Plain value — encode as JSON (or msgpack when the client asked for it).
+*
+* The function is async so callers have a single `await` point and do not
+* have to branch on sync-vs-async encoders underneath.
 */
-function makeResponse(output, route, format, ctx) {
+async function makeResponse(output, route, format) {
 	if (output instanceof Response) return output;
-	if (output instanceof ReadableStream) {
-		detachContext(ctx);
-		return new Response(wrapStreamWithRelease(output, ctx), { headers: { "content-type": "application/octet-stream" } });
-	}
+	if (output instanceof ReadableStream) return new Response(output, { headers: { "content-type": "application/octet-stream" } });
 	if (output && typeof output === "object" && Symbol.asyncIterator in output) {
-		detachContext(ctx);
 		const stream = iteratorToEventStream(output);
-		return new Response(wrapStreamWithRelease(stream, ctx), { headers: {
+		return new Response(stream, { headers: {
 			"content-type": "text/event-stream",
 			"cache-control": "no-cache"
 		} });
@@ -71,29 +58,44 @@ function makeResponse(output, route, format, ctx) {
 	} : { "content-type": "application/json" } });
 }
 /**
-* Lazily wrap a FetchHandler with analytics and/or scalar.
-* Returns a new handler that applies wrappers on first request (async import).
-* If no wrappers are needed, returns the original handler as-is.
+* Wrap a `FetchHandler` with Scalar UI and/or analytics, if configured.
+*
+* Both wrappers have non-trivial imports (Scalar pulls in the API
+* reference, analytics pulls in the dashboard). We defer those imports
+* until the first request so that a handler you never hit does not pay
+* the cost.
+*
+* If the lazy init fails (network blip, broken import) we fall back to
+* the raw handler and log once — one failed init must not wedge every
+* subsequent request.
 */
 function wrapHandler(handler, router, options, prefix) {
 	if (!options?.scalar && !options?.analytics) return handler;
-	let wrapped;
+	let wrapped = handler;
+	let initDone = false;
 	let initPromise;
-	async function init() {
-		let h = handler;
-		if (options.scalar) {
-			const { wrapWithScalar } = await import("../scalar.mjs");
-			const scalarOpts = typeof options.scalar === "object" ? options.scalar : {};
-			h = wrapWithScalar(h, router, scalarOpts, prefix, options.schemaRegistry);
-		}
-		if (options.analytics) {
-			const { wrapWithAnalytics } = await import("../plugins/analytics.mjs");
-			h = wrapWithAnalytics(h, router, options.analytics, options.schemaRegistry, options.hooks);
+	const init = async () => {
+		try {
+			let next = handler;
+			if (options.scalar) {
+				const { wrapWithScalar } = await import("../scalar.mjs");
+				const scalarOpts = typeof options.scalar === "object" ? options.scalar : {};
+				next = wrapWithScalar(next, router, scalarOpts, prefix, options.schemaRegistry);
+			}
+			if (options.analytics) {
+				const { wrapWithAnalytics } = await import("../plugins/analytics.mjs");
+				next = wrapWithAnalytics(next, router, options.analytics, options.schemaRegistry, options.hooks);
+			}
+			wrapped = next;
+		} catch (err) {
+			console.error("[silgi] Failed to initialise scalar/analytics wrapper:", err);
+			wrapped = handler;
+		} finally {
+			initDone = true;
 		}
-		wrapped = h;
-	}
+	};
 	return (request) => {
-		if (wrapped) return wrapped(request);
+		if (initDone) return wrapped(request);
 		initPromise ??= init();
 		return initPromise.then(() => wrapped(request));
 	};
@@ -111,25 +113,39 @@ function createFetchHandler(routerDef, contextFactory, hooks, prefix, bridge) {
 		status: 404,
 		message: "Procedure not found"
 	});
-	function callHook(name, event) {
+	/**
+	* Hook dispatch helpers.
+	*
+	* Hook errors never fail the request. But we do log them: silently
+	* swallowing a hook throw hides genuine user bugs (a typo'd field, a
+	* thrown assertion) and the dashboard / trace / logging pipeline just
+	* stops working with no visible signal.
+	*/
+	const reportHookError = (name, err) => {
+		console.error(`[silgi] hook "${name}" threw:`, err);
+	};
+	const callHook = (name, event) => {
 		if (!hooks) return;
 		try {
 			const result = hooks.callHook(name, event);
-			if (result instanceof Promise) result.catch(() => {});
-		} catch {}
-	}
-	function awaitHook(name, event) {
+			if (result instanceof Promise) result.catch((err) => reportHookError(name, err));
+		} catch (err) {
+			reportHookError(name, err);
+		}
+	};
+	const awaitHook = async (name, event) => {
 		if (!hooks) return;
 		try {
-			const result = hooks.callHook(name, event);
-			if (result instanceof Promise) return result.catch(() => {});
-		} catch {}
-	}
+			await hooks.callHook(name, event);
+		} catch (err) {
+			reportHookError(name, err);
+		}
+	};
 	return async function handleRequest(request) {
 		const url = request.url;
 		let fullPath = parseUrlPath(url);
 		if (prefix) {
-			if (!fullPath.startsWith(prefix)) return new Response(notFoundBody, {
+			if (fullPath !== prefix && !fullPath.startsWith(prefix + "/")) return new Response(notFoundBody, {
 				status: 404,
 				headers: jsonHeaders
 			});
@@ -158,17 +174,15 @@ function createFetchHandler(routerDef, contextFactory, hooks, prefix, bridge) {
 			});
 		}
 		const format = detectResponseFormat(request);
-		using ctx = createContext();
+		const ctx = Object.create(null);
 		let rawInput;
 		try {
-			const baseCtxResult = contextFactory(request);
-			applyContext(ctx, baseCtxResult instanceof Promise ? await baseCtxResult : baseCtxResult);
+			applyContext(ctx, await contextFactory(request));
 			if (match.params) ctx.params = match.params;
-			const prepareResult = awaitHook("request:prepare", {
+			await awaitHook("request:prepare", {
 				request,
 				ctx
 			});
-			if (prepareResult) await prepareResult;
 			if (!route.passthrough) rawInput = await parseInput(request, url, qMark);
 			if (match.params) rawInput = rawInput != null && typeof rawInput === "object" ? {
 				...match.params,
@@ -178,8 +192,7 @@ function createFetchHandler(routerDef, contextFactory, hooks, prefix, bridge) {
 				path: pathname,
 				input: rawInput
 			});
-			const pipelineResult = bridge ? bridge.run(ctx, () => route.handler(ctx, rawInput, request.signal)) : route.handler(ctx, rawInput, request.signal);
-			const output = pipelineResult instanceof Promise ? await pipelineResult : pipelineResult;
+			const output = await (bridge ? bridge.run(ctx, () => route.handler(ctx, rawInput, request.signal)) : route.handler(ctx, rawInput, request.signal));
 			callHook("response", {
 				path: pathname,
 				output,
@@ -190,15 +203,13 @@ function createFetchHandler(routerDef, contextFactory, hooks, prefix, bridge) {
 				ctx,
 				output
 			});
-			const response = makeResponse(output, route, format, ctx);
-			return response instanceof Promise ? await response : response;
+			return await makeResponse(output, route, format);
 		} catch (error) {
 			callHook("error", {
 				path: pathname,
 				error
 			});
-			const errorResponse = makeErrorResponse(error, format);
-			return errorResponse instanceof Promise ? await errorResponse : errorResponse;
+			return await makeErrorResponse(error, format);
 		}
 	};
 }

package/dist/core/input.mjs

@@ -1,49 +1,128 @@
 import { SilgiError } from "./error.mjs";
 //#region src/core/input.ts
 /**
-* Request input parsing — JSON, MessagePack, devalue, query string.
+* Request input parsing
+* -----------------------
+*
+* Pulls the RPC input payload out of an incoming `Request` and returns
+* it in its decoded form. The shape of the input depends on how the
+* client chose to send it:
+*
+*   - `GET` / no-body  — JSON-encoded, URL-escaped, on `?data=` query.
+*   - `content-type: application/msgpack` — binary, via the msgpack codec.
+*   - `content-type: application/x-devalue` — text, via devalue.
+*   - anything else (typically JSON) — JSON body.
+*
+* Empty bodies always resolve to `undefined` so that a procedure with
+* no input, or one whose schema allows `undefined`, works without the
+* client having to send a payload at all. Malformed non-empty bodies
+* throw `BAD_REQUEST` with a message the client can show to a user.
 */
-let _msgpack;
-let _devalue;
-const isBun = typeof globalThis.Bun !== "undefined";
-/** Max allowed size for GET ?data= parameter (bytes). Prevents JSON bomb via URL. */
+/**
+* The msgpack and devalue codecs are pulled in on first use so that a
+* handler that only ever sees JSON never pays the cost of loading
+* them. `Promise`-cached at module scope: once the first request
+* triggers the import, subsequent calls share the resolved module.
+*
+* Module-global is intentional and safe here — the cached value is a
+* reference to an immutable ES module, not user data. Two silgi
+* instances in the same process legitimately share it.
+*/
+let msgpackModule;
+let devalueModule;
+/** Max bytes permitted in the `?data=` query param. Shields against JSON-bomb payloads in a URL. */
 const MAX_QUERY_DATA_LENGTH = 8192;
-/** Parse request input from body or query string */
-async function parseInput(request, url, qMark) {
-	if (request.method === "GET" || !request.body) {
-		if (qMark !== -1) {
-			const searchStr = url.slice(qMark + 1);
-			const dataIdx = searchStr.indexOf("data=");
-			if (dataIdx !== -1) {
-				const valueStart = dataIdx + 5;
-				const valueEnd = searchStr.indexOf("&", valueStart);
-				const encoded = valueEnd === -1 ? searchStr.slice(valueStart) : searchStr.slice(valueStart, valueEnd);
-				if (encoded.length > MAX_QUERY_DATA_LENGTH) throw new SilgiError("BAD_REQUEST", { message: "Query data parameter too large" });
-				return JSON.parse(decodeURIComponent(encoded));
-			}
-		}
-		return;
-	}
-	const ct = request.headers.get("content-type");
-	if (ct) {
-		if (ct.includes("msgpack")) {
-			_msgpack ??= await import("../codec/msgpack.mjs");
-			const buf = new Uint8Array(await request.arrayBuffer());
-			return buf.length > 0 ? _msgpack.decode(buf) : void 0;
-		}
-		if (ct.includes("x-devalue")) {
-			_devalue ??= await import("../codec/devalue.mjs");
-			const text = await request.text();
-			return text ? _devalue.decode(text) : void 0;
+/**
+* Find the value of the `data=` query parameter by key, not by substring.
+*
+* A naive `searchStr.indexOf('data=')` matches `userdata=`, `mydata=`,
+* or any other key that merely ends in `data`, and silently returns
+* the wrong value. This scans for `data=` only at a parameter
+* boundary — i.e. at the start of the search string, or right after
+* an `&`.
+*/
+function findDataParam(searchStr) {
+	let i = 0;
+	while (i < searchStr.length) {
+		if (searchStr.startsWith("data=", i)) {
+			const valueStart = i + 5;
+			const valueEnd = searchStr.indexOf("&", valueStart);
+			return valueEnd === -1 ? searchStr.slice(valueStart) : searchStr.slice(valueStart, valueEnd);
 		}
+		const nextAmp = searchStr.indexOf("&", i);
+		if (nextAmp === -1) return null;
+		i = nextAmp + 1;
 	}
-	if (isBun) try {
-		return await request.json();
+	return null;
+}
+/**
+* Decode the `?data=` query param as JSON. Returns `undefined` when
+* the query is missing or has no `data=` field. Throws `BAD_REQUEST`
+* when the payload is oversized or unparsable.
+*/
+function decodeQueryInput(url, qMark) {
+	if (qMark === -1) return void 0;
+	const encoded = findDataParam(url.slice(qMark + 1));
+	if (encoded === null) return void 0;
+	if (encoded.length > MAX_QUERY_DATA_LENGTH) throw new SilgiError("BAD_REQUEST", { message: "Query data parameter too large" });
+	return JSON.parse(decodeURIComponent(encoded));
+}
+/**
+* Decode a MessagePack-encoded request body. Empty bodies resolve to
+* `undefined` (procedures with no input work without a payload).
+*/
+async function decodeMsgpackBody(request) {
+	msgpackModule ??= await import("../codec/msgpack.mjs");
+	const buf = new Uint8Array(await request.arrayBuffer());
+	return buf.length > 0 ? msgpackModule.decode(buf) : void 0;
+}
+/** Decode a devalue-encoded request body. Empty bodies resolve to `undefined`. */
+async function decodeDevalueBody(request) {
+	devalueModule ??= await import("../codec/devalue.mjs");
+	const text = await request.text();
+	return text ? devalueModule.decode(text) : void 0;
+}
+/**
+* Decode a JSON-encoded request body.
+*
+* Empty bodies resolve to `undefined` so the input schema sees the
+* same value whether or not the client sent a body at all. Malformed
+* non-empty bodies throw `BAD_REQUEST`.
+*
+* Why we `text()` first and then `JSON.parse` — instead of
+* `request.json()`: Bun's `request.json()` is a fast path, but it
+* throws a generic `SyntaxError` for **both** empty and malformed
+* bodies, so we cannot tell them apart. Reading text first keeps the
+* two cases distinct (and Bun's `text()` is also fast).
+*/
+async function decodeJsonBody(request) {
+	const text = await request.text();
+	if (!text) return void 0;
+	try {
+		return JSON.parse(text);
 	} catch {
-		return;
+		throw new SilgiError("BAD_REQUEST", { message: "Malformed JSON body" });
 	}
-	const text = await request.text();
-	return text ? JSON.parse(text) : void 0;
+}
+/**
+* Decode the input payload off a Fetch `Request`.
+*
+* @param request The incoming request.
+* @param url     The full request URL (reused by the caller — we avoid
+*                re-parsing it here).
+* @param qMark   Byte offset of the `?` in `url`, or `-1` when absent.
+*
+* @returns The decoded input value, or `undefined` when the request
+*          carries no payload.
+*/
+async function parseInput(request, url, qMark) {
+	if (request.method === "GET" || !request.body) return decodeQueryInput(url, qMark);
+	const contentType = request.headers.get("content-type");
+	if (contentType) {
+		if (contentType.includes("msgpack")) return decodeMsgpackBody(request);
+		if (contentType.includes("x-devalue")) return decodeDevalueBody(request);
+	}
+	return decodeJsonBody(request);
 }
 //#endregion
 export { parseInput };

package/dist/core/schema-converter.d.mts

@@ -2,7 +2,9 @@ import { AnySchema } from "./schema.mjs";
 
 //#region src/core/schema-converter.d.ts
 /**
- * JSON Schema subset used for OpenAPI / analytics output.
+ * JSON Schema subset used across silgi's OpenAPI and analytics output.
+ * Intentionally broad (`[key: string]: unknown`) so library-specific
+ * fields (e.g. Zod's `x-native-type`) pass through untouched.
  *
  * @category Schema
  */
@@ -22,54 +24,68 @@ interface JSONSchema {
   default?: unknown;
   [key: string]: unknown;
 }
+/**
+ * JSON Schema dialect passed through to the schema library. Matches the
+ * `target` field of the Standard JSON Schema spec. Unknown strings are
+ * allowed so new dialects can be threaded through without a silgi
+ * release; libraries that do not recognise the value should throw and
+ * the conversion falls back to an empty schema.
+ *
+ * @category Schema
+ */
+type JSONSchemaTarget = 'draft-2020-12' | 'draft-07' | 'openapi-3.0' | (string & {});
 /**
  * Options passed to a converter's `toJsonSchema` method.
  *
  * @category Schema
  */
 interface ConvertOptions {
+  /** `'input'` for pre-transform types, `'output'` for post-transform. */
   strategy: 'input' | 'output';
+  /** JSON Schema dialect to target. Defaults to `'draft-2020-12'`. */
+  target?: JSONSchemaTarget;
+  /** Opaque options the converter may forward to its underlying library. */
+  libraryOptions?: Record<string, unknown>;
 }
 /**
- * A converter that translates a specific Standard Schema vendor's schemas
- * into JSON Schema. Pass instances via `silgi({ schemaConverters: [...] })`.
+ * Fallback converter for a schema library that has not adopted the
+ * Standard JSON Schema extension yet. Pass instances via
+ * `silgi({ schemaConverters: [...] })`.
  *
  * @remarks
- * Implement this interface to add OpenAPI / analytics support for a custom
- * schema library. The `vendor` string must match the `~standard.vendor`
- * property reported by the schema library's Standard Schema implementation.
+ * Libraries that *do* implement the extension (Zod v4.2+, ArkType
+ * v2.1.28+, Valibot v1.2+) are handled without a converter — silgi
+ * calls their native `~standard.jsonSchema` directly. Write a converter
+ * only when you need to support a vendor that has not yet adopted the
+ * spec.
  *
  * @example
- * ```ts
- * import type { SchemaConverter } from 'silgi'
+ *   import type { SchemaConverter } from 'silgi'
  *
- * const myConverter: SchemaConverter = {
- *   vendor: 'my-lib',
- *   toJsonSchema(schema, opts) {
- *     return { type: 'string' }
- *   },
- * }
- * ```
+ *   const myConverter: SchemaConverter = {
+ *     vendor: 'my-lib',
+ *     toJsonSchema(schema, opts) {
+ *       return { type: 'string' }
+ *     },
+ *   }
  *
  * @category Schema
  */
 interface SchemaConverter {
-  /** The Standard Schema `~standard.vendor` string this converter handles (e.g. `"zod"`). */
+  /** Matches the `~standard.vendor` reported by the schema library. */
   vendor: string;
   /**
-   * Convert a schema to a JSON Schema object.
-   *
-   * @param schema - The schema to convert.
-   * @param opts - Conversion options including `strategy` (`'input'` | `'output'`).
-   * @returns A JSON Schema object. Return `{}` for unsupported/unknown schemas.
+   * Convert a schema to a JSON Schema object. Return `{}` for schemas
+   * the converter does not understand.
    */
   toJsonSchema(schema: AnySchema, opts: ConvertOptions): JSONSchema;
 }
 /**
- * A per-instance registry mapping vendor strings to their converters.
- *
- * Built by {@link createSchemaRegistry} and threaded through the handler
- * pipeline to scalar and analytics wrappers.
+ * Per-instance mapping of vendor string → fallback converter. Built by
+ * {@link createSchemaRegistry} and threaded through the handler pipeline
+ * to the scalar and analytics wrappers. Using `Map` gives O(1) lookup
+ * and keyed-by-vendor semantics that match the spec's own extension
+ * contract.
  *
  * @category Schema
  */
@@ -77,55 +93,44 @@ type SchemaRegistry = Map<string, SchemaConverter>;
 /**
  * Build a {@link SchemaRegistry} from an array of converters.
  *
- * @param converters - Array of {@link SchemaConverter} objects, each
- *   declaring their own `vendor`.
- * @returns A `Map<string, SchemaConverter>` keyed by `converter.vendor`.
- *
  * @example
- * ```ts
- * import { zodConverter } from 'silgi/zod'
- * import { createSchemaRegistry } from 'silgi'
- *
- * const registry = createSchemaRegistry([zodConverter])
- * ```
+ *   import { zodConverter } from 'silgi/zod'
+ *   const registry = createSchemaRegistry([zodConverter])
  *
  * @category Schema
  */
 declare function createSchemaRegistry(converters?: SchemaConverter[]): SchemaRegistry;
 /**
- * Convert any Standard Schema to JSON Schema.
- *
- * @remarks
- * Resolution order:
- * 1. **Native fast path** — `schema['~standard'].jsonSchema.input()`
- *    (Valibot, ArkType, Zod v4, …). No registry needed.
- * 2. **Registry lookup** — finds a converter by
- *    `schema['~standard'].vendor`. Registry must be passed explicitly;
- *    there is no global mutable state.
- * 3. **Empty schema `{}`** — emits a one-time `console.warn` per vendor
- *    when a registry was provided but contained no matching converter.
- *    No warn when no registry was passed (caller opted out).
- *
- * @param schema - Any Standard Schema compatible schema object.
- * @param strategy - `'input'` (default) for pre-transform types; `'output'`
- *   for post-transform.
- * @param registry - Optional {@link SchemaRegistry} built from
- *   {@link createSchemaRegistry}. When omitted the function still handles
- *   schemas that expose the native `jsonSchema.input()` fast path.
- * @returns A JSON Schema object. Returns `{}` when conversion is not possible.
+ * Convert any Standard Schema to a JSON Schema object.
+ *
+ * @param schema   The schema to convert.
+ * @param strategy `'input'` (default) for pre-transform types, `'output'`
+ *                 for post-transform. Matters for schemas that coerce
+ *                 (e.g. `z.coerce.number()` takes a string and yields a
+ *                 number — input and output schemas differ).
+ * @param registry Optional fallback registry built by
+ *                 {@link createSchemaRegistry}. Omit to rely solely on
+ *                 the native Standard JSON Schema extension.
+ * @param options  Extra knobs: `target` dialect (default
+ *                 `'draft-2020-12'`), opaque `libraryOptions`
+ *                 forwarded to the underlying library.
+ *
+ * @returns A JSON Schema object. `{}` when the schema cannot be
+ *          converted (silent fallback — analytics / OpenAPI output
+ *          still renders, just without schema detail for that field).
  *
  * @example
- * ```ts
- * import { zodConverter } from 'silgi/zod'
- * import { createSchemaRegistry, schemaToJsonSchema } from 'silgi'
- * import { z } from 'zod'
+ *   import { zodConverter } from 'silgi/zod'
+ *   import { createSchemaRegistry, schemaToJsonSchema } from 'silgi'
  *
- * const registry = createSchemaRegistry([zodConverter])
- * const json = schemaToJsonSchema(z.object({ name: z.string() }), 'input', registry)
- * ```
+ *   const registry = createSchemaRegistry([zodConverter])
+ *   const json = schemaToJsonSchema(MySchema, 'input', registry)
  *
  * @category Schema
  */
-declare function schemaToJsonSchema(schema: AnySchema, strategy?: 'input' | 'output', registry?: SchemaRegistry): JSONSchema;
+declare function schemaToJsonSchema(schema: AnySchema, strategy?: 'input' | 'output', registry?: SchemaRegistry, options?: {
+  target?: JSONSchemaTarget;
+  libraryOptions?: Record<string, unknown>;
+}): JSONSchema;
 //#endregion
 export { ConvertOptions, JSONSchema, SchemaConverter, SchemaRegistry, createSchemaRegistry, schemaToJsonSchema };