@victor-software-house/pi-openai-proxy 0.0.1

package/dist/index.mjs

@@ -0,0 +1,4256 @@
+#!/usr/bin/env node
+import { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+import { randomBytes } from "node:crypto";
+import * as z from "zod";
+import { completeSimple, streamSimple } from "@mariozechner/pi-ai";
+import { Hono } from "hono";
+import { stream } from "hono/streaming";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/config/env.ts
+/**
+* Environment and configuration loading.
+*
+* Defaults:
+* - Bind to 127.0.0.1 (safe for local use)
+* - Port 4141
+* - Proxy auth disabled
+* - Agentic mode disabled
+* - Remote image URLs disabled
+* - 50 MB request body limit
+* - 120s upstream timeout
+*/
+/** Default request body size limit: 50 MB (accommodates base64 image payloads). */
+const DEFAULT_MAX_BODY_SIZE = 50 * 1024 * 1024;
+/** Default upstream request timeout: 120 seconds. */
+const DEFAULT_UPSTREAM_TIMEOUT_MS = 12e4;
+function parsePositiveInt(raw, fallback) {
+	if (raw === void 0) return fallback;
+	const n = Number.parseInt(raw, 10);
+	if (!Number.isFinite(n) || n <= 0) return fallback;
+	return n;
+}
+function loadConfig() {
+	return {
+		host: process.env.PI_PROXY_HOST ?? "127.0.0.1",
+		port: Number.parseInt(process.env.PI_PROXY_PORT ?? "4141", 10),
+		proxyAuthToken: process.env.PI_PROXY_AUTH_TOKEN,
+		agenticEnabled: process.env.PI_PROXY_AGENTIC === "true",
+		remoteImagesEnabled: process.env.PI_PROXY_REMOTE_IMAGES === "true",
+		maxBodySize: parsePositiveInt(process.env.PI_PROXY_MAX_BODY_SIZE, DEFAULT_MAX_BODY_SIZE),
+		upstreamTimeoutMs: parsePositiveInt(process.env.PI_PROXY_UPSTREAM_TIMEOUT_MS, DEFAULT_UPSTREAM_TIMEOUT_MS)
+	};
+}
+//#endregion
+//#region src/pi/registry.ts
+let registry;
+let authStorage;
+/**
+* Initialize the registry. Call once at startup.
+* Returns the load error if models.json failed to parse, or undefined on success.
+*/
+function initRegistry() {
+	authStorage = AuthStorage.create();
+	registry = new ModelRegistry(authStorage);
+	return registry.getError();
+}
+function getRegistry() {
+	if (registry === void 0) throw new Error("ModelRegistry not initialized. Call initRegistry() first.");
+	return registry;
+}
+/**
+* Get all models available (have auth configured).
+*/
+function getAvailableModels() {
+	return getRegistry().getAvailable();
+}
+//#endregion
+//#region src/server/errors.ts
+function makeError(message, type, param, code) {
+	return { error: {
+		message,
+		type,
+		param,
+		code
+	} };
+}
+function invalidRequest(message, param) {
+	return makeError(message, "invalid_request_error", param ?? null, null);
+}
+function modelNotFound(modelId) {
+	return makeError(`The model '${modelId}' does not exist`, "invalid_request_error", "model", "model_not_found");
+}
+function unsupportedParameter(param, message) {
+	return makeError(message ?? `Unsupported parameter: '${param}'`, "invalid_request_error", param, "unsupported_parameter");
+}
+function authenticationError(message) {
+	return makeError(message, "authentication_error", null, null);
+}
+function upstreamError(message, code) {
+	return makeError(message, "server_error", null, code ?? "upstream_error");
+}
+function mapUpstreamError(err) {
+	const message = err instanceof Error ? err.message : "Unknown upstream error";
+	if (message.includes("rate") && message.includes("limit")) return {
+		status: 429,
+		body: upstreamError("Upstream rate limit exceeded", "rate_limit")
+	};
+	if (message.includes("timeout") || message.includes("ETIMEDOUT")) return {
+		status: 504,
+		body: upstreamError("Upstream request timed out", "timeout")
+	};
+	if (message.includes("401") || message.includes("403") || message.includes("Unauthorized")) return {
+		status: 502,
+		body: upstreamError("Upstream authentication failed", "upstream_auth_error")
+	};
+	if (message.includes("529") || message.includes("overloaded")) return {
+		status: 503,
+		body: upstreamError("Upstream provider is overloaded", "provider_overloaded")
+	};
+	return {
+		status: 502,
+		body: upstreamError("Upstream provider error")
+	};
+}
+//#endregion
+//#region src/server/logging.ts
+function timestamp() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+function logRequest(ctx) {
+	const entry = {
+		ts: timestamp(),
+		level: "info",
+		event: "request",
+		requestId: ctx.requestId,
+		clientRequestId: ctx.clientRequestId,
+		method: ctx.method,
+		path: ctx.path
+	};
+	console.error(JSON.stringify(entry));
+}
+function logResponse(ctx, status, durationMs) {
+	const entry = {
+		ts: timestamp(),
+		level: "info",
+		event: "response",
+		requestId: ctx.requestId,
+		status,
+		durationMs: Math.round(durationMs)
+	};
+	console.error(JSON.stringify(entry));
+}
+function logError(ctx, message, detail) {
+	const entry = {
+		ts: timestamp(),
+		level: "error",
+		event: "error",
+		requestId: ctx.requestId,
+		message,
+		detail
+	};
+	console.error(JSON.stringify(entry));
+}
+function logDisconnect(ctx) {
+	const entry = {
+		ts: timestamp(),
+		level: "info",
+		event: "disconnect",
+		requestId: ctx.requestId
+	};
+	console.error(JSON.stringify(entry));
+}
+function logStartup(host, port, modelCount) {
+	const entry = {
+		ts: timestamp(),
+		level: "info",
+		event: "startup",
+		host,
+		port,
+		modelCount
+	};
+	console.error(JSON.stringify(entry));
+}
+function logShutdown(signal) {
+	const entry = {
+		ts: timestamp(),
+		level: "info",
+		event: "shutdown",
+		signal
+	};
+	console.error(JSON.stringify(entry));
+}
+//#endregion
+//#region src/server/request-id.ts
+/**
+* Per-request proxy request ID generation.
+*
+* Format: "piproxy-{random}" to be easily distinguishable from upstream IDs.
+*/
+function generateRequestId() {
+	return `piproxy-${randomBytes(12).toString("hex")}`;
+}
+//#endregion
+//#region src/server/middleware.ts
+/**
+* Inject request ID, upstream API key, and logging context into every request.
+*/
+function requestIdMiddleware() {
+	return async (c, next) => {
+		const requestId = generateRequestId();
+		const clientRequestId = c.req.header("x-client-request-id");
+		const upstreamApiKey = c.req.header("x-pi-upstream-api-key");
+		const start = performance.now();
+		c.set("requestId", requestId);
+		c.set("clientRequestId", clientRequestId);
+		c.set("upstreamApiKey", upstreamApiKey);
+		logRequest({
+			requestId,
+			clientRequestId,
+			method: c.req.method,
+			path: c.req.path
+		});
+		c.header("x-request-id", requestId);
+		if (clientRequestId !== void 0) c.header("x-client-request-id", clientRequestId);
+		await next();
+		const duration = performance.now() - start;
+		logResponse({
+			requestId,
+			clientRequestId,
+			method: c.req.method,
+			path: c.req.path
+		}, c.res.status, duration);
+	};
+}
+/**
+* Optional proxy auth middleware.
+* Only active when PI_PROXY_AUTH_TOKEN is set.
+*/
+function proxyAuthMiddleware(config) {
+	return async (c, next) => {
+		if (config.proxyAuthToken === void 0) {
+			await next();
+			return;
+		}
+		const authHeader = c.req.header("authorization");
+		if (authHeader === void 0) return c.json(authenticationError("Missing Authorization header"), 401);
+		if ((authHeader.startsWith("Bearer ") ? authHeader.slice(7) : void 0) !== config.proxyAuthToken) return c.json(authenticationError("Invalid proxy authentication token"), 401);
+		await next();
+	};
+}
+/**
+* Client disconnect detection middleware.
+* Creates an AbortController for upstream cancellation.
+*/
+function disconnectMiddleware() {
+	return async (c, next) => {
+		const controller = new AbortController();
+		c.set("abortController", controller);
+		const reqSignal = c.req.raw.signal;
+		if (reqSignal !== void 0) {
+			const onAbort = () => {
+				logDisconnect({
+					requestId: c.get("requestId"),
+					method: c.req.method,
+					path: c.req.path
+				});
+				controller.abort();
+			};
+			if (reqSignal.aborted) onAbort();
+			else reqSignal.addEventListener("abort", onAbort, { once: true });
+		}
+		await next();
+	};
+}
+/**
+* Request body size limit middleware.
+* Rejects requests with Content-Length exceeding the configured maximum.
+* Only applies to POST/PUT/PATCH methods.
+*/
+function bodySizeLimitMiddleware(config) {
+	return async (c, next) => {
+		const method = c.req.method;
+		if (method !== "POST" && method !== "PUT" && method !== "PATCH") {
+			await next();
+			return;
+		}
+		const contentLength = c.req.header("content-length");
+		if (contentLength !== void 0) {
+			const length = Number.parseInt(contentLength, 10);
+			if (Number.isFinite(length) && length > config.maxBodySize) return c.json(invalidRequest(`Request body too large. Maximum size: ${String(config.maxBodySize)} bytes`), 413);
+		}
+		await next();
+	};
+}
+//#endregion
+//#region src/openai/messages.ts
+const toolArgsSchema = z.record(z.string().trim(), z.unknown());
+/**
+* Convert OpenAI messages array into a pi Context.
+*
+* System and developer messages are merged into `systemPrompt`.
+* Conversation messages are mapped into pi message types.
+*/
+function convertMessages(messages) {
+	const systemParts = [];
+	const piMessages = [];
+	for (let i = 0; i < messages.length; i++) {
+		const msg = messages[i];
+		if (msg === void 0) continue;
+		if (msg.role === "system") systemParts.push(msg.content);
+		else if (msg.role === "developer") systemParts.push(msg.content);
+		else if (msg.role === "user") {
+			const userMsg = convertUserMessage(msg.content, i);
+			if (!userMsg.ok) return userMsg;
+			piMessages.push(userMsg.message);
+		} else if (msg.role === "assistant") {
+			const assistantMsg = convertAssistantMessage(msg.content ?? null, msg.tool_calls);
+			piMessages.push(assistantMsg);
+		} else if (msg.role === "tool") {
+			const toolMsg = convertToolMessage(msg.content, msg.tool_call_id);
+			piMessages.push(toolMsg);
+		}
+	}
+	const context = { messages: piMessages };
+	if (systemParts.length > 0) context.systemPrompt = systemParts.join("\n\n");
+	return {
+		ok: true,
+		context
+	};
+}
+function convertUserMessage(content, index) {
+	if (typeof content === "string") return {
+		ok: true,
+		message: {
+			role: "user",
+			content,
+			timestamp: Date.now()
+		}
+	};
+	const parts = [];
+	for (let j = 0; j < content.length; j++) {
+		const part = content[j];
+		if (part === void 0) continue;
+		if (part.type === "text") parts.push({
+			type: "text",
+			text: part.text ?? ""
+		});
+		else if (part.type === "image_url") {
+			const url = part.image_url?.url ?? "";
+			if (url.startsWith("data:")) {
+				const result = parseAndValidateDataUri(url);
+				if (!result.ok) return {
+					ok: false,
+					message: `${result.message} at messages[${String(index)}].content[${String(j)}]`,
+					param: `messages[${String(index)}].content[${String(j)}].image_url.url`
+				};
+				parts.push({
+					type: "image",
+					data: result.parsed.data,
+					mimeType: result.parsed.mimeType
+				});
+			} else return {
+				ok: false,
+				message: "Remote image URLs are not supported. Use base64 data URIs instead.",
+				param: `messages[${String(index)}].content[${String(j)}].image_url.url`
+			};
+		} else return {
+			ok: false,
+			message: `Unsupported content part type: '${part.type}'`,
+			param: `messages[${String(index)}].content[${String(j)}].type`
+		};
+	}
+	return {
+		ok: true,
+		message: {
+			role: "user",
+			content: parts,
+			timestamp: Date.now()
+		}
+	};
+}
+function convertAssistantMessage(textContent, toolCalls) {
+	const content = [];
+	if (textContent !== null && textContent.length > 0) content.push({
+		type: "text",
+		text: textContent
+	});
+	if (toolCalls !== void 0) for (const tc of toolCalls) {
+		let args = {};
+		try {
+			const parsed = toolArgsSchema.safeParse(JSON.parse(tc.function.arguments));
+			if (parsed.success) args = parsed.data;
+		} catch {}
+		content.push({
+			type: "toolCall",
+			id: tc.id,
+			name: tc.function.name,
+			arguments: args
+		});
+	}
+	return {
+		role: "assistant",
+		content,
+		api: "openai-completions",
+		provider: "proxy",
+		model: "history",
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				total: 0
+			}
+		},
+		stopReason: "stop",
+		timestamp: Date.now()
+	};
+}
+function convertToolMessage(content, toolCallId) {
+	return {
+		role: "toolResult",
+		toolCallId,
+		toolName: "",
+		content: [{
+			type: "text",
+			text: content
+		}],
+		isError: false,
+		timestamp: Date.now()
+	};
+}
+/**
+* Supported image MIME types for base64 data URIs.
+*/
+const SUPPORTED_IMAGE_MIME_TYPES = new Set([
+	"image/png",
+	"image/jpeg",
+	"image/gif",
+	"image/webp"
+]);
+/**
+* Maximum base64 payload size (20 MB of base64 text, ~15 MB decoded).
+*/
+const MAX_BASE64_PAYLOAD_SIZE = 20 * 1024 * 1024;
+function parseAndValidateDataUri(uri) {
+	const match = /^data:([^;]+);base64,(.+)$/.exec(uri);
+	if (match === null) return {
+		ok: false,
+		message: "Invalid base64 data URI format"
+	};
+	const mimeType = match[1];
+	const data = match[2];
+	if (mimeType === void 0 || data === void 0) return {
+		ok: false,
+		message: "Invalid base64 data URI format"
+	};
+	if (!SUPPORTED_IMAGE_MIME_TYPES.has(mimeType)) return {
+		ok: false,
+		message: `Unsupported image MIME type '${mimeType}'. Supported: ${[...SUPPORTED_IMAGE_MIME_TYPES].join(", ")}`
+	};
+	if (data.length > MAX_BASE64_PAYLOAD_SIZE) return {
+		ok: false,
+		message: `Image payload exceeds maximum size of ${String(MAX_BASE64_PAYLOAD_SIZE)} bytes`
+	};
+	return {
+		ok: true,
+		parsed: {
+			data,
+			mimeType
+		}
+	};
+}
+//#endregion
+//#region src/openai/models.ts
+/**
+* Convert a pi Model to an OpenAI model object.
+*/
+function toOpenAIModel(model) {
+	return {
+		id: `${model.provider}/${model.id}`,
+		object: "model",
+		created: 0,
+		owned_by: model.provider,
+		x_pi: {
+			api: model.api,
+			reasoning: model.reasoning,
+			input: model.input,
+			context_window: model.contextWindow,
+			max_tokens: model.maxTokens
+		}
+	};
+}
+/**
+* Build the full model list response.
+*/
+function buildModelList(models) {
+	return {
+		object: "list",
+		data: models.map(toOpenAIModel)
+	};
+}
+//#endregion
+//#region src/openai/responses.ts
+/** Pi StopReason -> OpenAI finish_reason */
+const FINISH_REASON_MAP = {
+	stop: "stop",
+	length: "length",
+	toolUse: "tool_calls",
+	error: "stop",
+	aborted: "stop"
+};
+/**
+* Map pi StopReason to OpenAI finish_reason.
+*/
+function mapFinishReason(reason) {
+	return FINISH_REASON_MAP[reason];
+}
+/**
+* Map pi Usage to OpenAI usage.
+*/
+function mapUsage(usage) {
+	return {
+		prompt_tokens: usage.input,
+		completion_tokens: usage.output,
+		total_tokens: usage.totalTokens
+	};
+}
+/**
+* Build a complete non-streaming OpenAI response from a pi AssistantMessage.
+*/
+function buildChatCompletion(requestId, canonicalModelId, message) {
+	const textParts = message.content.filter((c) => c.type === "text");
+	const textContent = textParts.length > 0 ? textParts.map((t) => t.text).join("") : null;
+	const toolCalls = message.content.filter((c) => c.type === "toolCall").map((tc) => ({
+		id: tc.id,
+		type: "function",
+		function: {
+			name: tc.name,
+			arguments: JSON.stringify(tc.arguments)
+		}
+	}));
+	const messageBody = toolCalls.length > 0 ? {
+		role: "assistant",
+		content: textContent,
+		tool_calls: toolCalls
+	} : {
+		role: "assistant",
+		content: textContent
+	};
+	return {
+		id: requestId,
+		object: "chat.completion",
+		created: Math.floor(Date.now() / 1e3),
+		model: canonicalModelId,
+		choices: [{
+			index: 0,
+			message: messageBody,
+			finish_reason: mapFinishReason(message.stopReason)
+		}],
+		usage: mapUsage(message.usage),
+		x_pi: {
+			cost: message.usage.cost,
+			cache_read_tokens: message.usage.cacheRead,
+			cache_write_tokens: message.usage.cacheWrite
+		}
+	};
+}
+//#endregion
+//#region src/openai/sse.ts
+/**
+* Encode a single SSE data frame.
+*/
+function encodeSSE(chunk) {
+	return `data: ${JSON.stringify(chunk)}\n\n`;
+}
+/**
+* Encode the terminal [DONE] frame.
+*/
+function encodeDone() {
+	return "data: [DONE]\n\n";
+}
+/**
+* Create an async generator that yields SSE text frames from a pi event stream.
+*/
+async function* streamToSSE(events, requestId, model, includeUsage) {
+	const created = Math.floor(Date.now() / 1e3);
+	let sentFirstChunk = false;
+	let finishReason = null;
+	let finalUsage;
+	const toolCallIndexes = /* @__PURE__ */ new Map();
+	for await (const event of events) switch (event.type) {
+		case "start":
+			yield encodeSSE({
+				id: requestId,
+				object: "chat.completion.chunk",
+				created,
+				model,
+				choices: [{
+					index: 0,
+					delta: { role: "assistant" },
+					finish_reason: null
+				}]
+			});
+			sentFirstChunk = true;
+			break;
+		case "text_delta":
+			if (!sentFirstChunk) {
+				yield encodeSSE({
+					id: requestId,
+					object: "chat.completion.chunk",
+					created,
+					model,
+					choices: [{
+						index: 0,
+						delta: {
+							role: "assistant",
+							content: event.delta
+						},
+						finish_reason: null
+					}]
+				});
+				sentFirstChunk = true;
+			} else yield encodeSSE({
+				id: requestId,
+				object: "chat.completion.chunk",
+				created,
+				model,
+				choices: [{
+					index: 0,
+					delta: { content: event.delta },
+					finish_reason: null
+				}]
+			});
+			break;
+		case "toolcall_start": {
+			const ci = event.contentIndex;
+			const toolCallContent = event.partial.content[ci];
+			if (toolCallContent !== void 0 && toolCallContent.type === "toolCall") {
+				const tcIndex = toolCallIndexes.size;
+				toolCallIndexes.set(ci, true);
+				yield encodeSSE({
+					id: requestId,
+					object: "chat.completion.chunk",
+					created,
+					model,
+					choices: [{
+						index: 0,
+						delta: { tool_calls: [{
+							index: tcIndex,
+							id: toolCallContent.id,
+							type: "function",
+							function: {
+								name: toolCallContent.name,
+								arguments: ""
+							}
+						}] },
+						finish_reason: null
+					}]
+				});
+			}
+			break;
+		}
+		case "toolcall_delta": {
+			let tcIndex = 0;
+			let found = false;
+			for (const [ci] of toolCallIndexes) {
+				if (ci === event.contentIndex) {
+					found = true;
+					break;
+				}
+				tcIndex++;
+			}
+			if (!found) break;
+			yield encodeSSE({
+				id: requestId,
+				object: "chat.completion.chunk",
+				created,
+				model,
+				choices: [{
+					index: 0,
+					delta: { tool_calls: [{
+						index: tcIndex,
+						function: { arguments: event.delta }
+					}] },
+					finish_reason: null
+				}]
+			});
+			break;
+		}
+		case "done":
+			finishReason = mapFinishReason(event.reason);
+			finalUsage = event.message.usage;
+			break;
+		case "error": {
+			const errorMessage = event.error.errorMessage ?? "Upstream provider error";
+			yield `data: ${JSON.stringify({ error: {
+				message: errorMessage,
+				type: "server_error",
+				param: null,
+				code: "upstream_error"
+			} })}\n\n`;
+			yield encodeDone();
+			return;
+		}
+		default: break;
+	}
+	if (finishReason !== null) yield encodeSSE({
+		id: requestId,
+		object: "chat.completion.chunk",
+		created,
+		model,
+		choices: [{
+			index: 0,
+			delta: {},
+			finish_reason: finishReason
+		}]
+	});
+	if (includeUsage && finalUsage !== void 0) yield encodeSSE({
+		id: requestId,
+		object: "chat.completion.chunk",
+		created,
+		model,
+		choices: [],
+		usage: mapUsage(finalUsage)
+	});
+	yield encodeDone();
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
+/** Returns true if this value is an async iterator */
+function IsAsyncIterator$2(value) {
+	return IsObject$3(value) && !IsArray$3(value) && !IsUint8Array$2(value) && Symbol.asyncIterator in value;
+}
+/** Returns true if this value is an array */
+function IsArray$3(value) {
+	return Array.isArray(value);
+}
+/** Returns true if this value is bigint */
+function IsBigInt$2(value) {
+	return typeof value === "bigint";
+}
+/** Returns true if this value is a boolean */
+function IsBoolean$2(value) {
+	return typeof value === "boolean";
+}
+/** Returns true if this value is a Date object */
+function IsDate$2(value) {
+	return value instanceof globalThis.Date;
+}
+/** Returns true if this value is a function */
+function IsFunction$2(value) {
+	return typeof value === "function";
+}
+/** Returns true if this value is an iterator */
+function IsIterator$2(value) {
+	return IsObject$3(value) && !IsArray$3(value) && !IsUint8Array$2(value) && Symbol.iterator in value;
+}
+/** Returns true if this value is null */
+function IsNull$2(value) {
+	return value === null;
+}
+/** Returns true if this value is number */
+function IsNumber$3(value) {
+	return typeof value === "number";
+}
+/** Returns true if this value is an object */
+function IsObject$3(value) {
+	return typeof value === "object" && value !== null;
+}
+/** Returns true if this value is RegExp */
+function IsRegExp$2(value) {
+	return value instanceof globalThis.RegExp;
+}
+/** Returns true if this value is string */
+function IsString$2(value) {
+	return typeof value === "string";
+}
+/** Returns true if this value is symbol */
+function IsSymbol$2(value) {
+	return typeof value === "symbol";
+}
+/** Returns true if this value is a Uint8Array */
+function IsUint8Array$2(value) {
+	return value instanceof globalThis.Uint8Array;
+}
+/** Returns true if this value is undefined */
+function IsUndefined$3(value) {
+	return value === void 0;
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/clone/value.mjs
+function ArrayType(value) {
+	return value.map((value) => Visit$2(value));
+}
+function DateType(value) {
+	return new Date(value.getTime());
+}
+function Uint8ArrayType(value) {
+	return new Uint8Array(value);
+}
+function RegExpType(value) {
+	return new RegExp(value.source, value.flags);
+}
+function ObjectType(value) {
+	const result = {};
+	for (const key of Object.getOwnPropertyNames(value)) result[key] = Visit$2(value[key]);
+	for (const key of Object.getOwnPropertySymbols(value)) result[key] = Visit$2(value[key]);
+	return result;
+}
+function Visit$2(value) {
+	return IsArray$3(value) ? ArrayType(value) : IsDate$2(value) ? DateType(value) : IsUint8Array$2(value) ? Uint8ArrayType(value) : IsRegExp$2(value) ? RegExpType(value) : IsObject$3(value) ? ObjectType(value) : value;
+}
+/** Clones a value */
+function Clone(value) {
+	return Visit$2(value);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/clone/type.mjs
+/** Clones a Type */
+function CloneType(schema, options) {
+	return options === void 0 ? Clone(schema) : Clone({
+		...options,
+		...schema
+	});
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/value/guard/guard.mjs
+/** Returns true of this value is an object type */
+function IsObject$2(value) {
+	return value !== null && typeof value === "object";
+}
+/** Returns true if this value is an array, but not a typed array */
+function IsArray$2(value) {
+	return globalThis.Array.isArray(value) && !globalThis.ArrayBuffer.isView(value);
+}
+/** Returns true if this value is an undefined */
+function IsUndefined$2(value) {
+	return value === void 0;
+}
+/** Returns true if this value is an number */
+function IsNumber$2(value) {
+	return typeof value === "number";
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/system/policy.mjs
+var TypeSystemPolicy;
+(function(TypeSystemPolicy) {
+	/**
+	* Configures the instantiation behavior of TypeBox types. The `default` option assigns raw JavaScript
+	* references for embedded types, which may cause side effects if type properties are explicitly updated
+	* outside the TypeBox type builder. The `clone` option creates copies of any shared types upon creation,
+	* preventing unintended side effects. The `freeze` option applies `Object.freeze()` to the type, making
+	* it fully readonly and immutable. Implementations should use `default` whenever possible, as it is the
+	* fastest way to instantiate types. The default setting is `default`.
+	*/
+	TypeSystemPolicy.InstanceMode = "default";
+	/** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
+	TypeSystemPolicy.ExactOptionalPropertyTypes = false;
+	/** Sets whether arrays should be treated as a kind of objects. The default is `false` */
+	TypeSystemPolicy.AllowArrayObject = false;
+	/** Sets whether `NaN` or `Infinity` should be treated as valid numeric values. The default is `false` */
+	TypeSystemPolicy.AllowNaN = false;
+	/** Sets whether `null` should validate for void types. The default is `false` */
+	TypeSystemPolicy.AllowNullVoid = false;
+	/** Checks this value using the ExactOptionalPropertyTypes policy */
+	function IsExactOptionalProperty(value, key) {
+		return TypeSystemPolicy.ExactOptionalPropertyTypes ? key in value : value[key] !== void 0;
+	}
+	TypeSystemPolicy.IsExactOptionalProperty = IsExactOptionalProperty;
+	/** Checks this value using the AllowArrayObjects policy */
+	function IsObjectLike(value) {
+		const isObject = IsObject$2(value);
+		return TypeSystemPolicy.AllowArrayObject ? isObject : isObject && !IsArray$2(value);
+	}
+	TypeSystemPolicy.IsObjectLike = IsObjectLike;
+	/** Checks this value as a record using the AllowArrayObjects policy */
+	function IsRecordLike(value) {
+		return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
+	}
+	TypeSystemPolicy.IsRecordLike = IsRecordLike;
+	/** Checks this value using the AllowNaN policy */
+	function IsNumberLike(value) {
+		return TypeSystemPolicy.AllowNaN ? IsNumber$2(value) : Number.isFinite(value);
+	}
+	TypeSystemPolicy.IsNumberLike = IsNumberLike;
+	/** Checks this value using the AllowVoidNull policy */
+	function IsVoidLike(value) {
+		const isUndefined = IsUndefined$2(value);
+		return TypeSystemPolicy.AllowNullVoid ? isUndefined || value === null : isUndefined;
+	}
+	TypeSystemPolicy.IsVoidLike = IsVoidLike;
+})(TypeSystemPolicy || (TypeSystemPolicy = {}));
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/create/immutable.mjs
+function ImmutableArray(value) {
+	return globalThis.Object.freeze(value).map((value) => Immutable(value));
+}
+function ImmutableDate(value) {
+	return value;
+}
+function ImmutableUint8Array(value) {
+	return value;
+}
+function ImmutableRegExp(value) {
+	return value;
+}
+function ImmutableObject(value) {
+	const result = {};
+	for (const key of Object.getOwnPropertyNames(value)) result[key] = Immutable(value[key]);
+	for (const key of Object.getOwnPropertySymbols(value)) result[key] = Immutable(value[key]);
+	return globalThis.Object.freeze(result);
+}
+/** Specialized deep immutable value. Applies freeze recursively to the given value */
+function Immutable(value) {
+	return IsArray$3(value) ? ImmutableArray(value) : IsDate$2(value) ? ImmutableDate(value) : IsUint8Array$2(value) ? ImmutableUint8Array(value) : IsRegExp$2(value) ? ImmutableRegExp(value) : IsObject$3(value) ? ImmutableObject(value) : value;
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/create/type.mjs
+/** Creates TypeBox schematics using the configured InstanceMode */
+function CreateType(schema, options) {
+	const result = options !== void 0 ? {
+		...options,
+		...schema
+	} : schema;
+	switch (TypeSystemPolicy.InstanceMode) {
+		case "freeze": return Immutable(result);
+		case "clone": return Clone(result);
+		default: return result;
+	}
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/error/error.mjs
+/** The base Error type thrown for all TypeBox exceptions  */
+var TypeBoxError = class extends Error {
+	constructor(message) {
+		super(message);
+	}
+};
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/symbols/symbols.mjs
+/** Symbol key applied to transform types */
+const TransformKind = Symbol.for("TypeBox.Transform");
+/** Symbol key applied to readonly types */
+const ReadonlyKind = Symbol.for("TypeBox.Readonly");
+/** Symbol key applied to optional types */
+const OptionalKind = Symbol.for("TypeBox.Optional");
+/** Symbol key applied to types */
+const Hint = Symbol.for("TypeBox.Hint");
+/** Symbol key applied to types */
+const Kind = Symbol.for("TypeBox.Kind");
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/guard/kind.mjs
+/** `[Kind-Only]` Returns true if this value has a Readonly symbol */
+function IsReadonly(value) {
+	return IsObject$3(value) && value[ReadonlyKind] === "Readonly";
+}
+/** `[Kind-Only]` Returns true if this value has a Optional symbol */
+function IsOptional$1(value) {
+	return IsObject$3(value) && value[OptionalKind] === "Optional";
+}
+/** `[Kind-Only]` Returns true if the given value is TAny */
+function IsAny$1(value) {
+	return IsKindOf$1(value, "Any");
+}
+/** `[Kind-Only]` Returns true if the given value is TArgument */
+function IsArgument$1(value) {
+	return IsKindOf$1(value, "Argument");
+}
+/** `[Kind-Only]` Returns true if the given value is TArray */
+function IsArray$1(value) {
+	return IsKindOf$1(value, "Array");
+}
+/** `[Kind-Only]` Returns true if the given value is TAsyncIterator */
+function IsAsyncIterator$1(value) {
+	return IsKindOf$1(value, "AsyncIterator");
+}
+/** `[Kind-Only]` Returns true if the given value is TBigInt */
+function IsBigInt$1(value) {
+	return IsKindOf$1(value, "BigInt");
+}
+/** `[Kind-Only]` Returns true if the given value is TBoolean */
+function IsBoolean$1(value) {
+	return IsKindOf$1(value, "Boolean");
+}
+/** `[Kind-Only]` Returns true if the given value is TComputed */
+function IsComputed$1(value) {
+	return IsKindOf$1(value, "Computed");
+}
+/** `[Kind-Only]` Returns true if the given value is TConstructor */
+function IsConstructor$1(value) {
+	return IsKindOf$1(value, "Constructor");
+}
+/** `[Kind-Only]` Returns true if the given value is TDate */
+function IsDate$1(value) {
+	return IsKindOf$1(value, "Date");
+}
+/** `[Kind-Only]` Returns true if the given value is TFunction */
+function IsFunction$1(value) {
+	return IsKindOf$1(value, "Function");
+}
+/** `[Kind-Only]` Returns true if the given value is TInteger */
+function IsInteger$1(value) {
+	return IsKindOf$1(value, "Integer");
+}
+/** `[Kind-Only]` Returns true if the given value is TIntersect */
+function IsIntersect$1(value) {
+	return IsKindOf$1(value, "Intersect");
+}
+/** `[Kind-Only]` Returns true if the given value is TIterator */
+function IsIterator$1(value) {
+	return IsKindOf$1(value, "Iterator");
+}
+/** `[Kind-Only]` Returns true if the given value is a TKind with the given name. */
+function IsKindOf$1(value, kind) {
+	return IsObject$3(value) && Kind in value && value[Kind] === kind;
+}
+/** `[Kind-Only]` Returns true if the given value is TLiteralValue */
+function IsLiteralValue$1(value) {
+	return IsBoolean$2(value) || IsNumber$3(value) || IsString$2(value);
+}
+/** `[Kind-Only]` Returns true if the given value is TLiteral */
+function IsLiteral$1(value) {
+	return IsKindOf$1(value, "Literal");
+}
+/** `[Kind-Only]` Returns true if the given value is a TMappedKey */
+function IsMappedKey$1(value) {
+	return IsKindOf$1(value, "MappedKey");
+}
+/** `[Kind-Only]` Returns true if the given value is TMappedResult */
+function IsMappedResult$1(value) {
+	return IsKindOf$1(value, "MappedResult");
+}
+/** `[Kind-Only]` Returns true if the given value is TNever */
+function IsNever$1(value) {
+	return IsKindOf$1(value, "Never");
+}
+/** `[Kind-Only]` Returns true if the given value is TNot */
+function IsNot$1(value) {
+	return IsKindOf$1(value, "Not");
+}
+/** `[Kind-Only]` Returns true if the given value is TNull */
+function IsNull$1(value) {
+	return IsKindOf$1(value, "Null");
+}
+/** `[Kind-Only]` Returns true if the given value is TNumber */
+function IsNumber$1(value) {
+	return IsKindOf$1(value, "Number");
+}
+/** `[Kind-Only]` Returns true if the given value is TObject */
+function IsObject$1(value) {
+	return IsKindOf$1(value, "Object");
+}
+/** `[Kind-Only]` Returns true if the given value is TPromise */
+function IsPromise$1(value) {
+	return IsKindOf$1(value, "Promise");
+}
+/** `[Kind-Only]` Returns true if the given value is TRecord */
+function IsRecord$1(value) {
+	return IsKindOf$1(value, "Record");
+}
+/** `[Kind-Only]` Returns true if the given value is TRef */
+function IsRef$1(value) {
+	return IsKindOf$1(value, "Ref");
+}
+/** `[Kind-Only]` Returns true if the given value is TRegExp */
+function IsRegExp$1(value) {
+	return IsKindOf$1(value, "RegExp");
+}
+/** `[Kind-Only]` Returns true if the given value is TString */
+function IsString$1(value) {
+	return IsKindOf$1(value, "String");
+}
+/** `[Kind-Only]` Returns true if the given value is TSymbol */
+function IsSymbol$1(value) {
+	return IsKindOf$1(value, "Symbol");
+}
+/** `[Kind-Only]` Returns true if the given value is TTemplateLiteral */
+function IsTemplateLiteral$1(value) {
+	return IsKindOf$1(value, "TemplateLiteral");
+}
+/** `[Kind-Only]` Returns true if the given value is TThis */
+function IsThis$1(value) {
+	return IsKindOf$1(value, "This");
+}
+/** `[Kind-Only]` Returns true of this value is TTransform */
+function IsTransform$1(value) {
+	return IsObject$3(value) && TransformKind in value;
+}
+/** `[Kind-Only]` Returns true if the given value is TTuple */
+function IsTuple$1(value) {
+	return IsKindOf$1(value, "Tuple");
+}
+/** `[Kind-Only]` Returns true if the given value is TUndefined */
+function IsUndefined$1(value) {
+	return IsKindOf$1(value, "Undefined");
+}
+/** `[Kind-Only]` Returns true if the given value is TUnion */
+function IsUnion$1(value) {
+	return IsKindOf$1(value, "Union");
+}
+/** `[Kind-Only]` Returns true if the given value is TUint8Array */
+function IsUint8Array$1(value) {
+	return IsKindOf$1(value, "Uint8Array");
+}
+/** `[Kind-Only]` Returns true if the given value is TUnknown */
+function IsUnknown$1(value) {
+	return IsKindOf$1(value, "Unknown");
+}
+/** `[Kind-Only]` Returns true if the given value is a raw TUnsafe */
+function IsUnsafe$1(value) {
+	return IsKindOf$1(value, "Unsafe");
+}
+/** `[Kind-Only]` Returns true if the given value is TVoid */
+function IsVoid$1(value) {
+	return IsKindOf$1(value, "Void");
+}
+/** `[Kind-Only]` Returns true if the given value is TKind */
+function IsKind$1(value) {
+	return IsObject$3(value) && Kind in value && IsString$2(value[Kind]);
+}
+/** `[Kind-Only]` Returns true if the given value is TSchema */
+function IsSchema$1(value) {
+	return IsAny$1(value) || IsArgument$1(value) || IsArray$1(value) || IsBoolean$1(value) || IsBigInt$1(value) || IsAsyncIterator$1(value) || IsComputed$1(value) || IsConstructor$1(value) || IsDate$1(value) || IsFunction$1(value) || IsInteger$1(value) || IsIntersect$1(value) || IsIterator$1(value) || IsLiteral$1(value) || IsMappedKey$1(value) || IsMappedResult$1(value) || IsNever$1(value) || IsNot$1(value) || IsNull$1(value) || IsNumber$1(value) || IsObject$1(value) || IsPromise$1(value) || IsRecord$1(value) || IsRef$1(value) || IsRegExp$1(value) || IsString$1(value) || IsSymbol$1(value) || IsTemplateLiteral$1(value) || IsThis$1(value) || IsTuple$1(value) || IsUndefined$1(value) || IsUnion$1(value) || IsUint8Array$1(value) || IsUnknown$1(value) || IsUnsafe$1(value) || IsVoid$1(value) || IsKind$1(value);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/guard/type.mjs
+const KnownTypes = [
+	"Argument",
+	"Any",
+	"Array",
+	"AsyncIterator",
+	"BigInt",
+	"Boolean",
+	"Computed",
+	"Constructor",
+	"Date",
+	"Enum",
+	"Function",
+	"Integer",
+	"Intersect",
+	"Iterator",
+	"Literal",
+	"MappedKey",
+	"MappedResult",
+	"Not",
+	"Null",
+	"Number",
+	"Object",
+	"Promise",
+	"Record",
+	"Ref",
+	"RegExp",
+	"String",
+	"Symbol",
+	"TemplateLiteral",
+	"This",
+	"Tuple",
+	"Undefined",
+	"Union",
+	"Uint8Array",
+	"Unknown",
+	"Void"
+];
+function IsPattern(value) {
+	try {
+		new RegExp(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function IsControlCharacterFree(value) {
+	if (!IsString$2(value)) return false;
+	for (let i = 0; i < value.length; i++) {
+		const code = value.charCodeAt(i);
+		if (code >= 7 && code <= 13 || code === 27 || code === 127) return false;
+	}
+	return true;
+}
+function IsAdditionalProperties(value) {
+	return IsOptionalBoolean(value) || IsSchema(value);
+}
+function IsOptionalBigInt(value) {
+	return IsUndefined$3(value) || IsBigInt$2(value);
+}
+function IsOptionalNumber(value) {
+	return IsUndefined$3(value) || IsNumber$3(value);
+}
+function IsOptionalBoolean(value) {
+	return IsUndefined$3(value) || IsBoolean$2(value);
+}
+function IsOptionalString(value) {
+	return IsUndefined$3(value) || IsString$2(value);
+}
+function IsOptionalPattern(value) {
+	return IsUndefined$3(value) || IsString$2(value) && IsControlCharacterFree(value) && IsPattern(value);
+}
+function IsOptionalFormat(value) {
+	return IsUndefined$3(value) || IsString$2(value) && IsControlCharacterFree(value);
+}
+function IsOptionalSchema(value) {
+	return IsUndefined$3(value) || IsSchema(value);
+}
+/** Returns true if this value has a Optional symbol */
+function IsOptional(value) {
+	return IsObject$3(value) && value[OptionalKind] === "Optional";
+}
+/** Returns true if the given value is TAny */
+function IsAny(value) {
+	return IsKindOf(value, "Any") && IsOptionalString(value.$id);
+}
+/** Returns true if the given value is TArgument */
+function IsArgument(value) {
+	return IsKindOf(value, "Argument") && IsNumber$3(value.index);
+}
+/** Returns true if the given value is TArray */
+function IsArray(value) {
+	return IsKindOf(value, "Array") && value.type === "array" && IsOptionalString(value.$id) && IsSchema(value.items) && IsOptionalNumber(value.minItems) && IsOptionalNumber(value.maxItems) && IsOptionalBoolean(value.uniqueItems) && IsOptionalSchema(value.contains) && IsOptionalNumber(value.minContains) && IsOptionalNumber(value.maxContains);
+}
+/** Returns true if the given value is TAsyncIterator */
+function IsAsyncIterator(value) {
+	return IsKindOf(value, "AsyncIterator") && value.type === "AsyncIterator" && IsOptionalString(value.$id) && IsSchema(value.items);
+}
+/** Returns true if the given value is TBigInt */
+function IsBigInt(value) {
+	return IsKindOf(value, "BigInt") && value.type === "bigint" && IsOptionalString(value.$id) && IsOptionalBigInt(value.exclusiveMaximum) && IsOptionalBigInt(value.exclusiveMinimum) && IsOptionalBigInt(value.maximum) && IsOptionalBigInt(value.minimum) && IsOptionalBigInt(value.multipleOf);
+}
+/** Returns true if the given value is TBoolean */
+function IsBoolean(value) {
+	return IsKindOf(value, "Boolean") && value.type === "boolean" && IsOptionalString(value.$id);
+}
+/** Returns true if the given value is TComputed */
+function IsComputed(value) {
+	return IsKindOf(value, "Computed") && IsString$2(value.target) && IsArray$3(value.parameters) && value.parameters.every((schema) => IsSchema(schema));
+}
+/** Returns true if the given value is TConstructor */
+function IsConstructor(value) {
+	return IsKindOf(value, "Constructor") && value.type === "Constructor" && IsOptionalString(value.$id) && IsArray$3(value.parameters) && value.parameters.every((schema) => IsSchema(schema)) && IsSchema(value.returns);
+}
+/** Returns true if the given value is TDate */
+function IsDate(value) {
+	return IsKindOf(value, "Date") && value.type === "Date" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximumTimestamp) && IsOptionalNumber(value.exclusiveMinimumTimestamp) && IsOptionalNumber(value.maximumTimestamp) && IsOptionalNumber(value.minimumTimestamp) && IsOptionalNumber(value.multipleOfTimestamp);
+}
+/** Returns true if the given value is TFunction */
+function IsFunction(value) {
+	return IsKindOf(value, "Function") && value.type === "Function" && IsOptionalString(value.$id) && IsArray$3(value.parameters) && value.parameters.every((schema) => IsSchema(schema)) && IsSchema(value.returns);
+}
+/** Returns true if the given value is TInteger */
+function IsInteger(value) {
+	return IsKindOf(value, "Integer") && value.type === "integer" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
+}
+/** Returns true if the given schema is TProperties */
+function IsProperties(value) {
+	return IsObject$3(value) && Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && IsSchema(schema));
+}
+/** Returns true if the given value is TIntersect */
+function IsIntersect(value) {
+	return IsKindOf(value, "Intersect") && (IsString$2(value.type) && value.type !== "object" ? false : true) && IsArray$3(value.allOf) && value.allOf.every((schema) => IsSchema(schema) && !IsTransform(schema)) && IsOptionalString(value.type) && (IsOptionalBoolean(value.unevaluatedProperties) || IsOptionalSchema(value.unevaluatedProperties)) && IsOptionalString(value.$id);
+}
+/** Returns true if the given value is TIterator */
+function IsIterator(value) {
+	return IsKindOf(value, "Iterator") && value.type === "Iterator" && IsOptionalString(value.$id) && IsSchema(value.items);
+}
+/** Returns true if the given value is a TKind with the given name. */
+function IsKindOf(value, kind) {
+	return IsObject$3(value) && Kind in value && value[Kind] === kind;
+}
+/** Returns true if the given value is TLiteral<string> */
+function IsLiteralString(value) {
+	return IsLiteral(value) && IsString$2(value.const);
+}
+/** Returns true if the given value is TLiteral<number> */
+function IsLiteralNumber(value) {
+	return IsLiteral(value) && IsNumber$3(value.const);
+}
+/** Returns true if the given value is TLiteral<boolean> */
+function IsLiteralBoolean(value) {
+	return IsLiteral(value) && IsBoolean$2(value.const);
+}
+/** Returns true if the given value is TLiteral */
+function IsLiteral(value) {
+	return IsKindOf(value, "Literal") && IsOptionalString(value.$id) && IsLiteralValue(value.const);
+}
+/** Returns true if the given value is a TLiteralValue */
+function IsLiteralValue(value) {
+	return IsBoolean$2(value) || IsNumber$3(value) || IsString$2(value);
+}
+/** Returns true if the given value is a TMappedKey */
+function IsMappedKey(value) {
+	return IsKindOf(value, "MappedKey") && IsArray$3(value.keys) && value.keys.every((key) => IsNumber$3(key) || IsString$2(key));
+}
+/** Returns true if the given value is TMappedResult */
+function IsMappedResult(value) {
+	return IsKindOf(value, "MappedResult") && IsProperties(value.properties);
+}
+/** Returns true if the given value is TNever */
+function IsNever(value) {
+	return IsKindOf(value, "Never") && IsObject$3(value.not) && Object.getOwnPropertyNames(value.not).length === 0;
+}
+/** Returns true if the given value is TNot */
+function IsNot(value) {
+	return IsKindOf(value, "Not") && IsSchema(value.not);
+}
+/** Returns true if the given value is TNull */
+function IsNull(value) {
+	return IsKindOf(value, "Null") && value.type === "null" && IsOptionalString(value.$id);
+}
+/** Returns true if the given value is TNumber */
+function IsNumber(value) {
+	return IsKindOf(value, "Number") && value.type === "number" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
+}
+/** Returns true if the given value is TObject */
+function IsObject(value) {
+	return IsKindOf(value, "Object") && value.type === "object" && IsOptionalString(value.$id) && IsProperties(value.properties) && IsAdditionalProperties(value.additionalProperties) && IsOptionalNumber(value.minProperties) && IsOptionalNumber(value.maxProperties);
+}
+/** Returns true if the given value is TPromise */
+function IsPromise(value) {
+	return IsKindOf(value, "Promise") && value.type === "Promise" && IsOptionalString(value.$id) && IsSchema(value.item);
+}
+/** Returns true if the given value is TRecord */
+function IsRecord(value) {
+	return IsKindOf(value, "Record") && value.type === "object" && IsOptionalString(value.$id) && IsAdditionalProperties(value.additionalProperties) && IsObject$3(value.patternProperties) && ((schema) => {
+		const keys = Object.getOwnPropertyNames(schema.patternProperties);
+		return keys.length === 1 && IsPattern(keys[0]) && IsObject$3(schema.patternProperties) && IsSchema(schema.patternProperties[keys[0]]);
+	})(value);
+}
+/** Returns true if the given value is TRef */
+function IsRef(value) {
+	return IsKindOf(value, "Ref") && IsOptionalString(value.$id) && IsString$2(value.$ref);
+}
+/** Returns true if the given value is TRegExp */
+function IsRegExp(value) {
+	return IsKindOf(value, "RegExp") && IsOptionalString(value.$id) && IsString$2(value.source) && IsString$2(value.flags) && IsOptionalNumber(value.maxLength) && IsOptionalNumber(value.minLength);
+}
+/** Returns true if the given value is TString */
+function IsString(value) {
+	return IsKindOf(value, "String") && value.type === "string" && IsOptionalString(value.$id) && IsOptionalNumber(value.minLength) && IsOptionalNumber(value.maxLength) && IsOptionalPattern(value.pattern) && IsOptionalFormat(value.format);
+}
+/** Returns true if the given value is TSymbol */
+function IsSymbol(value) {
+	return IsKindOf(value, "Symbol") && value.type === "symbol" && IsOptionalString(value.$id);
+}
+/** Returns true if the given value is TTemplateLiteral */
+function IsTemplateLiteral(value) {
+	return IsKindOf(value, "TemplateLiteral") && value.type === "string" && IsString$2(value.pattern) && value.pattern[0] === "^" && value.pattern[value.pattern.length - 1] === "$";
+}
+/** Returns true if the given value is TThis */
+function IsThis(value) {
+	return IsKindOf(value, "This") && IsOptionalString(value.$id) && IsString$2(value.$ref);
+}
+/** Returns true of this value is TTransform */
+function IsTransform(value) {
+	return IsObject$3(value) && TransformKind in value;
+}
+/** Returns true if the given value is TTuple */
+function IsTuple(value) {
+	return IsKindOf(value, "Tuple") && value.type === "array" && IsOptionalString(value.$id) && IsNumber$3(value.minItems) && IsNumber$3(value.maxItems) && value.minItems === value.maxItems && (IsUndefined$3(value.items) && IsUndefined$3(value.additionalItems) && value.minItems === 0 || IsArray$3(value.items) && value.items.every((schema) => IsSchema(schema)));
+}
+/** Returns true if the given value is TUndefined */
+function IsUndefined(value) {
+	return IsKindOf(value, "Undefined") && value.type === "undefined" && IsOptionalString(value.$id);
+}
+/** Returns true if the given value is TUnion */
+function IsUnion(value) {
+	return IsKindOf(value, "Union") && IsOptionalString(value.$id) && IsObject$3(value) && IsArray$3(value.anyOf) && value.anyOf.every((schema) => IsSchema(schema));
+}
+/** Returns true if the given value is TUint8Array */
+function IsUint8Array(value) {
+	return IsKindOf(value, "Uint8Array") && value.type === "Uint8Array" && IsOptionalString(value.$id) && IsOptionalNumber(value.minByteLength) && IsOptionalNumber(value.maxByteLength);
+}
+/** Returns true if the given value is TUnknown */
+function IsUnknown(value) {
+	return IsKindOf(value, "Unknown") && IsOptionalString(value.$id);
+}
+/** Returns true if the given value is a raw TUnsafe */
+function IsUnsafe(value) {
+	return IsKindOf(value, "Unsafe");
+}
+/** Returns true if the given value is TVoid */
+function IsVoid(value) {
+	return IsKindOf(value, "Void") && value.type === "void" && IsOptionalString(value.$id);
+}
+/** Returns true if the given value is TKind */
+function IsKind(value) {
+	return IsObject$3(value) && Kind in value && IsString$2(value[Kind]) && !KnownTypes.includes(value[Kind]);
+}
+/** Returns true if the given value is TSchema */
+function IsSchema(value) {
+	return IsObject$3(value) && (IsAny(value) || IsArgument(value) || IsArray(value) || IsBoolean(value) || IsBigInt(value) || IsAsyncIterator(value) || IsComputed(value) || IsConstructor(value) || IsDate(value) || IsFunction(value) || IsInteger(value) || IsIntersect(value) || IsIterator(value) || IsLiteral(value) || IsMappedKey(value) || IsMappedResult(value) || IsNever(value) || IsNot(value) || IsNull(value) || IsNumber(value) || IsObject(value) || IsPromise(value) || IsRecord(value) || IsRef(value) || IsRegExp(value) || IsString(value) || IsSymbol(value) || IsTemplateLiteral(value) || IsThis(value) || IsTuple(value) || IsUndefined(value) || IsUnion(value) || IsUint8Array(value) || IsUnknown(value) || IsUnsafe(value) || IsVoid(value) || IsKind(value));
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/patterns/patterns.mjs
+const PatternBoolean = "(true|false)";
+const PatternNumber = "(0|[1-9][0-9]*)";
+const PatternString = "(.*)";
+const PatternNever = "(?!.*)";
+`${PatternBoolean}`;
+const PatternNumberExact = `^${PatternNumber}$`;
+const PatternStringExact = `^${PatternString}$`;
+const PatternNeverExact = `^${PatternNever}$`;
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/sets/set.mjs
+/** Returns true if element right is in the set of left */
+function SetIncludes(T, S) {
+	return T.includes(S);
+}
+/** Returns a distinct set of elements */
+function SetDistinct(T) {
+	return [...new Set(T)];
+}
+/** Returns the Intersect of the given sets */
+function SetIntersect(T, S) {
+	return T.filter((L) => S.includes(L));
+}
+function SetIntersectManyResolve(T, Init) {
+	return T.reduce((Acc, L) => {
+		return SetIntersect(Acc, L);
+	}, Init);
+}
+function SetIntersectMany(T) {
+	return T.length === 1 ? T[0] : T.length > 1 ? SetIntersectManyResolve(T.slice(1), T[0]) : [];
+}
+/** Returns the Union of multiple sets */
+function SetUnionMany(T) {
+	const Acc = [];
+	for (const L of T) Acc.push(...L);
+	return Acc;
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/any/any.mjs
+/** `[Json]` Creates an Any type */
+function Any(options) {
+	return CreateType({ [Kind]: "Any" }, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/array/array.mjs
+/** `[Json]` Creates an Array type */
+function Array$1(items, options) {
+	return CreateType({
+		[Kind]: "Array",
+		type: "array",
+		items
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/argument/argument.mjs
+/** `[JavaScript]` Creates an Argument Type. */
+function Argument(index) {
+	return CreateType({
+		[Kind]: "Argument",
+		index
+	});
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/async-iterator/async-iterator.mjs
+/** `[JavaScript]` Creates a AsyncIterator type */
+function AsyncIterator(items, options) {
+	return CreateType({
+		[Kind]: "AsyncIterator",
+		type: "AsyncIterator",
+		items
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/computed/computed.mjs
+/** `[Internal]` Creates a deferred computed type. This type is used exclusively in modules to defer resolution of computable types that contain interior references  */
+function Computed(target, parameters, options) {
+	return CreateType({
+		[Kind]: "Computed",
+		target,
+		parameters
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/discard/discard.mjs
+function DiscardKey(value, key) {
+	const { [key]: _, ...rest } = value;
+	return rest;
+}
+/** Discards property keys from the given value. This function returns a shallow Clone. */
+function Discard(value, keys) {
+	return keys.reduce((acc, key) => DiscardKey(acc, key), value);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/never/never.mjs
+/** `[Json]` Creates a Never type */
+function Never(options) {
+	return CreateType({
+		[Kind]: "Never",
+		not: {}
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/mapped/mapped-result.mjs
+function MappedResult(properties) {
+	return CreateType({
+		[Kind]: "MappedResult",
+		properties
+	});
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/constructor/constructor.mjs
+/** `[JavaScript]` Creates a Constructor type */
+function Constructor(parameters, returns, options) {
+	return CreateType({
+		[Kind]: "Constructor",
+		type: "Constructor",
+		parameters,
+		returns
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/function/function.mjs
+/** `[JavaScript]` Creates a Function type */
+function Function(parameters, returns, options) {
+	return CreateType({
+		[Kind]: "Function",
+		type: "Function",
+		parameters,
+		returns
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/union/union-create.mjs
+function UnionCreate(T, options) {
+	return CreateType({
+		[Kind]: "Union",
+		anyOf: T
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/union/union-evaluated.mjs
+function IsUnionOptional(types) {
+	return types.some((type) => IsOptional$1(type));
+}
+function RemoveOptionalFromRest$1(types) {
+	return types.map((left) => IsOptional$1(left) ? RemoveOptionalFromType$1(left) : left);
+}
+function RemoveOptionalFromType$1(T) {
+	return Discard(T, [OptionalKind]);
+}
+function ResolveUnion(types, options) {
+	return IsUnionOptional(types) ? Optional(UnionCreate(RemoveOptionalFromRest$1(types), options)) : UnionCreate(RemoveOptionalFromRest$1(types), options);
+}
+/** `[Json]` Creates an evaluated Union type */
+function UnionEvaluated(T, options) {
+	return T.length === 1 ? CreateType(T[0], options) : T.length === 0 ? Never(options) : ResolveUnion(T, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/union/union.mjs
+/** `[Json]` Creates a Union type */
+function Union(types, options) {
+	return types.length === 0 ? Never(options) : types.length === 1 ? CreateType(types[0], options) : UnionCreate(types, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/template-literal/parse.mjs
+var TemplateLiteralParserError = class extends TypeBoxError {};
+function Unescape(pattern) {
+	return pattern.replace(/\\\$/g, "$").replace(/\\\*/g, "*").replace(/\\\^/g, "^").replace(/\\\|/g, "|").replace(/\\\(/g, "(").replace(/\\\)/g, ")");
+}
+function IsNonEscaped(pattern, index, char) {
+	return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
+}
+function IsOpenParen(pattern, index) {
+	return IsNonEscaped(pattern, index, "(");
+}
+function IsCloseParen(pattern, index) {
+	return IsNonEscaped(pattern, index, ")");
+}
+function IsSeparator(pattern, index) {
+	return IsNonEscaped(pattern, index, "|");
+}
+function IsGroup(pattern) {
+	if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1))) return false;
+	let count = 0;
+	for (let index = 0; index < pattern.length; index++) {
+		if (IsOpenParen(pattern, index)) count += 1;
+		if (IsCloseParen(pattern, index)) count -= 1;
+		if (count === 0 && index !== pattern.length - 1) return false;
+	}
+	return true;
+}
+function InGroup(pattern) {
+	return pattern.slice(1, pattern.length - 1);
+}
+function IsPrecedenceOr(pattern) {
+	let count = 0;
+	for (let index = 0; index < pattern.length; index++) {
+		if (IsOpenParen(pattern, index)) count += 1;
+		if (IsCloseParen(pattern, index)) count -= 1;
+		if (IsSeparator(pattern, index) && count === 0) return true;
+	}
+	return false;
+}
+function IsPrecedenceAnd(pattern) {
+	for (let index = 0; index < pattern.length; index++) if (IsOpenParen(pattern, index)) return true;
+	return false;
+}
+function Or(pattern) {
+	let [count, start] = [0, 0];
+	const expressions = [];
+	for (let index = 0; index < pattern.length; index++) {
+		if (IsOpenParen(pattern, index)) count += 1;
+		if (IsCloseParen(pattern, index)) count -= 1;
+		if (IsSeparator(pattern, index) && count === 0) {
+			const range = pattern.slice(start, index);
+			if (range.length > 0) expressions.push(TemplateLiteralParse(range));
+			start = index + 1;
+		}
+	}
+	const range = pattern.slice(start);
+	if (range.length > 0) expressions.push(TemplateLiteralParse(range));
+	if (expressions.length === 0) return {
+		type: "const",
+		const: ""
+	};
+	if (expressions.length === 1) return expressions[0];
+	return {
+		type: "or",
+		expr: expressions
+	};
+}
+function And(pattern) {
+	function Group(value, index) {
+		if (!IsOpenParen(value, index)) throw new TemplateLiteralParserError(`TemplateLiteralParser: Index must point to open parens`);
+		let count = 0;
+		for (let scan = index; scan < value.length; scan++) {
+			if (IsOpenParen(value, scan)) count += 1;
+			if (IsCloseParen(value, scan)) count -= 1;
+			if (count === 0) return [index, scan];
+		}
+		throw new TemplateLiteralParserError(`TemplateLiteralParser: Unclosed group parens in expression`);
+	}
+	function Range(pattern, index) {
+		for (let scan = index; scan < pattern.length; scan++) if (IsOpenParen(pattern, scan)) return [index, scan];
+		return [index, pattern.length];
+	}
+	const expressions = [];
+	for (let index = 0; index < pattern.length; index++) if (IsOpenParen(pattern, index)) {
+		const [start, end] = Group(pattern, index);
+		const range = pattern.slice(start, end + 1);
+		expressions.push(TemplateLiteralParse(range));
+		index = end;
+	} else {
+		const [start, end] = Range(pattern, index);
+		const range = pattern.slice(start, end);
+		if (range.length > 0) expressions.push(TemplateLiteralParse(range));
+		index = end - 1;
+	}
+	return expressions.length === 0 ? {
+		type: "const",
+		const: ""
+	} : expressions.length === 1 ? expressions[0] : {
+		type: "and",
+		expr: expressions
+	};
+}
+/** Parses a pattern and returns an expression tree */
+function TemplateLiteralParse(pattern) {
+	return IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) : IsPrecedenceOr(pattern) ? Or(pattern) : IsPrecedenceAnd(pattern) ? And(pattern) : {
+		type: "const",
+		const: Unescape(pattern)
+	};
+}
+/** Parses a pattern and strips forward and trailing ^ and $ */
+function TemplateLiteralParseExact(pattern) {
+	return TemplateLiteralParse(pattern.slice(1, pattern.length - 1));
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/template-literal/finite.mjs
+var TemplateLiteralFiniteError = class extends TypeBoxError {};
+function IsNumberExpression(expression) {
+	return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "0" && expression.expr[1].type === "const" && expression.expr[1].const === "[1-9][0-9]*";
+}
+function IsBooleanExpression(expression) {
+	return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "true" && expression.expr[1].type === "const" && expression.expr[1].const === "false";
+}
+function IsStringExpression(expression) {
+	return expression.type === "const" && expression.const === ".*";
+}
+function IsTemplateLiteralExpressionFinite(expression) {
+	return IsNumberExpression(expression) || IsStringExpression(expression) ? false : IsBooleanExpression(expression) ? true : expression.type === "and" ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) : expression.type === "or" ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) : expression.type === "const" ? true : (() => {
+		throw new TemplateLiteralFiniteError(`Unknown expression type`);
+	})();
+}
+/** Returns true if this TemplateLiteral resolves to a finite set of values */
+function IsTemplateLiteralFinite(schema) {
+	return IsTemplateLiteralExpressionFinite(TemplateLiteralParseExact(schema.pattern));
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/template-literal/generate.mjs
+var TemplateLiteralGenerateError = class extends TypeBoxError {};
+function* GenerateReduce(buffer) {
+	if (buffer.length === 1) return yield* buffer[0];
+	for (const left of buffer[0]) for (const right of GenerateReduce(buffer.slice(1))) yield `${left}${right}`;
+}
+function* GenerateAnd(expression) {
+	return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralExpressionGenerate(expr)]));
+}
+function* GenerateOr(expression) {
+	for (const expr of expression.expr) yield* TemplateLiteralExpressionGenerate(expr);
+}
+function* GenerateConst(expression) {
+	return yield expression.const;
+}
+function* TemplateLiteralExpressionGenerate(expression) {
+	return expression.type === "and" ? yield* GenerateAnd(expression) : expression.type === "or" ? yield* GenerateOr(expression) : expression.type === "const" ? yield* GenerateConst(expression) : (() => {
+		throw new TemplateLiteralGenerateError("Unknown expression");
+	})();
+}
+/** Generates a tuple of strings from the given TemplateLiteral. Returns an empty tuple if infinite. */
+function TemplateLiteralGenerate(schema) {
+	const expression = TemplateLiteralParseExact(schema.pattern);
+	return IsTemplateLiteralExpressionFinite(expression) ? [...TemplateLiteralExpressionGenerate(expression)] : [];
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/literal/literal.mjs
+/** `[Json]` Creates a Literal type */
+function Literal(value, options) {
+	return CreateType({
+		[Kind]: "Literal",
+		const: value,
+		type: typeof value
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/boolean/boolean.mjs
+/** `[Json]` Creates a Boolean type */
+function Boolean(options) {
+	return CreateType({
+		[Kind]: "Boolean",
+		type: "boolean"
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/bigint/bigint.mjs
+/** `[JavaScript]` Creates a BigInt type */
+function BigInt(options) {
+	return CreateType({
+		[Kind]: "BigInt",
+		type: "bigint"
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/number/number.mjs
+/** `[Json]` Creates a Number type */
+function Number$1(options) {
+	return CreateType({
+		[Kind]: "Number",
+		type: "number"
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/string/string.mjs
+/** `[Json]` Creates a String type */
+function String$1(options) {
+	return CreateType({
+		[Kind]: "String",
+		type: "string"
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/template-literal/syntax.mjs
+function* FromUnion$9(syntax) {
+	const trim = syntax.trim().replace(/"|'/g, "");
+	return trim === "boolean" ? yield Boolean() : trim === "number" ? yield Number$1() : trim === "bigint" ? yield BigInt() : trim === "string" ? yield String$1() : yield (() => {
+		const literals = trim.split("|").map((literal) => Literal(literal.trim()));
+		return literals.length === 0 ? Never() : literals.length === 1 ? literals[0] : UnionEvaluated(literals);
+	})();
+}
+function* FromTerminal(syntax) {
+	if (syntax[1] !== "{") return yield* [Literal("$"), ...FromSyntax(syntax.slice(1))];
+	for (let i = 2; i < syntax.length; i++) if (syntax[i] === "}") {
+		const L = FromUnion$9(syntax.slice(2, i));
+		const R = FromSyntax(syntax.slice(i + 1));
+		return yield* [...L, ...R];
+	}
+	yield Literal(syntax);
+}
+function* FromSyntax(syntax) {
+	for (let i = 0; i < syntax.length; i++) if (syntax[i] === "$") return yield* [Literal(syntax.slice(0, i)), ...FromTerminal(syntax.slice(i))];
+	yield Literal(syntax);
+}
+/** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
+function TemplateLiteralSyntax(syntax) {
+	return [...FromSyntax(syntax)];
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/template-literal/pattern.mjs
+var TemplateLiteralPatternError = class extends TypeBoxError {};
+function Escape(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function Visit$1(schema, acc) {
+	return IsTemplateLiteral$1(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) : IsUnion$1(schema) ? `(${schema.anyOf.map((schema) => Visit$1(schema, acc)).join("|")})` : IsNumber$1(schema) ? `${acc}${PatternNumber}` : IsInteger$1(schema) ? `${acc}${PatternNumber}` : IsBigInt$1(schema) ? `${acc}${PatternNumber}` : IsString$1(schema) ? `${acc}${PatternString}` : IsLiteral$1(schema) ? `${acc}${Escape(schema.const.toString())}` : IsBoolean$1(schema) ? `${acc}${PatternBoolean}` : (() => {
+		throw new TemplateLiteralPatternError(`Unexpected Kind '${schema[Kind]}'`);
+	})();
+}
+function TemplateLiteralPattern(kinds) {
+	return `^${kinds.map((schema) => Visit$1(schema, "")).join("")}\$`;
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/template-literal/union.mjs
+/** Returns a Union from the given TemplateLiteral */
+function TemplateLiteralToUnion(schema) {
+	return UnionEvaluated(TemplateLiteralGenerate(schema).map((S) => Literal(S)));
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/template-literal/template-literal.mjs
+/** `[Json]` Creates a TemplateLiteral type */
+function TemplateLiteral(unresolved, options) {
+	const pattern = IsString$2(unresolved) ? TemplateLiteralPattern(TemplateLiteralSyntax(unresolved)) : TemplateLiteralPattern(unresolved);
+	return CreateType({
+		[Kind]: "TemplateLiteral",
+		type: "string",
+		pattern
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-property-keys.mjs
+function FromTemplateLiteral$2(templateLiteral) {
+	return TemplateLiteralGenerate(templateLiteral).map((key) => key.toString());
+}
+function FromUnion$8(types) {
+	const result = [];
+	for (const type of types) result.push(...IndexPropertyKeys(type));
+	return result;
+}
+function FromLiteral$1(literalValue) {
+	return [literalValue.toString()];
+}
+/** Returns a tuple of PropertyKeys derived from the given TSchema */
+function IndexPropertyKeys(type) {
+	return [...new Set(IsTemplateLiteral$1(type) ? FromTemplateLiteral$2(type) : IsUnion$1(type) ? FromUnion$8(type.anyOf) : IsLiteral$1(type) ? FromLiteral$1(type.const) : IsNumber$1(type) ? ["[number]"] : IsInteger$1(type) ? ["[number]"] : [])];
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-result.mjs
+function FromProperties$18(type, properties, options) {
+	const result = {};
+	for (const K2 of Object.getOwnPropertyNames(properties)) result[K2] = Index(type, IndexPropertyKeys(properties[K2]), options);
+	return result;
+}
+function FromMappedResult$11(type, mappedResult, options) {
+	return FromProperties$18(type, mappedResult.properties, options);
+}
+function IndexFromMappedResult(type, mappedResult, options) {
+	return MappedResult(FromMappedResult$11(type, mappedResult, options));
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/indexed/indexed.mjs
+function FromRest$6(types, key) {
+	return types.map((type) => IndexFromPropertyKey(type, key));
+}
+function FromIntersectRest(types) {
+	return types.filter((type) => !IsNever$1(type));
+}
+function FromIntersect$7(types, key) {
+	return IntersectEvaluated(FromIntersectRest(FromRest$6(types, key)));
+}
+function FromUnionRest(types) {
+	return types.some((L) => IsNever$1(L)) ? [] : types;
+}
+function FromUnion$7(types, key) {
+	return UnionEvaluated(FromUnionRest(FromRest$6(types, key)));
+}
+function FromTuple$4(types, key) {
+	return key in types ? types[key] : key === "[number]" ? UnionEvaluated(types) : Never();
+}
+function FromArray$5(type, key) {
+	return key === "[number]" ? type : Never();
+}
+function FromProperty$2(properties, propertyKey) {
+	return propertyKey in properties ? properties[propertyKey] : Never();
+}
+function IndexFromPropertyKey(type, propertyKey) {
+	return IsIntersect$1(type) ? FromIntersect$7(type.allOf, propertyKey) : IsUnion$1(type) ? FromUnion$7(type.anyOf, propertyKey) : IsTuple$1(type) ? FromTuple$4(type.items ?? [], propertyKey) : IsArray$1(type) ? FromArray$5(type.items, propertyKey) : IsObject$1(type) ? FromProperty$2(type.properties, propertyKey) : Never();
+}
+function IndexFromPropertyKeys(type, propertyKeys) {
+	return propertyKeys.map((propertyKey) => IndexFromPropertyKey(type, propertyKey));
+}
+function FromSchema(type, propertyKeys) {
+	return UnionEvaluated(IndexFromPropertyKeys(type, propertyKeys));
+}
+/** `[Json]` Returns an Indexed property type for the given keys */
+function Index(type, key, options) {
+	if (IsRef$1(type) || IsRef$1(key)) {
+		const error = `Index types using Ref parameters require both Type and Key to be of TSchema`;
+		if (!IsSchema$1(type) || !IsSchema$1(key)) throw new TypeBoxError(error);
+		return Computed("Index", [type, key]);
+	}
+	if (IsMappedResult$1(key)) return IndexFromMappedResult(type, key, options);
+	if (IsMappedKey$1(key)) return IndexFromMappedKey(type, key, options);
+	return CreateType(IsSchema$1(key) ? FromSchema(type, IndexPropertyKeys(key)) : FromSchema(type, key), options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-key.mjs
+function MappedIndexPropertyKey(type, key, options) {
+	return { [key]: Index(type, [key], Clone(options)) };
+}
+function MappedIndexPropertyKeys(type, propertyKeys, options) {
+	return propertyKeys.reduce((result, left) => {
+		return {
+			...result,
+			...MappedIndexPropertyKey(type, left, options)
+		};
+	}, {});
+}
+function MappedIndexProperties(type, mappedKey, options) {
+	return MappedIndexPropertyKeys(type, mappedKey.keys, options);
+}
+function IndexFromMappedKey(type, mappedKey, options) {
+	return MappedResult(MappedIndexProperties(type, mappedKey, options));
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/iterator/iterator.mjs
+/** `[JavaScript]` Creates an Iterator type */
+function Iterator(items, options) {
+	return CreateType({
+		[Kind]: "Iterator",
+		type: "Iterator",
+		items
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/object/object.mjs
+/** Creates a RequiredArray derived from the given TProperties value. */
+function RequiredArray(properties) {
+	return globalThis.Object.keys(properties).filter((key) => !IsOptional$1(properties[key]));
+}
+/** `[Json]` Creates an Object type */
+function _Object(properties, options) {
+	const required = RequiredArray(properties);
+	return CreateType(required.length > 0 ? {
+		[Kind]: "Object",
+		type: "object",
+		required,
+		properties
+	} : {
+		[Kind]: "Object",
+		type: "object",
+		properties
+	}, options);
+}
+/** `[Json]` Creates an Object type */
+var Object$1 = _Object;
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/promise/promise.mjs
+/** `[JavaScript]` Creates a Promise type */
+function Promise$1(item, options) {
+	return CreateType({
+		[Kind]: "Promise",
+		type: "Promise",
+		item
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/readonly/readonly.mjs
+function RemoveReadonly(schema) {
+	return CreateType(Discard(schema, [ReadonlyKind]));
+}
+function AddReadonly(schema) {
+	return CreateType({
+		...schema,
+		[ReadonlyKind]: "Readonly"
+	});
+}
+function ReadonlyWithFlag(schema, F) {
+	return F === false ? RemoveReadonly(schema) : AddReadonly(schema);
+}
+/** `[Json]` Creates a Readonly property */
+function Readonly(schema, enable) {
+	const F = enable ?? true;
+	return IsMappedResult$1(schema) ? ReadonlyFromMappedResult(schema, F) : ReadonlyWithFlag(schema, F);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/readonly/readonly-from-mapped-result.mjs
+function FromProperties$17(K, F) {
+	const Acc = {};
+	for (const K2 of globalThis.Object.getOwnPropertyNames(K)) Acc[K2] = Readonly(K[K2], F);
+	return Acc;
+}
+function FromMappedResult$10(R, F) {
+	return FromProperties$17(R.properties, F);
+}
+function ReadonlyFromMappedResult(R, F) {
+	return MappedResult(FromMappedResult$10(R, F));
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/tuple/tuple.mjs
+/** `[Json]` Creates a Tuple type */
+function Tuple(types, options) {
+	return CreateType(types.length > 0 ? {
+		[Kind]: "Tuple",
+		type: "array",
+		items: types,
+		additionalItems: false,
+		minItems: types.length,
+		maxItems: types.length
+	} : {
+		[Kind]: "Tuple",
+		type: "array",
+		minItems: types.length,
+		maxItems: types.length
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/mapped/mapped.mjs
+function FromMappedResult$9(K, P) {
+	return K in P ? FromSchemaType(K, P[K]) : MappedResult(P);
+}
+function MappedKeyToKnownMappedResultProperties(K) {
+	return { [K]: Literal(K) };
+}
+function MappedKeyToUnknownMappedResultProperties(P) {
+	const Acc = {};
+	for (const L of P) Acc[L] = Literal(L);
+	return Acc;
+}
+function MappedKeyToMappedResultProperties(K, P) {
+	return SetIncludes(P, K) ? MappedKeyToKnownMappedResultProperties(K) : MappedKeyToUnknownMappedResultProperties(P);
+}
+function FromMappedKey$3(K, P) {
+	return FromMappedResult$9(K, MappedKeyToMappedResultProperties(K, P));
+}
+function FromRest$5(K, T) {
+	return T.map((L) => FromSchemaType(K, L));
+}
+function FromProperties$16(K, T) {
+	const Acc = {};
+	for (const K2 of globalThis.Object.getOwnPropertyNames(T)) Acc[K2] = FromSchemaType(K, T[K2]);
+	return Acc;
+}
+function FromSchemaType(K, T) {
+	const options = { ...T };
+	return IsOptional$1(T) ? Optional(FromSchemaType(K, Discard(T, [OptionalKind]))) : IsReadonly(T) ? Readonly(FromSchemaType(K, Discard(T, [ReadonlyKind]))) : IsMappedResult$1(T) ? FromMappedResult$9(K, T.properties) : IsMappedKey$1(T) ? FromMappedKey$3(K, T.keys) : IsConstructor$1(T) ? Constructor(FromRest$5(K, T.parameters), FromSchemaType(K, T.returns), options) : IsFunction$1(T) ? Function(FromRest$5(K, T.parameters), FromSchemaType(K, T.returns), options) : IsAsyncIterator$1(T) ? AsyncIterator(FromSchemaType(K, T.items), options) : IsIterator$1(T) ? Iterator(FromSchemaType(K, T.items), options) : IsIntersect$1(T) ? Intersect(FromRest$5(K, T.allOf), options) : IsUnion$1(T) ? Union(FromRest$5(K, T.anyOf), options) : IsTuple$1(T) ? Tuple(FromRest$5(K, T.items ?? []), options) : IsObject$1(T) ? Object$1(FromProperties$16(K, T.properties), options) : IsArray$1(T) ? Array$1(FromSchemaType(K, T.items), options) : IsPromise$1(T) ? Promise$1(FromSchemaType(K, T.item), options) : T;
+}
+function MappedFunctionReturnType(K, T) {
+	const Acc = {};
+	for (const L of K) Acc[L] = FromSchemaType(L, T);
+	return Acc;
+}
+/** `[Json]` Creates a Mapped object type */
+function Mapped(key, map, options) {
+	const K = IsSchema$1(key) ? IndexPropertyKeys(key) : key;
+	return Object$1(MappedFunctionReturnType(K, map({
+		[Kind]: "MappedKey",
+		keys: K
+	})), options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/optional/optional.mjs
+function RemoveOptional(schema) {
+	return CreateType(Discard(schema, [OptionalKind]));
+}
+function AddOptional(schema) {
+	return CreateType({
+		...schema,
+		[OptionalKind]: "Optional"
+	});
+}
+function OptionalWithFlag(schema, F) {
+	return F === false ? RemoveOptional(schema) : AddOptional(schema);
+}
+/** `[Json]` Creates a Optional property */
+function Optional(schema, enable) {
+	const F = enable ?? true;
+	return IsMappedResult$1(schema) ? OptionalFromMappedResult(schema, F) : OptionalWithFlag(schema, F);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/optional/optional-from-mapped-result.mjs
+function FromProperties$15(P, F) {
+	const Acc = {};
+	for (const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Optional(P[K2], F);
+	return Acc;
+}
+function FromMappedResult$8(R, F) {
+	return FromProperties$15(R.properties, F);
+}
+function OptionalFromMappedResult(R, F) {
+	return MappedResult(FromMappedResult$8(R, F));
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-create.mjs
+function IntersectCreate(T, options = {}) {
+	const allObjects = T.every((schema) => IsObject$1(schema));
+	const clonedUnevaluatedProperties = IsSchema$1(options.unevaluatedProperties) ? { unevaluatedProperties: options.unevaluatedProperties } : {};
+	return CreateType(options.unevaluatedProperties === false || IsSchema$1(options.unevaluatedProperties) || allObjects ? {
+		...clonedUnevaluatedProperties,
+		[Kind]: "Intersect",
+		type: "object",
+		allOf: T
+	} : {
+		...clonedUnevaluatedProperties,
+		[Kind]: "Intersect",
+		allOf: T
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-evaluated.mjs
+function IsIntersectOptional(types) {
+	return types.every((left) => IsOptional$1(left));
+}
+function RemoveOptionalFromType(type) {
+	return Discard(type, [OptionalKind]);
+}
+function RemoveOptionalFromRest(types) {
+	return types.map((left) => IsOptional$1(left) ? RemoveOptionalFromType(left) : left);
+}
+function ResolveIntersect(types, options) {
+	return IsIntersectOptional(types) ? Optional(IntersectCreate(RemoveOptionalFromRest(types), options)) : IntersectCreate(RemoveOptionalFromRest(types), options);
+}
+/** `[Json]` Creates an evaluated Intersect type */
+function IntersectEvaluated(types, options = {}) {
+	if (types.length === 1) return CreateType(types[0], options);
+	if (types.length === 0) return Never(options);
+	if (types.some((schema) => IsTransform$1(schema))) throw new Error("Cannot intersect transform types");
+	return ResolveIntersect(types, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/intersect/intersect.mjs
+/** `[Json]` Creates an evaluated Intersect type */
+function Intersect(types, options) {
+	if (types.length === 1) return CreateType(types[0], options);
+	if (types.length === 0) return Never(options);
+	if (types.some((schema) => IsTransform$1(schema))) throw new Error("Cannot intersect transform types");
+	return IntersectCreate(types, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/ref/ref.mjs
+/** `[Json]` Creates a Ref type. The referenced type must contain a $id */
+function Ref(...args) {
+	const [$ref, options] = typeof args[0] === "string" ? [args[0], args[1]] : [args[0].$id, args[1]];
+	if (typeof $ref !== "string") throw new TypeBoxError("Ref: $ref must be a string");
+	return CreateType({
+		[Kind]: "Ref",
+		$ref
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/awaited/awaited.mjs
+function FromComputed$4(target, parameters) {
+	return Computed("Awaited", [Computed(target, parameters)]);
+}
+function FromRef$3($ref) {
+	return Computed("Awaited", [Ref($ref)]);
+}
+function FromIntersect$6(types) {
+	return Intersect(FromRest$4(types));
+}
+function FromUnion$6(types) {
+	return Union(FromRest$4(types));
+}
+function FromPromise$2(type) {
+	return Awaited(type);
+}
+function FromRest$4(types) {
+	return types.map((type) => Awaited(type));
+}
+/** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
+function Awaited(type, options) {
+	return CreateType(IsComputed$1(type) ? FromComputed$4(type.target, type.parameters) : IsIntersect$1(type) ? FromIntersect$6(type.allOf) : IsUnion$1(type) ? FromUnion$6(type.anyOf) : IsPromise$1(type) ? FromPromise$2(type.item) : IsRef$1(type) ? FromRef$3(type.$ref) : type, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-property-keys.mjs
+function FromRest$3(types) {
+	const result = [];
+	for (const L of types) result.push(KeyOfPropertyKeys(L));
+	return result;
+}
+function FromIntersect$5(types) {
+	return SetUnionMany(FromRest$3(types));
+}
+function FromUnion$5(types) {
+	return SetIntersectMany(FromRest$3(types));
+}
+function FromTuple$3(types) {
+	return types.map((_, indexer) => indexer.toString());
+}
+function FromArray$4(_) {
+	return ["[number]"];
+}
+function FromProperties$14(T) {
+	return globalThis.Object.getOwnPropertyNames(T);
+}
+function FromPatternProperties(patternProperties) {
+	if (!includePatternProperties) return [];
+	return globalThis.Object.getOwnPropertyNames(patternProperties).map((key) => {
+		return key[0] === "^" && key[key.length - 1] === "$" ? key.slice(1, key.length - 1) : key;
+	});
+}
+/** Returns a tuple of PropertyKeys derived from the given TSchema. */
+function KeyOfPropertyKeys(type) {
+	return IsIntersect$1(type) ? FromIntersect$5(type.allOf) : IsUnion$1(type) ? FromUnion$5(type.anyOf) : IsTuple$1(type) ? FromTuple$3(type.items ?? []) : IsArray$1(type) ? FromArray$4(type.items) : IsObject$1(type) ? FromProperties$14(type.properties) : IsRecord$1(type) ? FromPatternProperties(type.patternProperties) : [];
+}
+let includePatternProperties = false;
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/keyof/keyof.mjs
+function FromComputed$3(target, parameters) {
+	return Computed("KeyOf", [Computed(target, parameters)]);
+}
+function FromRef$2($ref) {
+	return Computed("KeyOf", [Ref($ref)]);
+}
+function KeyOfFromType(type, options) {
+	return CreateType(UnionEvaluated(KeyOfPropertyKeysToRest(KeyOfPropertyKeys(type))), options);
+}
+function KeyOfPropertyKeysToRest(propertyKeys) {
+	return propertyKeys.map((L) => L === "[number]" ? Number$1() : Literal(L));
+}
+/** `[Json]` Creates a KeyOf type */
+function KeyOf(type, options) {
+	return IsComputed$1(type) ? FromComputed$3(type.target, type.parameters) : IsRef$1(type) ? FromRef$2(type.$ref) : IsMappedResult$1(type) ? KeyOfFromMappedResult(type, options) : KeyOfFromType(type, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-from-mapped-result.mjs
+function FromProperties$13(properties, options) {
+	const result = {};
+	for (const K2 of globalThis.Object.getOwnPropertyNames(properties)) result[K2] = KeyOf(properties[K2], Clone(options));
+	return result;
+}
+function FromMappedResult$7(mappedResult, options) {
+	return FromProperties$13(mappedResult.properties, options);
+}
+function KeyOfFromMappedResult(mappedResult, options) {
+	return MappedResult(FromMappedResult$7(mappedResult, options));
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/composite/composite.mjs
+function CompositeKeys(T) {
+	const Acc = [];
+	for (const L of T) Acc.push(...KeyOfPropertyKeys(L));
+	return SetDistinct(Acc);
+}
+function FilterNever(T) {
+	return T.filter((L) => !IsNever$1(L));
+}
+function CompositeProperty(T, K) {
+	const Acc = [];
+	for (const L of T) Acc.push(...IndexFromPropertyKeys(L, [K]));
+	return FilterNever(Acc);
+}
+function CompositeProperties(T, K) {
+	const Acc = {};
+	for (const L of K) Acc[L] = IntersectEvaluated(CompositeProperty(T, L));
+	return Acc;
+}
+function Composite(T, options) {
+	return Object$1(CompositeProperties(T, CompositeKeys(T)), options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/date/date.mjs
+/** `[JavaScript]` Creates a Date type */
+function Date$1(options) {
+	return CreateType({
+		[Kind]: "Date",
+		type: "Date"
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/null/null.mjs
+/** `[Json]` Creates a Null type */
+function Null(options) {
+	return CreateType({
+		[Kind]: "Null",
+		type: "null"
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/symbol/symbol.mjs
+/** `[JavaScript]` Creates a Symbol type */
+function Symbol$1(options) {
+	return CreateType({
+		[Kind]: "Symbol",
+		type: "symbol"
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/undefined/undefined.mjs
+/** `[JavaScript]` Creates a Undefined type */
+function Undefined(options) {
+	return CreateType({
+		[Kind]: "Undefined",
+		type: "undefined"
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/uint8array/uint8array.mjs
+/** `[JavaScript]` Creates a Uint8Array type */
+function Uint8Array$1(options) {
+	return CreateType({
+		[Kind]: "Uint8Array",
+		type: "Uint8Array"
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/unknown/unknown.mjs
+/** `[Json]` Creates an Unknown type */
+function Unknown(options) {
+	return CreateType({ [Kind]: "Unknown" }, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/const/const.mjs
+function FromArray$3(T) {
+	return T.map((L) => FromValue(L, false));
+}
+function FromProperties$12(value) {
+	const Acc = {};
+	for (const K of globalThis.Object.getOwnPropertyNames(value)) Acc[K] = Readonly(FromValue(value[K], false));
+	return Acc;
+}
+function ConditionalReadonly(T, root) {
+	return root === true ? T : Readonly(T);
+}
+function FromValue(value, root) {
+	return IsAsyncIterator$2(value) ? ConditionalReadonly(Any(), root) : IsIterator$2(value) ? ConditionalReadonly(Any(), root) : IsArray$3(value) ? Readonly(Tuple(FromArray$3(value))) : IsUint8Array$2(value) ? Uint8Array$1() : IsDate$2(value) ? Date$1() : IsObject$3(value) ? ConditionalReadonly(Object$1(FromProperties$12(value)), root) : IsFunction$2(value) ? ConditionalReadonly(Function([], Unknown()), root) : IsUndefined$3(value) ? Undefined() : IsNull$2(value) ? Null() : IsSymbol$2(value) ? Symbol$1() : IsBigInt$2(value) ? BigInt() : IsNumber$3(value) ? Literal(value) : IsBoolean$2(value) ? Literal(value) : IsString$2(value) ? Literal(value) : Object$1({});
+}
+/** `[JavaScript]` Creates a readonly const type from the given value. */
+function Const(T, options) {
+	return CreateType(FromValue(T, true), options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/constructor-parameters/constructor-parameters.mjs
+/** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
+function ConstructorParameters(schema, options) {
+	return IsConstructor$1(schema) ? Tuple(schema.parameters, options) : Never(options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/enum/enum.mjs
+/** `[Json]` Creates a Enum type */
+function Enum(item, options) {
+	if (IsUndefined$3(item)) throw new Error("Enum undefined or empty");
+	const values1 = globalThis.Object.getOwnPropertyNames(item).filter((key) => isNaN(key)).map((key) => item[key]);
+	return Union([...new Set(values1)].map((value) => Literal(value)), {
+		...options,
+		[Hint]: "Enum"
+	});
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/extends/extends-check.mjs
+var ExtendsResolverError = class extends TypeBoxError {};
+var ExtendsResult;
+(function(ExtendsResult) {
+	ExtendsResult[ExtendsResult["Union"] = 0] = "Union";
+	ExtendsResult[ExtendsResult["True"] = 1] = "True";
+	ExtendsResult[ExtendsResult["False"] = 2] = "False";
+})(ExtendsResult || (ExtendsResult = {}));
+function IntoBooleanResult(result) {
+	return result === ExtendsResult.False ? result : ExtendsResult.True;
+}
+function Throw(message) {
+	throw new ExtendsResolverError(message);
+}
+function IsStructuralRight(right) {
+	return IsNever(right) || IsIntersect(right) || IsUnion(right) || IsUnknown(right) || IsAny(right);
+}
+function StructuralRight(left, right) {
+	return IsNever(right) ? FromNeverRight(left, right) : IsIntersect(right) ? FromIntersectRight(left, right) : IsUnion(right) ? FromUnionRight(left, right) : IsUnknown(right) ? FromUnknownRight(left, right) : IsAny(right) ? FromAnyRight(left, right) : Throw("StructuralRight");
+}
+function FromAnyRight(left, right) {
+	return ExtendsResult.True;
+}
+function FromAny(left, right) {
+	return IsIntersect(right) ? FromIntersectRight(left, right) : IsUnion(right) && right.anyOf.some((schema) => IsAny(schema) || IsUnknown(schema)) ? ExtendsResult.True : IsUnion(right) ? ExtendsResult.Union : IsUnknown(right) ? ExtendsResult.True : IsAny(right) ? ExtendsResult.True : ExtendsResult.Union;
+}
+function FromArrayRight(left, right) {
+	return IsUnknown(left) ? ExtendsResult.False : IsAny(left) ? ExtendsResult.Union : IsNever(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromArray$2(left, right) {
+	return IsObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : !IsArray(right) ? ExtendsResult.False : IntoBooleanResult(Visit(left.items, right.items));
+}
+function FromAsyncIterator$2(left, right) {
+	return IsStructuralRight(right) ? StructuralRight(left, right) : !IsAsyncIterator(right) ? ExtendsResult.False : IntoBooleanResult(Visit(left.items, right.items));
+}
+function FromBigInt(left, right) {
+	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsBigInt(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromBooleanRight(left, right) {
+	return IsLiteralBoolean(left) ? ExtendsResult.True : IsBoolean(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromBoolean(left, right) {
+	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsBoolean(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromConstructor$2(left, right) {
+	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : !IsConstructor(right) ? ExtendsResult.False : left.parameters.length > right.parameters.length ? ExtendsResult.False : !left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === ExtendsResult.True) ? ExtendsResult.False : IntoBooleanResult(Visit(left.returns, right.returns));
+}
+function FromDate(left, right) {
+	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsDate(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromFunction$2(left, right) {
+	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : !IsFunction(right) ? ExtendsResult.False : left.parameters.length > right.parameters.length ? ExtendsResult.False : !left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === ExtendsResult.True) ? ExtendsResult.False : IntoBooleanResult(Visit(left.returns, right.returns));
+}
+function FromIntegerRight(left, right) {
+	return IsLiteral(left) && IsNumber$3(left.const) ? ExtendsResult.True : IsNumber(left) || IsInteger(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromInteger(left, right) {
+	return IsInteger(right) || IsNumber(right) ? ExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : ExtendsResult.False;
+}
+function FromIntersectRight(left, right) {
+	return right.allOf.every((schema) => Visit(left, schema) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromIntersect$4(left, right) {
+	return left.allOf.some((schema) => Visit(schema, right) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromIterator$2(left, right) {
+	return IsStructuralRight(right) ? StructuralRight(left, right) : !IsIterator(right) ? ExtendsResult.False : IntoBooleanResult(Visit(left.items, right.items));
+}
+function FromLiteral(left, right) {
+	return IsLiteral(right) && right.const === left.const ? ExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsString(right) ? FromStringRight(left, right) : IsNumber(right) ? FromNumberRight(left, right) : IsInteger(right) ? FromIntegerRight(left, right) : IsBoolean(right) ? FromBooleanRight(left, right) : ExtendsResult.False;
+}
+function FromNeverRight(left, right) {
+	return ExtendsResult.False;
+}
+function FromNever(left, right) {
+	return ExtendsResult.True;
+}
+function UnwrapTNot(schema) {
+	let [current, depth] = [schema, 0];
+	while (true) {
+		if (!IsNot(current)) break;
+		current = current.not;
+		depth += 1;
+	}
+	return depth % 2 === 0 ? current : Unknown();
+}
+function FromNot(left, right) {
+	return IsNot(left) ? Visit(UnwrapTNot(left), right) : IsNot(right) ? Visit(left, UnwrapTNot(right)) : Throw("Invalid fallthrough for Not");
+}
+function FromNull(left, right) {
+	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsNull(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromNumberRight(left, right) {
+	return IsLiteralNumber(left) ? ExtendsResult.True : IsNumber(left) || IsInteger(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromNumber(left, right) {
+	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsInteger(right) || IsNumber(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function IsObjectPropertyCount(schema, count) {
+	return Object.getOwnPropertyNames(schema.properties).length === count;
+}
+function IsObjectStringLike(schema) {
+	return IsObjectArrayLike(schema);
+}
+function IsObjectSymbolLike(schema) {
+	return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "description" in schema.properties && IsUnion(schema.properties.description) && schema.properties.description.anyOf.length === 2 && (IsString(schema.properties.description.anyOf[0]) && IsUndefined(schema.properties.description.anyOf[1]) || IsString(schema.properties.description.anyOf[1]) && IsUndefined(schema.properties.description.anyOf[0]));
+}
+function IsObjectNumberLike(schema) {
+	return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectBooleanLike(schema) {
+	return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectBigIntLike(schema) {
+	return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectDateLike(schema) {
+	return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectUint8ArrayLike(schema) {
+	return IsObjectArrayLike(schema);
+}
+function IsObjectFunctionLike(schema) {
+	const length = Number$1();
+	return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "length" in schema.properties && IntoBooleanResult(Visit(schema.properties["length"], length)) === ExtendsResult.True;
+}
+function IsObjectConstructorLike(schema) {
+	return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectArrayLike(schema) {
+	const length = Number$1();
+	return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "length" in schema.properties && IntoBooleanResult(Visit(schema.properties["length"], length)) === ExtendsResult.True;
+}
+function IsObjectPromiseLike(schema) {
+	const then = Function([Any()], Any());
+	return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "then" in schema.properties && IntoBooleanResult(Visit(schema.properties["then"], then)) === ExtendsResult.True;
+}
+function Property(left, right) {
+	return Visit(left, right) === ExtendsResult.False ? ExtendsResult.False : IsOptional(left) && !IsOptional(right) ? ExtendsResult.False : ExtendsResult.True;
+}
+function FromObjectRight(left, right) {
+	return IsUnknown(left) ? ExtendsResult.False : IsAny(left) ? ExtendsResult.Union : IsNever(left) || IsLiteralString(left) && IsObjectStringLike(right) || IsLiteralNumber(left) && IsObjectNumberLike(right) || IsLiteralBoolean(left) && IsObjectBooleanLike(right) || IsSymbol(left) && IsObjectSymbolLike(right) || IsBigInt(left) && IsObjectBigIntLike(right) || IsString(left) && IsObjectStringLike(right) || IsSymbol(left) && IsObjectSymbolLike(right) || IsNumber(left) && IsObjectNumberLike(right) || IsInteger(left) && IsObjectNumberLike(right) || IsBoolean(left) && IsObjectBooleanLike(right) || IsUint8Array(left) && IsObjectUint8ArrayLike(right) || IsDate(left) && IsObjectDateLike(right) || IsConstructor(left) && IsObjectConstructorLike(right) || IsFunction(left) && IsObjectFunctionLike(right) ? ExtendsResult.True : IsRecord(left) && IsString(RecordKey$1(left)) ? right[Hint] === "Record" ? ExtendsResult.True : ExtendsResult.False : IsRecord(left) && IsNumber(RecordKey$1(left)) ? IsObjectPropertyCount(right, 0) ? ExtendsResult.True : ExtendsResult.False : ExtendsResult.False;
+}
+function FromObject$6(left, right) {
+	return IsStructuralRight(right) ? StructuralRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : !IsObject(right) ? ExtendsResult.False : (() => {
+		for (const key of Object.getOwnPropertyNames(right.properties)) {
+			if (!(key in left.properties) && !IsOptional(right.properties[key])) return ExtendsResult.False;
+			if (IsOptional(right.properties[key])) return ExtendsResult.True;
+			if (Property(left.properties[key], right.properties[key]) === ExtendsResult.False) return ExtendsResult.False;
+		}
+		return ExtendsResult.True;
+	})();
+}
+function FromPromise$1(left, right) {
+	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) && IsObjectPromiseLike(right) ? ExtendsResult.True : !IsPromise(right) ? ExtendsResult.False : IntoBooleanResult(Visit(left.item, right.item));
+}
+function RecordKey$1(schema) {
+	return PatternNumberExact in schema.patternProperties ? Number$1() : PatternStringExact in schema.patternProperties ? String$1() : Throw("Unknown record key pattern");
+}
+function RecordValue$1(schema) {
+	return PatternNumberExact in schema.patternProperties ? schema.patternProperties[PatternNumberExact] : PatternStringExact in schema.patternProperties ? schema.patternProperties[PatternStringExact] : Throw("Unable to get record value schema");
+}
+function FromRecordRight(left, right) {
+	const [Key, Value] = [RecordKey$1(right), RecordValue$1(right)];
+	return IsLiteralString(left) && IsNumber(Key) && IntoBooleanResult(Visit(left, Value)) === ExtendsResult.True ? ExtendsResult.True : IsUint8Array(left) && IsNumber(Key) ? Visit(left, Value) : IsString(left) && IsNumber(Key) ? Visit(left, Value) : IsArray(left) && IsNumber(Key) ? Visit(left, Value) : IsObject(left) ? (() => {
+		for (const key of Object.getOwnPropertyNames(left.properties)) if (Property(Value, left.properties[key]) === ExtendsResult.False) return ExtendsResult.False;
+		return ExtendsResult.True;
+	})() : ExtendsResult.False;
+}
+function FromRecord$2(left, right) {
+	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : !IsRecord(right) ? ExtendsResult.False : Visit(RecordValue$1(left), RecordValue$1(right));
+}
+function FromRegExp(left, right) {
+	return Visit(IsRegExp(left) ? String$1() : left, IsRegExp(right) ? String$1() : right);
+}
+function FromStringRight(left, right) {
+	return IsLiteral(left) && IsString$2(left.const) ? ExtendsResult.True : IsString(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromString(left, right) {
+	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsString(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromSymbol(left, right) {
+	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsSymbol(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromTemplateLiteral$1(left, right) {
+	return IsTemplateLiteral(left) ? Visit(TemplateLiteralToUnion(left), right) : IsTemplateLiteral(right) ? Visit(left, TemplateLiteralToUnion(right)) : Throw("Invalid fallthrough for TemplateLiteral");
+}
+function IsArrayOfTuple(left, right) {
+	return IsArray(right) && left.items !== void 0 && left.items.every((schema) => Visit(schema, right.items) === ExtendsResult.True);
+}
+function FromTupleRight(left, right) {
+	return IsNever(left) ? ExtendsResult.True : IsUnknown(left) ? ExtendsResult.False : IsAny(left) ? ExtendsResult.Union : ExtendsResult.False;
+}
+function FromTuple$2(left, right) {
+	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True : IsArray(right) && IsArrayOfTuple(left, right) ? ExtendsResult.True : !IsTuple(right) ? ExtendsResult.False : IsUndefined$3(left.items) && !IsUndefined$3(right.items) || !IsUndefined$3(left.items) && IsUndefined$3(right.items) ? ExtendsResult.False : IsUndefined$3(left.items) && !IsUndefined$3(right.items) ? ExtendsResult.True : left.items.every((schema, index) => Visit(schema, right.items[index]) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUint8Array(left, right) {
+	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsUint8Array(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUndefined(left, right) {
+	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsVoid(right) ? FromVoidRight(left, right) : IsUndefined(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUnionRight(left, right) {
+	return right.anyOf.some((schema) => Visit(left, schema) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUnion$4(left, right) {
+	return left.anyOf.every((schema) => Visit(schema, right) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUnknownRight(left, right) {
+	return ExtendsResult.True;
+}
+function FromUnknown(left, right) {
+	return IsNever(right) ? FromNeverRight(left, right) : IsIntersect(right) ? FromIntersectRight(left, right) : IsUnion(right) ? FromUnionRight(left, right) : IsAny(right) ? FromAnyRight(left, right) : IsString(right) ? FromStringRight(left, right) : IsNumber(right) ? FromNumberRight(left, right) : IsInteger(right) ? FromIntegerRight(left, right) : IsBoolean(right) ? FromBooleanRight(left, right) : IsArray(right) ? FromArrayRight(left, right) : IsTuple(right) ? FromTupleRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsUnknown(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromVoidRight(left, right) {
+	return IsUndefined(left) ? ExtendsResult.True : IsUndefined(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromVoid(left, right) {
+	return IsIntersect(right) ? FromIntersectRight(left, right) : IsUnion(right) ? FromUnionRight(left, right) : IsUnknown(right) ? FromUnknownRight(left, right) : IsAny(right) ? FromAnyRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsVoid(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function Visit(left, right) {
+	return IsTemplateLiteral(left) || IsTemplateLiteral(right) ? FromTemplateLiteral$1(left, right) : IsRegExp(left) || IsRegExp(right) ? FromRegExp(left, right) : IsNot(left) || IsNot(right) ? FromNot(left, right) : IsAny(left) ? FromAny(left, right) : IsArray(left) ? FromArray$2(left, right) : IsBigInt(left) ? FromBigInt(left, right) : IsBoolean(left) ? FromBoolean(left, right) : IsAsyncIterator(left) ? FromAsyncIterator$2(left, right) : IsConstructor(left) ? FromConstructor$2(left, right) : IsDate(left) ? FromDate(left, right) : IsFunction(left) ? FromFunction$2(left, right) : IsInteger(left) ? FromInteger(left, right) : IsIntersect(left) ? FromIntersect$4(left, right) : IsIterator(left) ? FromIterator$2(left, right) : IsLiteral(left) ? FromLiteral(left, right) : IsNever(left) ? FromNever(left, right) : IsNull(left) ? FromNull(left, right) : IsNumber(left) ? FromNumber(left, right) : IsObject(left) ? FromObject$6(left, right) : IsRecord(left) ? FromRecord$2(left, right) : IsString(left) ? FromString(left, right) : IsSymbol(left) ? FromSymbol(left, right) : IsTuple(left) ? FromTuple$2(left, right) : IsPromise(left) ? FromPromise$1(left, right) : IsUint8Array(left) ? FromUint8Array(left, right) : IsUndefined(left) ? FromUndefined(left, right) : IsUnion(left) ? FromUnion$4(left, right) : IsUnknown(left) ? FromUnknown(left, right) : IsVoid(left) ? FromVoid(left, right) : Throw(`Unknown left type operand '${left[Kind]}'`);
+}
+function ExtendsCheck(left, right) {
+	return Visit(left, right);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/extends/extends-from-mapped-result.mjs
+function FromProperties$11(P, Right, True, False, options) {
+	const Acc = {};
+	for (const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Extends(P[K2], Right, True, False, Clone(options));
+	return Acc;
+}
+function FromMappedResult$6(Left, Right, True, False, options) {
+	return FromProperties$11(Left.properties, Right, True, False, options);
+}
+function ExtendsFromMappedResult(Left, Right, True, False, options) {
+	return MappedResult(FromMappedResult$6(Left, Right, True, False, options));
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/extends/extends.mjs
+function ExtendsResolve(left, right, trueType, falseType) {
+	const R = ExtendsCheck(left, right);
+	return R === ExtendsResult.Union ? Union([trueType, falseType]) : R === ExtendsResult.True ? trueType : falseType;
+}
+/** `[Json]` Creates a Conditional type */
+function Extends(L, R, T, F, options) {
+	return IsMappedResult$1(L) ? ExtendsFromMappedResult(L, R, T, F, options) : IsMappedKey$1(L) ? CreateType(ExtendsFromMappedKey(L, R, T, F, options)) : CreateType(ExtendsResolve(L, R, T, F), options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/extends/extends-from-mapped-key.mjs
+function FromPropertyKey$2(K, U, L, R, options) {
+	return { [K]: Extends(Literal(K), U, L, R, Clone(options)) };
+}
+function FromPropertyKeys$2(K, U, L, R, options) {
+	return K.reduce((Acc, LK) => {
+		return {
+			...Acc,
+			...FromPropertyKey$2(LK, U, L, R, options)
+		};
+	}, {});
+}
+function FromMappedKey$2(K, U, L, R, options) {
+	return FromPropertyKeys$2(K.keys, U, L, R, options);
+}
+function ExtendsFromMappedKey(T, U, L, R, options) {
+	return MappedResult(FromMappedKey$2(T, U, L, R, options));
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/exclude/exclude-from-template-literal.mjs
+function ExcludeFromTemplateLiteral(L, R) {
+	return Exclude(TemplateLiteralToUnion(L), R);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/exclude/exclude.mjs
+function ExcludeRest(L, R) {
+	const excluded = L.filter((inner) => ExtendsCheck(inner, R) === ExtendsResult.False);
+	return excluded.length === 1 ? excluded[0] : Union(excluded);
+}
+/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+function Exclude(L, R, options = {}) {
+	if (IsTemplateLiteral$1(L)) return CreateType(ExcludeFromTemplateLiteral(L, R), options);
+	if (IsMappedResult$1(L)) return CreateType(ExcludeFromMappedResult(L, R), options);
+	return CreateType(IsUnion$1(L) ? ExcludeRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? Never() : L, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/exclude/exclude-from-mapped-result.mjs
+function FromProperties$10(P, U) {
+	const Acc = {};
+	for (const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Exclude(P[K2], U);
+	return Acc;
+}
+function FromMappedResult$5(R, T) {
+	return FromProperties$10(R.properties, T);
+}
+function ExcludeFromMappedResult(R, T) {
+	return MappedResult(FromMappedResult$5(R, T));
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-template-literal.mjs
+function ExtractFromTemplateLiteral(L, R) {
+	return Extract(TemplateLiteralToUnion(L), R);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/extract/extract.mjs
+function ExtractRest(L, R) {
+	const extracted = L.filter((inner) => ExtendsCheck(inner, R) !== ExtendsResult.False);
+	return extracted.length === 1 ? extracted[0] : Union(extracted);
+}
+/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+function Extract(L, R, options) {
+	if (IsTemplateLiteral$1(L)) return CreateType(ExtractFromTemplateLiteral(L, R), options);
+	if (IsMappedResult$1(L)) return CreateType(ExtractFromMappedResult(L, R), options);
+	return CreateType(IsUnion$1(L) ? ExtractRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never(), options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-mapped-result.mjs
+function FromProperties$9(P, T) {
+	const Acc = {};
+	for (const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Extract(P[K2], T);
+	return Acc;
+}
+function FromMappedResult$4(R, T) {
+	return FromProperties$9(R.properties, T);
+}
+function ExtractFromMappedResult(R, T) {
+	return MappedResult(FromMappedResult$4(R, T));
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/instance-type/instance-type.mjs
+/** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
+function InstanceType(schema, options) {
+	return IsConstructor$1(schema) ? CreateType(schema.returns, options) : Never(options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/readonly-optional/readonly-optional.mjs
+/** `[Json]` Creates a Readonly and Optional property */
+function ReadonlyOptional(schema) {
+	return Readonly(Optional(schema));
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/record/record.mjs
+function RecordCreateFromPattern(pattern, T, options) {
+	return CreateType({
+		[Kind]: "Record",
+		type: "object",
+		patternProperties: { [pattern]: T }
+	}, options);
+}
+function RecordCreateFromKeys(K, T, options) {
+	const result = {};
+	for (const K2 of K) result[K2] = T;
+	return Object$1(result, {
+		...options,
+		[Hint]: "Record"
+	});
+}
+function FromTemplateLiteralKey(K, T, options) {
+	return IsTemplateLiteralFinite(K) ? RecordCreateFromKeys(IndexPropertyKeys(K), T, options) : RecordCreateFromPattern(K.pattern, T, options);
+}
+function FromUnionKey(key, type, options) {
+	return RecordCreateFromKeys(IndexPropertyKeys(Union(key)), type, options);
+}
+function FromLiteralKey(key, type, options) {
+	return RecordCreateFromKeys([key.toString()], type, options);
+}
+function FromRegExpKey(key, type, options) {
+	return RecordCreateFromPattern(key.source, type, options);
+}
+function FromStringKey(key, type, options) {
+	return RecordCreateFromPattern(IsUndefined$3(key.pattern) ? PatternStringExact : key.pattern, type, options);
+}
+function FromAnyKey(_, type, options) {
+	return RecordCreateFromPattern(PatternStringExact, type, options);
+}
+function FromNeverKey(_key, type, options) {
+	return RecordCreateFromPattern(PatternNeverExact, type, options);
+}
+function FromBooleanKey(_key, type, options) {
+	return Object$1({
+		true: type,
+		false: type
+	}, options);
+}
+function FromIntegerKey(_key, type, options) {
+	return RecordCreateFromPattern(PatternNumberExact, type, options);
+}
+function FromNumberKey(_, type, options) {
+	return RecordCreateFromPattern(PatternNumberExact, type, options);
+}
+/** `[Json]` Creates a Record type */
+function Record(key, type, options = {}) {
+	return IsUnion$1(key) ? FromUnionKey(key.anyOf, type, options) : IsTemplateLiteral$1(key) ? FromTemplateLiteralKey(key, type, options) : IsLiteral$1(key) ? FromLiteralKey(key.const, type, options) : IsBoolean$1(key) ? FromBooleanKey(key, type, options) : IsInteger$1(key) ? FromIntegerKey(key, type, options) : IsNumber$1(key) ? FromNumberKey(key, type, options) : IsRegExp$1(key) ? FromRegExpKey(key, type, options) : IsString$1(key) ? FromStringKey(key, type, options) : IsAny$1(key) ? FromAnyKey(key, type, options) : IsNever$1(key) ? FromNeverKey(key, type, options) : Never(options);
+}
+/** Gets the Records Pattern */
+function RecordPattern(record) {
+	return globalThis.Object.getOwnPropertyNames(record.patternProperties)[0];
+}
+/** Gets the Records Key Type */
+function RecordKey(type) {
+	const pattern = RecordPattern(type);
+	return pattern === PatternStringExact ? String$1() : pattern === PatternNumberExact ? Number$1() : String$1({ pattern });
+}
+/** Gets a Record Value Type */
+function RecordValue(type) {
+	return type.patternProperties[RecordPattern(type)];
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/instantiate/instantiate.mjs
+function FromConstructor$1(args, type) {
+	type.parameters = FromTypes$1(args, type.parameters);
+	type.returns = FromType$1(args, type.returns);
+	return type;
+}
+function FromFunction$1(args, type) {
+	type.parameters = FromTypes$1(args, type.parameters);
+	type.returns = FromType$1(args, type.returns);
+	return type;
+}
+function FromIntersect$3(args, type) {
+	type.allOf = FromTypes$1(args, type.allOf);
+	return type;
+}
+function FromUnion$3(args, type) {
+	type.anyOf = FromTypes$1(args, type.anyOf);
+	return type;
+}
+function FromTuple$1(args, type) {
+	if (IsUndefined$3(type.items)) return type;
+	type.items = FromTypes$1(args, type.items);
+	return type;
+}
+function FromArray$1(args, type) {
+	type.items = FromType$1(args, type.items);
+	return type;
+}
+function FromAsyncIterator$1(args, type) {
+	type.items = FromType$1(args, type.items);
+	return type;
+}
+function FromIterator$1(args, type) {
+	type.items = FromType$1(args, type.items);
+	return type;
+}
+function FromPromise(args, type) {
+	type.item = FromType$1(args, type.item);
+	return type;
+}
+function FromObject$5(args, type) {
+	const mappedProperties = FromProperties$8(args, type.properties);
+	return {
+		...type,
+		...Object$1(mappedProperties)
+	};
+}
+function FromRecord$1(args, type) {
+	const result = Record(FromType$1(args, RecordKey(type)), FromType$1(args, RecordValue(type)));
+	return {
+		...type,
+		...result
+	};
+}
+function FromArgument(args, argument) {
+	return argument.index in args ? args[argument.index] : Unknown();
+}
+function FromProperty$1(args, type) {
+	const isReadonly = IsReadonly(type);
+	const isOptional = IsOptional$1(type);
+	const mapped = FromType$1(args, type);
+	return isReadonly && isOptional ? ReadonlyOptional(mapped) : isReadonly && !isOptional ? Readonly(mapped) : !isReadonly && isOptional ? Optional(mapped) : mapped;
+}
+function FromProperties$8(args, properties) {
+	return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
+		return {
+			...result,
+			[key]: FromProperty$1(args, properties[key])
+		};
+	}, {});
+}
+function FromTypes$1(args, types) {
+	return types.map((type) => FromType$1(args, type));
+}
+function FromType$1(args, type) {
+	return IsConstructor$1(type) ? FromConstructor$1(args, type) : IsFunction$1(type) ? FromFunction$1(args, type) : IsIntersect$1(type) ? FromIntersect$3(args, type) : IsUnion$1(type) ? FromUnion$3(args, type) : IsTuple$1(type) ? FromTuple$1(args, type) : IsArray$1(type) ? FromArray$1(args, type) : IsAsyncIterator$1(type) ? FromAsyncIterator$1(args, type) : IsIterator$1(type) ? FromIterator$1(args, type) : IsPromise$1(type) ? FromPromise(args, type) : IsObject$1(type) ? FromObject$5(args, type) : IsRecord$1(type) ? FromRecord$1(args, type) : IsArgument$1(type) ? FromArgument(args, type) : type;
+}
+/** `[JavaScript]` Instantiates a type with the given parameters */
+function Instantiate(type, args) {
+	return FromType$1(args, CloneType(type));
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/integer/integer.mjs
+/** `[Json]` Creates an Integer type */
+function Integer(options) {
+	return CreateType({
+		[Kind]: "Integer",
+		type: "integer"
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/intrinsic/intrinsic-from-mapped-key.mjs
+function MappedIntrinsicPropertyKey(K, M, options) {
+	return { [K]: Intrinsic(Literal(K), M, Clone(options)) };
+}
+function MappedIntrinsicPropertyKeys(K, M, options) {
+	return K.reduce((Acc, L) => {
+		return {
+			...Acc,
+			...MappedIntrinsicPropertyKey(L, M, options)
+		};
+	}, {});
+}
+function MappedIntrinsicProperties(T, M, options) {
+	return MappedIntrinsicPropertyKeys(T["keys"], M, options);
+}
+function IntrinsicFromMappedKey(T, M, options) {
+	return MappedResult(MappedIntrinsicProperties(T, M, options));
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/intrinsic/intrinsic.mjs
+function ApplyUncapitalize(value) {
+	const [first, rest] = [value.slice(0, 1), value.slice(1)];
+	return [first.toLowerCase(), rest].join("");
+}
+function ApplyCapitalize(value) {
+	const [first, rest] = [value.slice(0, 1), value.slice(1)];
+	return [first.toUpperCase(), rest].join("");
+}
+function ApplyUppercase(value) {
+	return value.toUpperCase();
+}
+function ApplyLowercase(value) {
+	return value.toLowerCase();
+}
+function FromTemplateLiteral(schema, mode, options) {
+	const expression = TemplateLiteralParseExact(schema.pattern);
+	if (!IsTemplateLiteralExpressionFinite(expression)) return {
+		...schema,
+		pattern: FromLiteralValue(schema.pattern, mode)
+	};
+	return TemplateLiteral([Union(FromRest$2([...TemplateLiteralExpressionGenerate(expression)].map((value) => Literal(value)), mode))], options);
+}
+function FromLiteralValue(value, mode) {
+	return typeof value === "string" ? mode === "Uncapitalize" ? ApplyUncapitalize(value) : mode === "Capitalize" ? ApplyCapitalize(value) : mode === "Uppercase" ? ApplyUppercase(value) : mode === "Lowercase" ? ApplyLowercase(value) : value : value.toString();
+}
+function FromRest$2(T, M) {
+	return T.map((L) => Intrinsic(L, M));
+}
+/** Applies an intrinsic string manipulation to the given type. */
+function Intrinsic(schema, mode, options = {}) {
+	return IsMappedKey$1(schema) ? IntrinsicFromMappedKey(schema, mode, options) : IsTemplateLiteral$1(schema) ? FromTemplateLiteral(schema, mode, options) : IsUnion$1(schema) ? Union(FromRest$2(schema.anyOf, mode), options) : IsLiteral$1(schema) ? Literal(FromLiteralValue(schema.const, mode), options) : CreateType(schema, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/intrinsic/capitalize.mjs
+/** `[Json]` Intrinsic function to Capitalize LiteralString types */
+function Capitalize(T, options = {}) {
+	return Intrinsic(T, "Capitalize", options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/intrinsic/lowercase.mjs
+/** `[Json]` Intrinsic function to Lowercase LiteralString types */
+function Lowercase(T, options = {}) {
+	return Intrinsic(T, "Lowercase", options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/intrinsic/uncapitalize.mjs
+/** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
+function Uncapitalize(T, options = {}) {
+	return Intrinsic(T, "Uncapitalize", options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/intrinsic/uppercase.mjs
+/** `[Json]` Intrinsic function to Uppercase LiteralString types */
+function Uppercase(T, options = {}) {
+	return Intrinsic(T, "Uppercase", options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/omit/omit-from-mapped-result.mjs
+function FromProperties$7(properties, propertyKeys, options) {
+	const result = {};
+	for (const K2 of globalThis.Object.getOwnPropertyNames(properties)) result[K2] = Omit(properties[K2], propertyKeys, Clone(options));
+	return result;
+}
+function FromMappedResult$3(mappedResult, propertyKeys, options) {
+	return FromProperties$7(mappedResult.properties, propertyKeys, options);
+}
+function OmitFromMappedResult(mappedResult, propertyKeys, options) {
+	return MappedResult(FromMappedResult$3(mappedResult, propertyKeys, options));
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/omit/omit.mjs
+function FromIntersect$2(types, propertyKeys) {
+	return types.map((type) => OmitResolve(type, propertyKeys));
+}
+function FromUnion$2(types, propertyKeys) {
+	return types.map((type) => OmitResolve(type, propertyKeys));
+}
+function FromProperty(properties, key) {
+	const { [key]: _, ...R } = properties;
+	return R;
+}
+function FromProperties$6(properties, propertyKeys) {
+	return propertyKeys.reduce((T, K2) => FromProperty(T, K2), properties);
+}
+function FromObject$4(type, propertyKeys, properties) {
+	const options = Discard(type, [
+		TransformKind,
+		"$id",
+		"required",
+		"properties"
+	]);
+	return Object$1(FromProperties$6(properties, propertyKeys), options);
+}
+function UnionFromPropertyKeys$1(propertyKeys) {
+	return Union(propertyKeys.reduce((result, key) => IsLiteralValue$1(key) ? [...result, Literal(key)] : result, []));
+}
+function OmitResolve(type, propertyKeys) {
+	return IsIntersect$1(type) ? Intersect(FromIntersect$2(type.allOf, propertyKeys)) : IsUnion$1(type) ? Union(FromUnion$2(type.anyOf, propertyKeys)) : IsObject$1(type) ? FromObject$4(type, propertyKeys, type.properties) : Object$1({});
+}
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+function Omit(type, key, options) {
+	const typeKey = IsArray$3(key) ? UnionFromPropertyKeys$1(key) : key;
+	const propertyKeys = IsSchema$1(key) ? IndexPropertyKeys(key) : key;
+	const isTypeRef = IsRef$1(type);
+	const isKeyRef = IsRef$1(key);
+	return IsMappedResult$1(type) ? OmitFromMappedResult(type, propertyKeys, options) : IsMappedKey$1(key) ? OmitFromMappedKey(type, key, options) : isTypeRef && isKeyRef ? Computed("Omit", [type, typeKey], options) : !isTypeRef && isKeyRef ? Computed("Omit", [type, typeKey], options) : isTypeRef && !isKeyRef ? Computed("Omit", [type, typeKey], options) : CreateType({
+		...OmitResolve(type, propertyKeys),
+		...options
+	});
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/omit/omit-from-mapped-key.mjs
+function FromPropertyKey$1(type, key, options) {
+	return { [key]: Omit(type, [key], Clone(options)) };
+}
+function FromPropertyKeys$1(type, propertyKeys, options) {
+	return propertyKeys.reduce((Acc, LK) => {
+		return {
+			...Acc,
+			...FromPropertyKey$1(type, LK, options)
+		};
+	}, {});
+}
+function FromMappedKey$1(type, mappedKey, options) {
+	return FromPropertyKeys$1(type, mappedKey.keys, options);
+}
+function OmitFromMappedKey(type, mappedKey, options) {
+	return MappedResult(FromMappedKey$1(type, mappedKey, options));
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/pick/pick-from-mapped-result.mjs
+function FromProperties$5(properties, propertyKeys, options) {
+	const result = {};
+	for (const K2 of globalThis.Object.getOwnPropertyNames(properties)) result[K2] = Pick(properties[K2], propertyKeys, Clone(options));
+	return result;
+}
+function FromMappedResult$2(mappedResult, propertyKeys, options) {
+	return FromProperties$5(mappedResult.properties, propertyKeys, options);
+}
+function PickFromMappedResult(mappedResult, propertyKeys, options) {
+	return MappedResult(FromMappedResult$2(mappedResult, propertyKeys, options));
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/pick/pick.mjs
+function FromIntersect$1(types, propertyKeys) {
+	return types.map((type) => PickResolve(type, propertyKeys));
+}
+function FromUnion$1(types, propertyKeys) {
+	return types.map((type) => PickResolve(type, propertyKeys));
+}
+function FromProperties$4(properties, propertyKeys) {
+	const result = {};
+	for (const K2 of propertyKeys) if (K2 in properties) result[K2] = properties[K2];
+	return result;
+}
+function FromObject$3(Type, keys, properties) {
+	const options = Discard(Type, [
+		TransformKind,
+		"$id",
+		"required",
+		"properties"
+	]);
+	return Object$1(FromProperties$4(properties, keys), options);
+}
+function UnionFromPropertyKeys(propertyKeys) {
+	return Union(propertyKeys.reduce((result, key) => IsLiteralValue$1(key) ? [...result, Literal(key)] : result, []));
+}
+function PickResolve(type, propertyKeys) {
+	return IsIntersect$1(type) ? Intersect(FromIntersect$1(type.allOf, propertyKeys)) : IsUnion$1(type) ? Union(FromUnion$1(type.anyOf, propertyKeys)) : IsObject$1(type) ? FromObject$3(type, propertyKeys, type.properties) : Object$1({});
+}
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+function Pick(type, key, options) {
+	const typeKey = IsArray$3(key) ? UnionFromPropertyKeys(key) : key;
+	const propertyKeys = IsSchema$1(key) ? IndexPropertyKeys(key) : key;
+	const isTypeRef = IsRef$1(type);
+	const isKeyRef = IsRef$1(key);
+	return IsMappedResult$1(type) ? PickFromMappedResult(type, propertyKeys, options) : IsMappedKey$1(key) ? PickFromMappedKey(type, key, options) : isTypeRef && isKeyRef ? Computed("Pick", [type, typeKey], options) : !isTypeRef && isKeyRef ? Computed("Pick", [type, typeKey], options) : isTypeRef && !isKeyRef ? Computed("Pick", [type, typeKey], options) : CreateType({
+		...PickResolve(type, propertyKeys),
+		...options
+	});
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/pick/pick-from-mapped-key.mjs
+function FromPropertyKey(type, key, options) {
+	return { [key]: Pick(type, [key], Clone(options)) };
+}
+function FromPropertyKeys(type, propertyKeys, options) {
+	return propertyKeys.reduce((result, leftKey) => {
+		return {
+			...result,
+			...FromPropertyKey(type, leftKey, options)
+		};
+	}, {});
+}
+function FromMappedKey(type, mappedKey, options) {
+	return FromPropertyKeys(type, mappedKey.keys, options);
+}
+function PickFromMappedKey(type, mappedKey, options) {
+	return MappedResult(FromMappedKey(type, mappedKey, options));
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/partial/partial.mjs
+function FromComputed$2(target, parameters) {
+	return Computed("Partial", [Computed(target, parameters)]);
+}
+function FromRef$1($ref) {
+	return Computed("Partial", [Ref($ref)]);
+}
+function FromProperties$3(properties) {
+	const partialProperties = {};
+	for (const K of globalThis.Object.getOwnPropertyNames(properties)) partialProperties[K] = Optional(properties[K]);
+	return partialProperties;
+}
+function FromObject$2(type, properties) {
+	const options = Discard(type, [
+		TransformKind,
+		"$id",
+		"required",
+		"properties"
+	]);
+	return Object$1(FromProperties$3(properties), options);
+}
+function FromRest$1(types) {
+	return types.map((type) => PartialResolve(type));
+}
+function PartialResolve(type) {
+	return IsComputed$1(type) ? FromComputed$2(type.target, type.parameters) : IsRef$1(type) ? FromRef$1(type.$ref) : IsIntersect$1(type) ? Intersect(FromRest$1(type.allOf)) : IsUnion$1(type) ? Union(FromRest$1(type.anyOf)) : IsObject$1(type) ? FromObject$2(type, type.properties) : IsBigInt$1(type) ? type : IsBoolean$1(type) ? type : IsInteger$1(type) ? type : IsLiteral$1(type) ? type : IsNull$1(type) ? type : IsNumber$1(type) ? type : IsString$1(type) ? type : IsSymbol$1(type) ? type : IsUndefined$1(type) ? type : Object$1({});
+}
+/** `[Json]` Constructs a type where all properties are optional */
+function Partial(type, options) {
+	if (IsMappedResult$1(type)) return PartialFromMappedResult(type, options);
+	else return CreateType({
+		...PartialResolve(type),
+		...options
+	});
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/partial/partial-from-mapped-result.mjs
+function FromProperties$2(K, options) {
+	const Acc = {};
+	for (const K2 of globalThis.Object.getOwnPropertyNames(K)) Acc[K2] = Partial(K[K2], Clone(options));
+	return Acc;
+}
+function FromMappedResult$1(R, options) {
+	return FromProperties$2(R.properties, options);
+}
+function PartialFromMappedResult(R, options) {
+	return MappedResult(FromMappedResult$1(R, options));
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/required/required.mjs
+function FromComputed$1(target, parameters) {
+	return Computed("Required", [Computed(target, parameters)]);
+}
+function FromRef($ref) {
+	return Computed("Required", [Ref($ref)]);
+}
+function FromProperties$1(properties) {
+	const requiredProperties = {};
+	for (const K of globalThis.Object.getOwnPropertyNames(properties)) requiredProperties[K] = Discard(properties[K], [OptionalKind]);
+	return requiredProperties;
+}
+function FromObject$1(type, properties) {
+	const options = Discard(type, [
+		TransformKind,
+		"$id",
+		"required",
+		"properties"
+	]);
+	return Object$1(FromProperties$1(properties), options);
+}
+function FromRest(types) {
+	return types.map((type) => RequiredResolve(type));
+}
+function RequiredResolve(type) {
+	return IsComputed$1(type) ? FromComputed$1(type.target, type.parameters) : IsRef$1(type) ? FromRef(type.$ref) : IsIntersect$1(type) ? Intersect(FromRest(type.allOf)) : IsUnion$1(type) ? Union(FromRest(type.anyOf)) : IsObject$1(type) ? FromObject$1(type, type.properties) : IsBigInt$1(type) ? type : IsBoolean$1(type) ? type : IsInteger$1(type) ? type : IsLiteral$1(type) ? type : IsNull$1(type) ? type : IsNumber$1(type) ? type : IsString$1(type) ? type : IsSymbol$1(type) ? type : IsUndefined$1(type) ? type : Object$1({});
+}
+/** `[Json]` Constructs a type where all properties are required */
+function Required(type, options) {
+	if (IsMappedResult$1(type)) return RequiredFromMappedResult(type, options);
+	else return CreateType({
+		...RequiredResolve(type),
+		...options
+	});
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/required/required-from-mapped-result.mjs
+function FromProperties(P, options) {
+	const Acc = {};
+	for (const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Required(P[K2], options);
+	return Acc;
+}
+function FromMappedResult(R, options) {
+	return FromProperties(R.properties, options);
+}
+function RequiredFromMappedResult(R, options) {
+	return MappedResult(FromMappedResult(R, options));
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/module/compute.mjs
+function DereferenceParameters(moduleProperties, types) {
+	return types.map((type) => {
+		return IsRef$1(type) ? Dereference(moduleProperties, type.$ref) : FromType(moduleProperties, type);
+	});
+}
+function Dereference(moduleProperties, ref) {
+	return ref in moduleProperties ? IsRef$1(moduleProperties[ref]) ? Dereference(moduleProperties, moduleProperties[ref].$ref) : FromType(moduleProperties, moduleProperties[ref]) : Never();
+}
+function FromAwaited(parameters) {
+	return Awaited(parameters[0]);
+}
+function FromIndex(parameters) {
+	return Index(parameters[0], parameters[1]);
+}
+function FromKeyOf(parameters) {
+	return KeyOf(parameters[0]);
+}
+function FromPartial(parameters) {
+	return Partial(parameters[0]);
+}
+function FromOmit(parameters) {
+	return Omit(parameters[0], parameters[1]);
+}
+function FromPick(parameters) {
+	return Pick(parameters[0], parameters[1]);
+}
+function FromRequired(parameters) {
+	return Required(parameters[0]);
+}
+function FromComputed(moduleProperties, target, parameters) {
+	const dereferenced = DereferenceParameters(moduleProperties, parameters);
+	return target === "Awaited" ? FromAwaited(dereferenced) : target === "Index" ? FromIndex(dereferenced) : target === "KeyOf" ? FromKeyOf(dereferenced) : target === "Partial" ? FromPartial(dereferenced) : target === "Omit" ? FromOmit(dereferenced) : target === "Pick" ? FromPick(dereferenced) : target === "Required" ? FromRequired(dereferenced) : Never();
+}
+function FromArray(moduleProperties, type) {
+	return Array$1(FromType(moduleProperties, type));
+}
+function FromAsyncIterator(moduleProperties, type) {
+	return AsyncIterator(FromType(moduleProperties, type));
+}
+function FromConstructor(moduleProperties, parameters, instanceType) {
+	return Constructor(FromTypes(moduleProperties, parameters), FromType(moduleProperties, instanceType));
+}
+function FromFunction(moduleProperties, parameters, returnType) {
+	return Function(FromTypes(moduleProperties, parameters), FromType(moduleProperties, returnType));
+}
+function FromIntersect(moduleProperties, types) {
+	return Intersect(FromTypes(moduleProperties, types));
+}
+function FromIterator(moduleProperties, type) {
+	return Iterator(FromType(moduleProperties, type));
+}
+function FromObject(moduleProperties, properties) {
+	return Object$1(globalThis.Object.keys(properties).reduce((result, key) => {
+		return {
+			...result,
+			[key]: FromType(moduleProperties, properties[key])
+		};
+	}, {}));
+}
+function FromRecord(moduleProperties, type) {
+	const [value, pattern] = [FromType(moduleProperties, RecordValue(type)), RecordPattern(type)];
+	const result = CloneType(type);
+	result.patternProperties[pattern] = value;
+	return result;
+}
+function FromTransform(moduleProperties, transform) {
+	return IsRef$1(transform) ? {
+		...Dereference(moduleProperties, transform.$ref),
+		[TransformKind]: transform[TransformKind]
+	} : transform;
+}
+function FromTuple(moduleProperties, types) {
+	return Tuple(FromTypes(moduleProperties, types));
+}
+function FromUnion(moduleProperties, types) {
+	return Union(FromTypes(moduleProperties, types));
+}
+function FromTypes(moduleProperties, types) {
+	return types.map((type) => FromType(moduleProperties, type));
+}
+function FromType(moduleProperties, type) {
+	return IsOptional$1(type) ? CreateType(FromType(moduleProperties, Discard(type, [OptionalKind])), type) : IsReadonly(type) ? CreateType(FromType(moduleProperties, Discard(type, [ReadonlyKind])), type) : IsTransform$1(type) ? CreateType(FromTransform(moduleProperties, type), type) : IsArray$1(type) ? CreateType(FromArray(moduleProperties, type.items), type) : IsAsyncIterator$1(type) ? CreateType(FromAsyncIterator(moduleProperties, type.items), type) : IsComputed$1(type) ? CreateType(FromComputed(moduleProperties, type.target, type.parameters)) : IsConstructor$1(type) ? CreateType(FromConstructor(moduleProperties, type.parameters, type.returns), type) : IsFunction$1(type) ? CreateType(FromFunction(moduleProperties, type.parameters, type.returns), type) : IsIntersect$1(type) ? CreateType(FromIntersect(moduleProperties, type.allOf), type) : IsIterator$1(type) ? CreateType(FromIterator(moduleProperties, type.items), type) : IsObject$1(type) ? CreateType(FromObject(moduleProperties, type.properties), type) : IsRecord$1(type) ? CreateType(FromRecord(moduleProperties, type)) : IsTuple$1(type) ? CreateType(FromTuple(moduleProperties, type.items || []), type) : IsUnion$1(type) ? CreateType(FromUnion(moduleProperties, type.anyOf), type) : type;
+}
+function ComputeType(moduleProperties, key) {
+	return key in moduleProperties ? FromType(moduleProperties, moduleProperties[key]) : Never();
+}
+function ComputeModuleProperties(moduleProperties) {
+	return globalThis.Object.getOwnPropertyNames(moduleProperties).reduce((result, key) => {
+		return {
+			...result,
+			[key]: ComputeType(moduleProperties, key)
+		};
+	}, {});
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/module/module.mjs
+var TModule = class {
+	constructor($defs) {
+		const computed = ComputeModuleProperties($defs);
+		this.$defs = this.WithIdentifiers(computed);
+	}
+	/** `[Json]` Imports a Type by Key. */
+	Import(key, options) {
+		const $defs = {
+			...this.$defs,
+			[key]: CreateType(this.$defs[key], options)
+		};
+		return CreateType({
+			[Kind]: "Import",
+			$defs,
+			$ref: key
+		});
+	}
+	WithIdentifiers($defs) {
+		return globalThis.Object.getOwnPropertyNames($defs).reduce((result, key) => {
+			return {
+				...result,
+				[key]: {
+					...$defs[key],
+					$id: key
+				}
+			};
+		}, {});
+	}
+};
+/** `[Json]` Creates a Type Definition Module. */
+function Module(properties) {
+	return new TModule(properties);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/not/not.mjs
+/** `[Json]` Creates a Not type */
+function Not(type, options) {
+	return CreateType({
+		[Kind]: "Not",
+		not: type
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/parameters/parameters.mjs
+/** `[JavaScript]` Extracts the Parameters from the given Function type */
+function Parameters(schema, options) {
+	return IsFunction$1(schema) ? Tuple(schema.parameters, options) : Never();
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/recursive/recursive.mjs
+let Ordinal = 0;
+/** `[Json]` Creates a Recursive type */
+function Recursive(callback, options = {}) {
+	if (IsUndefined$3(options.$id)) options.$id = `T${Ordinal++}`;
+	const thisType = CloneType(callback({
+		[Kind]: "This",
+		$ref: `${options.$id}`
+	}));
+	thisType.$id = options.$id;
+	return CreateType({
+		[Hint]: "Recursive",
+		...thisType
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/regexp/regexp.mjs
+/** `[JavaScript]` Creates a RegExp type */
+function RegExp$1(unresolved, options) {
+	const expr = IsString$2(unresolved) ? new globalThis.RegExp(unresolved) : unresolved;
+	return CreateType({
+		[Kind]: "RegExp",
+		type: "RegExp",
+		source: expr.source,
+		flags: expr.flags
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/rest/rest.mjs
+function RestResolve(T) {
+	return IsIntersect$1(T) ? T.allOf : IsUnion$1(T) ? T.anyOf : IsTuple$1(T) ? T.items ?? [] : [];
+}
+/** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
+function Rest(T) {
+	return RestResolve(T);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/return-type/return-type.mjs
+/** `[JavaScript]` Extracts the ReturnType from the given Function type */
+function ReturnType(schema, options) {
+	return IsFunction$1(schema) ? CreateType(schema.returns, options) : Never(options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/transform/transform.mjs
+var TransformDecodeBuilder = class {
+	constructor(schema) {
+		this.schema = schema;
+	}
+	Decode(decode) {
+		return new TransformEncodeBuilder(this.schema, decode);
+	}
+};
+var TransformEncodeBuilder = class {
+	constructor(schema, decode) {
+		this.schema = schema;
+		this.decode = decode;
+	}
+	EncodeTransform(encode, schema) {
+		const Encode = (value) => schema[TransformKind].Encode(encode(value));
+		const Decode = (value) => this.decode(schema[TransformKind].Decode(value));
+		const Codec = {
+			Encode,
+			Decode
+		};
+		return {
+			...schema,
+			[TransformKind]: Codec
+		};
+	}
+	EncodeSchema(encode, schema) {
+		const Codec = {
+			Decode: this.decode,
+			Encode: encode
+		};
+		return {
+			...schema,
+			[TransformKind]: Codec
+		};
+	}
+	Encode(encode) {
+		return IsTransform$1(this.schema) ? this.EncodeTransform(encode, this.schema) : this.EncodeSchema(encode, this.schema);
+	}
+};
+/** `[Json]` Creates a Transform type */
+function Transform(schema) {
+	return new TransformDecodeBuilder(schema);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/unsafe/unsafe.mjs
+/** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
+function Unsafe(options = {}) {
+	return CreateType({ [Kind]: options[Kind] ?? "Unsafe" }, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/void/void.mjs
+/** `[JavaScript]` Creates a Void type */
+function Void(options) {
+	return CreateType({
+		[Kind]: "Void",
+		type: "void"
+	}, options);
+}
+//#endregion
+//#region node_modules/@sinclair/typebox/build/esm/type/type/index.mjs
+/** JavaScript Type Builder with Static Resolution for TypeScript */
+const Type = /* @__PURE__ */ __exportAll({
+	Any: () => Any,
+	Argument: () => Argument,
+	Array: () => Array$1,
+	AsyncIterator: () => AsyncIterator,
+	Awaited: () => Awaited,
+	BigInt: () => BigInt,
+	Boolean: () => Boolean,
+	Capitalize: () => Capitalize,
+	Composite: () => Composite,
+	Const: () => Const,
+	Constructor: () => Constructor,
+	ConstructorParameters: () => ConstructorParameters,
+	Date: () => Date$1,
+	Enum: () => Enum,
+	Exclude: () => Exclude,
+	Extends: () => Extends,
+	Extract: () => Extract,
+	Function: () => Function,
+	Index: () => Index,
+	InstanceType: () => InstanceType,
+	Instantiate: () => Instantiate,
+	Integer: () => Integer,
+	Intersect: () => Intersect,
+	Iterator: () => Iterator,
+	KeyOf: () => KeyOf,
+	Literal: () => Literal,
+	Lowercase: () => Lowercase,
+	Mapped: () => Mapped,
+	Module: () => Module,
+	Never: () => Never,
+	Not: () => Not,
+	Null: () => Null,
+	Number: () => Number$1,
+	Object: () => Object$1,
+	Omit: () => Omit,
+	Optional: () => Optional,
+	Parameters: () => Parameters,
+	Partial: () => Partial,
+	Pick: () => Pick,
+	Promise: () => Promise$1,
+	Readonly: () => Readonly,
+	ReadonlyOptional: () => ReadonlyOptional,
+	Record: () => Record,
+	Recursive: () => Recursive,
+	Ref: () => Ref,
+	RegExp: () => RegExp$1,
+	Required: () => Required,
+	Rest: () => Rest,
+	ReturnType: () => ReturnType,
+	String: () => String$1,
+	Symbol: () => Symbol$1,
+	TemplateLiteral: () => TemplateLiteral,
+	Transform: () => Transform,
+	Tuple: () => Tuple,
+	Uint8Array: () => Uint8Array$1,
+	Uncapitalize: () => Uncapitalize,
+	Undefined: () => Undefined,
+	Union: () => Union,
+	Unknown: () => Unknown,
+	Unsafe: () => Unsafe,
+	Uppercase: () => Uppercase,
+	Void: () => Void
+});
+//#endregion
+//#region src/openai/json-schema-to-typebox.ts
+function isRecord$2(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/**
+* Unsupported JSON Schema keywords that we reject explicitly.
+* Note: `anyOf` is handled separately for common patterns (nullable types, simple unions).
+*/
+const REJECTED_KEYWORDS = [
+	"$ref",
+	"oneOf",
+	"allOf",
+	"if",
+	"then",
+	"else",
+	"patternProperties",
+	"not"
+];
+/**
+* Convert a JSON Schema object to a TypeBox TSchema.
+*
+* Returns a ConversionError for unsupported constructs.
+*/
+function jsonSchemaToTypebox(schema, path = "") {
+	if (!isRecord$2(schema)) return {
+		ok: false,
+		message: "Schema must be an object",
+		path
+	};
+	for (const keyword of REJECTED_KEYWORDS) if (schema[keyword] !== void 0) return {
+		ok: false,
+		message: `Unsupported JSON Schema keyword '${keyword}' at ${path || "root"}`,
+		path
+	};
+	const description = typeof schema["description"] === "string" ? schema["description"] : void 0;
+	const opts = {};
+	if (description !== void 0) opts["description"] = description;
+	const anyOf = schema["anyOf"];
+	if (Array.isArray(anyOf)) return convertAnyOf(anyOf, path, opts);
+	const enumValues = schema["enum"];
+	if (Array.isArray(enumValues)) return convertEnum(enumValues, path, opts);
+	const rawType = schema["type"];
+	if (Array.isArray(rawType)) return convertNullableType(rawType, schema, path, opts);
+	if (typeof rawType !== "string") {
+		if (Object.keys(schema).length === 0 || Object.keys(schema).length === 1 && description !== void 0) return {
+			ok: true,
+			schema: Type.Unknown(opts)
+		};
+		return {
+			ok: false,
+			message: `Missing or invalid 'type' at ${path || "root"}`,
+			path
+		};
+	}
+	switch (rawType) {
+		case "object": return convertObject(schema, path, opts);
+		case "string": return {
+			ok: true,
+			schema: Type.String(opts)
+		};
+		case "number": return {
+			ok: true,
+			schema: Type.Number(opts)
+		};
+		case "integer": return {
+			ok: true,
+			schema: Type.Integer(opts)
+		};
+		case "boolean": return {
+			ok: true,
+			schema: Type.Boolean(opts)
+		};
+		case "null": return {
+			ok: true,
+			schema: Type.Null(opts)
+		};
+		case "array": return convertArray(schema, path, opts);
+		default: return {
+			ok: false,
+			message: `Unsupported type '${rawType}' at ${path || "root"}`,
+			path
+		};
+	}
+}
+/**
+* Convert anyOf to a TypeBox Union.
+*
+* Supports:
+* - Nullable: anyOf: [{type: T}, {type: "null"}]
+* - Simple unions of supported types (max 10 branches)
+*/
+function convertAnyOf(branches, path, opts) {
+	if (branches.length === 0) return {
+		ok: false,
+		message: `Empty 'anyOf' at ${path || "root"}`,
+		path
+	};
+	if (branches.length > 10) return {
+		ok: false,
+		message: `'anyOf' with more than 10 branches is not supported at ${path || "root"}`,
+		path
+	};
+	const converted = [];
+	for (let i = 0; i < branches.length; i++) {
+		const branchPath = `${path || "root"}.anyOf[${String(i)}]`;
+		const result = jsonSchemaToTypebox(branches[i], branchPath);
+		if (!result.ok) return result;
+		converted.push(result.schema);
+	}
+	return {
+		ok: true,
+		schema: Type.Union(converted, opts)
+	};
+}
+function convertEnum(values, path, opts) {
+	const stringValues = [];
+	for (const v of values) {
+		if (typeof v !== "string") return {
+			ok: false,
+			message: `Only string enums are supported at ${path || "root"}`,
+			path
+		};
+		stringValues.push(v);
+	}
+	if (stringValues.length === 0) return {
+		ok: false,
+		message: `Empty enum at ${path || "root"}`,
+		path
+	};
+	const literals = stringValues.map((v) => Type.Literal(v));
+	return {
+		ok: true,
+		schema: Type.Union(literals, opts)
+	};
+}
+function convertNullableType(typeArray, schema, path, opts) {
+	const nonNullTypes = typeArray.filter((t) => t !== "null");
+	if (nonNullTypes.length !== 1 || typeArray.length !== 2) return {
+		ok: false,
+		message: `Only [type, "null"] nullable types are supported at ${path || "root"}`,
+		path
+	};
+	const innerType = nonNullTypes[0];
+	if (typeof innerType !== "string") return {
+		ok: false,
+		message: `Invalid nullable type at ${path || "root"}`,
+		path
+	};
+	const innerResult = jsonSchemaToTypebox({
+		...schema,
+		type: innerType
+	}, path);
+	if (!innerResult.ok) return innerResult;
+	return {
+		ok: true,
+		schema: Type.Union([innerResult.schema, Type.Null()], opts)
+	};
+}
+function convertObject(schema, path, opts) {
+	const rawProperties = schema["properties"];
+	const rawRequired = schema["required"];
+	const additionalProperties = schema["additionalProperties"];
+	if (additionalProperties !== void 0 && typeof additionalProperties !== "boolean") return {
+		ok: false,
+		message: `'additionalProperties' as a schema is not supported at ${path || "root"}; only boolean values are allowed`,
+		path
+	};
+	if (rawProperties === void 0) return {
+		ok: true,
+		schema: Type.Object({}, opts)
+	};
+	if (!isRecord$2(rawProperties)) return {
+		ok: false,
+		message: `'properties' must be an object at ${path || "root"}`,
+		path
+	};
+	const requiredSet = /* @__PURE__ */ new Set();
+	if (Array.isArray(rawRequired)) {
+		for (const r of rawRequired) if (typeof r === "string") requiredSet.add(r);
+	}
+	const typeboxProperties = {};
+	for (const [key, propSchema] of Object.entries(rawProperties)) {
+		const result = jsonSchemaToTypebox(propSchema, path.length > 0 ? `${path}.${key}` : key);
+		if (!result.ok) return result;
+		if (requiredSet.has(key)) typeboxProperties[key] = result.schema;
+		else typeboxProperties[key] = Type.Optional(result.schema);
+	}
+	return {
+		ok: true,
+		schema: Type.Object(typeboxProperties, opts)
+	};
+}
+function convertArray(schema, path, opts) {
+	const items = schema["items"];
+	if (items === void 0) return {
+		ok: true,
+		schema: Type.Array(Type.Unknown(), opts)
+	};
+	const itemResult = jsonSchemaToTypebox(items, path.length > 0 ? `${path}.items` : "items");
+	if (!itemResult.ok) return itemResult;
+	return {
+		ok: true,
+		schema: Type.Array(itemResult.schema, opts)
+	};
+}
+//#endregion
+//#region src/openai/tools.ts
+/**
+* Convert an array of OpenAI function tool definitions to pi Tool definitions.
+*/
+function convertTools(openaiTools) {
+	const piTools = [];
+	for (let i = 0; i < openaiTools.length; i++) {
+		const tool = openaiTools[i];
+		if (tool === void 0) continue;
+		const fn = tool.function;
+		let parameters;
+		if (fn.parameters !== void 0) {
+			const result = jsonSchemaToTypebox(fn.parameters, `tools[${String(i)}].function.parameters`);
+			if (!result.ok) return {
+				ok: false,
+				message: result.message,
+				param: result.path
+			};
+			parameters = result.schema;
+		} else parameters = Type.Object({});
+		piTools.push({
+			name: fn.name,
+			description: fn.description ?? "",
+			parameters
+		});
+	}
+	return {
+		ok: true,
+		tools: piTools
+	};
+}
+//#endregion
+//#region src/openai/schemas.ts
+/**
+* Zod schemas for the OpenAI chat-completions request subset.
+*
+* Phase 2 contract:
+* - Phase 1 supported fields: model, messages, stream, temperature,
+*   max_tokens, max_completion_tokens, stop, user, stream_options
+* - Phase 2 additions: tools, tool_choice, reasoning_effort,
+*   top_p, frequency_penalty, presence_penalty, seed, response_format
+* - Unknown top-level fields are rejected with 422
+* - `n > 1` is rejected
+* - `logprobs` is rejected
+*/
+const textContentPartSchema = z.object({
+	type: z.literal("text"),
+	text: z.string().trim()
+});
+const imageUrlContentPartSchema = z.object({
+	type: z.literal("image_url"),
+	image_url: z.object({
+		url: z.string().trim(),
+		detail: z.enum([
+			"auto",
+			"low",
+			"high"
+		]).optional()
+	})
+});
+const contentPartSchema = z.discriminatedUnion("type", [textContentPartSchema, imageUrlContentPartSchema]);
+const systemMessageSchema = z.object({
+	role: z.literal("system"),
+	content: z.string().trim(),
+	name: z.string().trim().optional()
+});
+const developerMessageSchema = z.object({
+	role: z.literal("developer"),
+	content: z.string().trim(),
+	name: z.string().trim().optional()
+});
+const userMessageTextSchema = z.object({
+	role: z.literal("user"),
+	content: z.string().trim(),
+	name: z.string().trim().optional()
+});
+const userMessagePartsSchema = z.object({
+	role: z.literal("user"),
+	content: z.array(contentPartSchema),
+	name: z.string().trim().optional()
+});
+const assistantMessageSchema = z.object({
+	role: z.literal("assistant"),
+	content: z.string().trim().nullable().optional(),
+	name: z.string().trim().optional(),
+	tool_calls: z.array(z.object({
+		id: z.string().trim(),
+		type: z.literal("function"),
+		function: z.object({
+			name: z.string().trim(),
+			arguments: z.string().trim()
+		})
+	})).optional()
+});
+const toolMessageSchema = z.object({
+	role: z.literal("tool"),
+	content: z.string().trim(),
+	tool_call_id: z.string().trim()
+});
+const messageSchema = z.union([
+	systemMessageSchema,
+	developerMessageSchema,
+	userMessageTextSchema,
+	userMessagePartsSchema,
+	assistantMessageSchema,
+	toolMessageSchema
+]);
+const streamOptionsSchema = z.object({ include_usage: z.boolean().optional() });
+/**
+* OpenAI function tool definition.
+* The `parameters` field is a JSON Schema object validated structurally;
+* semantic conversion to TypeBox happens in json-schema-to-typebox.ts.
+*/
+const functionToolSchema = z.object({
+	type: z.literal("function"),
+	function: z.object({
+		name: z.string().trim(),
+		description: z.string().trim().optional(),
+		parameters: z.record(z.string().trim(), z.unknown()).optional(),
+		strict: z.boolean().nullable().optional()
+	})
+});
+/**
+* OpenAI tool_choice: "none" | "auto" | "required" | { type: "function", function: { name: string } }
+*/
+const namedToolChoiceSchema = z.object({
+	type: z.literal("function"),
+	function: z.object({ name: z.string().trim() })
+});
+const toolChoiceSchema = z.union([z.enum([
+	"none",
+	"auto",
+	"required"
+]), namedToolChoiceSchema]);
+const responseFormatSchema = z.discriminatedUnion("type", [z.object({ type: z.literal("text") }), z.object({ type: z.literal("json_object") })]);
+const chatCompletionRequestSchema = z.object({
+	model: z.string().trim(),
+	messages: z.array(messageSchema).min(1),
+	stream: z.boolean().optional(),
+	temperature: z.number().min(0).max(2).optional(),
+	max_tokens: z.int().positive().optional(),
+	max_completion_tokens: z.int().positive().optional(),
+	stop: z.union([z.string().trim(), z.array(z.string().trim()).max(4)]).optional(),
+	user: z.string().trim().optional(),
+	stream_options: streamOptionsSchema.nullable().optional(),
+	tools: z.array(functionToolSchema).optional(),
+	tool_choice: toolChoiceSchema.optional(),
+	reasoning_effort: z.enum([
+		"low",
+		"medium",
+		"high"
+	]).optional(),
+	top_p: z.number().min(0).max(1).optional(),
+	frequency_penalty: z.number().min(-2).max(2).optional(),
+	presence_penalty: z.number().min(-2).max(2).optional(),
+	seed: z.int().optional(),
+	response_format: responseFormatSchema.optional()
+}).strict();
+/**
+* Fields that are explicitly rejected with a helpful error.
+* These are not supported and won't be promoted.
+*/
+const rejectedFields = [
+	"n",
+	"logprobs",
+	"top_logprobs",
+	"logit_bias",
+	"functions",
+	"function_call",
+	"parallel_tool_calls"
+];
+//#endregion
+//#region src/openai/validate.ts
+/**
+* Request validation: parse and reject unsupported fields.
+*
+* Phase 2 contract: unknown fields -> 422, rejected fields -> 422
+*/
+function isRecord$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/**
+* Validate a raw request body against the Phase 1 schema.
+*
+* Also checks for known rejected fields to give friendly errors.
+*/
+function validateChatRequest(body) {
+	if (isRecord$1(body)) {
+		for (const field of rejectedFields) if (body[field] !== void 0) return {
+			ok: false,
+			status: 422,
+			message: `'${field}' is not supported in this version of the proxy`,
+			param: field
+		};
+	}
+	const result = chatCompletionRequestSchema.safeParse(body);
+	if (result.success) return {
+		ok: true,
+		data: result.data
+	};
+	const firstIssue = result.error.issues[0];
+	if (firstIssue !== void 0) {
+		const path = firstIssue.path.join(".");
+		if (firstIssue.code === "unrecognized_keys") return {
+			ok: false,
+			status: 422,
+			message: `Unknown parameter(s): ${firstIssue.keys.join(", ")}`,
+			param: firstIssue.keys[0] ?? null
+		};
+		return {
+			ok: false,
+			status: 400,
+			message: `Invalid value for '${path}': ${firstIssue.message}`,
+			param: path.length > 0 ? path : null
+		};
+	}
+	return {
+		ok: false,
+		status: 400,
+		message: "Invalid request body",
+		param: null
+	};
+}
+//#endregion
+//#region src/pi/complete.ts
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/**
+* Map OpenAI reasoning_effort to pi ThinkingLevel.
+*
+* OpenAI: "low" | "medium" | "high"
+* Pi: "minimal" | "low" | "medium" | "high" | "xhigh"
+*
+* Direct mapping for the three shared values.
+*/
+const REASONING_EFFORT_MAP = {
+	low: "low",
+	medium: "medium",
+	high: "high"
+};
+/**
+* APIs where onPayload passthrough fields are not supported.
+* These APIs use non-standard request formats that reject standard OpenAI fields.
+*/
+const SKIP_PAYLOAD_PASSTHROUGH_APIS = new Set(["openai-codex-responses"]);
+/**
+* Collect fields that need to be injected via onPayload.
+* Skips passthrough for APIs that use non-standard request formats.
+*/
+function collectPayloadFields(request, api) {
+	if (SKIP_PAYLOAD_PASSTHROUGH_APIS.has(api)) return;
+	const fields = {};
+	let hasFields = false;
+	if (request.stop !== void 0) {
+		fields["stop"] = request.stop;
+		hasFields = true;
+	}
+	if (request.user !== void 0) {
+		fields["user"] = request.user;
+		hasFields = true;
+	}
+	if (request.top_p !== void 0) {
+		fields["top_p"] = request.top_p;
+		hasFields = true;
+	}
+	if (request.frequency_penalty !== void 0) {
+		fields["frequency_penalty"] = request.frequency_penalty;
+		hasFields = true;
+	}
+	if (request.presence_penalty !== void 0) {
+		fields["presence_penalty"] = request.presence_penalty;
+		hasFields = true;
+	}
+	if (request.seed !== void 0) {
+		fields["seed"] = request.seed;
+		hasFields = true;
+	}
+	if (request.response_format !== void 0) {
+		fields["response_format"] = request.response_format;
+		hasFields = true;
+	}
+	return hasFields ? fields : void 0;
+}
+/**
+* Combine a client disconnect signal with an upstream timeout into a single signal.
+* Returns the combined signal, or undefined if neither is provided.
+*/
+function buildCombinedSignal(clientSignal, timeoutMs) {
+	if (clientSignal === void 0 && timeoutMs === void 0) return;
+	if (timeoutMs === void 0) return clientSignal;
+	const timeoutSignal = AbortSignal.timeout(timeoutMs);
+	if (clientSignal === void 0) return timeoutSignal;
+	return AbortSignal.any([clientSignal, timeoutSignal]);
+}
+/**
+* Build pi SimpleStreamOptions from an OpenAI request.
+*/
+async function buildStreamOptions(model, request, options) {
+	const opts = {};
+	if (request.temperature !== void 0 && model.api !== "openai-codex-responses") opts.temperature = request.temperature;
+	const maxTokens = request.max_completion_tokens ?? request.max_tokens;
+	if (maxTokens !== void 0) opts.maxTokens = maxTokens;
+	if (request.reasoning_effort !== void 0) {
+		const level = REASONING_EFFORT_MAP[request.reasoning_effort];
+		if (level !== void 0) opts.reasoning = level;
+	}
+	const combinedSignal = buildCombinedSignal(options.signal, options.upstreamTimeoutMs);
+	if (combinedSignal !== void 0) opts.signal = combinedSignal;
+	if (options.upstreamApiKey !== void 0) opts.apiKey = options.upstreamApiKey;
+	else {
+		const apiKey = await getRegistry().getApiKey(model);
+		if (apiKey !== void 0) opts.apiKey = apiKey;
+	}
+	const payloadFields = collectPayloadFields(request, model.api);
+	if (payloadFields !== void 0) opts.onPayload = (payload) => {
+		if (isRecord(payload)) for (const [key, value] of Object.entries(payloadFields)) payload[key] = value;
+		return payload;
+	};
+	return opts;
+}
+/**
+* Non-streaming completion: returns the final AssistantMessage.
+*/
+async function piComplete(model, context, request, options) {
+	return completeSimple(model, context, await buildStreamOptions(model, request, options));
+}
+/**
+* Streaming completion: returns an async iterable of events.
+*/
+async function piStream(model, context, request, options) {
+	return streamSimple(model, context, await buildStreamOptions(model, request, options));
+}
+//#endregion
+//#region src/pi/resolve-model.ts
+/**
+* Parse a canonical model ID string into provider and model-id.
+*
+* "openai/gpt-4o" -> { provider: "openai", modelId: "gpt-4o" }
+* "openrouter/anthropic/claude-sonnet-4-20250514" -> { provider: "openrouter", modelId: "anthropic/claude-sonnet-4-20250514" }
+* "gpt-4o" -> null (shorthand, no slash)
+*/
+function parseCanonicalId(input) {
+	const slashIndex = input.indexOf("/");
+	if (slashIndex === -1) return null;
+	return {
+		provider: input.slice(0, slashIndex),
+		modelId: input.slice(slashIndex + 1)
+	};
+}
+/**
+* Resolve a model string (canonical or shorthand) to a pi Model.
+*/
+function resolveModel(input) {
+	const registry = getRegistry();
+	const parsed = parseCanonicalId(input);
+	if (parsed !== null) {
+		const model = registry.find(parsed.provider, parsed.modelId);
+		if (model === void 0) return {
+			ok: false,
+			status: 404,
+			message: `Model '${input}' not found`
+		};
+		return {
+			ok: true,
+			model
+		};
+	}
+	const allModels = registry.getAll();
+	const matches = [];
+	for (const m of allModels) if (m.id === input) matches.push(m);
+	if (matches.length === 0) return {
+		ok: false,
+		status: 404,
+		message: `Model '${input}' not found`
+	};
+	if (matches.length === 1) {
+		const match = matches[0];
+		if (match === void 0) return {
+			ok: false,
+			status: 404,
+			message: `Model '${input}' not found`
+		};
+		return {
+			ok: true,
+			model: match
+		};
+	}
+	const candidates = matches.map((m) => `${m.provider}/${m.id}`);
+	return {
+		ok: false,
+		status: 400,
+		message: `Ambiguous model '${input}'. Matches: ${candidates.join(", ")}. Use the canonical form 'provider/model-id'.`,
+		candidates
+	};
+}
+//#endregion
+//#region src/server/routes.ts
+function createRoutes(config) {
+	const routes = new Hono();
+	routes.get("/v1/models", (c) => {
+		const models = getAvailableModels();
+		return c.json(buildModelList(models));
+	});
+	routes.get("/v1/models/*", (c) => {
+		const rawPath = c.req.path;
+		if (!rawPath.startsWith("/v1/models/")) return c.json(modelNotFound(""), 404);
+		const modelIdEncoded = rawPath.slice(11);
+		if (modelIdEncoded.length === 0) return c.json(modelNotFound(""), 404);
+		const modelId = decodeURIComponent(modelIdEncoded);
+		const resolution = resolveModel(modelId);
+		if (!resolution.ok) {
+			if (resolution.status === 400) return c.json(invalidRequest(resolution.message, "model"), 400);
+			return c.json(modelNotFound(modelId), 404);
+		}
+		return c.json(toOpenAIModel(resolution.model));
+	});
+	routes.post("/v1/chat/completions", async (c) => {
+		const requestId = c.get("requestId");
+		const abortController = c.get("abortController");
+		const upstreamApiKey = c.get("upstreamApiKey");
+		let body;
+		try {
+			body = await c.req.json();
+		} catch {
+			return c.json(invalidRequest("Invalid JSON in request body"), 400);
+		}
+		const validation = validateChatRequest(body);
+		if (!validation.ok) {
+			if (validation.status === 422) return c.json(unsupportedParameter(validation.param ?? "unknown", validation.message), 422);
+			return c.json(invalidRequest(validation.message, validation.param ?? void 0), 400);
+		}
+		const request = validation.data;
+		const resolution = resolveModel(request.model);
+		if (!resolution.ok) {
+			if (resolution.status === 400) return c.json(invalidRequest(resolution.message, "model"), 400);
+			return c.json(modelNotFound(request.model), 404);
+		}
+		const model = resolution.model;
+		const canonicalModelId = `${model.provider}/${model.id}`;
+		const conversion = convertMessages(request.messages);
+		if (!conversion.ok) return c.json(invalidRequest(conversion.message, conversion.param), 400);
+		const context = conversion.context;
+		if (request.tools !== void 0 && request.tools.length > 0) {
+			const toolConversion = convertTools(request.tools);
+			if (!toolConversion.ok) return c.json(unsupportedParameter(toolConversion.param, toolConversion.message), 422);
+			context.tools = toolConversion.tools;
+		}
+		if (upstreamApiKey === void 0) {
+			if (await getRegistry().getApiKey(model) === void 0) return c.json(authenticationError(`No API key configured for provider '${model.provider}'. Configure credentials via 'pi /login' or pass X-Pi-Upstream-Api-Key header.`), 401);
+		}
+		const completionOptions = {
+			upstreamApiKey,
+			signal: abortController.signal,
+			upstreamTimeoutMs: config.upstreamTimeoutMs
+		};
+		if (request.stream === true) {
+			const includeUsage = request.stream_options !== null && request.stream_options !== void 0 && request.stream_options.include_usage === true;
+			c.header("content-type", "text/event-stream");
+			c.header("cache-control", "no-cache");
+			c.header("connection", "keep-alive");
+			return stream(c, async (stream) => {
+				try {
+					const eventStream = await piStream(model, context, request, completionOptions);
+					for await (const frame of streamToSSE(eventStream, requestId, canonicalModelId, includeUsage)) await stream.write(frame);
+				} catch (err) {
+					const mapped = mapUpstreamError(err);
+					logError({
+						requestId,
+						method: "POST",
+						path: "/v1/chat/completions"
+					}, mapped.body.error.message, err instanceof Error ? err.message : void 0);
+					const errorChunk = JSON.stringify({ error: mapped.body.error });
+					await stream.write(`data: ${errorChunk}\n\n`);
+					await stream.write("data: [DONE]\n\n");
+				}
+			});
+		}
+		try {
+			const message = await piComplete(model, context, request, completionOptions);
+			if (message.stopReason === "error" || message.stopReason === "aborted") {
+				const errorMessage = message.errorMessage ?? "Upstream provider error";
+				const mapped = mapUpstreamError(new Error(errorMessage));
+				logError({
+					requestId,
+					method: "POST",
+					path: "/v1/chat/completions"
+				}, errorMessage);
+				return c.json(mapped.body, mapped.status);
+			}
+			return c.json(buildChatCompletion(requestId, canonicalModelId, message));
+		} catch (err) {
+			const mapped = mapUpstreamError(err);
+			logError({
+				requestId,
+				method: "POST",
+				path: "/v1/chat/completions"
+			}, mapped.body.error.message, err instanceof Error ? err.message : void 0);
+			return c.json(mapped.body, mapped.status);
+		}
+	});
+	for (const path of [
+		"/v1/completions",
+		"/v1/embeddings",
+		"/v1/audio/*",
+		"/v1/images/*",
+		"/v1/assistants",
+		"/v1/assistants/*",
+		"/v1/threads",
+		"/v1/threads/*",
+		"/v1/files",
+		"/v1/files/*",
+		"/v1/batches",
+		"/v1/batches/*",
+		"/v1/fine_tuning/*"
+	]) routes.all(path, (c) => {
+		return c.json(invalidRequest(`Endpoint '${c.req.path}' is not supported by this proxy`, void 0), 404);
+	});
+	return routes;
+}
+//#endregion
+//#region src/server/app.ts
+function createApp(config) {
+	const app = new Hono();
+	app.use("*", requestIdMiddleware());
+	app.use("*", disconnectMiddleware());
+	app.use("*", bodySizeLimitMiddleware(config));
+	app.use("/v1/*", proxyAuthMiddleware(config));
+	app.route("/", createRoutes(config));
+	return app;
+}
+//#endregion
+//#region src/index.ts
+/**
+* pi-openai-proxy entry point.
+*
+* Initializes the pi model registry, creates the Hono app, and starts serving.
+* Implements graceful shutdown on SIGTERM/SIGINT.
+*/
+const config = loadConfig();
+const loadError = initRegistry();
+if (loadError !== void 0) {
+	console.error(`[warn] models.json load error: ${loadError}`);
+	console.error("[warn] Continuing with built-in models only.");
+}
+const models = getAvailableModels();
+const app = createApp(config);
+logStartup(config.host, config.port, models.length);
+console.error(`pi-openai-proxy listening on http://${config.host}:${String(config.port)} (${String(models.length)} models)`);
+let shutdownInitiated = false;
+function handleShutdown(signal) {
+	if (shutdownInitiated) return;
+	shutdownInitiated = true;
+	logShutdown(signal);
+	console.error(`[info] Received ${signal}, shutting down gracefully...`);
+	const SHUTDOWN_TIMEOUT_MS = 1e4;
+	if (server !== void 0) server.stop();
+	setTimeout(() => {
+		console.error("[warn] Shutdown timeout reached, forcing exit");
+		process.exit(1);
+	}, SHUTDOWN_TIMEOUT_MS).unref();
+}
+process.on("SIGTERM", () => handleShutdown("SIGTERM"));
+process.on("SIGINT", () => handleShutdown("SIGINT"));
+const server = Bun.serve({
+	port: config.port,
+	hostname: config.host,
+	fetch: app.fetch,
+	idleTimeout: 255
+});
+//#endregion
+export { server as default };