peta-docs 0.3.2 → 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 zfadhli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/elysia/index.d.mts

@@ -0,0 +1,13 @@
+import { p as RouteScanner } from "../types-ByYMmSfu.mjs";
+
+//#region src/elysia/scanner.d.ts
+/**
+ * Scans an Elysia app instance and extracts route metadata.
+ *
+ * Relies on Elysia's internal `app.router.history` array. If that structure
+ * changes in a future Elysia version, this scanner will warn and
+ * return an empty array.
+ */
+declare const elysiaScanner: RouteScanner;
+//#endregion
+export { elysiaScanner };

package/dist/elysia/index.mjs

@@ -0,0 +1,35 @@
+import { n as getRouteMeta } from "../route-Dd7Zp1HW.mjs";
+//#region src/elysia/scanner.ts
+/**
+* Scans an Elysia app instance and extracts route metadata.
+*
+* Relies on Elysia's internal `app.router.history` array. If that structure
+* changes in a future Elysia version, this scanner will warn and
+* return an empty array.
+*/
+const elysiaScanner = { scan(app) {
+	const entries = [];
+	if (app == null) return entries;
+	const rawRoutes = app.router?.history;
+	if (!Array.isArray(rawRoutes)) {
+		console.warn("[peta-docs] elysiaScanner: expected app.router.history to be an array, got " + typeof rawRoutes + ". Is this an Elysia app? Provide a custom RouteScanner for other frameworks.");
+		return entries;
+	}
+	for (const r of rawRoutes) {
+		const rec = r;
+		const handler = rec.handler;
+		const meta = typeof handler === "function" ? getRouteMeta(handler) : void 0;
+		if (meta) {
+			const path = typeof rec.path === "string" ? String(rec.path) : "";
+			const method = typeof rec.method === "string" ? String(rec.method) : "";
+			entries.push({
+				path,
+				method,
+				config: meta
+			});
+		}
+	}
+	return entries;
+} };
+//#endregion
+export { elysiaScanner };

package/dist/hono/index.d.mts

@@ -1,4 +1,4 @@
-import { a as FilterFields, f as RouteConfig, g as TypedContext, l as Pagination, n as ArkTypeSchema, o as FilterOperator, r as FieldsetParams, t as RouteScanner } from "../scanner-CU4MsJ2G.mjs";
+import { a as FilterOperator, c as Pagination, d as RouteConfig, g as TypedContext, i as FilterFields, n as FieldsetParams, p as RouteScanner, t as ArkTypeSchema } from "../types-ByYMmSfu.mjs";
 import { Context, Hono, MiddlewareHandler } from "hono";
 
 //#region src/hono/loader.d.ts
@@ -45,13 +45,7 @@ declare function loadRoutes(app: AnyHono, dir: string, options?: {
 }): Promise<void>;
 //#endregion
 //#region src/hono/route.d.ts
-interface PaginationOptions {
-  maxLimit?: number;
-  defaultLimit?: number;
-}
 type ValidationErrorHandler = (issues: unknown[], c: Context) => Response | Promise<Response>;
-/** @deprecated Use {@link RouteBuilder.onValidationError} on the route chain instead. Per-route handlers take precedence over the global handler. */
-declare function setOnValidationError(handler: ValidationErrorHandler): () => void;
 declare class RouteBuilder<B = undefined, Q = undefined, P = undefined, Hd = undefined, Pg extends Pagination | undefined = undefined, F = Record<string, unknown>, Sr = Record<string, unknown>, Ir = Record<string, unknown>, Fs = Record<string, unknown>> {
   private _config;
   private static readonly VALIDATOR_MAP;
@@ -77,8 +71,10 @@ declare class RouteBuilder<B = undefined, Q = undefined, P = undefined, Hd = und
   }, Fs>;
   fieldsets<R extends string[]>(resources: R): RouteBuilder<B, Q, P, Hd, Pg, F, Sr, Ir, FieldsetParams<R>>;
   onValidationError(handler: ValidationErrorHandler): this;
-  onResponseValidationError(handler: ValidationErrorHandler): this;
-  paginated(options?: PaginationOptions): RouteBuilder<B, Q, P, Hd, Pagination, F, Sr, Ir, Fs>;
+  paginated(options?: {
+    maxLimit?: number;
+    defaultLimit?: number;
+  }): RouteBuilder<B, Q, P, Hd, Pagination, F, Sr, Ir, Fs>;
   handle(handler: (c: TypedContext<B, Q, P, Hd, Pg, F, Sr, Ir, Fs>) => Response | Promise<Response>): MiddlewareHandler;
   private buildValidators;
   private buildRouteConfig;
@@ -99,4 +95,4 @@ declare function getRouteMeta(handler: unknown): RouteConfig | undefined;
  */
 declare const honoScanner: RouteScanner;
 //#endregion
-export { type PaginationOptions, RouteBuilder, type ValidationErrorHandler, getRouteMeta, honoScanner, loadRoutes, route, setOnValidationError };
+export { RouteBuilder, type ValidationErrorHandler, getRouteMeta, honoScanner, loadRoutes, route };

package/dist/hono/index.mjs

@@ -1,308 +1,8 @@
-import { n as setDefaultScanner } from "../spec-Bobwv7gP.mjs";
-import { validator } from "hono/validator";
+import { n as setDefaultScanner } from "../spec-CTxjSu78.mjs";
+import { n as getRouteMeta, r as route, t as RouteBuilder } from "../route-Dd7Zp1HW.mjs";
 import { readdirSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { Hono } from "hono";
-//#region src/hono/route.ts
-const OPENAPI_META = Symbol("openapi-meta");
-/** Parse a comma-separated string into a trimmed, non-empty array. */
-function parseCommaSeparated(value) {
-	return value ? value.split(",").map((s) => s.trim()).filter(Boolean) : [];
-}
-/**
-* Validate a value against a Standard Schema.
-* Returns the validated value, or calls `onError` and returns a Response.
-*/
-async function validateOrError(schema, value, c, onError) {
-	const result = await schema["~standard"].validate(value);
-	if (Array.isArray(result)) return onError(result, c);
-	const r = result;
-	if (r.issues) return onError([...r.issues], c);
-	if ("value" in r && r.value !== void 0) return r.value;
-	return value;
-}
-let onValidationError = (issues, c) => {
-	return c.json({
-		error: "Validation failed",
-		issues
-	}, 400);
-};
-/** @deprecated Use {@link RouteBuilder.onValidationError} on the route chain instead. Per-route handlers take precedence over the global handler. */
-function setOnValidationError(handler) {
-	const prev = onValidationError;
-	onValidationError = handler;
-	return () => {
-		onValidationError = prev;
-	};
-}
-const onResponseValidationError = (issues, c) => {
-	return c.json({
-		error: "Response validation failed",
-		issues
-	}, 500);
-};
-/** @internal */
-function createValidator(target, schema, onError) {
-	return validator(target, async (value, c) => {
-		const validated = await validateOrError(schema, value, c, onError);
-		if (validated instanceof Response) return validated;
-		return validated;
-	});
-}
-/**
-* Creates a middleware that checks for the presence of auth credentials.
-*
-* This is a mechanism-level guard — it verifies that the expected auth
-* header/cookie exists, but does NOT verify the credential itself
-* (e.g., JWT validity, session data). The app's own middleware or
-* handler is responsible for identity verification.
-*/
-function authGuard(schemes) {
-	return async (c, next) => {
-		for (const scheme of schemes) {
-			if (scheme === "bearerAuth") {
-				if (!c.req.header("Authorization")?.startsWith("Bearer ")) return c.json({ error: "unauthorized" }, 401);
-			}
-			if (scheme === "sessionAuth" || scheme === "cookieAuth") {
-				if (!c.req.header("Cookie")?.includes("session=")) return c.json({ error: "unauthorized" }, 401);
-			}
-		}
-		return await next();
-	};
-}
-var RouteBuilder = class RouteBuilder {
-	_config = { responses: {} };
-	static VALIDATOR_MAP = [
-		["requestBody", "json"],
-		["params", "param"],
-		["headers", "header"]
-	];
-	summary(s) {
-		this._config.summary = s;
-		return this;
-	}
-	description(s) {
-		this._config.description = s;
-		return this;
-	}
-	operationId(s) {
-		this._config.operationId = s;
-		return this;
-	}
-	tags(...t) {
-		this._config.tags = t;
-		return this;
-	}
-	deprecated(d = true) {
-		this._config.deprecated = d;
-		return this;
-	}
-	requestBody(schema) {
-		this._config.requestBody = schema;
-		return this;
-	}
-	query(schema) {
-		this._config.query = schema;
-		return this;
-	}
-	params(schema) {
-		this._config.params = schema;
-		return this;
-	}
-	headers(schema) {
-		this._config.headers = schema;
-		return this;
-	}
-	response(status, value) {
-		this._config.responses[String(status)] = value;
-		return this;
-	}
-	auth(scheme = "bearerAuth") {
-		const acc = this._config.security ?? [];
-		acc.push(scheme);
-		this._config.security = acc;
-		return this;
-	}
-	filter(name, schema, options) {
-		const acc = this._config.filters ?? [];
-		acc.push({
-			name,
-			schema,
-			operators: options?.operators ?? ["eq"]
-		});
-		this._config.filters = acc;
-		return this;
-	}
-	sort(fields) {
-		this._config.sort = fields;
-		return this;
-	}
-	include(relations) {
-		this._config.include = relations;
-		return this;
-	}
-	fieldsets(resources) {
-		this._config.fieldsets = resources;
-		return this;
-	}
-	onValidationError(handler) {
-		this._config.onValidationError = handler;
-		return this;
-	}
-	onResponseValidationError(handler) {
-		this._config.onResponseValidationError = handler;
-		return this;
-	}
-	paginated(options) {
-		this._config.pagination = {
-			maxLimit: options?.maxLimit ?? 100,
-			defaultLimit: options?.defaultLimit ?? 20
-		};
-		return this;
-	}
-	handle(handler) {
-		const onError = this._config.onValidationError ?? onValidationError;
-		const validators = this.buildValidators(onError);
-		if (this._config.security?.length) validators.unshift(authGuard(this._config.security));
-		const routeConfig = this.buildRouteConfig(handler);
-		const wrapped = this.composeHandler(validators, handler);
-		return this.attachRouteMeta(wrapped, routeConfig);
-	}
-	buildValidators(onError) {
-		const validators = [];
-		const querySchema = this._config.query;
-		const filters = this._config.filters;
-		const sortFields = this._config.sort;
-		const includeFields = this._config.include;
-		const fieldsetResources = this._config.fieldsets;
-		const pag = this._config.pagination;
-		if (querySchema || filters?.length || sortFields || includeFields || fieldsetResources || pag) validators.push(validator("query", async (value, c) => {
-			let merged = {};
-			const raw = value;
-			if (querySchema) {
-				const validated = await validateOrError(querySchema, value, c, onError);
-				if (validated instanceof Response) return validated;
-				merged = {
-					...merged,
-					...validated
-				};
-			}
-			if (filters) for (const filter of filters) for (const op of filter.operators) {
-				const paramName = op === "eq" ? filter.name : `${filter.name}__${op}`;
-				const val = raw[paramName];
-				if (val === void 0) continue;
-				if (op === "in") {
-					const items = parseCommaSeparated(val);
-					const validatedItems = [];
-					for (const item of items) {
-						const validated = await validateOrError(filter.schema, item, c, onError);
-						if (validated instanceof Response) return validated;
-						validatedItems.push(validated);
-					}
-					merged[paramName] = validatedItems;
-				} else {
-					const validated = await validateOrError(filter.schema, val, c, onError);
-					if (validated instanceof Response) return validated;
-					merged[paramName] = validated;
-				}
-			}
-			if (sortFields) {
-				const sortVal = raw.sort;
-				if (sortVal !== void 0) {
-					const parts = parseCommaSeparated(sortVal);
-					const allowed = new Set(sortFields.flatMap((f) => [f, `-${f}`]));
-					for (const part of parts) if (!allowed.has(part)) return onError([{ message: `Invalid sort field "${part}". Allowed: ${[...allowed].join(", ")}` }], c);
-					merged.sort = parts;
-				}
-			}
-			const includeFields = this._config.include;
-			if (includeFields) {
-				const rawInclude = raw.include;
-				if (rawInclude !== void 0) {
-					const parts = parseCommaSeparated(rawInclude);
-					const allowed = new Set(includeFields);
-					for (const part of parts) if (!allowed.has(part)) return onError([{ message: `Invalid include "${part}". Allowed: ${[...allowed].join(", ")}` }], c);
-					merged.include = parts;
-				}
-			}
-			const fieldsetResources = this._config.fieldsets;
-			if (fieldsetResources) for (const resource of fieldsetResources) {
-				const paramName = `fields[${resource}]`;
-				const val = raw[paramName];
-				if (val !== void 0 && typeof val !== "string") return onError([{ message: `"${paramName}" must be a string` }], c);
-				if (val !== void 0) merged[paramName] = val;
-			}
-			if (pag) {
-				const page = Math.floor(Number(raw.page ?? "1"));
-				const limit = Math.min(pag.maxLimit, Math.max(1, Math.floor(Number(raw.limit ?? String(pag.defaultLimit)))));
-				merged.page = Number.isFinite(page) && page >= 1 ? page : 1;
-				merged.limit = Number.isFinite(limit) ? limit : pag.defaultLimit;
-				merged.offset = (merged.page - 1) * merged.limit;
-			}
-			return merged;
-		}));
-		for (const [key, target] of RouteBuilder.VALIDATOR_MAP) {
-			const schema = this._config[key];
-			if (schema != null) validators.push(createValidator(target, schema, onError));
-		}
-		return validators;
-	}
-	buildRouteConfig(handler) {
-		return {
-			...this._config,
-			responses: this._config.responses,
-			pagination: this._config.pagination,
-			filters: this._config.filters,
-			sort: this._config.sort,
-			include: this._config.include,
-			fieldsets: this._config.fieldsets,
-			security: this._config.security,
-			handler
-		};
-	}
-	composeHandler(validators, handler) {
-		return async (c, _next) => {
-			const run = async (i) => {
-				if (i < validators.length) return await validators[i](c, run.bind(null, i + 1)) ?? void 0;
-				const response = await handler(c) ?? void 0;
-				if (response) {
-					const onError = this._config.onResponseValidationError ?? onResponseValidationError;
-					return await this.validateResponse(response, c, onError) ?? void 0;
-				}
-				return response;
-			};
-			return run(0);
-		};
-	}
-	async validateResponse(response, c, onError) {
-		if (!(response.headers.get("content-type") ?? "").includes("application/json")) return response;
-		if (response.status === 204) return response;
-		const schema = this._config.responses[String(response.status)];
-		if (!schema || typeof schema !== "object" && typeof schema !== "function" || !("~standard" in schema)) return response;
-		try {
-			const validated = await validateOrError(schema, await response.clone().json(), c, onError);
-			if (validated instanceof Response) return validated;
-			return response;
-		} catch {
-			return response;
-		}
-	}
-	attachRouteMeta(handler, config) {
-		Object.defineProperty(handler, OPENAPI_META, {
-			value: config,
-			writable: false
-		});
-		return handler;
-	}
-};
-function route() {
-	return new RouteBuilder();
-}
-function getRouteMeta(handler) {
-	if (typeof handler !== "function") return void 0;
-	return handler[OPENAPI_META];
-}
-//#endregion
 //#region src/hono/scanner.ts
 function routeProp(obj, key) {
 	if (obj == null) return void 0;
@@ -432,4 +132,4 @@ async function loadRoutes(app, dir, options) {
 */
 setDefaultScanner(honoScanner);
 //#endregion
-export { RouteBuilder, getRouteMeta, honoScanner, loadRoutes, route, setOnValidationError };
+export { RouteBuilder, getRouteMeta, honoScanner, loadRoutes, route };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { a as FilterFields, c as OpenAPIObject, d as ResponseValue, f as RouteConfig, g as TypedContext, h as StatusCode, i as FilterDef, l as Pagination, m as SchemaObject, n as ArkTypeSchema, o as FilterOperator, p as RouteEntry, r as FieldsetParams, s as InfoObject, t as RouteScanner, u as PathItemObject } from "./scanner-CU4MsJ2G.mjs";
+import { a as FilterOperator, c as Pagination, d as RouteConfig, f as RouteEntry, g as TypedContext, h as StatusCode, i as FilterFields, l as PathItemObject, m as SchemaObject, n as FieldsetParams, o as InfoObject, p as RouteScanner, r as FilterDef, s as OpenAPIObject, t as ArkTypeSchema, u as ResponseValue } from "./types-ByYMmSfu.mjs";
 
 //#region src/scalar.d.ts
 interface ScalarUIOptions {

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { i as toOpenAPISchema, r as buildOpenAPISpec, t as getOpenAPISpec } from "./spec-Bobwv7gP.mjs";
+import { i as toOpenAPISchema, r as buildOpenAPISpec, t as getOpenAPISpec } from "./spec-CTxjSu78.mjs";
 //#region src/scalar.ts
 function escapeHtml(str) {
 	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");

package/dist/route-Dd7Zp1HW.mjs

@@ -0,0 +1,292 @@
+import { validator } from "hono/validator";
+//#region src/hono/route.ts
+const OPENAPI_META = Symbol("openapi-meta");
+/** Parse a comma-separated string into a trimmed, non-empty array. */
+function parseCommaSeparated(value) {
+	return value ? value.split(",").map((s) => s.trim()).filter(Boolean) : [];
+}
+/**
+* Validate a value against a Standard Schema.
+* Returns the validated value, or calls `onError` and returns a Response.
+*/
+async function validateOrError(schema, value, c, onError) {
+	const result = await schema["~standard"].validate(value);
+	if (Array.isArray(result)) return onError(result, c);
+	const r = result;
+	if (r.issues) return onError([...r.issues], c);
+	if ("value" in r && r.value !== void 0) return r.value;
+	return value;
+}
+const onValidationError = (issues, c) => {
+	return c.json({
+		error: "Validation failed",
+		issues
+	}, 400);
+};
+const onResponseValidationError = (issues, c) => {
+	return c.json({
+		error: "Response validation failed",
+		issues
+	}, 500);
+};
+/** @internal */
+function createValidator(target, schema, onError) {
+	return validator(target, async (value, c) => {
+		const validated = await validateOrError(schema, value, c, onError);
+		if (validated instanceof Response) return validated;
+		return validated;
+	});
+}
+/**
+* Creates a middleware that checks for the presence of auth credentials.
+*
+* This is a mechanism-level guard — it verifies that the expected auth
+* header/cookie exists, but does NOT verify the credential itself
+* (e.g., JWT validity, session data). The app's own middleware or
+* handler is responsible for identity verification.
+*/
+function authGuard(schemes) {
+	return async (c, next) => {
+		for (const scheme of schemes) {
+			if (scheme === "bearerAuth") {
+				if (!c.req.header("Authorization")?.startsWith("Bearer ")) return c.json({ error: "unauthorized" }, 401);
+			}
+			if (scheme === "sessionAuth" || scheme === "cookieAuth") {
+				const cookie = c.req.header("Cookie");
+				if (!cookie) return c.json({ error: "unauthorized" }, 401);
+				if (!cookie.split(";").some((pair) => pair.trim().split("=")[0] === "session")) return c.json({ error: "unauthorized" }, 401);
+			}
+		}
+		return await next();
+	};
+}
+var RouteBuilder = class RouteBuilder {
+	_config = { responses: {} };
+	static VALIDATOR_MAP = [
+		["requestBody", "json"],
+		["params", "param"],
+		["headers", "header"]
+	];
+	summary(s) {
+		this._config.summary = s;
+		return this;
+	}
+	description(s) {
+		this._config.description = s;
+		return this;
+	}
+	operationId(s) {
+		this._config.operationId = s;
+		return this;
+	}
+	tags(...t) {
+		this._config.tags = t;
+		return this;
+	}
+	deprecated(d = true) {
+		this._config.deprecated = d;
+		return this;
+	}
+	requestBody(schema) {
+		this._config.requestBody = schema;
+		return this;
+	}
+	query(schema) {
+		this._config.query = schema;
+		return this;
+	}
+	params(schema) {
+		this._config.params = schema;
+		return this;
+	}
+	headers(schema) {
+		this._config.headers = schema;
+		return this;
+	}
+	response(status, value) {
+		this._config.responses[String(status)] = value;
+		return this;
+	}
+	auth(scheme = "bearerAuth") {
+		const acc = this._config.security ?? [];
+		acc.push(scheme);
+		this._config.security = acc;
+		return this;
+	}
+	filter(name, schema, options) {
+		const acc = this._config.filters ?? [];
+		acc.push({
+			name,
+			schema,
+			operators: options?.operators ?? ["eq"]
+		});
+		this._config.filters = acc;
+		return this;
+	}
+	sort(fields) {
+		this._config.sort = fields;
+		return this;
+	}
+	include(relations) {
+		this._config.include = relations;
+		return this;
+	}
+	fieldsets(resources) {
+		this._config.fieldsets = resources;
+		return this;
+	}
+	onValidationError(handler) {
+		this._config.onValidationError = handler;
+		return this;
+	}
+	paginated(options) {
+		this._config.pagination = {
+			maxLimit: options?.maxLimit ?? 100,
+			defaultLimit: options?.defaultLimit ?? 20
+		};
+		return this;
+	}
+	handle(handler) {
+		const onError = this._config.onValidationError ?? onValidationError;
+		const validators = this.buildValidators(onError);
+		if (this._config.security?.length) validators.unshift(authGuard(this._config.security));
+		const routeConfig = this.buildRouteConfig(handler);
+		const wrapped = this.composeHandler(validators, handler);
+		return this.attachRouteMeta(wrapped, routeConfig);
+	}
+	buildValidators(onError) {
+		const validators = [];
+		const querySchema = this._config.query;
+		const filters = this._config.filters;
+		const sortFields = this._config.sort;
+		const includeFields = this._config.include;
+		const fieldsetResources = this._config.fieldsets;
+		const pag = this._config.pagination;
+		if (querySchema || filters?.length || sortFields || includeFields || fieldsetResources || pag) validators.push(validator("query", async (value, c) => {
+			let merged = {};
+			const raw = value;
+			if (querySchema) {
+				const validated = await validateOrError(querySchema, value, c, onError);
+				if (validated instanceof Response) return validated;
+				merged = {
+					...merged,
+					...validated
+				};
+			}
+			if (filters) for (const filter of filters) for (const op of filter.operators) {
+				const paramName = op === "eq" ? filter.name : `${filter.name}__${op}`;
+				const val = raw[paramName];
+				if (val === void 0) continue;
+				if (op === "in") {
+					const items = parseCommaSeparated(val);
+					const validatedItems = [];
+					for (const item of items) {
+						const validated = await validateOrError(filter.schema, item, c, onError);
+						if (validated instanceof Response) return validated;
+						validatedItems.push(validated);
+					}
+					merged[paramName] = validatedItems;
+				} else {
+					const validated = await validateOrError(filter.schema, val, c, onError);
+					if (validated instanceof Response) return validated;
+					merged[paramName] = validated;
+				}
+			}
+			if (sortFields) {
+				const sortVal = raw.sort;
+				if (sortVal !== void 0) {
+					const parts = parseCommaSeparated(sortVal);
+					const allowed = new Set(sortFields.flatMap((f) => [f, `-${f}`]));
+					for (const part of parts) if (!allowed.has(part)) return onError([{ message: `Invalid sort field "${part}". Allowed: ${[...allowed].join(", ")}` }], c);
+					merged.sort = parts;
+				}
+			}
+			const includeFields = this._config.include;
+			if (includeFields) {
+				const rawInclude = raw.include;
+				if (rawInclude !== void 0) {
+					const parts = parseCommaSeparated(rawInclude);
+					const allowed = new Set(includeFields);
+					for (const part of parts) if (!allowed.has(part)) return onError([{ message: `Invalid include "${part}". Allowed: ${[...allowed].join(", ")}` }], c);
+					merged.include = parts;
+				}
+			}
+			const fieldsetResources = this._config.fieldsets;
+			if (fieldsetResources) for (const resource of fieldsetResources) {
+				const paramName = `fields[${resource}]`;
+				const val = raw[paramName];
+				if (val !== void 0 && typeof val !== "string") return onError([{ message: `"${paramName}" must be a string` }], c);
+				if (val !== void 0) merged[paramName] = val;
+			}
+			if (pag) {
+				const page = Math.floor(Number(raw.page ?? "1"));
+				const limit = Math.min(pag.maxLimit, Math.max(1, Math.floor(Number(raw.limit ?? String(pag.defaultLimit)))));
+				merged.page = Number.isFinite(page) && page >= 1 ? page : 1;
+				merged.limit = Number.isFinite(limit) ? limit : pag.defaultLimit;
+				merged.offset = (merged.page - 1) * merged.limit;
+			}
+			return merged;
+		}));
+		for (const [key, target] of RouteBuilder.VALIDATOR_MAP) {
+			const schema = this._config[key];
+			if (schema != null) validators.push(createValidator(target, schema, onError));
+		}
+		return validators;
+	}
+	buildRouteConfig(handler) {
+		return {
+			...this._config,
+			responses: this._config.responses,
+			pagination: this._config.pagination,
+			filters: this._config.filters,
+			sort: this._config.sort,
+			include: this._config.include,
+			fieldsets: this._config.fieldsets,
+			security: this._config.security,
+			handler
+		};
+	}
+	composeHandler(validators, handler) {
+		return async (c, _next) => {
+			const run = async (i) => {
+				if (i < validators.length) return await validators[i](c, run.bind(null, i + 1)) ?? void 0;
+				const response = await handler(c) ?? void 0;
+				if (response) {
+					const onError = onResponseValidationError;
+					return await this.validateResponse(response, c, onError) ?? void 0;
+				}
+				return response;
+			};
+			return run(0);
+		};
+	}
+	async validateResponse(response, c, onError) {
+		if (!(response.headers.get("content-type") ?? "").includes("application/json")) return response;
+		if (response.status === 204) return response;
+		const schema = this._config.responses[String(response.status)];
+		if (!schema || typeof schema !== "object" && typeof schema !== "function" || !("~standard" in schema)) return response;
+		try {
+			const validated = await validateOrError(schema, await response.clone().json(), c, onError);
+			if (validated instanceof Response) return validated;
+			return response;
+		} catch {
+			return response;
+		}
+	}
+	attachRouteMeta(handler, config) {
+		Object.defineProperty(handler, OPENAPI_META, {
+			value: config,
+			writable: false
+		});
+		return handler;
+	}
+};
+function route() {
+	return new RouteBuilder();
+}
+function getRouteMeta(handler) {
+	if (typeof handler !== "function") return void 0;
+	return handler[OPENAPI_META];
+}
+//#endregion
+export { getRouteMeta as n, route as r, RouteBuilder as t };

package/dist/{spec-Bobwv7gP.mjs → spec-CTxjSu78.mjs}

@@ -24,9 +24,7 @@ function toOpenAPISchema(schema) {
 	return {};
 }
 function mapContentSchemas(content, convert) {
-	const result = {};
-	for (const [mediaType, { schema }] of Object.entries(content)) result[mediaType] = { schema: convert(schema) };
-	return result;
+	return Object.fromEntries(Object.entries(content).map(([mt, v]) => [mt, { schema: convert(v.schema) }]));
 }
 const STATUS_DESCRIPTIONS = {
 	"200": "OK",
@@ -73,14 +71,7 @@ function honoPathToOpenAPI(path) {
 	return path.replace(/:(\w+)/g, "{$1}");
 }
 function parsePathParams(path) {
-	const params = [];
-	const regex = /{(\w+)}/g;
-	let match = regex.exec(path);
-	while (match !== null) {
-		params.push(match[1]);
-		match = regex.exec(path);
-	}
-	return params;
+	return [...path.matchAll(/{(\w+)}/g)].map((m) => m[1]);
 }
 function extractProperties(schema) {
 	const props = schema.properties;
@@ -93,7 +84,7 @@ function extractProperties(schema) {
 	}));
 }
 function autoOperationId(method, path) {
-	const segments = path.replace(/{(\w+)}/g, (_m, name) => `By${name[0].toUpperCase() + name.slice(1)}`).replace(/:(\w+)/g, (_m, name) => `By${name[0].toUpperCase() + name.slice(1)}`).replace(/\/+/g, "/").replace(/^\//, "").split("/").filter(Boolean);
+	const segments = path.replace(/{(\w+)}/g, (_m, name) => `By${name[0].toUpperCase() + name.slice(1)}`).replace(/\/+/g, "/").replace(/^\//, "").split("/").filter(Boolean);
 	return method.toLowerCase() + segments.map((s) => s[0].toUpperCase() + s.slice(1)).join("");
 }
 function autoTags(path, basePath) {
@@ -108,10 +99,37 @@ const METHOD_ORDER = {
 	delete: 3,
 	patch: 4
 };
+const VALID_METHODS = new Set(Object.keys(METHOD_ORDER));
 function buildOpenAPISpec(routes, info, options) {
 	const basePath = options?.basePath ?? "/api";
 	const s = (schema) => toOpenAPISchema(schema);
 	const paths = {};
+	const schemaCount = /* @__PURE__ */ new Map();
+	for (const { config } of routes) {
+		if (config.requestBody) {
+			const normalized = normalizeRequestBody(config.requestBody);
+			if (normalized?.content) {
+				for (const { schema } of Object.values(normalized.content)) if (typeof schema === "function" && "toJsonSchema" in schema) schemaCount.set(schema, (schemaCount.get(schema) ?? 0) + 1);
+			}
+		}
+		for (const [status, rawResponse] of Object.entries(config.responses)) {
+			const normalized = normalizeResponse(status, rawResponse);
+			if (normalized?.content) {
+				for (const { schema } of Object.values(normalized.content)) if (typeof schema === "function" && "toJsonSchema" in schema) schemaCount.set(schema, (schemaCount.get(schema) ?? 0) + 1);
+			}
+		}
+	}
+	const schemaRegistry = /* @__PURE__ */ new Map();
+	const componentSchemas = {};
+	function refOrInline(schema) {
+		if (!(typeof schema === "function" && "toJsonSchema" in schema)) return toOpenAPISchema(schema);
+		if ((schemaCount.get(schema) ?? 0) <= 1) return toOpenAPISchema(schema);
+		if (schemaRegistry.has(schema)) return { $ref: `#/components/schemas/${schemaRegistry.get(schema)}` };
+		const name = `Schema${schemaRegistry.size + 1}`;
+		schemaRegistry.set(schema, name);
+		componentSchemas[name] = toOpenAPISchema(schema);
+		return { $ref: `#/components/schemas/${name}` };
+	}
 	const tagged = routes.map((r) => ({
 		...r,
 		tag: (r.config.tags ?? autoTags(r.path, basePath))[0] ?? "__untagged"
@@ -181,27 +199,37 @@ function buildOpenAPISpec(routes, info, options) {
 			});
 		}
 		if (config.sort) {
-			const enumValues = config.sort.flatMap((f) => [f, `-${f}`]);
+			const itemEnum = config.sort.flatMap((f) => [f, `-${f}`]);
 			parameters.push({
 				name: "sort",
 				in: "query",
 				required: false,
+				style: "form",
+				explode: false,
 				schema: {
-					type: "string",
-					enum: enumValues,
-					description: "Comma-separated sort fields. Prefix with - for descending."
-				}
+					type: "array",
+					items: {
+						type: "string",
+						enum: itemEnum
+					}
+				},
+				description: "Comma-separated sort fields. Prefix with - for descending."
 			});
 		}
 		if (config.include) parameters.push({
 			name: "include",
 			in: "query",
 			required: false,
+			style: "form",
+			explode: false,
 			schema: {
-				type: "string",
-				enum: config.include,
-				description: "Comma-separated related resources to sideload."
-			}
+				type: "array",
+				items: {
+					type: "string",
+					enum: config.include
+				}
+			},
+			description: "Comma-separated related resources to sideload."
 		});
 		if (config.fieldsets) for (const resource of config.fieldsets) parameters.push({
 			name: `fields[${resource}]`,
@@ -224,6 +252,7 @@ function buildOpenAPISpec(routes, info, options) {
 		const operation = { operationId: config.operationId ?? autoOperationId(method, path) };
 		if (config.summary) operation.summary = config.summary;
 		if (config.description) operation.description = config.description;
+		if (config.deprecated) operation.deprecated = config.deprecated;
 		if (config.tags) operation.tags = config.tags;
 		else operation.tags = autoTags(path, basePath);
 		if (config.security) operation.security = [{ ...Object.fromEntries(config.security.map((s) => [s, []])) }];
@@ -233,48 +262,42 @@ function buildOpenAPISpec(routes, info, options) {
 			if (normalized) operation.requestBody = {
 				description: normalized.description,
 				required: normalized.required,
-				content: mapContentSchemas(normalized.content, s)
+				content: mapContentSchemas(normalized.content, refOrInline)
 			};
 		}
 		const responses = {};
 		for (const [status, rawResponse] of Object.entries(config.responses)) {
 			const normalized = normalizeResponse(status, rawResponse);
 			const resp = { description: normalized.description };
-			if (normalized.content) resp.content = mapContentSchemas(normalized.content, s);
+			if (normalized.content) resp.content = mapContentSchemas(normalized.content, refOrInline);
 			responses[status] = resp;
 		}
 		operation.responses = responses;
 		const methodLower = method.toLowerCase();
-		const key = [
-			"get",
-			"post",
-			"put",
-			"delete",
-			"patch"
-		].includes(methodLower) ? methodLower : void 0;
-		if (key) pathItem[key] = operation;
+		if (VALID_METHODS.has(methodLower)) pathItem[methodLower] = operation;
 	}
 	const spec = {
 		openapi: "3.1.0",
 		info,
 		paths
 	};
-	if (options?.components) spec.components = options.components;
+	if (Object.keys(componentSchemas).length > 0) spec.components = {
+		...options?.components ?? {},
+		schemas: componentSchemas
+	};
+	else if (options?.components) spec.components = options.components;
 	return spec;
 }
 //#endregion
 //#region src/spec.ts
 let _defaultScanner = null;
-/**
-* Register a default scanner for `getOpenAPISpec`.
-* Called automatically by framework adapter modules (e.g., `peta-docs/hono`).
-*/
+/** @deprecated Import 'peta-docs/hono' which auto-registers the Hono scanner. Pass the scanner as the 3rd argument to getOpenAPISpec instead. */
 function setDefaultScanner(scanner) {
 	_defaultScanner = scanner;
 }
 function getOpenAPISpec(app, info, scanner, options) {
 	const active = scanner ?? _defaultScanner;
-	if (!active) throw new Error("No RouteScanner provided. Pass one explicitly or import from 'peta-docs/hono' which registers a default scanner.");
+	if (!active) throw new Error("No RouteScanner provided. Import 'peta-docs/hono' or pass a scanner explicitly.");
 	return buildOpenAPISpec(active.scan(app), info, options);
 }
 //#endregion

package/dist/{scanner-CU4MsJ2G.d.mts → types-ByYMmSfu.d.mts}

@@ -51,6 +51,8 @@ interface ParameterObject {
   description?: string;
   required?: boolean;
   deprecated?: boolean;
+  style?: string;
+  explode?: boolean;
   schema: SchemaObject;
 }
 interface MediaTypeObject {
@@ -113,6 +115,7 @@ interface RouteConfig {
   description?: string;
   operationId?: string;
   tags?: string[];
+  deprecated?: boolean;
   query?: unknown;
   params?: unknown;
   headers?: unknown;
@@ -140,16 +143,8 @@ interface RouteEntry {
   method: string;
   config: RouteConfig;
 }
-//#endregion
-//#region src/scanner.d.ts
-/**
- * Scans a framework app instance and extracts registered routes.
- *
- * Each framework adapter implements this interface to bridge the
- * framework-specific route registry to the generic OpenAPI pipeline.
- */
 interface RouteScanner {
   scan(app: unknown): RouteEntry[];
 }
 //#endregion
-export { FilterFields as a, OpenAPIObject as c, ResponseValue as d, RouteConfig as f, TypedContext as g, StatusCode as h, FilterDef as i, Pagination as l, SchemaObject as m, ArkTypeSchema as n, FilterOperator as o, RouteEntry as p, FieldsetParams as r, InfoObject as s, RouteScanner as t, PathItemObject as u };
+export { FilterOperator as a, Pagination as c, RouteConfig as d, RouteEntry as f, TypedContext as g, StatusCode as h, FilterFields as i, PathItemObject as l, SchemaObject as m, FieldsetParams as n, InfoObject as o, RouteScanner as p, FilterDef as r, OpenAPIObject as s, ArkTypeSchema as t, ResponseValue as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peta-docs",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "private": false,
   "type": "module",
   "description": "OpenAPI + Scalar docs for Hono (and more), powered by Standard Schema",
@@ -11,7 +11,8 @@
   },
   "files": [
     "dist/",
-    "README.md"
+    "README.md",
+    "LICENSE"
   ],
   "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",
@@ -26,14 +27,16 @@
       "types": "./dist/hono/index.d.mts",
       "import": "./dist/hono/index.mjs",
       "default": "./dist/hono/index.mjs"
+    },
+    "./elysia": {
+      "types": "./dist/elysia/index.d.mts",
+      "import": "./dist/elysia/index.mjs",
+      "default": "./dist/elysia/index.mjs"
     }
   },
   "dependencies": {
     "hono": "^4"
   },
-  "optionalDependencies": {
-    "arktype": "^2"
-  },
   "peerDependencies": {
     "typescript": "^6.0.3"
   },
@@ -48,6 +51,8 @@
   "devDependencies": {
     "@biomejs/biome": "^2.5.0",
     "@types/bun": "^1.3.14",
+    "elysia": "^1.4.29",
+    "arktype": "^2",
     "tsdown": "^0.22.1"
   }
 }