asphodelos 0.0.1

package/dist/core-DS3sAabb.mjs

@@ -0,0 +1,4018 @@
+import { t as __exportAll } from "./rolldown-runtime-wcPFST8Q.mjs";
+import { n as fmt } from "./format-B0W7HIAg.mjs";
+import { r as pathEntries } from "./openapi-B4aAnx4P.mjs";
+import { Data, Effect, FileSystem } from "effect";
+import path from "node:path";
+import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
+import { Node, Project } from "ts-morph";
+//#region src/fsp/index.ts
+/**
+* Node's `FileSystem` implementation.
+*
+* Every function below reads the service out of the environment, so a program that uses them
+* provides this once at its boundary — the CLI folds it in through `NodeServices.layer`, the Vite
+* plugin provides it directly.
+*/
+const fileSystemLayer = NodeFileSystem.layer;
+/** Whether a platform failure is "the path is not there", the one case worth absorbing. */
+function isNotFound(e) {
+	return e.reason._tag === "NotFound";
+}
+/** Removes a file. A path that is already gone is not an error. */
+function unlink(path) {
+	return Effect.gen(function* () {
+		yield* (yield* FileSystem.FileSystem).remove(path, { force: true });
+	});
+}
+/** Creates `dir` and every missing parent. */
+function mkdir(dir) {
+	return Effect.gen(function* () {
+		yield* (yield* FileSystem.FileSystem).makeDirectory(dir, { recursive: true });
+	});
+}
+/** Lists `dir`. A directory that does not exist reads as empty. */
+function readdir(dir) {
+	return Effect.gen(function* () {
+		return yield* (yield* FileSystem.FileSystem).readDirectory(dir);
+	}).pipe(Effect.catchIf(isNotFound, () => Effect.succeed([])));
+}
+/** Reads `path` as UTF-8, answering `null` when there is nothing there yet. */
+function readFile(path) {
+	return Effect.gen(function* () {
+		return yield* (yield* FileSystem.FileSystem).readFileString(path);
+	}).pipe(Effect.catchIf(isNotFound, () => Effect.succeed(null)));
+}
+/**
+* Writes `data` to `path`, skipping the write when the bytes already match.
+*
+* That skip is contract, not optimization: the Vite plugin watches its own output, so rewriting
+* an unchanged file would feed a change event straight back into the generator.
+*/
+function writeFile(path, data) {
+	return Effect.gen(function* () {
+		const fs = yield* FileSystem.FileSystem;
+		if ((yield* fs.readFileString(path).pipe(Effect.orElseSucceed(() => null))) === data) return;
+		yield* fs.writeFileString(path, data);
+	});
+}
+//#endregion
+//#region src/emit/index.ts
+/** Formats generated source and writes it to `output`, creating `dir` on the way. */
+function emit(code, dir, output) {
+	return Effect.gen(function* () {
+		const [formatted] = yield* Effect.all([fmt(code), mkdir(dir)], { concurrency: "unbounded" });
+		yield* writeFile(output, formatted);
+	});
+}
+//#endregion
+//#region src/guard/index.ts
+function isReference(v) {
+	return typeof v === "object" && v !== null && "$ref" in v && typeof v.$ref === "string" && !!v.$ref;
+}
+function isStringRef(v) {
+	return "$ref" in v && typeof v.$ref === "string";
+}
+function isRecord(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isMediaWithSchema(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v) && "schema" in v;
+}
+function isSecurityArray(v) {
+	return Array.isArray(v) && v.every((x) => typeof x === "object" && x !== null);
+}
+function isSchemaArray(v) {
+	return Array.isArray(v);
+}
+function isTypeArray(v) {
+	return Array.isArray(v);
+}
+//#endregion
+//#region src/openapi/vendor-ext.ts
+const VENDOR_EXT_KEYS = [
+	"x-error-message",
+	"x-required-message",
+	"x-const-message",
+	"x-enum-message",
+	"x-minimum-message",
+	"x-maximum-message",
+	"x-exclusiveMinimum-message",
+	"x-exclusiveMaximum-message",
+	"x-multipleOf-message",
+	"x-minLength-message",
+	"x-maxLength-message",
+	"x-pattern-message",
+	"x-length-message",
+	"x-minItems-message",
+	"x-maxItems-message",
+	"x-uniqueItems-message",
+	"x-contains-message",
+	"x-minContains-message",
+	"x-maxContains-message",
+	"x-prefixItems-message",
+	"x-items-message",
+	"x-minProperties-message",
+	"x-maxProperties-message",
+	"x-additionalProperties-message",
+	"x-propertyNames-message",
+	"x-patternProperties-message",
+	"x-dependentRequired-message",
+	"x-dependentSchemas-message",
+	"x-properties-message",
+	"x-unevaluatedProperties-message",
+	"x-unevaluatedItems-message",
+	"x-if-message",
+	"x-then-message",
+	"x-else-message",
+	"x-allOf-message",
+	"x-anyOf-message",
+	"x-oneOf-message",
+	"x-not-message",
+	"x-implication-message",
+	"x-brand"
+];
+//#endregion
+//#region src/utils/index.ts
+function capitalize(s) {
+	return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function uncapitalize(s) {
+	return s.charAt(0).toLowerCase() + s.slice(1);
+}
+function encodeNonAscii(name) {
+	return [...name].map((ch) => {
+		const cp = ch.codePointAt(0) ?? 0;
+		return cp > 127 ? `u${cp.toString(16)}` : ch;
+	}).join("");
+}
+function pascalCase(s) {
+	const parts = encodeNonAscii(s).split(/[^A-Za-z0-9]+/u).filter(Boolean);
+	if (parts.length === 0) return "Schema";
+	const result = parts.map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+	return /^[0-9]/u.test(result) ? `_${result}` : result;
+}
+function filterDefined(arr) {
+	return arr.filter((e) => e !== null && e !== void 0);
+}
+const JS_RESERVED = new Set([
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"import",
+	"in",
+	"instanceof",
+	"new",
+	"null",
+	"return",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"let",
+	"static",
+	"yield",
+	"await",
+	"implements",
+	"interface",
+	"package",
+	"private",
+	"protected",
+	"public"
+]);
+/**
+* Produce a valid lower-camel JavaScript identifier for a module variable.
+* Already-valid, non-reserved names pass through unchanged; reserved words get
+* a `Module` suffix (`class` → `classModule`) and non-identifier characters /
+* leading digits are normalized so `export const <name>` always parses.
+*/
+function toSafeIdentifier(name) {
+	const cleaned = /^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(name) ? name : (() => {
+		const joined = name.split(/[^A-Za-z0-9]+/u).filter(Boolean).map((p, i) => i === 0 ? p : p.charAt(0).toUpperCase() + p.slice(1)).join("");
+		if (joined.length === 0) return "_";
+		return /^[0-9]/u.test(joined) ? `_${joined}` : joined;
+	})();
+	return JS_RESERVED.has(cleaned) ? `${cleaned}Module` : cleaned;
+}
+/**
+* Encode an HTTP response status as an object key: pure-integer codes stay
+* unquoted (`200`), ranges and `default` (`2XX`, `default`) are quoted so they
+* are not parsed as malformed numeric literals.
+*/
+function safeStatusKey(status) {
+	return /^[0-9]+$/u.test(status) ? status : JSON.stringify(status);
+}
+/**
+* The top-level resource segment of a path, used as the first element of every
+* cache-key tuple (`/posts/{id}` → `posts`). An empty path falls back to `''`.
+*/
+function resourcePrefix(pathStr) {
+	return pathStr.replace(/^\//u, "").split("/")[0] ?? "";
+}
+//#endregion
+//#region src/helper/schema.ts
+function pickVendorExtensions(source) {
+	if (!source) return {};
+	const picked = {};
+	for (const key of VENDOR_EXT_KEYS) {
+		const value = source[key];
+		if (typeof value === "string") picked[key] = value;
+	}
+	return picked;
+}
+function jsonSchema(content) {
+	return content?.["application/json"]?.schema;
+}
+const BODY_MEDIA_PRIORITY = [
+	"application/json",
+	"multipart/form-data",
+	"application/octet-stream"
+];
+function pickBodyMedia(content) {
+	if (!content) return void 0;
+	for (const m of BODY_MEDIA_PRIORITY) {
+		const entry = content[m];
+		if (entry?.schema) return {
+			mediaType: m,
+			schema: entry.schema
+		};
+	}
+}
+function refSchemaName(s) {
+	if (!s?.$ref) return null;
+	const m = /^#\/components\/schemas\/([^/]+)$/u.exec(s.$ref);
+	return m?.[1] ? decodeURIComponent(m[1]) : null;
+}
+function bodyInfo(operation) {
+	const body = operation.requestBody;
+	if (!body || isReference(body)) return {};
+	const picked = pickBodyMedia(body.content);
+	if (!picked) return {};
+	const { mediaType, schema } = picked;
+	const ref = refSchemaName(schema);
+	if (ref) return { ref };
+	const media = body.content?.[mediaType];
+	const mediaExt = media && !isReference(media) ? pickVendorExtensions(media) : {};
+	const bodyExt = pickVendorExtensions(body);
+	const schemaExt = pickVendorExtensions(schema);
+	const inline = {
+		...mediaExt,
+		...bodyExt,
+		...schema,
+		...schemaExt
+	};
+	if (mediaType === "application/json") return { inline };
+	return {
+		inline,
+		ctx: { mediaType }
+	};
+}
+function responseInfo(res) {
+	const schema = jsonSchema(res.content);
+	if (!schema) return { void: true };
+	const ref = refSchemaName(schema);
+	return ref ? { ref } : { inline: schema };
+}
+function makeParamsSchema(params, where) {
+	const filtered = params.filter((p) => !isReference(p) && p.in === where);
+	if (filtered.length === 0) return void 0;
+	const withSchema = filtered.filter((p) => {
+		if (!p.schema) {
+			if (p.content) console.warn(`asphodelos: Parameter '${p.name}' uses 'content' field (OpenAPI 3.1 alternative to 'schema'). This is not yet supported; the parameter will be omitted from the generated route.`);
+			return false;
+		}
+		return true;
+	});
+	if (withSchema.length === 0) return void 0;
+	const properties = Object.fromEntries(withSchema.map((p) => [p.name, p.schema]));
+	const required = withSchema.filter((p) => p.required).map((p) => p.name);
+	const hoisted = {};
+	for (const p of withSchema) {
+		const fromParam = pickVendorExtensions(p);
+		const fromSchema = pickVendorExtensions(p.schema);
+		for (const key of VENDOR_EXT_KEYS) {
+			if (hoisted[key] !== void 0) continue;
+			const value = fromParam[key] ?? fromSchema[key];
+			if (value !== void 0) hoisted[key] = value;
+		}
+	}
+	const schema = {
+		type: "object",
+		properties,
+		...required.length > 0 ? { required } : {},
+		...hoisted
+	};
+	if (where === "cookie") return {
+		schema,
+		ctx: { elysiaKind: "cookie" }
+	};
+	if (where === "query") return {
+		schema,
+		ctx: { parameterLocation: "query" }
+	};
+	return { schema };
+}
+function collectSchemaRefs$1(schema, acc = /* @__PURE__ */ new Set()) {
+	if (schema.properties) for (const v of Object.values(schema.properties)) collectSchemaRefs$1(v, acc);
+	if (schema.items) {
+		const items = schema.items;
+		if (isSchemaArray(items)) for (const i of items) collectSchemaRefs$1(i, acc);
+		else collectSchemaRefs$1(items, acc);
+	}
+	if (schema.prefixItems) for (const i of schema.prefixItems) collectSchemaRefs$1(i, acc);
+	if (schema.additionalProperties && typeof schema.additionalProperties === "object") collectSchemaRefs$1(schema.additionalProperties, acc);
+	if (schema.$ref) {
+		const m = /^#\/components\/schemas\/([^/]+)$/u.exec(schema.$ref);
+		if (m?.[1]) acc.add(decodeURIComponent(m[1]));
+	}
+	if (schema.oneOf) for (const s of schema.oneOf) collectSchemaRefs$1(s, acc);
+	if (schema.allOf) for (const s of schema.allOf) collectSchemaRefs$1(s, acc);
+	if (schema.anyOf) for (const s of schema.anyOf) collectSchemaRefs$1(s, acc);
+	if (schema.not) collectSchemaRefs$1(schema.not, acc);
+	if (schema.patternProperties) for (const v of Object.values(schema.patternProperties)) collectSchemaRefs$1(v, acc);
+	if (schema.propertyNames) collectSchemaRefs$1(schema.propertyNames, acc);
+	if (schema.dependentSchemas) for (const v of Object.values(schema.dependentSchemas)) collectSchemaRefs$1(v, acc);
+	if (schema.contains) collectSchemaRefs$1(schema.contains, acc);
+	return acc;
+}
+function topoSortSchemas(schemas) {
+	const byName = new Map(schemas.map((s) => [s.name, s]));
+	const visited = /* @__PURE__ */ new Set();
+	const result = [];
+	const visit = (name, stack) => {
+		if (visited.has(name) || stack.has(name)) return;
+		const def = byName.get(name);
+		if (!def) return;
+		stack.add(name);
+		for (const dep of collectSchemaRefs$1(def.schema)) visit(dep, stack);
+		stack.delete(name);
+		visited.add(name);
+		result.push(def);
+	};
+	for (const { name } of schemas) visit(name, /* @__PURE__ */ new Set());
+	return result;
+}
+function sccSchemas(schemas) {
+	const byName = new Map(schemas.map((s) => [s.name, s]));
+	const refsOf = (name) => {
+		const def = byName.get(name);
+		if (!def) return [];
+		return [...collectSchemaRefs$1(def.schema)].filter((ref) => byName.has(ref));
+	};
+	const index = /* @__PURE__ */ new Map();
+	const lowlink = /* @__PURE__ */ new Map();
+	const onStack = /* @__PURE__ */ new Set();
+	const stack = [];
+	const sccs = [];
+	const counter = { value: 0 };
+	const strongconnect = (v) => {
+		index.set(v, counter.value);
+		lowlink.set(v, counter.value);
+		counter.value += 1;
+		stack.push(v);
+		onStack.add(v);
+		for (const w of refsOf(v)) if (!index.has(w)) {
+			strongconnect(w);
+			lowlink.set(v, Math.min(lowlink.get(v) ?? 0, lowlink.get(w) ?? 0));
+		} else if (onStack.has(w)) lowlink.set(v, Math.min(lowlink.get(v) ?? 0, index.get(w) ?? 0));
+		if ((lowlink.get(v) ?? 0) === (index.get(v) ?? 0)) {
+			const group = [];
+			while (true) {
+				const w = stack.pop();
+				if (w === void 0) break;
+				onStack.delete(w);
+				const def = byName.get(w);
+				if (def) group.push(def);
+				if (w === v) break;
+			}
+			sccs.push(group);
+		}
+	};
+	for (const { name } of schemas) if (!index.has(name)) strongconnect(name);
+	return sccs;
+}
+const REF_SUFFIX = {
+	schemas: "Schema",
+	parameters: "ParamsSchema",
+	headers: "HeaderSchema",
+	securitySchemes: "SecurityScheme",
+	requestBodies: "RequestBodySchema",
+	responses: "ResponseSchema",
+	examples: "Example",
+	links: "Link",
+	callbacks: "Callback",
+	pathItems: "PathItem",
+	mediaTypes: "MediaTypeSchema"
+};
+const REF_PATTERN = new RegExp(`^#/components/(${Object.keys(REF_SUFFIX).join("|")})/(.+)$`, "u");
+function refIdent(ref) {
+	const m = REF_PATTERN.exec(ref);
+	if (!m?.[1] || !m[2]) return void 0;
+	const suffix = REF_SUFFIX[m[1]];
+	if (!suffix) return void 0;
+	return `${pascalCase(decodeURIComponent(m[2]))}${suffix}`;
+}
+function stringifyRefs(value) {
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (Array.isArray(value)) return `[${value.map(stringifyRefs).join(",")}]`;
+	if (typeof value === "object") {
+		if (isReference(value) && value.$ref) {
+			const ident = refIdent(value.$ref);
+			if (ident) return ident;
+		}
+		return `{${Object.entries(value).map(([k, v]) => `${JSON.stringify(k)}:${stringifyRefs(v)}`).join(",")}}`;
+	}
+	return JSON.stringify(value);
+}
+function moduleInlineSchemas(inline) {
+	return topoSortSchemas(inline);
+}
+function moduleComponentRefs(routes, inline, componentNames, componentSchemas = {}) {
+	const direct = /* @__PURE__ */ new Set();
+	for (const r of routes) {
+		if (r.bodyRef && componentNames.has(r.bodyRef)) direct.add(r.bodyRef);
+		for (const res of r.responses) if (res.schema.kind === "ref" && componentNames.has(res.schema.name)) direct.add(res.schema.name);
+	}
+	for (const { schema } of inline) for (const n of collectSchemaRefs$1(schema)) if (componentNames.has(n)) direct.add(n);
+	const closure = new Set(direct);
+	const queue = [...direct];
+	while (queue.length > 0) {
+		const name = queue.shift();
+		if (name === void 0) break;
+		const def = componentSchemas[name];
+		if (!def) continue;
+		for (const dep of collectSchemaRefs$1(def)) if (componentNames.has(dep) && !closure.has(dep)) {
+			closure.add(dep);
+			queue.push(dep);
+		}
+	}
+	return closure;
+}
+//#endregion
+//#region src/helper/typebox.ts
+const RAW = Symbol.for("asphodelos.options.raw");
+function raw(expr) {
+	return {
+		[RAW]: true,
+		expr
+	};
+}
+function isRaw(v) {
+	return typeof v === "object" && v !== null && RAW in v;
+}
+function formatKey(k) {
+	return /^[a-zA-Z_$][a-zA-Z_$0-9]*$/u.test(k) ? k : JSON.stringify(k);
+}
+function options(pairs) {
+	const filtered = pairs.filter(([, v]) => v !== void 0);
+	if (filtered.length === 0) return "";
+	return `{${filtered.map(([k, v]) => `${formatKey(k)}:${isRaw(v) ? v.expr : JSON.stringify(v)}`).join(",")}}`;
+}
+function exclusiveBound(flag, inclusive) {
+	if (flag === true) return inclusive;
+	if (typeof flag === "number") return flag;
+}
+/**
+* Normalize OpenAPI 3.0's boolean `exclusiveMinimum`/`exclusiveMaximum` to the
+* JSON Schema 2020-12 numeric form TypeBox expects. In 3.0 a boolean `true`
+* makes the sibling `minimum`/`maximum` exclusive; 2020-12 (and TypeBox) carry
+* the bound value on `exclusiveMinimum`/`exclusiveMaximum` itself. `false`
+* collapses back to the inclusive bound.
+* https://spec.openapis.org/oas/v3.0.3#schema-object
+*/
+function normalizeBounds(schema) {
+	return {
+		minimum: schema.exclusiveMinimum === true ? void 0 : schema.minimum,
+		maximum: schema.exclusiveMaximum === true ? void 0 : schema.maximum,
+		exclusiveMinimum: exclusiveBound(schema.exclusiveMinimum, schema.minimum),
+		exclusiveMaximum: exclusiveBound(schema.exclusiveMaximum, schema.maximum)
+	};
+}
+function commonOpts(schema) {
+	return [
+		["externalDocs", schema.externalDocs],
+		["example", schema.example],
+		["examples", schema.examples],
+		["title", schema.title],
+		["description", schema.description],
+		["default", schema.default],
+		["readOnly", schema.readOnly],
+		["writeOnly", schema.writeOnly],
+		["deprecated", schema.deprecated],
+		["x-error-message", schema["x-error-message"]],
+		["x-required-message", schema["x-required-message"]],
+		["x-const-message", schema["x-const-message"]],
+		["x-enum-message", schema["x-enum-message"]],
+		["x-minimum-message", schema["x-minimum-message"]],
+		["x-maximum-message", schema["x-maximum-message"]],
+		["x-exclusiveMinimum-message", schema["x-exclusiveMinimum-message"]],
+		["x-exclusiveMaximum-message", schema["x-exclusiveMaximum-message"]],
+		["x-multipleOf-message", schema["x-multipleOf-message"]],
+		["x-minLength-message", schema["x-minLength-message"]],
+		["x-maxLength-message", schema["x-maxLength-message"]],
+		["x-pattern-message", schema["x-pattern-message"]],
+		["x-length-message", schema["x-length-message"]],
+		["x-minItems-message", schema["x-minItems-message"]],
+		["x-maxItems-message", schema["x-maxItems-message"]],
+		["x-uniqueItems-message", schema["x-uniqueItems-message"]],
+		["x-contains-message", schema["x-contains-message"]],
+		["x-minContains-message", schema["x-minContains-message"]],
+		["x-maxContains-message", schema["x-maxContains-message"]],
+		["x-prefixItems-message", schema["x-prefixItems-message"]],
+		["x-items-message", schema["x-items-message"]],
+		["x-minProperties-message", schema["x-minProperties-message"]],
+		["x-maxProperties-message", schema["x-maxProperties-message"]],
+		["x-additionalProperties-message", schema["x-additionalProperties-message"]],
+		["x-propertyNames-message", schema["x-propertyNames-message"]],
+		["x-patternProperties-message", schema["x-patternProperties-message"]],
+		["x-dependentRequired-message", schema["x-dependentRequired-message"]],
+		["x-dependentSchemas-message", schema["x-dependentSchemas-message"]],
+		["x-properties-message", schema["x-properties-message"]],
+		["x-unevaluatedProperties-message", schema["x-unevaluatedProperties-message"]],
+		["x-unevaluatedItems-message", schema["x-unevaluatedItems-message"]],
+		["x-if-message", schema["x-if-message"]],
+		["x-then-message", schema["x-then-message"]],
+		["x-else-message", schema["x-else-message"]],
+		["x-allOf-message", schema["x-allOf-message"]],
+		["x-anyOf-message", schema["x-anyOf-message"]],
+		["x-oneOf-message", schema["x-oneOf-message"]],
+		["x-not-message", schema["x-not-message"]],
+		["x-implication-message", schema["x-implication-message"]],
+		["x-brand", schema["x-brand"]]
+	];
+}
+function branch(message, hasConstraint, type, note) {
+	return message !== void 0 && hasConstraint ? [{
+		type,
+		note,
+		message
+	}] : [];
+}
+function branches(schema, kind) {
+	const requiredMessage = schema["x-required-message"];
+	const constMessage = schema["x-const-message"];
+	const enumMessage = schema["x-enum-message"];
+	const minLength = schema["x-minLength-message"];
+	const maxLength = schema["x-maxLength-message"];
+	const length = schema["x-length-message"];
+	const pattern = schema["x-pattern-message"];
+	const minimum = schema["x-minimum-message"];
+	const maximum = schema["x-maximum-message"];
+	const exclusiveMinimum = schema["x-exclusiveMinimum-message"];
+	const exclusiveMaximum = schema["x-exclusiveMaximum-message"];
+	const multipleOf = schema["x-multipleOf-message"];
+	const minItems = schema["x-minItems-message"];
+	const maxItems = schema["x-maxItems-message"];
+	const uniqueItems = schema["x-uniqueItems-message"];
+	const contains = schema["x-contains-message"];
+	const minContains = schema["x-minContains-message"];
+	const maxContains = schema["x-maxContains-message"];
+	const minProperties = schema["x-minProperties-message"];
+	const maxProperties = schema["x-maxProperties-message"];
+	const additionalPropertiesMessage = schema["x-additionalProperties-message"];
+	const oneOf = schema["x-oneOf-message"];
+	const anyOf = schema["x-anyOf-message"];
+	const allOf = schema["x-allOf-message"];
+	const not = schema["x-not-message"];
+	const implication = schema["x-implication-message"];
+	if (kind === "string") return [
+		...length !== void 0 && schema.minLength !== void 0 && schema.minLength === schema.maxLength ? [{
+			type: 52,
+			note: "StringMinLength",
+			message: length
+		}, {
+			type: 51,
+			note: "StringMaxLength",
+			message: length
+		}] : [...branch(minLength, schema.minLength !== void 0, 52, "StringMinLength"), ...branch(maxLength, schema.maxLength !== void 0, 51, "StringMaxLength")],
+		...branch(pattern, schema.pattern !== void 0, 53, "StringPattern"),
+		...branch(pattern, schema.pattern !== void 0, 48, "RegExp")
+	];
+	if (kind === "number") return [
+		...branch(minimum, schema.minimum !== void 0, 39, "NumberMinimum"),
+		...branch(maximum, schema.maximum !== void 0, 38, "NumberMaximum"),
+		...branch(exclusiveMinimum, schema.exclusiveMinimum !== void 0, 37, "NumberExclusiveMinimum"),
+		...branch(exclusiveMaximum, schema.exclusiveMaximum !== void 0, 36, "NumberExclusiveMaximum"),
+		...branch(multipleOf, schema.multipleOf !== void 0, 40, "NumberMultipleOf")
+	];
+	if (kind === "integer") return [
+		...branch(minimum, schema.minimum !== void 0, 25, "IntegerMinimum"),
+		...branch(maximum, schema.maximum !== void 0, 24, "IntegerMaximum"),
+		...branch(exclusiveMinimum, schema.exclusiveMinimum !== void 0, 23, "IntegerExclusiveMinimum"),
+		...branch(exclusiveMaximum, schema.exclusiveMaximum !== void 0, 22, "IntegerExclusiveMaximum"),
+		...branch(multipleOf, schema.multipleOf !== void 0, 26, "IntegerMultipleOf")
+	];
+	if (kind === "boolean") return [];
+	if (kind === "array") return [
+		...length !== void 0 && schema.minItems !== void 0 && schema.minItems === schema.maxItems ? [{
+			type: 4,
+			note: "ArrayMinItems",
+			message: length
+		}, {
+			type: 2,
+			note: "ArrayMaxItems",
+			message: length
+		}] : [...branch(minItems, schema.minItems !== void 0, 4, "ArrayMinItems"), ...branch(maxItems, schema.maxItems !== void 0, 2, "ArrayMaxItems")],
+		...branch(uniqueItems, schema.uniqueItems === true, 5, "ArrayUniqueItems"),
+		...branch(contains, schema.contains !== void 0, 0, "ArrayContains"),
+		...branch(minContains, schema.minContains !== void 0, 3, "ArrayMinContains"),
+		...branch(maxContains, schema.maxContains !== void 0, 1, "ArrayMaxContains")
+	];
+	if (kind === "object") {
+		const requiredArr = Array.isArray(schema.required) ? schema.required : [];
+		return [
+			...branch(minProperties, schema.minProperties !== void 0, 44, "ObjectMinProperties"),
+			...branch(maxProperties, schema.maxProperties !== void 0, 43, "ObjectMaxProperties"),
+			...branch(requiredMessage, requiredArr.length > 0, 45, "ObjectRequiredProperty"),
+			...branch(additionalPropertiesMessage, schema.additionalProperties === false, 42, "ObjectAdditionalProperties")
+		];
+	}
+	return [
+		...branch((schema.anyOf ? implication : void 0) ?? oneOf ?? anyOf ?? enumMessage, Boolean(schema.oneOf ?? schema.anyOf ?? schema.enum), 62, "Union"),
+		...branch(allOf, Boolean(schema.allOf), 29, "Intersect"),
+		...branch(not, Boolean(schema.not), 34, "Not"),
+		...branch(constMessage, schema.const !== void 0, 32, "Literal")
+	];
+}
+function errorCallback(schema, kind) {
+	const fallback = schema["x-error-message"];
+	const branchList = branches(schema, kind);
+	if (branchList.length === 0) return fallback !== void 0 ? ["error", fallback] : void 0;
+	const fallbackExpr = fallback !== void 0 ? JSON.stringify(fallback) : "undefined";
+	return ["error", raw(`(error)=>{const type=error?.errors?.[0]?.type;${branchList.reduce((acc, b) => {
+		const last = acc.at(-1);
+		if (last && last.message === b.message) return [...acc.slice(0, -1), {
+			message: last.message,
+			types: [...last.types, b.type]
+		}];
+		return [...acc, {
+			message: b.message,
+			types: [b.type]
+		}];
+	}, []).map((g) => {
+		return `if(${[...g.types].toSorted((a, b) => a - b).map((t) => `type===${t}`).join("||")})return ${JSON.stringify(g.message)}`;
+	}).join(";")};return ${fallbackExpr}}`)];
+}
+function enumErrorCallback(schema) {
+	const enumMessage = schema["x-enum-message"];
+	const fallback = schema["x-error-message"];
+	if (enumMessage === void 0) return fallback !== void 0 ? ["error", fallback] : void 0;
+	if (fallback === void 0) return ["error", enumMessage];
+	return ["error", raw(`(error)=>{const type=error?.errors?.[0]?.type;if(type===62)return ${JSON.stringify(enumMessage)};return ${JSON.stringify(fallback)}}`)];
+}
+function transformWrap(expr, schema, renderSubSchema) {
+	const active = [
+		propertyNamesSection(schema),
+		patternPropertiesSection(schema),
+		dependentRequiredSection(schema),
+		dependentSchemasSection(schema, renderSubSchema)
+	].filter((s) => s !== null);
+	if (active.length === 0) return expr;
+	const prelude = active.flatMap((s) => s.prelude);
+	const checks = active.map((s) => s.check);
+	return `t.Transform(${expr}).Decode(${`(v)=>{${prelude.length > 0 ? `${prelude.join(";")};` : ""}if(v&&typeof v==='object'){${checks.join(";")}}return v}`}).Encode((v)=>v)`;
+}
+function propertyNamesSection(schema) {
+	const message = schema["x-propertyNames-message"];
+	if (message === void 0) return null;
+	const pattern = schema.propertyNames?.pattern;
+	if (typeof pattern === "string") return {
+		prelude: [`const propNamesRe=new RegExp(${JSON.stringify(pattern)})`],
+		check: `for(const k of Object.keys(v)){if(!propNamesRe.test(k))throw new Error(${JSON.stringify(message)})}`
+	};
+	if (schema.propertyNames !== void 0) {
+		const unsupported = Object.keys(schema.propertyNames).filter((k) => k !== "pattern");
+		if (unsupported.length > 0) console.warn(`[asphodelos] x-propertyNames-message: only \`pattern\` is enforced via transform; ignoring ${unsupported.map((k) => `\`${k}\``).join(", ")} on propertyNames`);
+	}
+	return null;
+}
+function patternPropertiesSection(schema) {
+	const message = schema["x-patternProperties-message"];
+	const map = schema.patternProperties;
+	if (message === void 0 || !map || Object.keys(map).length === 0 || schema.additionalProperties !== false) return null;
+	const arrLit = Object.keys(map).map((p) => `new RegExp(${JSON.stringify(p)})`).join(",");
+	const declaredKeys = Object.keys(schema.properties ?? {});
+	return {
+		prelude: [`const patternPropsRes=[${arrLit}]`, `const declaredProps=new Set<string>(${JSON.stringify(declaredKeys)})`],
+		check: `for(const k of Object.keys(v)){if(declaredProps.has(k))continue;if(!patternPropsRes.some(r=>r.test(k)))throw new Error(${JSON.stringify(message)})}`
+	};
+}
+function dependentRequiredSection(schema) {
+	const message = schema["x-dependentRequired-message"];
+	const map = schema.dependentRequired;
+	if (message === void 0 || !map || Object.keys(map).length === 0) return null;
+	const emptyEntries = Object.entries(map).filter(([, requiredKeys]) => !requiredKeys || requiredKeys.length === 0).map(([trigger]) => trigger);
+	if (emptyEntries.length > 0) console.warn(`[asphodelos] x-dependentRequired-message: dependentRequired entries with empty arrays are silently skipped — ${emptyEntries.map((t) => `\`${t}\``).join(", ")} produce no runtime check. Add at least one required key or remove the entry.`);
+	const check = Object.entries(map).map(([trigger, requiredKeys]) => {
+		const triggerJson = JSON.stringify(trigger);
+		const missing = (requiredKeys ?? []).map((k) => `!(${JSON.stringify(k)} in v)`).join("||");
+		return missing ? `if(${triggerJson} in v&&(${missing}))throw new Error(${JSON.stringify(message)})` : null;
+	}).filter((s) => s !== null).join(";");
+	return check ? {
+		prelude: [],
+		check
+	} : null;
+}
+function dependentSchemasSection(schema, renderSubSchema) {
+	const message = schema["x-dependentSchemas-message"];
+	const map = schema.dependentSchemas;
+	if (message === void 0 || !map || Object.keys(map).length === 0) return null;
+	if (renderSubSchema) {
+		for (const [trigger, sub] of Object.entries(map)) {
+			if (sub?.additionalProperties === false) {
+				if (!Object.keys(sub.properties ?? {}).includes(trigger)) console.warn(`[asphodelos] x-dependentSchemas-message: sub-schema for \`${trigger}\` has \`additionalProperties: false\` but does not list \`${trigger}\` in its properties. Per JSON Schema spec the dependent schema applies to the whole instance, so the trigger key itself is rejected as unexpected — every payload (including conforming ones) will fail. Add \`${trigger}\` to the sub-schema's properties, drop \`additionalProperties: false\`, or restructure the dependency.`);
+			}
+			const subType = sub?.type;
+			if (subType !== void 0 && subType !== "object") console.warn(`[asphodelos] x-dependentSchemas-message: sub-schema for \`${trigger}\` has \`type: ${typeof subType === "string" ? subType : JSON.stringify(subType)}\` — non-object sub-schemas can't match the parent object at runtime so every payload will fail. dependentSchemas applies to the whole instance; the sub-schema must be \`type: 'object'\` (or omit \`type\`).`);
+		}
+		const subsLit = Object.entries(map).map(([trigger, sub]) => `${JSON.stringify(trigger)}:${renderSubSchema(sub)}`).join(",");
+		const check = Object.keys(map).map((trigger) => `if(${JSON.stringify(trigger)} in v&&!Value.Check(depSubs[${JSON.stringify(trigger)}],v))throw new Error(${JSON.stringify(message)})`).join(";");
+		return {
+			prelude: [`const depSubs={${subsLit}}`],
+			check
+		};
+	}
+	console.warn("[asphodelos] x-dependentSchemas-message: deep enforcement requires a renderSubSchema callback. Falling back to shallow `required[]`-only check; nested constraints in dependent sub-schemas (pattern, enum, …) will not be enforced at runtime.");
+	const check = Object.entries(map).map(([trigger, sub]) => {
+		const triggerJson = JSON.stringify(trigger);
+		const missing = (Array.isArray(sub?.required) ? sub.required : []).map((k) => `!(${JSON.stringify(k)} in v)`).join("||");
+		return missing ? `if(${triggerJson} in v&&(${missing}))throw new Error(${JSON.stringify(message)})` : null;
+	}).filter((s) => s !== null).join(";");
+	return check ? {
+		prelude: [],
+		check
+	} : null;
+}
+function regexEscape(s) {
+	return s.replaceAll(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function stringPatternFrom(schema) {
+	if (schema.format === "email" && typeof schema["x-emailRegex"] === "string") return schema["x-emailRegex"];
+	const start = schema["x-startsWith"];
+	const incl = schema["x-includes"];
+	const end = schema["x-endsWith"];
+	if (start === void 0 && incl === void 0 && end === void 0) return schema.pattern;
+	return [
+		start !== void 0 ? `^${regexEscape(start)}` : "",
+		incl !== void 0 ? regexEscape(incl) : "",
+		end !== void 0 ? `${regexEscape(end)}$` : ""
+	].filter((p) => p !== "").join(".*");
+}
+function stringTransformWrap(expr, schema) {
+	const steps = [];
+	if (schema["x-trim"] === true) steps.push("v.trim()");
+	if (schema["x-toLowerCase"] === true || schema["x-lowercase"] === true) steps.push("v.toLowerCase()");
+	if (schema["x-toUpperCase"] === true || schema["x-uppercase"] === true) steps.push("v.toUpperCase()");
+	const norm = schema["x-normalize"];
+	if (norm === "NFC" || norm === "NFD" || norm === "NFKC" || norm === "NFKD") steps.push(`v.normalize(${JSON.stringify(norm)})`);
+	if (steps.length === 0) return expr;
+	return `t.Transform(${expr}).Decode((v)=>{${steps.map((s) => `v=${s}`).join(";")};return v}).Encode((v)=>v)`;
+}
+function wrap(expr, schema) {
+	return schema.nullable === true || Array.isArray(schema.type) && schema.type.includes("null") ? `t.Union([${expr},t.Null()])` : expr;
+}
+function readonly(expr, enabled) {
+	return enabled ? `t.Readonly(${expr})` : expr;
+}
+function brand(expr, schema) {
+	const name = schema["x-brand"];
+	if (!name) return expr;
+	const TS_BASE_TYPE = {
+		string: "string",
+		integer: "number",
+		number: "number",
+		boolean: "boolean"
+	};
+	const primary = typeof schema.type === "string" ? schema.type : Array.isArray(schema.type) ? schema.type.find((t) => t !== "null") : void 0;
+	const base = primary ? TS_BASE_TYPE[primary] : void 0;
+	if (!base) return expr;
+	return `t.Unsafe<${base} & { readonly __brand: '${name}' }>(${expr})`;
+}
+//#endregion
+//#region src/generator/typebox/t/array.ts
+function isMultipartBinaryArray(items, ctx) {
+	return items.format === "binary" && ctx.mediaType === "multipart/form-data";
+}
+function array(schema, ctx = {}) {
+	const childCtx = ctx.mediaType ? { mediaType: ctx.mediaType } : {};
+	if (schema.prefixItems) return `t.Tuple([${schema.prefixItems.map((s) => typebox(s, childCtx)).join(",")}])`;
+	const items = schema.items;
+	if (items && isSchemaArray(items)) return `t.Tuple([${items.map((s) => typebox(s, childCtx)).join(",")}])`;
+	if (items && !isSchemaArray(items) && isMultipartBinaryArray(items, ctx)) {
+		const filesOpts = options([
+			["type", items.contentMediaType],
+			["minItems", schema.minItems],
+			["maxItems", schema.maxItems],
+			["minSize", items.minLength],
+			["maxSize", items.maxLength],
+			...filterDefined([errorCallback(schema, "array")]),
+			...commonOpts(schema)
+		]);
+		return filesOpts ? `t.Files(${filesOpts})` : "t.Files()";
+	}
+	const itemExpr = items ? typebox(items, childCtx) : "t.Unknown()";
+	const containsExpr = schema.contains ? raw(typebox(schema.contains, childCtx)) : void 0;
+	const opts = options([
+		["minItems", schema.minItems],
+		["maxItems", schema.maxItems],
+		["uniqueItems", schema.uniqueItems],
+		["contains", containsExpr],
+		["minContains", schema.minContains],
+		["maxContains", schema.maxContains],
+		...filterDefined([errorCallback(schema, "array")]),
+		...commonOpts(schema)
+	]);
+	return opts ? `t.Array(${itemExpr},${opts})` : `t.Array(${itemExpr})`;
+}
+//#endregion
+//#region src/generator/typebox/t/boolean.ts
+function boolean(schema) {
+	const opts = options([
+		["format", schema.format],
+		...filterDefined([errorCallback(schema, "boolean")]),
+		...commonOpts(schema)
+	]);
+	return `${schema.format === "boolean-string" ? "t.BooleanString" : "t.Boolean"}(${opts})`;
+}
+//#endregion
+//#region src/generator/typebox/t/enum.ts
+function isUnionEnumValue(v) {
+	return typeof v === "string" || typeof v === "number";
+}
+function literalSchema(value) {
+	if (value === null) return "t.Null()";
+	if (Array.isArray(value)) return `t.Tuple([${value.map(literalSchema).join(",")}])`;
+	if (isRecord(value)) return `t.Object({${Object.entries(value).map(([key, v]) => `${JSON.stringify(key)}:${literalSchema(v)}`).join(",")}})`;
+	return `t.Literal(${JSON.stringify(value)})`;
+}
+function _enum(schema) {
+	const values = schema.enum ?? [];
+	const opts = options([...filterDefined([enumErrorCallback(schema)]), ...commonOpts(schema)]);
+	if (values.length === 0) return "t.Never()";
+	if (values.length === 1) {
+		const v = values[0];
+		if (v === null) return opts ? `t.Null(${opts})` : "t.Null()";
+		if (opts && typeof v !== "object") return `t.Literal(${JSON.stringify(v)},${opts})`;
+		return literalSchema(v);
+	}
+	if (values.every(isUnionEnumValue)) {
+		const list = JSON.stringify(values);
+		return opts ? `t.UnionEnum(${list},${opts})` : `t.UnionEnum(${list})`;
+	}
+	return opts ? `t.Union([${values.map(literalSchema).join(",")}],${opts})` : `t.Union([${values.map(literalSchema).join(",")}])`;
+}
+//#endregion
+//#region src/generator/typebox/t/integer.ts
+function autoMaximum(format, maximum, exclusiveMaximum) {
+	if (maximum !== void 0) return maximum;
+	if (exclusiveMaximum !== void 0) return void 0;
+	if (format === "int32") return 2147483647;
+	return Number.MAX_SAFE_INTEGER;
+}
+function integer(schema) {
+	const bounds = normalizeBounds(schema);
+	const opts = options([
+		["format", schema.format],
+		["minimum", bounds.minimum],
+		["maximum", autoMaximum(schema.format, bounds.maximum, bounds.exclusiveMaximum)],
+		["exclusiveMinimum", bounds.exclusiveMinimum],
+		["exclusiveMaximum", bounds.exclusiveMaximum],
+		["multipleOf", schema.multipleOf],
+		...filterDefined([errorCallback(schema, "integer")]),
+		...commonOpts(schema)
+	]);
+	return `${schema.format === "numeric" ? "t.Numeric" : "t.Integer"}(${opts})`;
+}
+//#endregion
+//#region src/generator/typebox/t/intersect.ts
+function intersect(schemas, parent) {
+	if (schemas.length === 0) return "t.Unknown()";
+	if (schemas.length === 1 && schemas[0]) return typebox(schemas[0]);
+	const opts = parent ? options([...filterDefined([errorCallback(parent, "composition")]), ...commonOpts(parent)]) : "";
+	return opts ? `t.Intersect([${schemas.map((s) => typebox(s)).join(",")}],${opts})` : `t.Intersect([${schemas.map((s) => typebox(s)).join(",")}])`;
+}
+//#endregion
+//#region src/generator/typebox/t/not.ts
+function notType(inner, parent) {
+	const innerExpr = typebox(inner);
+	const opts = options([...filterDefined([errorCallback(parent, "composition")]), ...commonOpts(parent)]);
+	return opts ? `t.Not(${innerExpr},${opts})` : `t.Not(${innerExpr})`;
+}
+//#endregion
+//#region src/generator/typebox/t/null.ts
+function nullType() {
+	return "t.Null()";
+}
+//#endregion
+//#region src/generator/typebox/t/number.ts
+function number(schema) {
+	const bounds = normalizeBounds(schema);
+	const opts = options([
+		["format", schema.format],
+		["minimum", bounds.minimum],
+		["maximum", bounds.maximum],
+		["exclusiveMinimum", bounds.exclusiveMinimum],
+		["exclusiveMaximum", bounds.exclusiveMaximum],
+		["multipleOf", schema.multipleOf],
+		...filterDefined([errorCallback(schema, "number")]),
+		...commonOpts(schema)
+	]);
+	return `${schema.format === "numeric" ? "t.Numeric" : "t.Number"}(${opts})`;
+}
+//#endregion
+//#region src/generator/typebox/t/object.ts
+function pickObjectFactory(ctx) {
+	if (ctx.elysiaKind === "object-string") return "ObjectString";
+	if (ctx.elysiaKind === "cookie") return "Cookie";
+	if (ctx.mediaType === "multipart/form-data") return "Form";
+	return "Object";
+}
+function childCtxFor(parentCtx, propSchema) {
+	const inheritedMedia = parentCtx.mediaType ? { mediaType: parentCtx.mediaType } : {};
+	if (parentCtx.parameterLocation === "query" && propSchema.type === "object") return {
+		...inheritedMedia,
+		elysiaKind: "object-string"
+	};
+	return inheritedMedia;
+}
+function object(schema, ctx = {}) {
+	const properties = schema.properties ?? {};
+	const required = new Set(schema.required);
+	const propEntries = Object.entries(properties).map(([key, propSchema]) => {
+		const inner = typebox(propSchema, childCtxFor(ctx, propSchema));
+		const isRequired = required.has(key);
+		const wrapped = propSchema.readOnly === true ? isRequired ? `t.Readonly(${inner})` : `t.ReadonlyOptional(${inner})` : isRequired ? inner : `t.Optional(${inner})`;
+		return `${JSON.stringify(key)}:${wrapped}`;
+	});
+	const additional = schema.additionalProperties;
+	if (Object.keys(properties).length === 0 && additional && typeof additional === "object") {
+		const additionalCtx = childCtxFor(ctx, additional);
+		const valueExpr = typebox(additional, additionalCtx);
+		const opts = options([
+			["minProperties", schema.minProperties],
+			["maxProperties", schema.maxProperties],
+			...filterDefined([errorCallback(schema, "object")]),
+			...commonOpts(schema)
+		]);
+		return transformWrap(opts ? `t.Record(t.String(),${valueExpr},${opts})` : `t.Record(t.String(),${valueExpr})`, schema, (s) => typebox(s, additionalCtx));
+	}
+	const opts = options([
+		["minProperties", schema.minProperties],
+		["maxProperties", schema.maxProperties],
+		["additionalProperties", additional === false ? false : void 0],
+		...filterDefined([errorCallback(schema, "object")]),
+		...commonOpts(schema)
+	]);
+	const body = `{${propEntries.join(",")}}`;
+	const factory = pickObjectFactory(ctx);
+	const objectExpr = opts ? `t.${factory}(${body},${opts})` : `t.${factory}(${body})`;
+	const subCtx = ctx.mediaType ? { mediaType: ctx.mediaType } : {};
+	return transformWrap(objectExpr, schema, (s) => typebox(s, subCtx));
+}
+//#endregion
+//#region src/generator/typebox/t/ref.ts
+function ref(schema) {
+	if (!schema.$ref) return "t.Unknown()";
+	const m = /^#\/components\/schemas\/([^/]+)$/u.exec(schema.$ref);
+	if (m?.[1]) return `${pascalCase(decodeURIComponent(m[1]))}Schema`;
+	return "t.Unknown()";
+}
+//#endregion
+//#region src/generator/typebox/t/string.ts
+function string(schema, ctx = {}) {
+	if (schema.format === "date" || schema.format === "date-time") return `t.Date(${options([...commonOpts(schema)])})`;
+	if (schema.format === "binary") {
+		if (ctx.mediaType === "application/octet-stream") return `t.Uint8Array(${options([
+			["minByteLength", schema.minLength],
+			["maxByteLength", schema.maxLength],
+			...commonOpts(schema)
+		])})`;
+		return `t.File(${options([
+			["type", schema.contentMediaType],
+			["minSize", schema.minLength],
+			["maxSize", schema.maxLength],
+			...commonOpts(schema)
+		])})`;
+	}
+	return stringTransformWrap(`t.String(${options([
+		["format", schema.format],
+		["pattern", stringPatternFrom(schema)],
+		["minLength", schema.minLength],
+		["maxLength", schema.maxLength],
+		...filterDefined([errorCallback(schema, "string")]),
+		...commonOpts(schema)
+	])})`, schema);
+}
+//#endregion
+//#region src/generator/typebox/t/union.ts
+function union(schemas, parent) {
+	if (schemas.length === 0) return "t.Never()";
+	if (schemas.length === 1 && schemas[0]) return typebox(schemas[0]);
+	const opts = parent ? options([...filterDefined([errorCallback(parent, "composition")]), ...commonOpts(parent)]) : "";
+	return opts ? `t.Union([${schemas.map((s) => typebox(s)).join(",")}],${opts})` : `t.Union([${schemas.map((s) => typebox(s)).join(",")}])`;
+}
+//#endregion
+//#region src/generator/typebox/index.ts
+function typebox(schema, ctx = {}) {
+	const enabled = schema["x-readonly"] === true;
+	const rawTransform = schema["x-transform"];
+	if (typeof rawTransform === "string" && rawTransform.length > 0) return readonly(wrap(brand(rawTransform, schema), schema), enabled);
+	if (schema.$ref) return ref(schema);
+	if (schema.allOf) return readonly(wrap(intersect(schema.allOf, schema), schema), enabled);
+	if (schema.oneOf) return readonly(wrap(union(schema.oneOf, schema), schema), enabled);
+	if (schema.anyOf) return readonly(wrap(union(schema.anyOf, schema), schema), enabled);
+	if (schema.not) return readonly(wrap(notType(schema.not, schema), schema), enabled);
+	if (schema.enum) return readonly(wrap(brand(_enum(schema), schema), schema), enabled);
+	if (schema.const !== void 0) {
+		const opts = options([...filterDefined([errorCallback(schema, "composition")]), ...commonOpts(schema)]);
+		const optsPart = opts ? `,${opts}` : "";
+		return readonly(wrap(brand(schema.const === null ? `t.Null(${opts})` : typeof schema.const === "object" ? literalSchema(schema.const) : `t.Literal(${JSON.stringify(schema.const)}${optsPart})`, schema), schema), enabled);
+	}
+	const primaryType = () => {
+		if (typeof schema.type === "string") return schema.type;
+		if (isTypeArray(schema.type)) return schema.type.find((t) => t !== "null");
+		if (schema.properties ?? schema.additionalProperties !== void 0) return "object";
+		if (schema.items ?? schema.prefixItems) return "array";
+	};
+	switch (primaryType()) {
+		case "string": return readonly(wrap(brand(string(schema, ctx), schema), schema), enabled);
+		case "integer": return readonly(wrap(brand(integer(schema), schema), schema), enabled);
+		case "number": return readonly(wrap(brand(number(schema), schema), schema), enabled);
+		case "boolean": return readonly(wrap(brand(boolean(schema), schema), schema), enabled);
+		case "array": return readonly(wrap(array(schema, ctx), schema), enabled);
+		case "object": return readonly(wrap(object(schema, ctx), schema), enabled);
+		case "null": return nullType();
+		case "date":
+		case void 0: return "t.Unknown()";
+		default: return "t.Unknown()";
+	}
+}
+//#endregion
+//#region src/generator/components/schemas.ts
+function sub(code, from, to) {
+	return code.replaceAll(new RegExp(`\\b${from}\\b`, "gu"), to);
+}
+function findFree(base, i, used) {
+	const candidate = `${base}${i}`;
+	return used.has(candidate) ? findFree(base, i + 1, used) : candidate;
+}
+/**
+* OpenAPI schema keys are case-sensitive, but `pascalCase` upper-cases the first
+* letter, so `User` and `user` both emit `const UserSchema` / `type User`
+* (TS2451 / TS2300). Map each colliding key to a deterministic suffixed exported
+* name (`User`, `User2`, …) so every declaration is unique. The map is global
+* across SCC groups; TypeBox refs (`t.Ref('user')`, recursive `Self`) keep using
+* the original key, so only the exported binding names change.
+*/
+function resolveUniqueNames(keys) {
+	return keys.reduce((acc, key) => {
+		const base = pascalCase(key);
+		const unique = acc.used.has(base) ? findFree(base, 2, acc.used) : base;
+		acc.used.add(unique);
+		acc.map.set(key, unique);
+		return acc;
+	}, {
+		used: /* @__PURE__ */ new Set(),
+		map: /* @__PURE__ */ new Map()
+	}).map;
+}
+function schemasCode(schemas, readonlyMode, exportTypes, exported = true) {
+	if (!schemas || Object.keys(schemas).length === 0) return "";
+	const names = resolveUniqueNames(Object.keys(schemas));
+	return sccSchemas(Object.entries(schemas).map(([name, schema]) => ({
+		name,
+		schema
+	}))).map((group) => emitGroup(group, readonlyMode, exportTypes, exported, names)).filter((s) => s.length > 0).join("\n\n");
+}
+function refsWithin(schema, memberNames) {
+	return new Set([...collectSchemaRefs$1(schema)].filter((r) => memberNames.has(r)));
+}
+function findStar(group, exportedName) {
+	if (group.some((g) => exportedName(g.name) !== pascalCase(g.name))) return null;
+	const memberNames = new Set(group.map((g) => g.name));
+	const refs = new Map(group.map((g) => [g.name, refsWithin(g.schema, memberNames)]));
+	const candidates = group.filter((hub) => {
+		const spokes = group.filter((g) => g.name !== hub.name);
+		const hubRefs = refs.get(hub.name) ?? /* @__PURE__ */ new Set();
+		return spokes.every((s) => {
+			const r = refs.get(s.name) ?? /* @__PURE__ */ new Set();
+			return r.size === 1 && r.has(hub.name);
+		}) && spokes.every((s) => hubRefs.has(s.name));
+	});
+	if (candidates.length === 0) return null;
+	const hub = candidates.reduce((a, b) => {
+		const ra = (refs.get(a.name) ?? /* @__PURE__ */ new Set()).size;
+		const rb = (refs.get(b.name) ?? /* @__PURE__ */ new Set()).size;
+		if (rb > ra) return b;
+		if (rb < ra) return a;
+		return b.name < a.name ? b : a;
+	});
+	return {
+		hub,
+		spokes: group.filter((g) => g.name !== hub.name)
+	};
+}
+function emitStar(star, exportKw, readonlyMode, exportTypes) {
+	const { hub, spokes } = star;
+	const hubRef = `${pascalCase(hub.name)}Schema`;
+	const hubExpr = `t.Recursive((Self)=>${sub(spokes.reduce((acc, s) => sub(acc, `${pascalCase(s.name)}Schema`, `(${sub(typebox(s.schema), hubRef, "Self")})`), typebox(hub.schema)), hubRef, "Self")})`;
+	const decl = (name, expr) => {
+		const ident = `${pascalCase(name)}Schema`;
+		const d = `${exportKw}const ${ident}=${readonly(expr, readonlyMode)}`;
+		return exportTypes ? `${d}\n\nexport type ${pascalCase(name)}=Static<typeof ${ident}>` : d;
+	};
+	return [decl(hub.name, hubExpr), ...spokes.map((s) => decl(s.name, typebox(s.schema)))].join("\n\n");
+}
+function emitGroup(group, readonlyMode, exportTypes, exported, names) {
+	const exportKw = exported ? "export " : "";
+	const head = group[0];
+	const exportedName = (name) => names.get(name) ?? pascalCase(name);
+	if (group.length === 1 && head) {
+		const { name, schema } = head;
+		const ident = `${exportedName(name)}Schema`;
+		const selfRef = `${pascalCase(name)}Schema`;
+		const refs = collectSchemaRefs$1(schema);
+		const inner = typebox(schema);
+		const decl = `${exportKw}const ${ident}=${readonly(refs.has(name) ? `t.Recursive((Self)=>${inner.replaceAll(new RegExp(`\\b${selfRef}\\b`, "gu"), "Self")})` : inner, readonlyMode)}`;
+		return exportTypes ? `${decl}\n\nexport type ${exportedName(name)}=Static<typeof ${ident}>` : decl;
+	}
+	const star = findStar(group, exportedName);
+	if (star) return emitStar(star, exportKw, readonlyMode, exportTypes);
+	const memberNames = new Set(group.map((g) => g.name));
+	const moduleEntries = group.map(({ name, schema }) => {
+		const inner = typebox(schema);
+		return `${name}:${[...memberNames].reduce((acc, m) => {
+			const ident = `${pascalCase(m)}Schema`;
+			return acc.replaceAll(new RegExp(`\\b${ident}\\b`, "gu"), `t.Ref('${m}')`);
+		}, inner)}`;
+	}).join(",");
+	const moduleId = head ? `${pascalCase(head.name)}Module` : "Module";
+	return `const ${moduleId}=t.Module({${moduleEntries}})\n\n${group.map(({ name }) => {
+		const ident = `${exportedName(name)}Schema`;
+		const decl = `${exportKw}const ${ident}=${readonly(`${moduleId}.Import('${name}')`, readonlyMode)}`;
+		return exportTypes ? `${decl}\n\nexport type ${exportedName(name)}=Static<typeof ${ident}>` : decl;
+	}).join("\n\n")}`;
+}
+//#endregion
+//#region src/generator/components/typeboxKinds.ts
+function makeCode(suffix, extract) {
+	return (section, readonlyMode, exportTypes, exported = true) => {
+		if (!section) return "";
+		const entries = extract(section);
+		if (entries.length === 0) return "";
+		const exportKw = exported ? "export " : "";
+		return entries.map(([name, expr]) => {
+			const ident = `${pascalCase(name)}${suffix}`;
+			const decl = `${exportKw}const ${ident}=${readonly(expr, readonlyMode)}`;
+			const typeStripped = pascalCase(name);
+			return exportTypes ? `${decl}\n\nexport type ${typeStripped}${suffix.replace(/Schema$/u, "")}=Static<typeof ${ident}>` : decl;
+		}).join("\n\n");
+	};
+}
+const responsesCode = makeCode("ResponseSchema", (s) => Object.entries(s).map(([name, res]) => {
+	const schema = jsonSchema(res.content);
+	return [name, schema ? typebox(schema) : "t.Void()"];
+}));
+const parametersCode = makeCode("ParamsSchema", (s) => Object.entries(s).map(([name, p]) => {
+	if (!p.schema) {
+		if (p.content) console.warn(`asphodelos: Component parameter '${name}' uses 'content' field (OpenAPI 3.1 alternative to 'schema'). This is not yet supported; emitting t.Unknown() placeholder.`);
+		return [name, "t.Unknown()"];
+	}
+	return [name, typebox(p.schema)];
+}));
+const requestBodiesCode = makeCode("RequestBodySchema", (s) => Object.entries(s).map(([name, body]) => {
+	const schema = jsonSchema(body.content);
+	return [name, schema ? typebox(schema) : "t.Unknown()"];
+}));
+const headersCode = makeCode("HeaderSchema", (s) => Object.entries(s).map(([name, h]) => {
+	if (isReference(h) && h.$ref) return [name, refIdent(h.$ref) ?? "t.Unknown()"];
+	const schema = "schema" in h ? h.schema : void 0;
+	return [name, schema ? typebox(schema) : "t.Unknown()"];
+}));
+const mediaTypesCode = makeCode("MediaTypeSchema", (s) => Object.entries(s).map(([name, mt]) => {
+	if (isReference(mt) && mt.$ref) return [name, refIdent(mt.$ref) ?? "t.Unknown()"];
+	const schema = !isReference(mt) && "schema" in mt ? mt.schema : void 0;
+	return [name, schema ? typebox(schema) : "t.Unknown()"];
+}));
+//#endregion
+//#region src/generator/components/metadataKinds.ts
+function makeMetadataCode(suffix) {
+	return (section, exported = true) => {
+		if (!section) return "";
+		const entries = Object.entries(section);
+		if (entries.length === 0) return "";
+		const exportKw = exported ? "export " : "";
+		return entries.map(([name, v]) => {
+			const ident = `${pascalCase(name)}${suffix}`;
+			if (isReference(v) && v.$ref) return `${exportKw}const ${ident}=${refIdent(v.$ref) ?? `${stringifyRefs(v)} as const`}`;
+			return `${exportKw}const ${ident}=${stringifyRefs(v)} as const`;
+		}).join("\n\n");
+	};
+}
+const examplesCode = makeMetadataCode("Example");
+const securitySchemesCode = makeMetadataCode("SecurityScheme");
+const linksCode = makeMetadataCode("Link");
+const callbacksCode = makeMetadataCode("Callback");
+const pathItemsCode = makeMetadataCode("PathItem");
+//#endregion
+//#region src/helper/code.ts
+function makeModuleSpec(fromFile, target) {
+	const stripped = path.relative(path.dirname(fromFile), target.output).replaceAll("\\", "/").replace(/\.ts$/u, "").replace(/(^|\/)index$/u, "");
+	return stripped === "" ? "." : stripped.startsWith(".") ? stripped : `./${stripped}`;
+}
+function makeBarrel(value) {
+	return `${Object.keys(value).toSorted().map((k) => `export * from './${k.charAt(0).toLowerCase() + k.slice(1)}'`).join("\n")}\n`;
+}
+const JS_IDENT = "[A-Za-z_$][A-Za-z0-9_$]*";
+const COMPONENT_SUFFIXES = [
+	["schemas", "Schema"],
+	["responses", "ResponseSchema"],
+	["parameters", "ParamsSchema"],
+	["examples", "Example"],
+	["requestBodies", "RequestBodySchema"],
+	["headers", "HeaderSchema"],
+	["securitySchemes", "SecurityScheme"],
+	["links", "Link"],
+	["callbacks", "Callback"],
+	["pathItems", "PathItem"],
+	["mediaTypes", "MediaTypeSchema"]
+];
+const SCAN = new RegExp([
+	String.raw`"(?:\\.|[^"\\])*"`,
+	String.raw`'(?:\\.|[^'\\])*'`,
+	"`(?:\\\\.|[^`\\\\])*`",
+	String.raw`//[^\n]*`,
+	String.raw`/\*[\s\S]*?\*/`,
+	`\\b(${JS_IDENT}(?:${COMPONENT_SUFFIXES.map(([, suf]) => suf).join("|")}))\\b`
+].join("|"), "gu");
+const CONST_PATTERN = new RegExp(`(?:export\\s+)?const\\s+(${JS_IDENT})\\s*=`, "gu");
+const EXPORT_TYPE_PATTERN = new RegExp(`export\\s+type\\s+(${JS_IDENT})\\s*=`, "gu");
+function classifyRef(name) {
+	return COMPONENT_SUFFIXES.reduce((best, entry) => name.endsWith(entry[1]) && (!best || entry[1].length > best[1].length) ? entry : best, void 0)?.[0];
+}
+function makeImports(code, fromFile, components, split = false, excludeKinds = /* @__PURE__ */ new Set()) {
+	const fallbackPrefix = split ? ".." : ".";
+	const resolvePath = (k) => {
+		const target = components?.[k];
+		return target?.import ?? (target ? makeModuleSpec(fromFile, target) : `${fallbackPrefix}/${k}`);
+	};
+	const definedConsts = new Set(Array.from(code.matchAll(CONST_PATTERN), (m) => m[1]).filter(Boolean));
+	const definedTypes = new Set(Array.from(code.matchAll(EXPORT_TYPE_PATTERN), (m) => m[1]).filter(Boolean));
+	const grouped = /* @__PURE__ */ new Map();
+	for (const match of code.matchAll(SCAN)) {
+		const name = match[1];
+		if (!name || definedConsts.has(name) || definedTypes.has(name)) continue;
+		const kind = classifyRef(name);
+		if (!kind || excludeKinds.has(kind)) continue;
+		const bucket = grouped.get(kind) ?? /* @__PURE__ */ new Set();
+		bucket.add(name);
+		grouped.set(kind, bucket);
+	}
+	const needsT = /\bt\.[A-Z]/u.test(code);
+	const needsStatic = /\bStatic\s*</u.test(code) && !definedTypes.has("Static");
+	const needsUnwrap = /\bUnwrapSchema\s*</u.test(code) && !definedTypes.has("UnwrapSchema");
+	const elysiaParts = [
+		needsT ? "t" : "",
+		needsStatic ? "type Static" : "",
+		needsUnwrap ? "type UnwrapSchema" : ""
+	].filter(Boolean);
+	const headerLines = [
+		elysiaParts.length > 0 ? `import {${elysiaParts.join(",")}} from 'elysia'` : "",
+		/\bValue\.Check\b/u.test(code) ? `import {Value} from '@sinclair/typebox/value'` : "",
+		...COMPONENT_SUFFIXES.flatMap(([kind]) => {
+			const names = grouped.get(kind);
+			if (!names) return [];
+			return [`import {${[...names].toSorted().join(",")}} from '${resolvePath(kind)}'`];
+		})
+	].filter(Boolean);
+	if (headerLines.length === 0) return code;
+	return `${headerLines.join("\n")}\n\n${code}`;
+}
+//#endregion
+//#region src/helper/eden.ts
+function isIdentifierSegment(seg) {
+	return /^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(seg);
+}
+function bracketKey(seg) {
+	return `['${seg.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}']`;
+}
+function accessSegment(seg) {
+	return isIdentifierSegment(seg) ? `.${seg}` : bracketKey(seg);
+}
+function edenChain(pathStr, client, method) {
+	const { callChain, typeChain, typeIsValue, typeChainHasBracket, paramArgs } = pathStr.split("/").filter(Boolean).reduce((acc, seg) => {
+		if (/^\{([^}]+)\}$/u.exec(seg)) {
+			const t = acc.typeIsValue ? `typeof ${acc.typeChain}` : acc.typeChain;
+			const name = acc.paramArgs.length === 0 ? "params" : `params${acc.paramArgs.length + 1}`;
+			return {
+				callChain: `${acc.callChain}(${name})`,
+				typeChain: `ReturnType<${t}>`,
+				typeIsValue: false,
+				typeChainHasBracket: acc.typeChainHasBracket,
+				paramArgs: [...acc.paramArgs, {
+					name,
+					typeExpr: `Parameters<${t}>[0]`
+				}]
+			};
+		}
+		const isIdent = isIdentifierSegment(seg);
+		const valueTypeAccess = acc.typeChainHasBracket || !isIdent ? bracketKey(seg) : `.${seg}`;
+		return {
+			callChain: `${acc.callChain}${accessSegment(seg)}`,
+			typeChain: acc.typeIsValue ? `${acc.typeChain}${valueTypeAccess}` : `${acc.typeChain}${bracketKey(seg)}`,
+			typeIsValue: acc.typeIsValue,
+			typeChainHasBracket: acc.typeChainHasBracket || acc.typeIsValue && !isIdent,
+			paramArgs: acc.paramArgs
+		};
+	}, {
+		callChain: client,
+		typeChain: client,
+		typeIsValue: true,
+		typeChainHasBracket: false,
+		paramArgs: []
+	});
+	const methodHostTypeExpr = typeIsValue ? typeChainHasBracket ? `typeof ${typeChain}${bracketKey(method)}` : `typeof ${typeChain}.${method}` : `${typeChain}['${method}']`;
+	return {
+		callExpr: `${callChain}.${method}`,
+		methodHostTypeExpr,
+		paramArgs
+	};
+}
+//#endregion
+//#region src/helper/path-params.ts
+function isIdentifier(name) {
+	return /^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(name);
+}
+function paramToken(segment) {
+	return /^\{(.+)\}$/u.exec(segment)?.[1] ?? null;
+}
+function canonicalParamNames(paths) {
+	const namesByPosition = /* @__PURE__ */ new Map();
+	for (const path of paths) {
+		const norm = [];
+		for (const segment of path.split("/").filter(Boolean)) {
+			const token = paramToken(segment);
+			if (token === null) {
+				norm.push(segment);
+				continue;
+			}
+			const key = [...norm, "{}"].join("/");
+			const names = namesByPosition.get(key) ?? /* @__PURE__ */ new Set();
+			names.add(token);
+			namesByPosition.set(key, names);
+			norm.push("{}");
+		}
+	}
+	const canonical = /* @__PURE__ */ new Map();
+	for (const [key, names] of namesByPosition) {
+		if (names.size < 2) continue;
+		const spellings = [...names];
+		if (!spellings.every(isIdentifier)) continue;
+		const representative = spellings.reduce((a, b) => b.length > a.length || b.length === a.length && b < a ? b : a);
+		canonical.set(key, representative);
+	}
+	return canonical;
+}
+function normalizePath(path, canonical) {
+	const norm = [];
+	const renames = /* @__PURE__ */ new Map();
+	return {
+		path: `/${path.split("/").filter(Boolean).map((segment) => {
+			const token = paramToken(segment);
+			if (token === null) {
+				norm.push(segment);
+				return segment;
+			}
+			const key = [...norm, "{}"].join("/");
+			norm.push("{}");
+			const representative = canonical.get(key);
+			if (representative && representative !== token) {
+				renames.set(token, representative);
+				return `{${representative}}`;
+			}
+			return segment;
+		}).join("/")}`,
+		renames
+	};
+}
+function renameOperationParams(operation, renames) {
+	if (renames.size === 0 || !operation.parameters) return operation;
+	const parameters = operation.parameters.map((p) => !isReference(p) && p.in === "path" && renames.has(p.name) ? {
+		...p,
+		name: renames.get(p.name) ?? p.name
+	} : p);
+	return {
+		...operation,
+		parameters
+	};
+}
+//#endregion
+//#region src/helper/openapi.ts
+/**
+* Generates prefix-only query-key getters (`get<Prefix>Key() => ['<prefix>']`)
+* for each unique first path segment, mirroring hono-takibi. Used for
+* per-resource cache invalidation.
+*/
+function makePrefixKeyCode(prefix) {
+	return `export function get${pascalCase(prefix)}Key() {\n  return ['${prefix}'] as const\n}`;
+}
+function makePrefixKeyCodes(openAPI, basePath) {
+	const prefixes = /* @__PURE__ */ new Set();
+	for (const pathStr of Object.keys(openAPI.paths ?? {})) {
+		const seg = resourcePrefix(`${basePath}${pathStr}`);
+		if (seg) prefixes.add(seg);
+	}
+	return [...prefixes].toSorted().map(makePrefixKeyCode);
+}
+function tagName(tag) {
+	const cleaned = tag.replaceAll(/[^a-zA-Z0-9]+/gu, " ").trim();
+	if (!cleaned) return "default";
+	return cleaned.split(/\s+/u).map((p, i) => i === 0 ? p.toLowerCase() : p.charAt(0).toUpperCase() + p.slice(1).toLowerCase()).join("");
+}
+function resourceName(pathStr) {
+	const first = pathStr.split("/").find((s) => s.length > 0 && !s.startsWith("{"));
+	return first ? tagName(first) : "root";
+}
+function makeOperationId(method, path) {
+	const camel = path.replaceAll(/\{([^}]+)\}/gu, "By-$1").split("/").filter(Boolean).map((p, i) => i === 0 ? p : p.charAt(0).toUpperCase() + p.slice(1)).join("").replaceAll(/-([a-z])/giu, (_, c) => c.toUpperCase());
+	return camel ? `${method}${camel.charAt(0).toUpperCase()}${camel.slice(1)}` : method;
+}
+function resolveOperationId(operation, method, path) {
+	const id = operation.operationId;
+	return typeof id === "string" && id.length > 0 ? id : makeOperationId(method, path);
+}
+function lookup$1(ref, section, table) {
+	const m = new RegExp(`^#/components/${section}/(.+)$`, "u").exec(ref);
+	return m?.[1] && table ? table[decodeURIComponent(m[1])] : void 0;
+}
+function resolveParameter$1(p, components) {
+	if (isReference(p) && p.$ref) return lookup$1(p.$ref, "parameters", components?.parameters);
+	return "name" in p && "in" in p ? p : void 0;
+}
+function resolveRequestBody(b, components) {
+	if (!b) return void 0;
+	if (isReference(b) && b.$ref) return lookup$1(b.$ref, "requestBodies", components?.requestBodies);
+	return b;
+}
+function resolveResponse(r, components) {
+	if (isReference(r) && r.$ref) return lookup$1(r.$ref, "responses", components?.responses) ?? {};
+	return r;
+}
+function resolveOperation(operation, components) {
+	return {
+		...operation,
+		parameters: (operation.parameters ?? []).map((p) => resolveParameter$1(p, components)).filter((p) => p !== void 0),
+		requestBody: resolveRequestBody(operation.requestBody, components),
+		responses: Object.fromEntries(Object.entries(operation.responses ?? {}).map(([status, res]) => [status, resolveResponse(res, components)]))
+	};
+}
+const HTTP_METHODS = [
+	"get",
+	"put",
+	"post",
+	"delete",
+	"options",
+	"head",
+	"patch"
+];
+function makeRoute(method, path, operation) {
+	const operationId = resolveOperationId(operation, method, path);
+	const tags = operation.tags ?? [];
+	const params = makeParamsSchema(operation.parameters ?? [], "path");
+	const query = makeParamsSchema(operation.parameters ?? [], "query");
+	const headers = makeParamsSchema(operation.parameters ?? [], "header");
+	const cookie = makeParamsSchema(operation.parameters ?? [], "cookie");
+	const body = bodyInfo(operation);
+	const synth = (kind) => `${toSafeIdentifier(operationId)}${kind}`;
+	const responsesAndInline = Object.entries(operation.responses ?? {}).map(([status, res]) => {
+		const info = responseInfo(res);
+		if (info.ref) return { entry: {
+			status,
+			schema: {
+				kind: "ref",
+				name: info.ref
+			}
+		} };
+		if (info.inline) {
+			const name = synth(`Response${status}`);
+			return {
+				entry: {
+					status,
+					schema: {
+						kind: "ref",
+						name
+					}
+				},
+				inline: {
+					name,
+					schema: info.inline
+				}
+			};
+		}
+		return { entry: {
+			status,
+			schema: { kind: "void" }
+		} };
+	});
+	const inlineSchemas = [
+		...params ? [{
+			name: synth("Params"),
+			schema: params.schema,
+			ctx: params.ctx
+		}] : [],
+		...query ? [{
+			name: synth("Query"),
+			schema: query.schema,
+			ctx: query.ctx
+		}] : [],
+		...headers ? [{
+			name: synth("Headers"),
+			schema: headers.schema,
+			ctx: headers.ctx
+		}] : [],
+		...cookie ? [{
+			name: synth("Cookie"),
+			schema: cookie.schema,
+			ctx: cookie.ctx
+		}] : [],
+		...body.inline ? [{
+			name: synth("Body"),
+			schema: body.inline,
+			ctx: body.ctx
+		}] : [],
+		...responsesAndInline.flatMap((item) => "inline" in item && item.inline ? [item.inline] : [])
+	];
+	const security = isSecurityArray(operation.security) ? operation.security : [];
+	return {
+		route: {
+			method,
+			path,
+			operationId,
+			summary: operation.summary,
+			description: operation.description,
+			tags,
+			paramsRef: params ? synth("Params") : void 0,
+			queryRef: query ? synth("Query") : void 0,
+			headersRef: headers ? synth("Headers") : void 0,
+			cookieRef: cookie ? synth("Cookie") : void 0,
+			bodyRef: body.ref ?? (body.inline ? synth("Body") : void 0),
+			responses: responsesAndInline.map((item) => item.entry),
+			security,
+			callbacks: operation.callbacks && Object.keys(operation.callbacks).length > 0 ? operation.callbacks : void 0
+		},
+		inlineSchemas
+	};
+}
+function resolvePathItem(pathItem, api) {
+	if (!pathItem.$ref) return pathItem;
+	const m = /^#\/components\/pathItems\/(.+)$/u.exec(pathItem.$ref);
+	return (m?.[1] ? api.components?.pathItems?.[decodeURIComponent(m[1])] : void 0) ?? pathItem;
+}
+function walk(path, resource, pathItem, api, canonical) {
+	const resolved = resolvePathItem(pathItem, api);
+	const { path: normalizedPath, renames } = normalizePath(path, canonical);
+	return HTTP_METHODS.flatMap((method) => {
+		const operation = resolved[method];
+		if (!operation) return [];
+		return [[resource, makeRoute(method, normalizedPath, renameOperationParams(resolveOperation(operation, api.components), renames))]];
+	});
+}
+function operationsByResource(api) {
+	const canonical = canonicalParamNames([...Object.keys(api.paths), ...Object.keys(api.webhooks ?? {}).map((event) => `/webhooks/${event}`)]);
+	const grouped = /* @__PURE__ */ new Map();
+	const collect = (resource, item) => {
+		const bucket = grouped.get(resource) ?? [];
+		bucket.push(item);
+		grouped.set(resource, bucket);
+	};
+	for (const [path, pathItem] of pathEntries(api)) {
+		if (!pathItem) continue;
+		for (const [resource, route] of walk(path, resourceName(path), pathItem, api, canonical)) collect(resource, route);
+	}
+	for (const [event, pathItem] of Object.entries(api.webhooks ?? {})) {
+		if (!pathItem) continue;
+		for (const [resource, route] of walk(`/webhooks/${event}`, "webhooks", pathItem, api, canonical)) collect(resource, route);
+	}
+	return grouped;
+}
+//#endregion
+//#region src/core/components/output.ts
+/**
+* Emits every component kind into a single file (`components.output` mode).
+* Cross-component references resolve within the same file — `makeImports`
+* skips them since they are locally-defined consts — so it only injects the
+* elysia / typebox runtime imports the combined body needs.
+*/
+function components(section, output, readonly) {
+	return Effect.gen(function* () {
+		if (!section) return "No components found";
+		const blocks = [
+			schemasCode(section.schemas, readonly),
+			responsesCode(section.responses, readonly),
+			parametersCode(section.parameters, readonly),
+			examplesCode(section.examples),
+			requestBodiesCode(section.requestBodies, readonly),
+			headersCode(section.headers, readonly),
+			securitySchemesCode(section.securitySchemes),
+			linksCode(section.links),
+			callbacksCode(section.callbacks),
+			pathItemsCode(section.pathItems),
+			mediaTypesCode(section.mediaTypes, readonly)
+		].filter((block) => block !== "");
+		if (blocks.length === 0) return "No components found";
+		const abs = path.resolve(process.cwd(), output);
+		yield* emit(makeImports(blocks.join("\n\n"), abs, void 0, false), path.dirname(abs), abs);
+		return `Generated components code written to ${output}`;
+	});
+}
+//#endregion
+//#region src/error/index.ts
+/**
+* A generator refused the work it was given — an empty section, an output path that does not fit
+* the mode, a document that says nothing to write.
+*
+* Distinct from `PlatformError` (the filesystem said no) and `FormatError` (oxfmt rejected the
+* source): this one is always the caller's input, and the CLI renders its message as-is.
+*/
+var GenerateError = class extends Data.TaggedError("GenerateError") {};
+//#endregion
+//#region src/core/components/schemas.ts
+function fileNameOf(group) {
+	return uncapitalize(group.map((g) => g.name).toSorted()[0] ?? "schema");
+}
+function splitSchemaFiles(section, readonly, exportTypes) {
+	const sccs = sccSchemas(Object.entries(section).map(([name, schema]) => ({
+		name,
+		schema
+	})));
+	const nameToFile = new Map(sccs.flatMap((g) => g.map((s) => [s.name, fileNameOf(g)])));
+	return sccs.map((group) => {
+		const fileName = fileNameOf(group);
+		const body = schemasCode(Object.fromEntries(group.map((g) => [g.name, g.schema])), readonly, exportTypes);
+		if (body === "") return {
+			fileName,
+			code: ""
+		};
+		const memberNames = new Set(group.map((g) => g.name));
+		const bySibling = /* @__PURE__ */ new Map();
+		for (const { schema } of group) for (const refName of collectSchemaRefs$1(schema)) {
+			const sibling = nameToFile.get(refName);
+			if (!sibling || sibling === fileName || memberNames.has(refName)) continue;
+			const bucket = bySibling.get(sibling) ?? /* @__PURE__ */ new Set();
+			bucket.add(`${pascalCase(refName)}Schema`);
+			bySibling.set(sibling, bucket);
+		}
+		const siblingImports = [...bySibling.entries()].toSorted(([a], [b]) => a.localeCompare(b)).map(([sibling, idents]) => `import {${[...idents].toSorted().join(",")}} from './${sibling}'`).join("\n");
+		return {
+			fileName,
+			code: siblingImports ? `${siblingImports}\n\n${body}` : body
+		};
+	});
+}
+function schemas(section, output, split, exportTypes, components, readonly) {
+	return Effect.gen(function* () {
+		if (!section) return yield* new GenerateError({ message: "No schemas found" });
+		if (Object.keys(section).length === 0) return "No schemas found";
+		const abs = path.resolve(process.cwd(), output);
+		if (split) {
+			const exclude = new Set(["schemas"]);
+			const outDir = path.join(path.dirname(abs), path.basename(abs, ".ts"));
+			const files = splitSchemaFiles(section, readonly, exportTypes);
+			const barrelLines = files.map((f) => `export * from './${f.fileName}'`).toSorted();
+			yield* Effect.all([...files.map((f) => {
+				const filePath = path.join(outDir, `${f.fileName}.ts`);
+				return emit(f.code === "" ? "" : makeImports(f.code, filePath, components, true, exclude), path.dirname(filePath), filePath);
+			}), emit(`${barrelLines.join("\n")}\n`, outDir, path.join(outDir, "index.ts"))], { concurrency: "unbounded" });
+			return `Generated schemas code written to ${outDir}/*.ts (index.ts included)`;
+		}
+		const code = schemasCode(section, readonly, exportTypes);
+		if (code === "") return "No schemas found";
+		yield* emit(makeImports(code, abs, components, false), path.dirname(abs), abs);
+		return `Generated schemas code written to ${output}`;
+	});
+}
+//#endregion
+//#region src/core/components/responses.ts
+function responses(section, output, split, exportTypes, components, readonly) {
+	return Effect.gen(function* () {
+		if (!section) return yield* new GenerateError({ message: "No responses found" });
+		const entries = Object.entries(section);
+		if (entries.length === 0) return "No responses found";
+		if (split) {
+			const outDir = path.join(path.dirname(output), path.basename(output, ".ts"));
+			yield* Effect.all([...entries.map(([name, value]) => {
+				const code = responsesCode({ [name]: value }, readonly, exportTypes);
+				const filePath = path.join(outDir, `${uncapitalize(name)}.ts`);
+				return emit(makeImports(code, filePath, components, split), path.dirname(filePath), filePath);
+			}), emit(makeBarrel(section), outDir, path.join(outDir, "index.ts"))], { concurrency: "unbounded" });
+			return `Generated responses code written to ${outDir}/*.ts (index.ts included)`;
+		}
+		yield* emit(makeImports(responsesCode(section, readonly, exportTypes), output, components, split), path.dirname(output), output);
+		return `Generated responses code written to ${output}`;
+	});
+}
+//#endregion
+//#region src/core/components/parameters.ts
+function parameters(section, output, split, exportTypes, components, readonly) {
+	return Effect.gen(function* () {
+		if (!section) return yield* new GenerateError({ message: "No parameters found" });
+		const entries = Object.entries(section);
+		if (entries.length === 0) return "No parameters found";
+		if (split) {
+			const outDir = path.join(path.dirname(output), path.basename(output, ".ts"));
+			yield* Effect.all([...entries.map(([name, value]) => {
+				const code = parametersCode({ [name]: value }, readonly, exportTypes);
+				const filePath = path.join(outDir, `${uncapitalize(name)}.ts`);
+				return emit(makeImports(code, filePath, components, split), path.dirname(filePath), filePath);
+			}), emit(makeBarrel(section), outDir, path.join(outDir, "index.ts"))], { concurrency: "unbounded" });
+			return `Generated parameters code written to ${outDir}/*.ts (index.ts included)`;
+		}
+		yield* emit(makeImports(parametersCode(section, readonly, exportTypes), output, components, split), path.dirname(output), output);
+		return `Generated parameters code written to ${output}`;
+	});
+}
+//#endregion
+//#region src/core/components/examples.ts
+function examples(section, output, split, components) {
+	return Effect.gen(function* () {
+		if (!section) return yield* new GenerateError({ message: "No examples found" });
+		const entries = Object.entries(section);
+		if (entries.length === 0) return "No examples found";
+		if (split) {
+			const outDir = path.join(path.dirname(output), path.basename(output, ".ts"));
+			yield* Effect.all([...entries.map(([name, value]) => {
+				const code = examplesCode({ [name]: value });
+				const filePath = path.join(outDir, `${uncapitalize(name)}.ts`);
+				return emit(makeImports(code, filePath, components, split), path.dirname(filePath), filePath);
+			}), emit(makeBarrel(section), outDir, path.join(outDir, "index.ts"))], { concurrency: "unbounded" });
+			return `Generated examples code written to ${outDir}/*.ts (index.ts included)`;
+		}
+		yield* emit(makeImports(examplesCode(section), output, components, split), path.dirname(output), output);
+		return `Generated examples code written to ${output}`;
+	});
+}
+//#endregion
+//#region src/core/components/requestBodies.ts
+function requestBodies(section, output, split, exportTypes, components, readonly) {
+	return Effect.gen(function* () {
+		if (!section) return yield* new GenerateError({ message: "No requestBodies found" });
+		const entries = Object.entries(section);
+		if (entries.length === 0) return "No requestBodies found";
+		if (split) {
+			const outDir = path.join(path.dirname(output), path.basename(output, ".ts"));
+			yield* Effect.all([...entries.map(([name, value]) => {
+				const code = requestBodiesCode({ [name]: value }, readonly, exportTypes);
+				const filePath = path.join(outDir, `${uncapitalize(name)}.ts`);
+				return emit(makeImports(code, filePath, components, split), path.dirname(filePath), filePath);
+			}), emit(makeBarrel(section), outDir, path.join(outDir, "index.ts"))], { concurrency: "unbounded" });
+			return `Generated requestBodies code written to ${outDir}/*.ts (index.ts included)`;
+		}
+		yield* emit(makeImports(requestBodiesCode(section, readonly, exportTypes), output, components, split), path.dirname(output), output);
+		return `Generated requestBodies code written to ${output}`;
+	});
+}
+//#endregion
+//#region src/core/components/headers.ts
+function headers(section, output, split, exportTypes, components, readonly) {
+	return Effect.gen(function* () {
+		if (!section) return yield* new GenerateError({ message: "No headers found" });
+		const entries = Object.entries(section);
+		if (entries.length === 0) return "No headers found";
+		if (split) {
+			const outDir = path.join(path.dirname(output), path.basename(output, ".ts"));
+			yield* Effect.all([...entries.map(([name, value]) => {
+				const code = headersCode({ [name]: value }, readonly, exportTypes);
+				const filePath = path.join(outDir, `${uncapitalize(name)}.ts`);
+				return emit(makeImports(code, filePath, components, split), path.dirname(filePath), filePath);
+			}), emit(makeBarrel(section), outDir, path.join(outDir, "index.ts"))], { concurrency: "unbounded" });
+			return `Generated headers code written to ${outDir}/*.ts (index.ts included)`;
+		}
+		yield* emit(makeImports(headersCode(section, readonly, exportTypes), output, components, split), path.dirname(output), output);
+		return `Generated headers code written to ${output}`;
+	});
+}
+//#endregion
+//#region src/core/components/securitySchemes.ts
+function securitySchemes(section, output, split, components) {
+	return Effect.gen(function* () {
+		if (!section) return yield* new GenerateError({ message: "No securitySchemes found" });
+		const entries = Object.entries(section);
+		if (entries.length === 0) return "No securitySchemes found";
+		if (split) {
+			const outDir = path.join(path.dirname(output), path.basename(output, ".ts"));
+			yield* Effect.all([...entries.map(([name, value]) => {
+				const code = securitySchemesCode({ [name]: value });
+				const filePath = path.join(outDir, `${uncapitalize(name)}.ts`);
+				return emit(makeImports(code, filePath, components, split), path.dirname(filePath), filePath);
+			}), emit(makeBarrel(section), outDir, path.join(outDir, "index.ts"))], { concurrency: "unbounded" });
+			return `Generated securitySchemes code written to ${outDir}/*.ts (index.ts included)`;
+		}
+		yield* emit(makeImports(securitySchemesCode(section), output, components, split), path.dirname(output), output);
+		return `Generated securitySchemes code written to ${output}`;
+	});
+}
+//#endregion
+//#region src/core/components/links.ts
+function links(section, output, split, components) {
+	return Effect.gen(function* () {
+		if (!section) return yield* new GenerateError({ message: "No links found" });
+		const entries = Object.entries(section);
+		if (entries.length === 0) return "No links found";
+		if (split) {
+			const outDir = path.join(path.dirname(output), path.basename(output, ".ts"));
+			yield* Effect.all([...entries.map(([name, value]) => {
+				const code = linksCode({ [name]: value });
+				const filePath = path.join(outDir, `${uncapitalize(name)}.ts`);
+				return emit(makeImports(code, filePath, components, split), path.dirname(filePath), filePath);
+			}), emit(makeBarrel(section), outDir, path.join(outDir, "index.ts"))], { concurrency: "unbounded" });
+			return `Generated links code written to ${outDir}/*.ts (index.ts included)`;
+		}
+		yield* emit(makeImports(linksCode(section), output, components, split), path.dirname(output), output);
+		return `Generated links code written to ${output}`;
+	});
+}
+//#endregion
+//#region src/core/components/callbacks.ts
+function callbacks(section, output, split, components) {
+	return Effect.gen(function* () {
+		if (!section) return yield* new GenerateError({ message: "No callbacks found" });
+		const entries = Object.entries(section);
+		if (entries.length === 0) return "No callbacks found";
+		if (split) {
+			const outDir = path.join(path.dirname(output), path.basename(output, ".ts"));
+			yield* Effect.all([...entries.map(([name, value]) => {
+				const code = callbacksCode({ [name]: value });
+				const filePath = path.join(outDir, `${uncapitalize(name)}.ts`);
+				return emit(makeImports(code, filePath, components, split), path.dirname(filePath), filePath);
+			}), emit(makeBarrel(section), outDir, path.join(outDir, "index.ts"))], { concurrency: "unbounded" });
+			return `Generated callbacks code written to ${outDir}/*.ts (index.ts included)`;
+		}
+		yield* emit(makeImports(callbacksCode(section), output, components, split), path.dirname(output), output);
+		return `Generated callbacks code written to ${output}`;
+	});
+}
+//#endregion
+//#region src/core/components/pathItems.ts
+function pathItems(section, output, split, components) {
+	return Effect.gen(function* () {
+		if (!section) return yield* new GenerateError({ message: "No pathItems found" });
+		const entries = Object.entries(section);
+		if (entries.length === 0) return "No pathItems found";
+		if (split) {
+			const outDir = path.join(path.dirname(output), path.basename(output, ".ts"));
+			yield* Effect.all([...entries.map(([name, value]) => {
+				const code = pathItemsCode({ [name]: value });
+				const filePath = path.join(outDir, `${uncapitalize(name)}.ts`);
+				return emit(makeImports(code, filePath, components, split), path.dirname(filePath), filePath);
+			}), emit(makeBarrel(section), outDir, path.join(outDir, "index.ts"))], { concurrency: "unbounded" });
+			return `Generated pathItems code written to ${outDir}/*.ts (index.ts included)`;
+		}
+		yield* emit(makeImports(pathItemsCode(section), output, components, split), path.dirname(output), output);
+		return `Generated pathItems code written to ${output}`;
+	});
+}
+//#endregion
+//#region src/core/components/mediaTypes.ts
+function mediaTypes(section, output, split, exportTypes, components, readonly) {
+	return Effect.gen(function* () {
+		if (!section) return yield* new GenerateError({ message: "No mediaTypes found" });
+		const entries = Object.entries(section);
+		if (entries.length === 0) return "No mediaTypes found";
+		if (split) {
+			const outDir = path.join(path.dirname(output), path.basename(output, ".ts"));
+			yield* Effect.all([...entries.map(([name, value]) => {
+				const code = mediaTypesCode({ [name]: value }, readonly, exportTypes);
+				const filePath = path.join(outDir, `${uncapitalize(name)}.ts`);
+				return emit(makeImports(code, filePath, components, split), path.dirname(filePath), filePath);
+			}), emit(makeBarrel(section), outDir, path.join(outDir, "index.ts"))], { concurrency: "unbounded" });
+			return `Generated mediaTypes code written to ${outDir}/*.ts (index.ts included)`;
+		}
+		yield* emit(makeImports(mediaTypesCode(section, readonly, exportTypes), output, components, split), path.dirname(output), output);
+		return `Generated mediaTypes code written to ${output}`;
+	});
+}
+//#endregion
+//#region src/core/eden/index.ts
+function makeJsDocs(method, pathStr, operation) {
+	const blocks = [];
+	if (operation.summary) blocks.push([operation.summary]);
+	if (operation.description) blocks.push(operation.description.split("\n"));
+	blocks.push([`${method.toUpperCase()} ${pathStr}`]);
+	const tagLines = [];
+	if (operation.deprecated) tagLines.push("@deprecated");
+	if (tagLines.length > 0) blocks.push(tagLines);
+	return `/**\n${blocks.map((lines) => lines.map((l) => l === "" ? " *" : ` * ${l}`).join("\n")).join("\n *\n")}\n */`;
+}
+function makeOperation$1(pathStr, method, operation, client, docs) {
+	const funcName = toSafeIdentifier(resolveOperationId(operation, method, pathStr));
+	const { callExpr, methodHostTypeExpr, paramArgs } = edenChain(pathStr, client, method);
+	const fn = `export async function ${funcName}(${[...paramArgs.map((p) => `${p.name}: ${p.typeExpr}`), `...args: Parameters<${methodHostTypeExpr}>`].join(", ")}) {\n  return ${callExpr}(...args)\n}`;
+	return docs ? `${makeJsDocs(method, pathStr, operation)}\n${fn}` : fn;
+}
+function eden(openAPI, output, importPath, client, basePath, docs = false) {
+	return Effect.gen(function* () {
+		const prefix = basePath && basePath !== "/" ? basePath : "";
+		const operations = [];
+		for (const [pathStr, pathItem] of pathEntries(openAPI)) {
+			if (!pathItem) continue;
+			for (const method of HTTP_METHODS) {
+				const operation = pathItem[method];
+				if (!operation) continue;
+				operations.push(makeOperation$1(`${prefix}${pathStr}`, method, operation, client, docs));
+			}
+		}
+		if (operations.length === 0) return "No operations found";
+		yield* emit(`${`import { ${client} } from '${importPath}'\n\n`}${`${operations.join("\n\n")}\n`}`, path.dirname(output), output);
+		return `Generated eden code written to ${output}`;
+	});
+}
+//#endregion
+//#region src/generator/app/index.ts
+function exportName(name) {
+	return toSafeIdentifier(name);
+}
+function appFile(resources, { prefix, integration, port = "3000" } = {}) {
+	const ROOT_NAME = "app";
+	const localAlias = (name) => exportName(name) === ROOT_NAME ? `${ROOT_NAME}Module` : exportName(name);
+	const moduleImports = resources.map((name) => {
+		const exported = exportName(name);
+		const alias = localAlias(name);
+		return alias === exported ? `import {${exported}} from './modules/${name}'` : `import {${exported} as ${alias}} from './modules/${name}'`;
+	}).join("\n");
+	const moduleUses = resources.map((name) => `.use(${localAlias(name)})`).join("");
+	return `import {Elysia} from 'elysia'
+${moduleImports}
+
+export const app=new Elysia(${prefix ? `{prefix:${JSON.stringify(prefix)}}` : ""})${moduleUses}${integration ? "" : `
+
+if (import.meta.main) {
+  app.listen(${port})\n  console.log(\`🦊 Elysia is running at \${app.server?.hostname}:\${app.server?.port}\`)
+}`}
+`;
+}
+//#endregion
+//#region src/generator/controller/index.ts
+function schemaIdent(name) {
+	return `${pascalCase(name)}Schema`;
+}
+function join(entries, sep) {
+	return filterDefined(entries).join(sep);
+}
+function toElysiaPath(p) {
+	return p.replaceAll(/\{([^}]+)\}/gu, ":$1");
+}
+function componentKey(name) {
+	return `'${pascalCase(name)}'`;
+}
+function controllerFile(tag, routes, componentImports = [], componentNames = /* @__PURE__ */ new Set(), schemasImportPath = "../../components") {
+	const className = `${pascalCase(tag)}Model`;
+	const isComponent = (name) => componentNames.has(name);
+	const inlineRef = (name) => `${className}.${name}`;
+	const refValue = (name) => isComponent(name) ? componentKey(name) : inlineRef(name);
+	const renderRoute = (route) => {
+		const renderResponseValue = (schema) => schema.kind === "ref" ? refValue(schema.name) : "t.Void()";
+		const argKeys = filterDefined([
+			route.paramsRef ? "params" : null,
+			route.queryRef ? "query" : null,
+			route.headersRef ? "headers" : null,
+			route.cookieRef ? "cookie" : null,
+			route.bodyRef ? "body" : null
+		]);
+		const handler = `${argKeys.length > 0 ? `({${argKeys.join(",")}})` : "()"}=>{}`;
+		const responseEntries = route.responses.map((res) => `${safeStatusKey(res.status)}:${renderResponseValue(res.schema)}`).join(",");
+		const detail = join([
+			`tags:${JSON.stringify(route.tags)}`,
+			route.summary ? `summary:${JSON.stringify(route.summary)}` : null,
+			route.description ? `description:${JSON.stringify(route.description)}` : null,
+			`operationId:${JSON.stringify(route.operationId)}`,
+			route.callbacks ? `callbacks:${JSON.stringify(route.callbacks)}` : null,
+			route.security.length > 0 ? `security:${JSON.stringify(route.security)}` : null
+		], ",");
+		const opts = join([
+			route.paramsRef ? `params:${refValue(route.paramsRef)}` : null,
+			route.queryRef ? `query:${refValue(route.queryRef)}` : null,
+			route.headersRef ? `headers:${refValue(route.headersRef)}` : null,
+			route.cookieRef ? `cookie:${refValue(route.cookieRef)}` : null,
+			route.bodyRef ? `body:${refValue(route.bodyRef)}` : null,
+			responseEntries ? `response:{${responseEntries}}` : null,
+			`detail:{${detail}}`
+		], ",");
+		return `.${route.method}(${JSON.stringify(toElysiaPath(route.path))},${handler},{${opts}})`;
+	};
+	const chain = routes.map(renderRoute).join("");
+	const importedSchemaIdents = componentImports.map(schemaIdent);
+	const componentImport = componentImports.length > 0 ? `import {${importedSchemaIdents.join(",")}} from '${schemasImportPath}'\n` : "";
+	const componentRegister = componentImports.length > 0 ? `.model({${componentImports.map((n) => `${pascalCase(n)}:${schemaIdent(n)}`).join(",")}})` : "";
+	return `${/\bt\.[A-Z]\w*\(/u.test(chain) ? `import {Elysia,t} from 'elysia'` : `import {Elysia} from 'elysia'`}
+${componentImport}import {${className}} from './model'
+
+export const ${toSafeIdentifier(tag)}=new Elysia()${componentRegister}${chain}
+`;
+}
+//#endregion
+//#region src/generator/model/index.ts
+function modelFile(tag, schemas, componentNames = /* @__PURE__ */ new Set(), schemasImportPath = "../../components", readonlyMode) {
+	const className = `${pascalCase(tag)}Model`;
+	const referenced = /* @__PURE__ */ new Set();
+	for (const { schema } of schemas) for (const r of collectSchemaRefs$1(schema)) if (componentNames.has(r)) referenced.add(r);
+	const importedIdents = [...referenced].toSorted().map((n) => `${pascalCase(n)}Schema`);
+	const componentImport = importedIdents.length > 0 ? `import {${importedIdents.join(",")}} from '${schemasImportPath}'\n` : "";
+	const entries = schemas.map(({ name, schema, ctx }) => `${name}:${readonly(typebox(schema, ctx), readonlyMode)}`).join(",");
+	if (entries === "") return `${componentImport}
+export const ${className}={} as const
+
+export type ${className}=typeof ${className}
+`;
+	return `import {t,type UnwrapSchema} from 'elysia'
+${componentImport}
+export const ${className}={${entries}} as const
+
+export type ${className}={[k in keyof typeof ${className}]:UnwrapSchema<(typeof ${className})[k]>}
+`;
+}
+//#endregion
+//#region src/generator/service/index.ts
+function serviceFile(tag) {
+	return `export abstract class ${pascalCase(tag)}{}
+`;
+}
+//#endregion
+//#region src/merge/statement-key.ts
+function statementKey(stmt) {
+	if (Node.isClassDeclaration(stmt)) {
+		const name = stmt.getName();
+		return name ? `class:${name}` : null;
+	}
+	if (Node.isFunctionDeclaration(stmt)) {
+		const name = stmt.getName();
+		return name ? `fn:${name}` : null;
+	}
+	if (Node.isVariableStatement(stmt)) {
+		const first = stmt.getDeclarations()[0];
+		return first ? `var:${first.getName()}` : null;
+	}
+	if (Node.isTypeAliasDeclaration(stmt)) {
+		const name = stmt.getName();
+		return name ? `type:${name}` : null;
+	}
+	if (Node.isInterfaceDeclaration(stmt)) {
+		const name = stmt.getName();
+		return name ? `interface:${name}` : null;
+	}
+	if (Node.isIfStatement(stmt)) return `if:${stmt.getExpression().getText().trim()}`;
+	if (Node.isExpressionStatement(stmt)) {
+		const expr = stmt.getExpression();
+		if (Node.isCallExpression(expr)) {
+			const callee = expr.getExpression();
+			if (Node.isIdentifier(callee) && callee.getText() === "describe") {
+				const first = expr.getArguments()[0];
+				if (first && Node.isStringLiteral(first)) return `describe:${first.getLiteralText()}`;
+			}
+			const argSig = expr.getArguments().map((a) => a.getText().trim().replace(/;$/u, "")).join(",");
+			return `expr:${callee.getText().trim()}(${argSig})`;
+		}
+	}
+	return null;
+}
+//#endregion
+//#region src/merge/index.ts
+function stmtText(s) {
+	if (Node.isJSDocable(s)) {
+		const docs = s.getJsDocs().map((d) => d.getText()).join("\n");
+		if (docs.length > 0) return `${docs}\n${s.getText()}`;
+	}
+	return s.getText();
+}
+function collectNames(imp) {
+	const names = [];
+	const def = imp.getDefaultImport();
+	if (def) names.push(def.getText());
+	const ns = imp.getNamespaceImport();
+	if (ns) names.push(ns.getText());
+	for (const b of imp.getNamedImports()) names.push(b.getNameNode().getText());
+	return names;
+}
+function mergeSource(existing, generated) {
+	const project = new Project({ useInMemoryFileSystem: true });
+	const existingFile = project.createSourceFile("existing.ts", existing);
+	const generatedFile = project.createSourceFile("generated.ts", generated);
+	const claimedByGenerated = /* @__PURE__ */ new Set();
+	for (const imp of generatedFile.getImportDeclarations()) for (const n of collectNames(imp)) claimedByGenerated.add(n);
+	const importBySpec = /* @__PURE__ */ new Map();
+	for (const imp of generatedFile.getImportDeclarations()) importBySpec.set(imp.getModuleSpecifierValue(), imp.getText());
+	for (const imp of existingFile.getImportDeclarations()) {
+		const spec = imp.getModuleSpecifierValue();
+		if (importBySpec.has(spec)) {
+			importBySpec.set(spec, imp.getText());
+			continue;
+		}
+		const named = imp.getNamedImports();
+		const def = imp.getDefaultImport();
+		const ns = imp.getNamespaceImport();
+		const survivingNamed = named.filter((b) => !claimedByGenerated.has(b.getNameNode().getText()));
+		const defClaimed = def ? claimedByGenerated.has(def.getText()) : false;
+		const nsClaimed = ns ? claimedByGenerated.has(ns.getText()) : false;
+		if (survivingNamed.length === named.length && !defClaimed && !nsClaimed) {
+			importBySpec.set(spec, imp.getText());
+			continue;
+		}
+		const clauseParts = [
+			def && !defClaimed ? def.getText() : "",
+			ns && !nsClaimed ? `* as ${ns.getText()}` : "",
+			survivingNamed.length > 0 ? `{${survivingNamed.map((b) => b.getText()).join(",")}}` : ""
+		].filter(Boolean);
+		if (clauseParts.length === 0) continue;
+		importBySpec.set(spec, `import ${clauseParts.join(",")} from '${spec}'`);
+	}
+	const existingStmts = existingFile.getStatements().filter((s) => !Node.isImportDeclaration(s));
+	const generatedStmts = generatedFile.getStatements().filter((s) => !Node.isImportDeclaration(s));
+	const existingByKey = /* @__PURE__ */ new Map();
+	for (const s of existingStmts) {
+		const k = statementKey(s);
+		if (k) existingByKey.set(k, s);
+	}
+	const usedExistingKeys = /* @__PURE__ */ new Set();
+	const isFirstEmit = existingStmts.length === 0;
+	const fromGenerated = generatedStmts.flatMap((s) => {
+		const k = statementKey(s);
+		if (k && existingByKey.has(k)) {
+			usedExistingKeys.add(k);
+			const existingStmt = existingByKey.get(k);
+			return [existingStmt ? stmtText(existingStmt) : stmtText(s)];
+		}
+		if (!isFirstEmit && k?.startsWith("expr:")) return [];
+		return [stmtText(s)];
+	});
+	const fromExistingOnly = existingStmts.filter((s) => {
+		const k = statementKey(s);
+		return k ? !usedExistingKeys.has(k) : true;
+	}).map(stmtText);
+	return [
+		[...importBySpec.values()].join("\n"),
+		"",
+		[...fromGenerated, ...fromExistingOnly].join("\n\n"),
+		""
+	].join("\n");
+}
+//#endregion
+//#region src/core/elysia/index.ts
+/** Keeps whatever the user already wrote in `output` when regenerating over it. */
+function merged(code, output) {
+	return Effect.gen(function* () {
+		const existing = yield* readFile(output);
+		return existing === null ? code : mergeSource(existing, code);
+	});
+}
+function elysia(api, options = {}) {
+	return Effect.gen(function* () {
+		const byResource = operationsByResource(api);
+		const resources = [...byResource.keys()];
+		if (resources.length === 0) return yield* new GenerateError({ message: "no operations found in OpenAPI document" });
+		const componentSchemas = (api.components ?? {}).schemas ?? {};
+		const componentNames = new Set(Object.keys(componentSchemas));
+		const appOutput = options.output ?? "src/index.ts";
+		const appAbs = path.resolve(process.cwd(), appOutput);
+		const baseDir = path.dirname(appAbs);
+		const modulesDir = path.join(baseDir, "modules");
+		const schemasImportFromModule = (() => {
+			const fromFile = path.join(modulesDir, "_", "index.ts");
+			if (options.componentsOutput) return makeModuleSpec(fromFile, {
+				output: path.resolve(process.cwd(), options.componentsOutput),
+				split: false
+			});
+			const cfg = options.components?.schemas;
+			if (cfg?.import) return cfg.import;
+			if (cfg?.output) return makeModuleSpec(fromFile, {
+				output: path.resolve(process.cwd(), cfg.output),
+				split: cfg.split
+			});
+			return options.pathAlias ? `${options.pathAlias}/schemas` : "../../components/schemas";
+		})();
+		function writeResource(resource) {
+			return Effect.gen(function* () {
+				const items = byResource.get(resource) ?? [];
+				const routes = items.map((i) => i.route);
+				const inline = items.flatMap((i) => i.inlineSchemas);
+				const inlineSchemas = moduleInlineSchemas(inline);
+				const refs = [...moduleComponentRefs(routes, inline, componentNames, componentSchemas)].toSorted();
+				const dir = path.join(modulesDir, resource);
+				const servicePath = path.join(dir, "service.ts");
+				const controllerPath = path.join(dir, "index.ts");
+				const [serviceCode, controllerCode] = yield* Effect.all([merged(serviceFile(resource), servicePath), merged(controllerFile(resource, routes, refs, componentNames, schemasImportFromModule), controllerPath)], { concurrency: "unbounded" });
+				return [
+					emit(modelFile(resource, inlineSchemas, componentNames, schemasImportFromModule, options.readonly), dir, path.join(dir, "model.ts")),
+					emit(serviceCode, dir, servicePath),
+					emit(controllerCode, dir, controllerPath)
+				];
+			});
+		}
+		const appCode = yield* merged(appFile(resources, {
+			prefix: options.prefix,
+			integration: options.integration,
+			port: options.port
+		}), appAbs);
+		const moduleWrites = yield* Effect.all(resources.map(writeResource), { concurrency: "unbounded" });
+		yield* Effect.all([emit(appCode, baseDir, appAbs), ...moduleWrites.flat()], { concurrency: "unbounded" });
+		return `Generated ${resources.length} module(s) (${resources.join(", ")}) → ${path.posix.dirname(appOutput)}/`;
+	});
+}
+//#endregion
+//#region src/helper/query.ts
+function optionsObjectType(config, optionsType) {
+	return config.unwrapOptionsAccessor ? `ReturnType<${optionsType}>` : optionsType;
+}
+const QUERY_OMIT_KEYS = `'queryKey' | 'queryFn'`;
+const INFINITE_OMIT_KEYS = `'queryKey' | 'queryFn' | 'initialPageParam' | 'getNextPageParam'`;
+function omitInjectedKeys(config, optionsType, keys) {
+	return `Omit<${config.maybeRefOptions ? `Extract<${optionsType}, { queryKey: unknown }>` : optionsObjectType(config, optionsType)}, ${keys}>`;
+}
+function makeGetQueryOptionsParam(config, dataT, keyName) {
+	const optType = config.queryOptionsType;
+	const omit = (optionsType) => omitInjectedKeys(config, optionsType, QUERY_OMIT_KEYS);
+	if (config.useQueryGenerics) return `queryOptions?: ${omit(`${optType}<${dataT}, TError, TData>`)}`;
+	if (config.maybeRefOptions) return `queryOptions?: ${omit(`${optType}<${dataT}, TError, TData, ${dataT}, ReturnType<typeof ${keyName}>>`)}`;
+	if (config.thunkOptionsCall) return `queryOptions?: () => ${omit(`${optType}<${dataT}, TError, TData, ReturnType<typeof ${keyName}>>`)}`;
+	return `queryOptions?: ${omit(`${optType}<${dataT}, TError, TData>`)}`;
+}
+function makeMutationOptionsParam(config, dataT, errorT, variablesType) {
+	const optType = `${config.mutationOptionsType}<${dataT}, ${errorT}, ${variablesType}>`;
+	return config.thunkOptionsCall ? `mutationOptions?: () => ${optionsObjectType(config, optType)}` : `mutationOptions?: ${optType}`;
+}
+function makeGetHookBody(config, dataT, keyCall, queryFnBlock) {
+	const inner = `${config.thunkOptionsCall ? "...queryOptions?.()" : "...queryOptions"},queryKey:${keyCall},${queryFnBlock}`;
+	if (config.useQueryGenerics) return `${config.queryFn}<${dataT},TError,TData>({${inner}})`;
+	if (config.useThunk) return `${config.queryFn}(()=>({${inner}}))`;
+	return `${config.queryFn}({${inner}})`;
+}
+function makeMutationFactoryCode(name, keySig, keyCall, dataT, errorT, variablesType, mutationFnBlock) {
+	return `export function ${name}<TError = ${errorT}>(${keySig}){return mutationOptions<${dataT},TError,${variablesType}>({mutationKey:${keyCall},${mutationFnBlock}})}`;
+}
+function makeMutationHookBody(config, dataT, variablesType, factoryCall) {
+	const inner = `${config.thunkOptionsCall ? "...mutationOptions?.()" : "...mutationOptions"},...${factoryCall}`;
+	if (config.useQueryGenerics) return `${config.mutationFn}<${dataT},TError,${variablesType}>({${inner}})`;
+	if (config.useThunk) return `${config.mutationFn}(()=>({${inner}}))`;
+	return `${config.mutationFn}({${inner}})`;
+}
+function makeTanstackInfiniteParts(config, args) {
+	const { funcName, hookName, suspenseHookName, keyPrefix, pathStr } = args;
+	const { paramSig, paramPass, optionsType, dataT, errorT, callExpr } = args;
+	const infiniteKeyName = `${funcName}InfiniteQueryKey`;
+	const infiniteKeyCode = `export function ${infiniteKeyName}(${[...paramSig, `options?: ${optionsType}`].join(", ")}){const{headers:_h,fetch:_f,throwHttpError:_t,...keyArgs}=options??{};return[${[
+		`'${keyPrefix}'`,
+		`'${pathStr}'`,
+		`'infinite'`,
+		...paramPass,
+		"keyArgs"
+	].join(", ")}]as const}`;
+	const infiniteKeyCall = `${infiniteKeyName}(${[...paramPass, "options"].join(", ")})`;
+	const infiniteHookName = `${hookName}Infinite`;
+	const suspenseInfiniteHookName = `${suspenseHookName}Infinite`;
+	const queryKeyType = `ReturnType<typeof ${infiniteKeyName}>`;
+	const paginationParam = `pagination: { initialPageParam: TPageParam; getNextPageParam: (lastPage: ${dataT}, allPages: ${dataT}[], lastPageParam: TPageParam, allPageParams: TPageParam[]) => TPageParam | undefined | null; buildInit: (pageParam: unknown) => ${optionsType} }`;
+	const infiniteSig = [
+		...paramSig,
+		`options: ${optionsType} | undefined`,
+		paginationParam
+	].join(", ");
+	const infiniteQueryFnBody = `queryFn:async({pageParam,signal})=>{const overlay=pagination.buildInit(pageParam);const{data,error}=await ${callExpr}({...options,...overlay,query:{...options?.query,...overlay?.query},headers:{...options?.headers,...overlay?.headers},fetch:{...options?.fetch,...overlay?.fetch,signal}});if(error)throw error;return data},`;
+	const infiniteOptionsCode = `export function ${`${funcName}InfiniteQueryOptions`}<TPageParam>(${infiniteSig}){return infiniteQueryOptions<${dataT},${errorT},InfiniteData<${dataT},TPageParam>,${queryKeyType},TPageParam>({queryKey:${infiniteKeyCall},${infiniteQueryFnBody}initialPageParam:pagination.initialPageParam,getNextPageParam:pagination.getNextPageParam})}`;
+	const infiniteGenerics = `<TPageParam = unknown, TData = InfiniteData<${dataT}, TPageParam>, TError = ${errorT}>`;
+	const hookQueryFnBody = `queryFn:async({pageParam,signal}:QueryFunctionContext<${queryKeyType},TPageParam>)=>{const overlay=pagination.buildInit(pageParam);const{data,error}=await ${callExpr}({...options,...overlay,query:{...options?.query,...overlay?.query},headers:{...options?.headers,...overlay?.headers},fetch:{...options?.fetch,...overlay?.fetch,signal}});if(error)throw error;return data},`;
+	const inner = `${config.thunkOptionsCall ? "...queryOptions?.()" : "...queryOptions"},queryKey:${infiniteKeyCall},${hookQueryFnBody}initialPageParam:pagination.initialPageParam,getNextPageParam:pagination.getNextPageParam`;
+	const hookBody = (queryFn) => config.useThunk ? `${queryFn}(()=>({${inner}}))` : `${queryFn}({${inner}})`;
+	const hookSig = (libOptionsType) => {
+		const fullType = omitInjectedKeys(config, `${libOptionsType}<${dataT}, TError, TData, ${queryKeyType}, TPageParam>`, INFINITE_OMIT_KEYS);
+		return [infiniteSig, config.thunkOptionsCall ? `queryOptions?: () => ${fullType}` : `queryOptions?: ${fullType}`].join(", ");
+	};
+	const infiniteCode = `export function ${infiniteHookName}${infiniteGenerics}(${hookSig(config.infiniteOptionsType)}){return ${hookBody(config.infiniteQueryFn)}}`;
+	if (!config.suspenseInfiniteQueryFn) return [
+		infiniteKeyCode,
+		infiniteOptionsCode,
+		infiniteCode
+	];
+	return [
+		infiniteKeyCode,
+		infiniteOptionsCode,
+		infiniteCode,
+		`export function ${suspenseInfiniteHookName}${infiniteGenerics}(${hookSig(config.suspenseInfiniteOptionsType)}){return ${hookBody(config.suspenseInfiniteQueryFn)}}`
+	];
+}
+function makeInfiniteParts(config, args) {
+	if (config.hasInfiniteQueryOptionsHelper) return makeTanstackInfiniteParts(config, args);
+	const { funcName, hookName, keyPrefix, pathStr } = args;
+	const { paramSig, paramPass, optionsType, dataT, errorT, callExpr } = args;
+	const infiniteKeyName = `${funcName}InfiniteQueryKey`;
+	const infiniteKeyCode = `export function ${infiniteKeyName}(${[...paramSig, `options?: ${optionsType}`].join(", ")}){const{headers:_h,fetch:_f,throwHttpError:_t,...keyArgs}=options??{};return[${[
+		`'${keyPrefix}'`,
+		`'${pathStr}'`,
+		`'infinite'`,
+		...paramPass,
+		"keyArgs"
+	].join(", ")}]as const}`;
+	const infiniteKeyCall = `${infiniteKeyName}(${[...paramPass, "options"].join(", ")})`;
+	const infiniteHookName = `${hookName}Infinite`;
+	const infiniteGenerics = `<TPageParam = unknown, TData = InfiniteData<${dataT}, TPageParam>, TError = ${errorT}>`;
+	const infiniteQueryFnBlock = `queryFn:async({pageParam,signal}:QueryFunctionContext)=>{const overlay=pagination.buildInit(pageParam);const{data,error}=await ${callExpr}({...options,...overlay,query:{...options?.query,...overlay?.query},headers:{...options?.headers,...overlay?.headers},fetch:{...options?.fetch,...overlay?.fetch,signal}});if(error)throw error;return data},`;
+	const fullOptionsType = `${config.infiniteOptionsType}<${dataT}, TError, TData, ReturnType<typeof ${infiniteKeyName}>, TPageParam>`;
+	const infiniteHookSig = [
+		...paramSig,
+		`options: ${optionsType} | undefined`,
+		`pagination: { buildInit: (pageParam: unknown) => ${optionsType} }`,
+		`queryOptions: ${omitInjectedKeys(config, fullOptionsType, QUERY_OMIT_KEYS)}`
+	].join(", ");
+	const inner = `...queryOptions,queryKey:${infiniteKeyCall},${infiniteQueryFnBlock}`;
+	return [infiniteKeyCode, `export function ${infiniteHookName}${infiniteGenerics}(${infiniteHookSig}){return ${config.infiniteQueryFn}({${inner}})}`];
+}
+function makeSwrOperation(config, args) {
+	const { hookName, immutableHookName, keyName, keyPrefix, pathStr, method } = args;
+	const { paramSig, paramPass } = args;
+	const { argsType, optionsType, dataT, errorT, callExpr } = args;
+	const { isQuery, isBodyMethod, isPaginated, hasKeyArgs, optMark } = args;
+	if (isQuery) {
+		const keySig = (hasKeyArgs ? [...paramSig, `options?: ${optionsType}`] : paramSig).join(", ");
+		const keyTuple = [
+			`'${keyPrefix}'`,
+			`'${pathStr}'`,
+			...paramPass,
+			...hasKeyArgs ? ["keyArgs"] : []
+		].join(", ");
+		const keyCode = hasKeyArgs ? `export function ${keyName}(${keySig}){const{headers:_h,fetch:_f,throwHttpError:_t,...keyArgs}=options??{};return[${keyTuple}]as const}` : `export function ${keyName}(${keySig}){return[${keyTuple}]as const}`;
+		const keyCall = `${keyName}(${[...paramPass, ...hasKeyArgs ? ["options"] : []].join(", ")})`;
+		const generics = `<TError = ${errorT}>`;
+		const hookSig = [
+			...paramSig,
+			`options${optMark}: ${optionsType}`,
+			`config?: SWRConfiguration<${dataT}, TError>`
+		].join(", ");
+		const swrHook = (name, swrFn) => `export function ${name}${generics}(${hookSig}){return ${swrFn}<${dataT},TError>(${keyCall},async()=>{const{data,error}=await ${callExpr}(options);if(error)throw error;return data},config)}`;
+		const hookCode = config.immutableQueryFn ? `${swrHook(hookName, config.queryFn)}\n\n${swrHook(immutableHookName, config.immutableQueryFn)}` : swrHook(hookName, config.queryFn);
+		if (isPaginated) {
+			const infiniteHookName = `${hookName}Infinite`;
+			const infiniteHookSig = [
+				...paramSig,
+				`buildInit: (pageIndex: number, previousPage: ${dataT} | null) => ${optionsType} | null`,
+				`config?: SWRInfiniteConfiguration<${dataT}, TError>`
+			].join(", ");
+			const infiniteKeyTuple = [
+				`'${keyPrefix}'`,
+				`'${pathStr}'`,
+				`'infinite'`,
+				"pageIndex",
+				...paramPass,
+				"keyArgs"
+			].join(", ");
+			const fetcherDestructure = [
+				"_resource",
+				"_opId",
+				"_infinite",
+				"_pageIndex",
+				...paramPass.map((_, i) => `_key${i}`),
+				"keyArgs"
+			].join(", ");
+			return `${keyCode}\n\n${hookCode}\n\n${`export function ${infiniteHookName}${generics}(${infiniteHookSig}){${`const getKey=(pageIndex:number,previousPage:${dataT}|null)=>{const options=buildInit(pageIndex,previousPage);if(options===null)return null;const{headers:_h,fetch:_f,throwHttpError:_t,...keyArgs}=options??{};return[${infiniteKeyTuple}]as const}`};return useSWRInfinite<${dataT},TError,typeof getKey>(getKey,async([${fetcherDestructure}])=>{const{data,error}=await ${callExpr}(keyArgs);if(error)throw error;return data},config)}`}`;
+		}
+		return `${keyCode}\n\n${hookCode}`;
+	}
+	const keyCode = `export function ${keyName}(${paramSig.join(", ")}){return ${`[${[
+		`'${keyPrefix}'`,
+		`'${pathStr}'`,
+		`'${method.toUpperCase()}'`,
+		...paramPass
+	].join(", ")}] as const`}}`;
+	const keyCall = `${keyName}(${paramPass.join(", ")})`;
+	const variablesType = isBodyMethod ? `{ body: ${argsType}[0]; options${optMark}: ${argsType}[1] }` : `{ options${optMark}: ${argsType}[0] }`;
+	const triggerCallExpr = isBodyMethod ? `${callExpr}(arg.body, arg.options)` : `${callExpr}(arg.options)`;
+	return `${keyCode}\n\n${`export function ${hookName}${`<TError = ${errorT}>`}(${[...paramSig, `config?: SWRMutationConfiguration<${dataT}, TError, ReturnType<typeof ${keyName}>, ${variablesType}>`].join(", ")}){return useSWRMutation<${dataT},TError,ReturnType<typeof ${keyName}>,${variablesType}>(${keyCall},${`async(_key:ReturnType<typeof ${keyName}>,{arg}:{arg:${variablesType}})=>{const{data,error}=await ${triggerCallExpr};if(error)throw error;return data}`},config)}`}`;
+}
+function needsFetchHook(pathStr) {
+	return pathStr.split("/").filter(Boolean).some((seg) => seg.includes(".") || seg.includes("{") && !/^\{[^}]+\}$/u.test(seg));
+}
+function pathParamNames(pathStr) {
+	return [...pathStr.matchAll(/\{([^}]+)\}/gu)].map((m) => m[1] ?? "");
+}
+function successType(operation) {
+	const ok = Object.entries(operation.responses ?? {}).find(([status]) => status.startsWith("2"));
+	if (!ok) return { dataT: "void" };
+	const info = responseInfo(ok[1]);
+	if (info.ref) return {
+		dataT: pascalCase(info.ref),
+		importName: pascalCase(info.ref)
+	};
+	if (info.void) return { dataT: "void" };
+	return { dataT: "unknown" };
+}
+function fetchTypeImport(pathStr, operation) {
+	return needsFetchHook(pathStr) ? successType(operation).importName : void 0;
+}
+function makeFetchOperation(pathStr, method, operation, config) {
+	const funcName = toSafeIdentifier(resolveOperationId(operation, method, pathStr));
+	const Op = capitalize(funcName);
+	const hookName = `${config.hookPrefix}${Op}`;
+	const suspenseHookName = `${config.hookPrefix}Suspense${Op}`;
+	const immutableHookName = `${config.hookPrefix}Immutable${Op}`;
+	const keyPrefix = resourcePrefix(pathStr);
+	const isQuery = method === "get" || method === "head";
+	const params = pathParamNames(pathStr);
+	const paramSig = params.map((p) => `${p}: string`);
+	const paramPass = [...params];
+	const hasQuery = (operation.parameters ?? []).some((p) => "in" in p && p.in === "query");
+	const optionsType = hasQuery ? "{ headers?: Record<string, string>; query?: Record<string, unknown> }" : "{ headers?: Record<string, string> }";
+	const { dataT } = successType(operation);
+	const errorT = "unknown";
+	const urlInner = pathStr.replaceAll(/\{([^}]+)\}/gu, (_, n) => `\${encodeURIComponent(${n})}`);
+	const urlExpr = hasQuery ? `\`${urlInner}\${search.size ? \`?\${search}\` : ''}\`` : `\`${urlInner}\``;
+	const searchCode = (opt) => hasQuery ? `const search=new URLSearchParams();for(const[k,v]of Object.entries(${opt}?.query??{})){if(v===undefined)continue;if(Array.isArray(v)){for(const x of v){search.append(k,String(x))}}else{search.set(k,String(v))}}` : "";
+	const getBody = (returnAnnotation, opt, signal) => `${searchCode(opt)}const res=await fetch(${urlExpr},{headers:${opt}?.headers${signal ? ",signal" : ""}});if(!res.ok)throw await res.json();return JSON.parse(await res.text())`;
+	const keyArgsDecl = hasQuery ? "const{headers:_h,...keyArgs}=options??{};" : "";
+	const keyTuple = [
+		`'${keyPrefix}'`,
+		`'${pathStr}'`,
+		...paramPass,
+		...hasQuery ? ["keyArgs"] : []
+	].join(", ");
+	if (config.isSWR && isQuery) {
+		const keyName = `${funcName}QueryKey`;
+		const keyCode = `export function ${keyName}(${[...paramSig, `options?: ${optionsType}`].join(", ")}){${keyArgsDecl}return[${keyTuple}]as const}`;
+		const keyCall = `${keyName}(${[...paramPass, "options"].join(", ")})`;
+		const fetcher = `async():Promise<${dataT}>=>{${getBody(dataT, "options", false)}}`;
+		const hookSig = [
+			...paramSig,
+			`options?: ${optionsType}`,
+			`config?: SWRConfiguration<${dataT}, TError>`
+		].join(", ");
+		const swrHook = (name, swrFn) => `export function ${name}<TError=${errorT}>(${hookSig}){return ${swrFn}<${dataT},TError>(${keyCall},${fetcher},config)}`;
+		return `${keyCode}\n\n${config.immutableQueryFn ? `${swrHook(hookName, config.queryFn)}\n\n${swrHook(immutableHookName, config.immutableQueryFn)}` : swrHook(hookName, config.queryFn)}`;
+	}
+	const mutationBody = (opt, body) => `${searchCode(opt)}const res=await fetch(${urlExpr},{method:'${method.toUpperCase()}',headers:{'content-type':'application/json',...${opt}?.headers},body:${body}===undefined?undefined:JSON.stringify(${body})});if(!res.ok)throw await res.json();return JSON.parse(await res.text())`;
+	const variablesType = `{ body?: unknown; options?: ${optionsType} }`;
+	if (config.isSWR) {
+		const keyName = `${funcName}MutationKey`;
+		const keyExpr = `[${[
+			`'${keyPrefix}'`,
+			`'${pathStr}'`,
+			`'${method.toUpperCase()}'`,
+			...paramPass
+		].join(", ")}] as const`;
+		const keyCode = `export function ${keyName}(${paramSig.join(", ")}){return ${keyExpr}}`;
+		const keyCall = `${keyName}(${paramPass.join(", ")})`;
+		const triggerCb = `async(_key:ReturnType<typeof ${keyName}>,{arg}:{arg:${variablesType}}):Promise<${dataT}>=>{${mutationBody("arg.options", "arg.body")}}`;
+		return `${keyCode}\n\n${`export function ${hookName}<TError=${errorT}>(${[...paramSig, `config?: SWRMutationConfiguration<${dataT}, TError, ReturnType<typeof ${keyName}>, ${variablesType}>`].join(", ")}){return useSWRMutation<${dataT},TError,ReturnType<typeof ${keyName}>,${variablesType}>(${keyCall},${triggerCb},config)}`}`;
+	}
+	if (isQuery) {
+		const keyName = `${funcName}QueryKey`;
+		const keyCode = `export function ${keyName}(${[...paramSig, `options?: ${optionsType}`].join(", ")}){${keyArgsDecl}return[${keyTuple}]as const}`;
+		const keyCall = `${keyName}(${[...paramPass, "options"].join(", ")})`;
+		const queryFnBlock = `queryFn:async(${config.queryFnContext ? "{signal}:QueryFunctionContext" : "{signal}"}):Promise<${dataT}>=>{${getBody(dataT, "options", true)}},`;
+		const queryOptionsCode = `export function ${`${funcName}QueryOptions`}(${[...paramSig, `options?: ${optionsType}`].join(", ")}){return queryOptions({queryKey:${keyCall},queryFn:async({signal}):Promise<${dataT}>=>{${getBody(dataT, "options", true)}}})}`;
+		const generics = `<TData = ${dataT}, TError = ${errorT}>`;
+		const queryOptionsParam = makeGetQueryOptionsParam(config, dataT, keyName);
+		const parts = [
+			keyCode,
+			queryOptionsCode,
+			`export function ${hookName}${generics}(${[
+				...paramSig,
+				`options?: ${optionsType}`,
+				queryOptionsParam
+			].join(", ")}){return ${makeGetHookBody(config, dataT, keyCall, queryFnBlock)}}`
+		];
+		if (config.suspenseQueryFn) {
+			const suspenseHookCode = `export function ${suspenseHookName}${generics}(${[
+				...paramSig,
+				`options?: ${optionsType}`,
+				`queryOptions?: ${omitInjectedKeys(config, `${config.suspenseQueryOptionsType}<${dataT}, TError, TData>`, QUERY_OMIT_KEYS)}`
+			].join(", ")}){return ${config.suspenseQueryFn}<${dataT},TError,TData>({...queryOptions,queryKey:${keyCall},${queryFnBlock}})}`;
+			parts.push(suspenseHookCode);
+		}
+		return parts.join("\n\n");
+	}
+	const keyName = `${funcName}MutationKey`;
+	const keyExpr = `[${[
+		`'${keyPrefix}'`,
+		`'${pathStr}'`,
+		`'${method.toUpperCase()}'`,
+		...paramPass
+	].join(", ")}] as const`;
+	const keyCode = `export function ${keyName}(${paramSig.join(", ")}){return ${keyExpr}}`;
+	const keyCall = `${keyName}(${paramPass.join(", ")})`;
+	const mutationFnBlock = `mutationFn:async({body,options}):Promise<${dataT}>=>{${mutationBody("options", "body")}},`;
+	const mutationOptionsName = `${funcName}MutationOptions`;
+	const factoryCode = makeMutationFactoryCode(mutationOptionsName, paramSig.join(", "), keyCall, dataT, errorT, variablesType, mutationFnBlock);
+	const factoryCall = `${mutationOptionsName}<TError>(${paramPass.join(", ")})`;
+	const mutationOptionsParam = makeMutationOptionsParam(config, dataT, "TError", variablesType);
+	return `${keyCode}\n\n${factoryCode}\n\n${`export function ${hookName}<TError=${errorT}>(${[...paramSig, mutationOptionsParam].join(", ")}){return ${makeMutationHookBody(config, dataT, variablesType, factoryCall)}}`}`;
+}
+function makeOperation(pathStr, method, operation, client, config) {
+	if (needsFetchHook(pathStr)) return makeFetchOperation(pathStr, method, operation, config);
+	const funcName = toSafeIdentifier(resolveOperationId(operation, method, pathStr));
+	const Op = capitalize(funcName);
+	const hookName = `${config.hookPrefix}${Op}`;
+	const suspenseHookName = `${config.hookPrefix}Suspense${Op}`;
+	const immutableHookName = `${config.hookPrefix}Immutable${Op}`;
+	const isQuery = method === "get" || method === "head";
+	const keyName = `${funcName}${isQuery ? "QueryKey" : "MutationKey"}`;
+	const keyPrefix = resourcePrefix(pathStr);
+	const { callExpr, methodHostTypeExpr, paramArgs } = edenChain(pathStr, client, method);
+	const paramSig = paramArgs.map((p) => `${p.name}: ${p.typeExpr}`);
+	const paramPass = paramArgs.map((p) => p.name);
+	const argsType = `Parameters<${methodHostTypeExpr}>`;
+	const optionsType = `${argsType}[0]`;
+	const response = `Awaited<ReturnType<${methodHostTypeExpr}>>`;
+	const dataT = `Extract<${response}, { error: null }>['data']`;
+	const errorT = `Exclude<${response}['error'], null>`;
+	const isBodyMethod = method === "post" || method === "put" || method === "patch" || method === "delete";
+	const isPaginated = operation["x-pagination"] === true;
+	const hasKeyArgs = (operation.parameters ?? []).some((p) => "in" in p ? p.in === "query" : true);
+	const requiredOptions = (operation.parameters ?? []).some((p) => "in" in p && (p.in === "query" || p.in === "header") && p.required === true);
+	const optMark = requiredOptions ? "" : "?";
+	const optFetch = requiredOptions ? "options.fetch" : "options?.fetch";
+	if (config.isSWR) return makeSwrOperation(config, {
+		hookName,
+		immutableHookName,
+		keyName,
+		keyPrefix,
+		pathStr,
+		method,
+		paramSig,
+		paramPass,
+		argsType,
+		optionsType,
+		dataT,
+		errorT,
+		callExpr,
+		isQuery,
+		isBodyMethod,
+		isPaginated,
+		hasKeyArgs,
+		optMark
+	});
+	if (isQuery) {
+		const keySig = (hasKeyArgs ? [...paramSig, `options?: ${optionsType}`] : paramSig).join(", ");
+		const keyTuple = [
+			`'${keyPrefix}'`,
+			`'${pathStr}'`,
+			...paramPass,
+			...hasKeyArgs ? ["keyArgs"] : []
+		].join(", ");
+		const keyCode = hasKeyArgs ? `export function ${keyName}(${keySig}){const{headers:_h,fetch:_f,throwHttpError:_t,...keyArgs}=options??{};return[${keyTuple}]as const}` : `export function ${keyName}(${keySig}){return[${keyTuple}]as const}`;
+		const keyCall = `${keyName}(${[...paramPass, ...hasKeyArgs ? ["options"] : []].join(", ")})`;
+		const queryOptionsCode = `export function ${`${funcName}QueryOptions`}(${[...paramSig, `options${optMark}: ${optionsType}`].join(", ")}){return queryOptions({queryKey:${keyCall},queryFn:async({signal})=>{const{data,error}=await ${callExpr}({...options,fetch:{...${optFetch},signal}});if(error)throw error;return data}})}`;
+		const queryFnBlock = `queryFn:async(${config.queryFnContext ? "{signal}:QueryFunctionContext" : "{signal}"})=>{const{data,error}=await ${callExpr}({...options,fetch:{...${optFetch},signal}});if(error)throw error;return data},`;
+		const generics = `<TData = ${dataT}, TError = ${errorT}>`;
+		const queryOptionsParam = makeGetQueryOptionsParam(config, dataT, keyName);
+		const parts = [
+			keyCode,
+			queryOptionsCode,
+			`export function ${hookName}${generics}(${[
+				...paramSig,
+				`options${optMark}: ${optionsType}`,
+				queryOptionsParam
+			].join(", ")}){return ${makeGetHookBody(config, dataT, keyCall, queryFnBlock)}}`
+		];
+		if (config.suspenseQueryFn) {
+			const suspenseHookCode = `export function ${suspenseHookName}${generics}(${[
+				...paramSig,
+				`options${optMark}: ${optionsType}`,
+				`queryOptions?: ${omitInjectedKeys(config, `${config.suspenseQueryOptionsType}<${dataT}, TError, TData>`, QUERY_OMIT_KEYS)}`
+			].join(", ")}){return ${config.suspenseQueryFn}<${dataT},TError,TData>({...queryOptions,queryKey:${keyCall},${queryFnBlock}})}`;
+			parts.push(suspenseHookCode);
+		}
+		if (isPaginated) parts.push(...makeInfiniteParts(config, {
+			funcName,
+			hookName,
+			suspenseHookName,
+			keyPrefix,
+			pathStr,
+			paramSig,
+			paramPass,
+			optionsType,
+			dataT,
+			errorT,
+			callExpr
+		}));
+		return parts.join("\n\n");
+	}
+	const keySig = paramSig.join(", ");
+	const keyCode = `export function ${keyName}(${keySig}){return ${`[${[
+		`'${keyPrefix}'`,
+		`'${pathStr}'`,
+		`'${method.toUpperCase()}'`,
+		...paramPass
+	].join(", ")}] as const`}}`;
+	const keyCall = `${keyName}(${paramPass.join(", ")})`;
+	const variablesType = isBodyMethod ? `{ body: ${argsType}[0]; options${optMark}: ${argsType}[1] }` : `{ options${optMark}: ${argsType}[0] }`;
+	const mutationFnBlock = isBodyMethod ? `mutationFn:async({body,options})=>{const{data,error}=await ${callExpr}(body,options);if(error)throw error;return data},` : `mutationFn:async({options})=>{const{data,error}=await ${callExpr}(options);if(error)throw error;return data},`;
+	const mutationOptionsName = `${funcName}MutationOptions`;
+	const factoryCode = makeMutationFactoryCode(mutationOptionsName, keySig, keyCall, dataT, errorT, variablesType, mutationFnBlock);
+	const factoryCall = `${mutationOptionsName}<TError>(${paramPass.join(", ")})`;
+	const mutationGenerics = `<TError = ${errorT}>`;
+	const mutationOptionsParam = makeMutationOptionsParam(config, dataT, "TError", variablesType);
+	return `${keyCode}\n\n${factoryCode}\n\n${`export function ${hookName}${mutationGenerics}(${[...paramSig, mutationOptionsParam].join(", ")}){return ${makeMutationHookBody(config, dataT, variablesType, factoryCall)}}`}`;
+}
+function makeSwrHeader(config, client, importPath, deps) {
+	return `${deps.isQuery ? `import useSWR from 'swr'\nimport type { SWRConfiguration } from 'swr'\n` : ""}${deps.isQuery && config.immutableQueryFn ? `import ${config.immutableQueryFn} from 'swr/immutable'\n` : ""}${deps.isInfinite ? `import useSWRInfinite from 'swr/infinite'\nimport type { SWRInfiniteConfiguration } from 'swr/infinite'\n` : ""}${deps.isMutation ? `import useSWRMutation from 'swr/mutation'\nimport type { SWRMutationConfiguration } from 'swr/mutation'\n` : ""}import { ${client} } from '${importPath}'\n\n`;
+}
+function makeHeader(config, client, importPath, deps) {
+	if (config.isSWR) return makeSwrHeader(config, client, importPath, deps);
+	const pkg = config.packageName;
+	const suspenseValue = config.suspenseQueryFn ? `, ${config.suspenseQueryFn}` : "";
+	const suspenseType = config.suspenseQueryOptionsType ? `, ${config.suspenseQueryOptionsType}` : "";
+	const suspenseInfiniteValue = config.suspenseInfiniteQueryFn ? `, ${config.suspenseInfiniteQueryFn}` : "";
+	const suspenseInfiniteType = config.suspenseInfiniteOptionsType ? `, ${config.suspenseInfiniteOptionsType}` : "";
+	return `${deps.isQuery ? `import { ${config.queryFn}${suspenseValue}, queryOptions } from '${pkg}'\n` : ""}${deps.isQuery ? `import type { ${config.queryOptionsType}${suspenseType} } from '${pkg}'\n` : ""}${deps.isInfinite ? config.hasInfiniteQueryOptionsHelper ? `import { ${config.infiniteQueryFn}${suspenseInfiniteValue}, infiniteQueryOptions } from '${pkg}'\n` : `import { ${config.infiniteQueryFn}${suspenseInfiniteValue} } from '${pkg}'\n` : ""}${deps.isInfinite ? `import type { ${config.infiniteOptionsType}, InfiniteData${suspenseInfiniteType} } from '${pkg}'\n` : ""}${deps.isMutation ? `import { ${config.mutationFn}, mutationOptions } from '${pkg}'\n` : ""}${deps.isMutation ? `import type { ${config.mutationOptionsType} } from '${pkg}'\n` : ""}${config.queryFnContext && deps.isQuery || deps.isInfinite ? `import type { QueryFunctionContext } from '${pkg}'\n` : ""}import { ${client} } from '${importPath}'\n\n`;
+}
+function makeQueryHooks(openAPI, output, importPath, config, client, basePath, split = false) {
+	return Effect.gen(function* () {
+		const prefix = basePath && basePath !== "/" ? basePath : "";
+		const ops = [];
+		for (const [pathStr, pathItem] of pathEntries(openAPI)) {
+			if (!pathItem) continue;
+			for (const method of HTTP_METHODS) {
+				const rawOperation = pathItem[method];
+				if (!rawOperation) continue;
+				const operation = resolveOperation(rawOperation, openAPI.components);
+				const funcName = toSafeIdentifier(resolveOperationId(operation, method, `${prefix}${pathStr}`));
+				const code = makeOperation(`${prefix}${pathStr}`, method, operation, client, config);
+				const keyPrefix = resourcePrefix(`${prefix}${pathStr}`);
+				const isQuery = method === "get" || method === "head";
+				ops.push({
+					funcName,
+					code,
+					prefix: keyPrefix,
+					deps: {
+						isQuery,
+						isInfinite: isQuery && operation["x-pagination"] === true,
+						isMutation: !isQuery
+					},
+					fetchType: fetchTypeImport(`${prefix}${pathStr}`, operation)
+				});
+			}
+		}
+		if (ops.length === 0) return "No operations found";
+		if (split) {
+			const prefixKeys = makePrefixKeyCodes(openAPI, prefix);
+			const keysCode = prefixKeys.length > 0 ? `${prefixKeys.join("\n\n")}\n` : "";
+			if (keysCode && ops.some((op) => op.funcName === "keys")) return yield* new GenerateError({ message: "Operation file name 'keys.ts' collides with the aggregated cache-key file. Rename the operation (operationId) that resolves to 'keys'." });
+			for (const op of ops) {
+				const header = makeHeader(config, client, importPath, op.deps);
+				const typeImport = op.fetchType ? `import type { ${op.fetchType} } from '../components/schemas'\n` : "";
+				const file = path.join(output, `${op.funcName}.ts`);
+				yield* emit(`${typeImport}${header}${op.code}\n`, output, file);
+			}
+			if (keysCode) yield* emit(keysCode, output, path.join(output, "keys.ts"));
+			yield* emit(`${[...keysCode ? [`export * from './keys'`] : [], ...ops.map((op) => `export * from './${op.funcName}'`)].join("\n")}\n`, output, path.join(output, "index.ts"));
+			return `Generated split ${config.label} code → ${output}/`;
+		}
+		yield* emit(`${makeHeader(config, client, importPath, ops.reduce((acc, op) => ({
+			isQuery: acc.isQuery || op.deps.isQuery,
+			isInfinite: acc.isInfinite || op.deps.isInfinite,
+			isMutation: acc.isMutation || op.deps.isMutation
+		}), {
+			isQuery: false,
+			isInfinite: false,
+			isMutation: false
+		}))}${`${[...makePrefixKeyCodes(openAPI, prefix), ...ops.map((op) => op.code)].join("\n\n")}\n`}`, path.dirname(output), output);
+		return `Generated ${config.label} code written to ${output}`;
+	});
+}
+//#endregion
+//#region src/core/hooks/index.ts
+const TANSTACK = {
+	label: "tanstack-query",
+	packageName: "@tanstack/react-query",
+	hookPrefix: "use",
+	queryFn: "useQuery",
+	mutationFn: "useMutation",
+	infiniteQueryFn: "useInfiniteQuery",
+	useQueryGenerics: true,
+	hasInfiniteQueryOptionsHelper: true,
+	suspenseQueryFn: "useSuspenseQuery",
+	suspenseInfiniteQueryFn: "useSuspenseInfiniteQuery",
+	queryOptionsType: "UseQueryOptions",
+	suspenseQueryOptionsType: "UseSuspenseQueryOptions",
+	mutationOptionsType: "UseMutationOptions",
+	infiniteOptionsType: "UseInfiniteQueryOptions",
+	suspenseInfiniteOptionsType: "UseSuspenseInfiniteQueryOptions"
+};
+const HOOK_CONFIGS = {
+	swr: {
+		label: "swr",
+		packageName: "swr",
+		hookPrefix: "use",
+		queryFn: "useSWR",
+		mutationFn: "useSWRMutation",
+		infiniteQueryFn: "useSWRInfinite",
+		immutableQueryFn: "useSWRImmutable",
+		isSWR: true
+	},
+	"tanstack-query": TANSTACK,
+	"preact-query": {
+		...TANSTACK,
+		label: "preact-query",
+		packageName: "@tanstack/preact-query"
+	},
+	"vue-query": {
+		label: "vue-query",
+		packageName: "@tanstack/vue-query",
+		hookPrefix: "use",
+		queryFn: "useQuery",
+		mutationFn: "useMutation",
+		infiniteQueryFn: "useInfiniteQuery",
+		queryFnContext: true,
+		maybeRefOptions: true,
+		queryOptionsType: "UseQueryOptions",
+		mutationOptionsType: "UseMutationOptions",
+		infiniteOptionsType: "UseInfiniteQueryOptions"
+	},
+	"solid-query": {
+		label: "solid-query",
+		packageName: "@tanstack/solid-query",
+		hookPrefix: "create",
+		queryFn: "createQuery",
+		mutationFn: "createMutation",
+		infiniteQueryFn: "createInfiniteQuery",
+		queryFnContext: true,
+		useThunk: true,
+		thunkOptionsCall: true,
+		unwrapOptionsAccessor: true,
+		hasInfiniteQueryOptionsHelper: true,
+		queryOptionsType: "UndefinedInitialDataOptions",
+		mutationOptionsType: "CreateMutationOptions",
+		infiniteOptionsType: "UndefinedInitialDataInfiniteOptions"
+	},
+	"svelte-query": {
+		label: "svelte-query",
+		packageName: "@tanstack/svelte-query",
+		hookPrefix: "create",
+		queryFn: "createQuery",
+		mutationFn: "createMutation",
+		infiniteQueryFn: "createInfiniteQuery",
+		queryFnContext: true,
+		useThunk: true,
+		hasInfiniteQueryOptionsHelper: true,
+		queryOptionsType: "CreateQueryOptions",
+		mutationOptionsType: "CreateMutationOptions",
+		infiniteOptionsType: "CreateInfiniteQueryOptions"
+	},
+	"angular-query": {
+		label: "angular-query",
+		packageName: "@tanstack/angular-query-experimental",
+		hookPrefix: "inject",
+		queryFn: "injectQuery",
+		mutationFn: "injectMutation",
+		infiniteQueryFn: "injectInfiniteQuery",
+		queryFnContext: true,
+		useThunk: true,
+		hasInfiniteQueryOptionsHelper: true,
+		queryOptionsType: "CreateQueryOptions",
+		mutationOptionsType: "CreateMutationOptions",
+		infiniteOptionsType: "CreateInfiniteQueryOptions"
+	}
+};
+function hooks(openAPI, output, importPath, library, options) {
+	return makeQueryHooks(openAPI, output, importPath, HOOK_CONFIGS[library], options.client, options.basePath, options.split);
+}
+//#endregion
+//#region src/helper/faker.ts
+function hasNumericConstraint(schema) {
+	return schema.minimum !== void 0 || schema.maximum !== void 0 || schema.exclusiveMinimum !== void 0 || schema.exclusiveMaximum !== void 0 || schema.multipleOf !== void 0;
+}
+function hasStringConstraint(schema) {
+	return schema.minLength !== void 0 || schema.maxLength !== void 0 || schema.pattern !== void 0;
+}
+function numericFakerExpr(schema, isInt) {
+	const bounds = normalizeBounds(schema);
+	const epsilon = isInt ? 1 : .01;
+	const lo = bounds.exclusiveMinimum !== void 0 ? bounds.exclusiveMinimum + epsilon : bounds.minimum ?? 1;
+	const hi = Math.max(lo, bounds.exclusiveMaximum !== void 0 ? bounds.exclusiveMaximum - epsilon : bounds.maximum ?? 1e3);
+	const multipleOf = schema.multipleOf;
+	if (multipleOf !== void 0 && multipleOf > 0) {
+		const kMin = Math.ceil(lo / multipleOf);
+		return `faker.number.int({ min: ${kMin}, max: ${Math.max(kMin, Math.floor(hi / multipleOf))} }) * ${multipleOf}`;
+	}
+	if (isInt) return `faker.number.int({ min: ${lo}, max: ${hi} })`;
+	return `faker.number.float({ min: ${lo}, max: ${hi}, fractionDigits: 2 })`;
+}
+/**
+* Rewrites a `pattern` into the string `faker.helpers.fromRegExp` samples.
+*
+* faker strips `^`/`$` only from a `RegExp` argument; given a string it copies them into the
+* value (`^abc$`), which then fails the very pattern it was drawn from. The anchors are removed
+* here instead, together with the no-op `\/` escape that faker would copy verbatim as well.
+*/
+function fakerPattern(pattern) {
+	return pattern.replace(/^\^+/u, "").replace(/(?<!\\)(?:\\\\)*\$+$/u, (anchor) => anchor.replaceAll("$", "")).replaceAll(/\\([\s\S])/gu, (match, escaped) => escaped === "/" ? "/" : match);
+}
+function stringFakerExpr(schema) {
+	if (schema.pattern !== void 0) return `faker.helpers.fromRegExp(${JSON.stringify(fakerPattern(schema.pattern))})`;
+	const lower = schema.minLength ?? 5;
+	const max = schema.maxLength ?? Math.max(lower, 20);
+	return `faker.string.alpha({ length: { min: ${Math.min(lower, max)}, max: ${max} } })`;
+}
+function arrayLengthExpr(schema, options = {}) {
+	const min = schema.minItems ?? Math.min(options.arrayMin ?? 1, schema.maxItems ?? Infinity);
+	return `faker.number.int({ min: ${min}, max: ${Math.max(schema.maxItems ?? options.arrayMax ?? 5, min)} })`;
+}
+const NON_EXISTENT_CEIL = 2147483647;
+function primaryType$2(schema) {
+	const type = schema.type;
+	if (Array.isArray(type)) return type.find((t) => t !== "null") ?? type[0];
+	return type;
+}
+function nonExistentNumber(schema, isInt) {
+	const bounds = normalizeBounds(schema);
+	const epsilon = isInt ? 1 : .01;
+	const lo = bounds.exclusiveMinimum !== void 0 ? bounds.exclusiveMinimum + epsilon : bounds.minimum ?? Number.NEGATIVE_INFINITY;
+	const hiRaw = bounds.exclusiveMaximum !== void 0 ? bounds.exclusiveMaximum - epsilon : bounds.maximum;
+	const hi = hiRaw ?? Math.max(lo === Number.NEGATIVE_INFINITY ? NON_EXISTENT_CEIL : lo, NON_EXISTENT_CEIL);
+	const multipleOf = schema.multipleOf;
+	if (multipleOf !== void 0 && multipleOf > 0) {
+		const value = lo === Number.NEGATIVE_INFINITY ? Math.floor(NON_EXISTENT_CEIL / multipleOf) * multipleOf : Math.ceil(lo / multipleOf) * multipleOf;
+		if (value < lo || hiRaw !== void 0 && value > hi) return void 0;
+		return String(value);
+	}
+	const value = isInt ? Math.floor(hi) : hi;
+	if (value < lo) return void 0;
+	return String(value);
+}
+function nonExistentStringLiteral(schema) {
+	const base = "__non_existent__";
+	const min = schema.minLength ?? 0;
+	const max = schema.maxLength ?? Math.max(16, min);
+	if (16 > max) return "x".repeat(max);
+	if (16 < min) return base + "x".repeat(min - 16);
+	return base;
+}
+function nonExistentPathValue(schema) {
+	if (schema.enum !== void 0 || schema.const !== void 0) return void 0;
+	const type = primaryType$2(schema);
+	if (type === "integer" || type === "number") {
+		const value = nonExistentNumber(schema, type === "integer");
+		return value === void 0 ? void 0 : {
+			kind: "literal",
+			value
+		};
+	}
+	if (schema.format === "uuid") return {
+		kind: "literal",
+		value: "00000000-0000-0000-0000-000000000000"
+	};
+	if (schema.pattern !== void 0) return {
+		kind: "expr",
+		code: `faker.helpers.fromRegExp(${JSON.stringify(fakerPattern(schema.pattern))})`
+	};
+	return {
+		kind: "literal",
+		value: nonExistentStringLiteral(schema)
+	};
+}
+//#endregion
+//#region src/generator/faker/index.ts
+function safeObjectKey(key) {
+	return /^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(key) ? key : JSON.stringify(key);
+}
+function mockName(schemaName) {
+	return `mock${schemaName.replaceAll(".", "").replaceAll(/[^A-Za-z0-9_$]/gu, "_")}`;
+}
+const FORMAT_TO_FAKER = {
+	date: "faker.date.past().toISOString().slice(0, 10)",
+	"date-time": "faker.date.past().toISOString()",
+	time: "faker.date.past().toISOString().slice(11)",
+	uri: "faker.internet.url()",
+	url: "faker.internet.url()",
+	email: "faker.internet.email()",
+	ipv4: "faker.internet.ipv4()",
+	ipv6: "faker.internet.ipv6()",
+	hostname: "faker.internet.domainName()",
+	uuid: "faker.string.uuid()",
+	password: "faker.internet.password()",
+	binary: "new Blob([faker.string.alphanumeric(100)])",
+	byte: "btoa(faker.string.alphanumeric(10))",
+	int32: "faker.number.int({ min: -2147483648, max: 2147483647 })",
+	int64: "faker.number.int({ min: Number.MIN_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER })",
+	float: "faker.number.float({ min: 0, max: 1000, fractionDigits: 2 })",
+	double: "faker.number.float({ min: 0, max: 1000000, fractionDigits: 4 })",
+	"iso-time": "faker.date.past().toISOString().slice(11, 19)",
+	"iso-date-time": "faker.date.past().toISOString()",
+	duration: "`P${faker.number.int({ min: 1, max: 30 })}D`",
+	"uri-reference": "faker.internet.url()",
+	"uri-template": "faker.internet.url()",
+	"json-pointer": "`/${faker.string.alpha(8)}`",
+	"json-pointer-uri-fragment": "`#/${faker.string.alpha(8)}`",
+	"relative-json-pointer": "`0/${faker.string.alpha(8)}`",
+	iri: "faker.internet.url()",
+	"iri-reference": "faker.internet.url()",
+	"idn-email": "faker.internet.email()",
+	"idn-hostname": "faker.internet.domainName()",
+	uuidv4: "faker.string.uuid({ version: 4 })",
+	uuidv7: "faker.string.uuid({ version: 7 })",
+	ulid: "faker.string.ulid()",
+	nanoid: "faker.string.nanoid()",
+	jwt: "faker.internet.jwt()",
+	emoji: "faker.internet.emoji()",
+	mac: "faker.internet.mac()",
+	e164: "faker.phone.number({ style: 'international' })",
+	decimal: "faker.commerce.price()"
+};
+const TYPE_TO_FAKER = {
+	string: "faker.string.alpha({ length: { min: 5, max: 20 } })",
+	number: "faker.number.float({ min: 0, max: 1000, fractionDigits: 2 })",
+	integer: "faker.number.int({ min: 1, max: 1000 })",
+	boolean: "faker.datatype.boolean()",
+	date: "faker.date.past().toISOString()",
+	null: "null"
+};
+const PROPERTY_NAME_TO_FAKER = {
+	id: "faker.number.int({ min: 1, max: 99999 })",
+	uuid: "faker.string.uuid()",
+	email: "faker.internet.email()",
+	name: "faker.person.fullName()",
+	firstName: "faker.person.firstName()",
+	lastName: "faker.person.lastName()",
+	username: "faker.internet.username()",
+	password: "faker.internet.password()",
+	phone: "faker.phone.number()",
+	address: "faker.location.streetAddress()",
+	city: "faker.location.city()",
+	state: "faker.location.state()",
+	country: "faker.location.country()",
+	zip: "faker.location.zipCode()",
+	zipCode: "faker.location.zipCode()",
+	url: "faker.internet.url()",
+	website: "faker.internet.url()",
+	createdAt: "faker.date.past().toISOString()",
+	updatedAt: "faker.date.recent().toISOString()",
+	deletedAt: "faker.date.past().toISOString()",
+	title: "faker.lorem.sentence()",
+	description: "faker.lorem.paragraph()",
+	content: "faker.lorem.paragraphs(2)",
+	status: "faker.helpers.arrayElement(['active', 'inactive', 'pending'])",
+	type: "faker.helpers.arrayElement(['A', 'B', 'C'])",
+	price: "faker.number.float({ min: 1, max: 10000, fractionDigits: 2 })",
+	quantity: "faker.number.int({ min: 1, max: 100 })",
+	count: "faker.number.int({ min: 0, max: 1000 })",
+	age: "faker.number.int({ min: 1, max: 120 })"
+};
+function lookup(table, key) {
+	return Object.hasOwn(table, key) ? table[key] : void 0;
+}
+function isHintCompatible(type, expr) {
+	if (type === void 0) return true;
+	const isInt = expr.startsWith("faker.number.int(");
+	if (type === "integer") return isInt;
+	if (type === "number") return isInt || expr.startsWith("faker.number.float(");
+	if (type === "string") return !expr.startsWith("faker.number.");
+	return false;
+}
+function propertyNameHint(propertyName) {
+	return lookup(PROPERTY_NAME_TO_FAKER, propertyName) ?? lookup(PROPERTY_NAME_TO_FAKER, propertyName.replaceAll(/[_-]+([a-zA-Z0-9])/gu, (_, c) => c.toUpperCase()));
+}
+function primaryType$1(type) {
+	if (isTypeArray(type)) return type.find((t) => t !== "null") ?? type[0];
+	return type;
+}
+function isNullType(type) {
+	return isTypeArray(type) ? type.includes("null") : type === "null";
+}
+function schemaExample(schema) {
+	if (schema.example !== void 0) return schema.example;
+	return Array.isArray(schema.examples) ? schema.examples[0] : void 0;
+}
+function exampleLiteral(schema) {
+	const example = schemaExample(schema);
+	if (example === void 0 || schema.$ref !== void 0) return void 0;
+	const types = isTypeArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
+	if (types.length === 0 && !schema.enum) return void 0;
+	const isAccepted = (type) => types.length === 0 || types.includes(type);
+	if (example === null) return isAccepted("null") || schema.nullable ? "null" : void 0;
+	if (schema.enum && !schema.enum.some((member) => member === example)) return void 0;
+	const asConst = schema.enum ? " as const" : "";
+	if (typeof example === "string") return isAccepted("string") && schema.format !== "binary" ? `${JSON.stringify(example)}${asConst}` : void 0;
+	if (typeof example === "number") {
+		if (!(isAccepted("number") || isAccepted("integer") && Number.isInteger(example))) return;
+		return `${JSON.stringify(example)}${asConst}`;
+	}
+	if (typeof example === "boolean") return isAccepted("boolean") ? `${String(example)}${asConst}` : void 0;
+}
+function schemaToFaker(schema, propertyName, options = {}) {
+	if (schema.const !== void 0) return `${JSON.stringify(schema.const)} as const`;
+	if (options.useExamples) {
+		const example = exampleLiteral(schema);
+		if (example !== void 0) return example;
+	}
+	if (schema.enum && schema.enum.length > 0) return `faker.helpers.arrayElement([${schema.enum.map((v) => JSON.stringify(v)).join(", ")}] as const)`;
+	if (schema.$ref) return `${mockName(schema.$ref.split("/").pop() || "unknown")}()`;
+	if (isTypeArray(schema.type)) {
+		const type = primaryType$1(schema.type);
+		if (type === void 0 || type === "null") return "null";
+		const value = schemaToFaker({
+			...schema,
+			type
+		}, propertyName, options);
+		return schema.type.includes("null") ? `faker.helpers.arrayElement([${value}, null])` : value;
+	}
+	const type = primaryType$1(schema.type);
+	if (type === "array" && schema.items) {
+		const itemSchema = isSchemaArray(schema.items) ? schema.items[0] : schema.items;
+		if (!itemSchema) return "[]";
+		const itemFaker = schemaToFaker(itemSchema, void 0, options);
+		return `Array.from({ length: ${arrayLengthExpr(schema, options)} }, () => (${itemFaker}))`;
+	}
+	const renderProps = (properties, required) => {
+		const requiredSet = new Set(required);
+		return Object.entries(properties).map(([k, v]) => {
+			const key = safeObjectKey(k);
+			const value = schemaToFaker(v, k, options);
+			const isNullable = v.nullable === true || isNullType(v.type);
+			if (!(requiredSet.has(k) || isNullable)) return `${key}: faker.helpers.arrayElement([${value}, undefined])`;
+			if (v.nullable) return `${key}: faker.helpers.arrayElement([${value}, null])`;
+			return `${key}: ${value}`;
+		}).join(", ");
+	};
+	if (type === "object" && schema.properties) return `{ ${renderProps(schema.properties, schema.required)} }`;
+	if (type === "object" && !schema.properties && schema.additionalProperties) {
+		if (typeof schema.additionalProperties === "boolean" || schema.propertyNames !== void 0 || schema.patternProperties !== void 0) return "{}";
+		const value = schemaToFaker(schema.additionalProperties, void 0, options);
+		const max = schema.maxProperties ?? Math.max(schema.minProperties ?? 1, 3);
+		return `Object.fromEntries(Array.from({ length: faker.number.int({ min: ${schema.minProperties ?? Math.min(1, max)}, max: ${max} }) }, () => [faker.string.alpha(8), ${value}] satisfies [string, unknown]))`;
+	}
+	if (schema.allOf && schema.allOf.length > 0) {
+		const merged = schema.allOf.map((s) => schemaToFaker(s, propertyName, options)).map((m) => `...${m}`).join(", ");
+		if (schema.properties) return `{ ${merged}, ${renderProps(schema.properties, schema.required)} }`;
+		return `{ ${merged} }`;
+	}
+	const union = schema.oneOf && schema.oneOf.length > 0 ? schema.oneOf : schema.anyOf && schema.anyOf.length > 0 ? schema.anyOf : void 0;
+	if (union) return `faker.helpers.arrayElement([${union.map((s) => schemaToFaker(s, propertyName, options)).join(", ")}])`;
+	const constrainedNumeric = (type === "integer" || type === "number") && hasNumericConstraint(schema);
+	const constrainedString = type === "string" && hasStringConstraint(schema);
+	const formatFaker = schema.format ? lookup(FORMAT_TO_FAKER, schema.format) : void 0;
+	if (formatFaker && !constrainedNumeric && isHintCompatible(type, formatFaker)) return formatFaker;
+	const nameHint = propertyName ? propertyNameHint(propertyName) : void 0;
+	if (nameHint && !constrainedNumeric && !constrainedString && isHintCompatible(type, nameHint)) return nameHint;
+	if (type === "string") return stringFakerExpr(schema);
+	if (type === "integer") return numericFakerExpr(schema, true);
+	if (type === "number") return numericFakerExpr(schema, false);
+	if (type === "object") return "{}";
+	if (type === "array") return "[]";
+	return (type ? lookup(TYPE_TO_FAKER, type) : void 0) ?? "undefined";
+}
+function collectSchemaRefs(schema, schemas, visited = /* @__PURE__ */ new Set()) {
+	if (schema.$ref) {
+		const refName = schema.$ref.replace("#/components/schemas/", "");
+		if (visited.has(refName)) return [];
+		visited.add(refName);
+		const referenced = schemas?.[refName];
+		return [refName, ...referenced ? collectSchemaRefs(referenced, schemas, visited) : []];
+	}
+	const propRefs = schema.properties ? Object.values(schema.properties).flatMap((p) => collectSchemaRefs(p, schemas, visited)) : [];
+	const itemRefs = (schema.items ? isSchemaArray(schema.items) ? schema.items : [schema.items] : []).flatMap((item) => collectSchemaRefs(item, schemas, visited));
+	const compositeRefs = [
+		"allOf",
+		"oneOf",
+		"anyOf"
+	].flatMap((k) => {
+		const composite = schema[k];
+		return composite ? composite.flatMap((sub) => collectSchemaRefs(sub, schemas, visited)) : [];
+	});
+	return [
+		...propRefs,
+		...itemRefs,
+		...compositeRefs
+	];
+}
+function shallowRefs(schema) {
+	const selfRef = schema.$ref ? [schema.$ref.replace("#/components/schemas/", "")] : [];
+	const propRefs = schema.properties ? Object.values(schema.properties).flatMap(shallowRefs) : [];
+	const itemRefs = (schema.items ? Array.isArray(schema.items) ? schema.items : [schema.items] : []).flatMap(shallowRefs);
+	const compositeRefs = [
+		"allOf",
+		"oneOf",
+		"anyOf"
+	].flatMap((k) => {
+		const composite = schema[k];
+		return composite ? composite.flatMap(shallowRefs) : [];
+	});
+	return [
+		...selfRef,
+		...propRefs,
+		...itemRefs,
+		...compositeRefs
+	];
+}
+function reachesSelf(start, target, schemas, visited = /* @__PURE__ */ new Set()) {
+	if (start === target) return true;
+	if (visited.has(start)) return false;
+	visited.add(start);
+	const schema = schemas[start];
+	if (!schema) return false;
+	return shallowRefs(schema).some((dep) => reachesSelf(dep, target, schemas, visited));
+}
+function detectCircularSchemas(schemas) {
+	return new Set(Object.keys(schemas).filter((name) => {
+		const schema = schemas[name];
+		if (!schema) return false;
+		return shallowRefs(schema).some((dep) => reachesSelf(dep, name, schemas));
+	}));
+}
+function topologicalOrder(usedSchemaNames, schemas) {
+	const visit = (name, visited, visiting) => {
+		if (visited.has(name) || !usedSchemaNames.has(name) || visiting.has(name)) return [];
+		const nextVisiting = new Set(visiting).add(name);
+		const schema = schemas[name];
+		const depOrder = schema ? collectSchemaRefs(schema, schemas, new Set([name])).flatMap((dep) => {
+			const subOrder = visit(dep, visited, nextVisiting);
+			for (const n of subOrder) visited.add(n);
+			return subOrder;
+		}) : [];
+		visited.add(name);
+		return [...depOrder, name];
+	};
+	const visited = /* @__PURE__ */ new Set();
+	return [...usedSchemaNames].flatMap((name) => visit(name, visited, /* @__PURE__ */ new Set()));
+}
+function makeMockFunctions(spec, usedSchemaNames, options = {}) {
+	if (!spec.components?.schemas || usedSchemaNames.size === 0) return "";
+	const schemas = spec.components.schemas;
+	const circular = detectCircularSchemas(schemas);
+	return topologicalOrder(usedSchemaNames, schemas).map((name) => {
+		const schema = schemas[name];
+		const returnType = circular.has(name) ? ": any" : "";
+		const value = schema ? schemaToFaker(schema, void 0, options) : "undefined";
+		return `function ${mockName(name)}()${returnType} {\n  return ${value}\n}`;
+	}).join("\n\n");
+}
+//#endregion
+//#region src/generator/mock/index.ts
+const SEED_REF_DATE = "2025-01-01T00:00:00.000Z";
+function normalizeKey(key) {
+	return /^[1-5]xx$/iu.test(key) ? key.toUpperCase() : key;
+}
+function pickSuccessResponse(responses) {
+	const keys = Object.keys(responses);
+	const [status] = keys.filter((k) => /^2\d\d$/u.test(k)).map((k) => Number.parseInt(k, 10)).toSorted((a, b) => a - b);
+	if (status !== void 0) return {
+		key: String(status),
+		status,
+		response: responses[String(status)]
+	};
+	const wildcard = [
+		"2XX",
+		"2xx",
+		"default"
+	].find((k) => k in responses);
+	if (wildcard) return {
+		key: normalizeKey(wildcard),
+		status: 200,
+		response: responses[wildcard]
+	};
+	const first = keys[0];
+	if (first === void 0) return {
+		key: "200",
+		status: 200,
+		response: void 0
+	};
+	const parsed = Number.parseInt(first, 10);
+	return {
+		key: normalizeKey(first),
+		status: Number.isNaN(parsed) ? 200 : parsed,
+		response: responses[first]
+	};
+}
+/**
+* The example a media type declares, if it declares one.
+*
+* `example` wins over `examples`, and the first `examples` entry wins over the rest — a document
+* that lists several is showing variants of one realistic response, and a mock only serves one.
+* A `$ref` entry resolves against `components.examples`; an entry that only carries
+* `externalValue` has nothing to serve, so it falls through to faker.
+*/
+function mediaExample(media, components) {
+	if (!isRecord(media)) return void 0;
+	if (media.example !== void 0) return media.example;
+	if (!isRecord(media.examples)) return void 0;
+	return exampleEntryValue(Object.values(media.examples)[0], components);
+}
+function exampleEntryValue(entry, components) {
+	if (!isRecord(entry)) return void 0;
+	const ref = entry.$ref;
+	const resolved = typeof ref === "string" ? components?.examples?.[ref.replace("#/components/examples/", "")] : entry;
+	return isRecord(resolved) ? resolved.value : void 0;
+}
+function namedExamples(media, components) {
+	if (!isRecord(media) || !isRecord(media.examples)) return [];
+	return Object.entries(media.examples).flatMap(([name, entry]) => {
+		const value = exampleEntryValue(entry, components);
+		return value === void 0 ? [] : [[name, value]];
+	});
+}
+function jsonMediaType(content) {
+	const types = Object.keys(content ?? {});
+	return types.includes("application/json") ? "application/json" : types.find((type) => /^application\/(?:[\w.-]+\+)?json(?:;|$)/u.test(type));
+}
+function responseBody(response, example, fakerOptions) {
+	const content = response?.content;
+	if (!content) return {
+		kind: "empty",
+		expr: ""
+	};
+	const jsonType = jsonMediaType(content);
+	const json = jsonType ? content[jsonType] : void 0;
+	if (jsonType && json) {
+		if (example !== void 0) return {
+			kind: "json",
+			expr: JSON.stringify(example),
+			mediaType: jsonType
+		};
+		if (isMediaWithSchema(json)) return {
+			kind: "json",
+			expr: schemaToFaker(json.schema, void 0, fakerOptions),
+			mediaType: jsonType
+		};
+	}
+	const text = content["text/plain"];
+	if (text) {
+		if (typeof example === "string") return {
+			kind: "text",
+			expr: JSON.stringify(example)
+		};
+		return {
+			kind: "text",
+			expr: isMediaWithSchema(text) ? schemaToFaker(text.schema, void 0, fakerOptions) : "faker.lorem.sentence()"
+		};
+	}
+	return {
+		kind: "empty",
+		expr: ""
+	};
+}
+function defaultExample(response, components, useExamples) {
+	const content = response?.content;
+	if (!useExamples || !content) return void 0;
+	const jsonType = jsonMediaType(content);
+	return jsonType ? mediaExample(content[jsonType], components) : mediaExample(content["text/plain"], components);
+}
+/**
+* The expression that reads the credential a security scheme expects, or `undefined` when the
+* scheme is one a mock cannot check for.
+*
+* Only presence is checked: a mock that validated credentials would need a user store, and the
+* point of the 401 branch is that a client can exercise the unauthorized path at all.
+*/
+function credentialExpr(scheme) {
+	if (scheme.type === "http" || scheme.type === "oauth2" || scheme.type === "openIdConnect") return "c.headers.authorization";
+	if (scheme.type !== "apiKey") return void 0;
+	const name = scheme.name ?? "X-API-Key";
+	if (scheme.in === "query") return `c.query[${quoteSingle$1(name)}]`;
+	if (scheme.in === "cookie") return `c.cookie[${quoteSingle$1(name)}]?.value`;
+	return `c.headers[${quoteSingle$1(name.toLowerCase())}]`;
+}
+/**
+* The guard a secured operation answers 401 with, or `''` when there is nothing to guard.
+*
+* Emitted only when the operation declares a 401: without that in the contract a 401 would be a
+* response the client was never told about. Alternatives are OR'd, because OpenAPI's security
+* array is a list of ways to satisfy the requirement.
+*/
+function authGuard(operation, spec, responses) {
+	if (!("401" in responses)) return "";
+	const requirements = operation.security ?? spec.security;
+	if (!requirements || requirements.length === 0) return "";
+	const schemes = spec.components?.securitySchemes ?? {};
+	const checks = requirements.flatMap((requirement) => Object.keys(requirement)).map((name) => schemes[name]).flatMap((scheme) => {
+		if (!scheme || isReference(scheme)) return [];
+		const expr = credentialExpr(scheme);
+		return expr === void 0 ? [] : [expr];
+	}).filter((expr, index, all) => all.indexOf(expr) === index);
+	if (checks.length === 0) return "";
+	return `if (!(${checks.join(" || ")})) return c.status(401)\n    `;
+}
+/**
+* The guard a path parameter answers 404 with, or `''` when there is nothing to guard.
+*
+* Emitted only when the operation declares a 404, for the same reason as the 401: a status the
+* document never mentioned is one the client was never told to expect. The sentinel value is
+* shared with the test generator, so a generated 404 test and the mock agree on which value
+* means "not there".
+*/
+function notFoundGuard(operation, components, responses) {
+	if (!("404" in responses)) return "";
+	const guards = (operation.parameters ?? []).map((parameter) => parameter.$ref ? components?.parameters?.[parameter.$ref.replace("#/components/parameters/", "")] : parameter).flatMap((parameter) => {
+		if (!parameter || !("in" in parameter) || parameter.in !== "path") return [];
+		const schema = parameter.schema;
+		if (!schema) return [];
+		const sentinel = nonExistentPathValue(schema);
+		if (!sentinel) return [];
+		const value = sentinel.kind === "literal" ? quoteSingle$1(sentinel.value) : `String(${sentinel.code})`;
+		return [`if (prefer.key === undefined && c.params[${quoteSingle$1(parameter.name)}] === ${value}) return c.status(404)`];
+	});
+	return guards.length === 0 ? "" : `${guards.join("\n    ")}\n    `;
+}
+/**
+* The return statement for one answer. 200 returns the value directly (Elysia defaults to 200);
+* other statuses use the `status(code, body)` helper so the code reaches the wire. A `+json`
+* media type other than `application/json` is set on the response so it survives serialization.
+*/
+function returnStatement(status, body) {
+	if (body.kind === "empty") return `return c.status(${status})`;
+	const header = body.kind === "json" && body.mediaType !== "application/json" ? `c.set.headers['content-type'] = ${quoteSingle$1(body.mediaType)}\n    ` : "";
+	if (status === "200") return `${header}return ${body.kind === "json" ? `(${body.expr})` : body.expr}`;
+	return `${header}return c.status(${status}, ${body.expr})`;
+}
+/**
+* The handler: guards first, in this order — a request without credentials never reaches the 404
+* check, which matches what a real server tells an unauthenticated client about what exists —
+* then the `Prefer` selection, then the declared success response.
+*/
+function makeHandler(parts) {
+	return `(c) => {\n    ${parts.seed}${parts.auth}${parts.prefer}${parts.notFound}${parts.success}\n  }`;
+}
+/**
+* Module-level helpers for Prism-compatible response selection, emitted once per mock file. The
+* names carry no `mock` prefix, so they can never collide with a component factory
+* (`mock<Name>`).
+*/
+const PREFER_HELPERS = `// Reads Prism's \`Prefer: code=<status>, example=<name>\` header (or the \`__code\` /
+// \`__example\` query) and resolves it against the responses the operation declares: the exact
+// status, then its \`NXX\` range, then \`default\`. Without a code the example is looked up in
+// the success response. Anything the operation does not declare answers 500 problem+json, as
+// Prism does.
+function resolvePrefer(
+  header: string | undefined,
+  query: { readonly [k: string]: string | undefined },
+  responses: { readonly [key: string]: readonly string[] },
+  success: string,
+) {
+  let code = query.__code
+  let example = query.__example
+  for (const [, name = '', quoted, bare] of (header ?? '').matchAll(
+    /([A-Za-z]+)\\s*=\\s*(?:"([^"]*)"|([^\\s,;]*))/gu,
+  )) {
+    if (name.toLowerCase() === 'code') code ??= quoted ?? bare
+    if (name.toLowerCase() === 'example') example ??= quoted ?? bare
+  }
+  if (code === undefined && example === undefined) return {}
+  if (code !== undefined && !/^[2-5]\\d\\d$/u.test(code)) {
+    return { problem: preferProblem(\`Prefer code=\${code} is not a status code between 200 and 599.\`) }
+  }
+  const key =
+    code === undefined
+      ? success
+      : [code, \`\${code.slice(0, 1)}XX\`, 'default'].find((k) => Object.hasOwn(responses, k))
+  if (key === undefined) {
+    return { problem: preferProblem(\`No \${code} response is declared for this operation.\`) }
+  }
+  if (example !== undefined && !responses[key]?.includes(example)) {
+    return {
+      problem: preferProblem(
+        \`No example named "\${example}" is declared for the \${key} response.\`,
+      ),
+    }
+  }
+  return { key, status: code === undefined ? undefined : Number(code), example }
+}
+
+function preferProblem(detail: string) {
+  return new Response(
+    JSON.stringify({ type: 'about:blank', title: 'Mock response unavailable', status: 500, detail }),
+    { status: 500, headers: { 'content-type': 'application/problem+json' } },
+  )
+}`;
+function indent(statement) {
+	return statement.replaceAll("\n    ", "\n      ");
+}
+function quoteSingle$1(s) {
+	return `'${s.replaceAll("\\", "\\\\").replaceAll("'", "\\'").replaceAll("\n", "\\n").replaceAll("\r", "\\r").replaceAll("	", "\\t")}'`;
+}
+function routePath(path) {
+	return quoteSingle$1(path.replaceAll(/\{([^}]+)\}/gu, ":$1"));
+}
+/**
+* The middleware every response passes through when `delay` is configured.
+*
+* Cross-cutting rather than woven into each handler, so the handlers stay exactly what they would
+* be without it and the output is byte-identical when no delay is asked for.
+*/
+function delayMiddleware(delay) {
+	if (delay === void 0 || delay === false) return "";
+	return `\n  .onBeforeHandle(() => new Promise((resolve) => setTimeout(resolve, ${typeof delay === "number" ? String(delay) : `faker.number.int({ min: ${String(delay.min)}, max: ${String(delay.max)} })`})))`;
+}
+/**
+* One self-contained Elysia file that stands up a mock server: a faker factory per referenced
+* component schema, then every operation wired to a handler that returns a mock of its declared
+* success response. `import.meta.main` guards `listen()` so importing the module (e.g. from a
+* test) starts no server.
+*
+* A secured operation that declares a 401 checks for the credential first, and a path parameter
+* with a recognisable "missing" value answers 404 — so a client can drive the unhappy paths the
+* document promises, not just the happy one.
+*/
+function makeMock(spec, options = {}) {
+	const { prefix, port = "3000", useExamples = true, locale, delay, arrayMin, arrayMax, seed } = options;
+	const fakerOptions = {
+		...arrayMin !== void 0 ? { arrayMin } : {},
+		...arrayMax !== void 0 ? { arrayMax } : {},
+		...useExamples === "all" ? { useExamples: true } : {}
+	};
+	const components = spec.components;
+	const routes = pathEntries(spec).flatMap(([path, pathItem]) => {
+		if (!pathItem) return [];
+		return HTTP_METHODS.flatMap((method) => {
+			const operation = pathItem[method];
+			if (!operation) return [];
+			const resolved = resolveOperation(operation, components);
+			const success = pickSuccessResponse(resolved.responses);
+			const responses = Object.entries(resolved.responses).map(([rawKey, declared]) => {
+				const response = declared;
+				const content = response.content;
+				const jsonType = jsonMediaType(content);
+				return {
+					key: normalizeKey(rawKey),
+					response,
+					example: defaultExample(response, components, useExamples !== false),
+					named: jsonType ? namedExamples(content?.[jsonType], components) : [],
+					jsonSchema: jsonType ? content?.[jsonType] : void 0
+				};
+			});
+			const refs = responses.flatMap(({ jsonSchema }) => jsonSchema && isMediaWithSchema(jsonSchema) ? collectSchemaRefs(jsonSchema.schema, components?.schemas) : []);
+			const preferTable = Object.fromEntries(responses.map((r) => [r.key, r.named.map(([name]) => name)]));
+			const render = (r, example) => {
+				return indent(returnStatement(/^\d{3}$/u.test(r.key) ? r.key : `prefer.status ?? ${/^[1-5]XX$/u.test(r.key) ? `${r.key.slice(0, 1)}00` : "200"}`, responseBody(r.response, example, fakerOptions)));
+			};
+			const branches = [responses.flatMap((r) => r.named.filter(([, value]) => value !== r.example).map(([name, value]) => `if (prefer.key === ${quoteSingle$1(r.key)} && prefer.example === ${quoteSingle$1(name)}) {\n      ${render(r, value)}\n    }\n    `)), responses.filter((r) => !(r.key === success.key && /^\d{3}$/u.test(r.key))).map((r) => `if (prefer.key === ${quoteSingle$1(r.key)}) {\n      ${render(r, r.example)}\n    }\n    `)].flat();
+			const prefer = `const prefer = resolvePrefer(c.headers.prefer, c.query, ${JSON.stringify(preferTable)}, ${quoteSingle$1(success.key)})\n    if (prefer.problem) return prefer.problem\n    ${branches.join("")}`;
+			const successBody = responseBody(success.response, defaultExample(success.response, components, useExamples !== false), fakerOptions);
+			const auth = authGuard(resolved, spec, resolved.responses);
+			const notFound = notFoundGuard(resolved, components, resolved.responses);
+			const successReturn = returnStatement(String(success.status), successBody);
+			const usesFaker = /\bfaker\.|\bmock[A-Za-z0-9_$]*\(/u.test(`${branches.join("")}${notFound}${successReturn}`);
+			const handler = makeHandler({
+				seed: seed !== void 0 && usesFaker ? `faker.seed(${JSON.stringify(seed)})\n    faker.setDefaultRefDate('${SEED_REF_DATE}')\n    ` : "",
+				auth,
+				prefer,
+				notFound,
+				success: successReturn
+			});
+			return [{
+				method,
+				path,
+				code: `.${method}(${routePath(path)}, ${handler})`,
+				refs
+			}];
+		});
+	});
+	const mockFunctions = makeMockFunctions(spec, new Set(routes.flatMap((r) => r.refs)), fakerOptions);
+	const ctorArgs = prefix ? `{ prefix: ${quoteSingle$1(prefix)} }` : "";
+	const routeChain = routes.map((r) => `  ${r.code}`).join("\n");
+	const listenBlock = `
+
+if (import.meta.main) {
+  app.listen(${port})\n  console.log(\`🦊 Elysia is running at \${app.server?.hostname}:\${app.server?.port}\`)
+}`;
+	const appCode = `export const app = new Elysia(${ctorArgs})${delayMiddleware(delay)}\n${routeChain}${listenBlock}`;
+	const helpers = routes.length > 0 ? `${PREFER_HELPERS}\n\n` : "";
+	const body = mockFunctions ? `${mockFunctions}\n\n${helpers}${appCode}` : `${helpers}${appCode}`;
+	const fakerModule = locale === void 0 ? "@faker-js/faker" : `@faker-js/faker/locale/${locale}`;
+	return `import { Elysia } from 'elysia'${body.includes("faker.") ? `\nimport { faker } from '${fakerModule}'` : ""}\n\n${body}\n`;
+}
+//#endregion
+//#region src/core/mock/index.ts
+function mock(openAPI, output, options = {}) {
+	return Effect.gen(function* () {
+		yield* emit(makeMock(openAPI, options), path.dirname(output), output);
+		return `Generated mock server written to ${output}`;
+	});
+}
+//#endregion
+//#region src/generator/test/test-generator.ts
+function extractSecurity(opSecurity, globalSecurity, securitySchemes) {
+	return (opSecurity ?? globalSecurity ?? []).flatMap((secDef) => Object.keys(secDef).flatMap((schemeName) => {
+		const scheme = securitySchemes?.[schemeName];
+		if (!scheme || typeof scheme.type !== "string") return [];
+		if (scheme.type === "http" && scheme.scheme === "bearer") return [{
+			type: "bearer",
+			name: "Authorization"
+		}];
+		if (scheme.type === "http" && scheme.scheme === "basic") return [{
+			type: "basic",
+			name: "Authorization"
+		}];
+		if (scheme.type === "apiKey") {
+			const inLocation = scheme.in === "header" || scheme.in === "query" || scheme.in === "cookie" ? scheme.in : "header";
+			return [{
+				type: "apiKey",
+				name: scheme.name || "X-API-Key",
+				in: inLocation
+			}];
+		}
+		if (scheme.type === "oauth2") return [{
+			type: "oauth2",
+			name: "Authorization"
+		}];
+		return [];
+	}));
+}
+function extractTestCases(spec) {
+	const components = spec.components;
+	return pathEntries(spec).flatMap(([path, pathItem]) => {
+		if (!pathItem) return [];
+		return HTTP_METHODS.flatMap((method) => {
+			const operation = pathItem[method];
+			if (!operation) return [];
+			const resolved = resolveOperation(operation, components);
+			const resolvedParams = resolved.parameters.map((param) => {
+				const schema = param.schema ?? { type: "string" };
+				return {
+					param,
+					schema,
+					fakerCode: schemaToFaker(schema, param.name)
+				};
+			});
+			const pathParams = resolvedParams.filter((p) => p.param.in === "path").map((p) => ({
+				name: p.param.name,
+				fakerCode: p.fakerCode,
+				schema: p.schema
+			}));
+			const queryParams = resolvedParams.filter((p) => p.param.in === "query").map((p) => ({
+				name: p.param.name,
+				fakerCode: p.fakerCode,
+				required: p.param.required ?? false
+			}));
+			const headerParams = resolvedParams.filter((p) => p.param.in === "header").map((p) => ({
+				name: p.param.name,
+				fakerCode: p.fakerCode,
+				required: p.param.required ?? false
+			}));
+			const requestBodyDef = resolved.requestBody;
+			const jsonMedia = requestBodyDef && "content" in requestBodyDef ? requestBodyDef.content?.["application/json"] : void 0;
+			const jsonBodySchema = jsonMedia && isMediaWithSchema(jsonMedia) ? jsonMedia.schema : void 0;
+			const requestBody = jsonBodySchema ? { fakerCode: schemaToFaker(jsonBodySchema) } : void 0;
+			const bodyRefs = jsonBodySchema ? collectSchemaRefs(jsonBodySchema, components?.schemas) : [];
+			const paramRefs = resolvedParams.flatMap((p) => collectSchemaRefs(p.schema, components?.schemas));
+			const usedSchemaRefs = [...new Set([...bodyRefs, ...paramRefs])];
+			const responseKeys = Object.keys(operation.responses ?? {});
+			const successStatus = responseKeys.filter((s) => s.startsWith("2")).map((s) => Number.parseInt(s, 10)).toSorted((a, b) => a - b)[0] ?? 200;
+			const errorStatuses = responseKeys.filter((s) => (s.startsWith("4") || s.startsWith("5")) && s !== "default").map((s) => Number.parseInt(s, 10)).toSorted((a, b) => a - b);
+			const security = extractSecurity(operation.security, spec.security, components?.securitySchemes);
+			return [{
+				operationId: resolveOperationId(operation, method, path),
+				method: method.toUpperCase(),
+				path,
+				summary: operation.summary || "",
+				tag: operation.tags?.[0],
+				pathParams,
+				queryParams,
+				headerParams,
+				requestBody,
+				successStatus,
+				errorStatuses,
+				security,
+				usedSchemaRefs
+			}];
+		});
+	});
+}
+function quoteSingle(s) {
+	return `'${s.replaceAll("\\", "\\\\").replaceAll("'", "\\'").replaceAll("\n", "\\n").replaceAll("\r", "\\r").replaceAll("	", "\\t")}'`;
+}
+function escapeTemplateLiteral(s) {
+	return s.replaceAll("\\", "\\\\").replaceAll("`", "\\`").replaceAll("${", "\\${");
+}
+function resolveNonExistent(schema, schemas) {
+	return nonExistentPathValue(schema.$ref && schemas ? schemas[schema.$ref.replace("#/components/schemas/", "")] ?? schema : schema);
+}
+function makeAuthHeader(sec) {
+	switch (sec.type) {
+		case "bearer":
+		case "oauth2": return "'Authorization':`Bearer ${faker.string.alphanumeric(32)}`";
+		case "basic": return "'Authorization':`Basic ${btoa(`${faker.internet.username()}:${faker.internet.password()}`)}`";
+		case "apiKey":
+			if (sec.in === "header") return `${quoteSingle(sec.name)}:faker.string.alphanumeric(32)`;
+			if (sec.in === "cookie") return `'Cookie':\`${escapeTemplateLiteral(sec.name)}=\${faker.string.alphanumeric(32)}\``;
+			return "";
+		default: return "";
+	}
+}
+function makeTestCase(tc, prefix = "", schemas) {
+	const fullPath = `${prefix && prefix !== "/" ? prefix : ""}${tc.path}`;
+	const escapedFullPath = escapeTemplateLiteral(fullPath);
+	const testPath = tc.pathParams.reduce((path, param) => path.replace(`{${param.name}}`, `\${${toSafeIdentifier(param.name)}}`), escapedFullPath);
+	const pathSetup = tc.pathParams.map((param) => `const ${toSafeIdentifier(param.name)}=${param.fakerCode}`);
+	const querySetup = tc.queryParams.map((param) => `const ${toSafeIdentifier(param.name)}=${param.fakerCode}`);
+	const queryParts = tc.queryParams.map((param) => `${escapeTemplateLiteral(param.name)}=\${encodeURIComponent(String(${toSafeIdentifier(param.name)}))}`);
+	const queryString = queryParts.length > 0 ? `?${queryParts.join("&")}` : "";
+	const authQueryParts = tc.security.filter((sec) => sec.type === "apiKey" && sec.in === "query").map((sec) => `${escapeTemplateLiteral(sec.name)}=\${faker.string.alphanumeric(32)}`);
+	const authQueryString = authQueryParts.length > 0 ? queryString ? `&${authQueryParts.join("&")}` : `?${authQueryParts.join("&")}` : "";
+	const requiredHeaderParams = tc.headerParams.filter((p) => p.required);
+	const headerSetup = requiredHeaderParams.map((param) => `const ${toSafeIdentifier(param.name)}=${param.fakerCode}`);
+	const headerEntries = requiredHeaderParams.map((param) => `${quoteSingle(param.name)}:String(${toSafeIdentifier(param.name)})`);
+	const authHeaders = tc.security.map(makeAuthHeader).filter(Boolean);
+	const { bodySetup, bodyOption, contentTypeHeader } = tc.requestBody ? {
+		bodySetup: `const body=${tc.requestBody.fakerCode}`,
+		bodyOption: ",body:JSON.stringify(body)",
+		contentTypeHeader: "'Content-Type':'application/json'"
+	} : {
+		bodySetup: "",
+		bodyOption: "",
+		contentTypeHeader: ""
+	};
+	const headers = [...headerEntries, ...contentTypeHeader ? [contentTypeHeader] : []];
+	const allHeaders = [...headers, ...authHeaders];
+	const headersOption = allHeaders.length > 0 ? `,headers:{${allHeaders.join(",")}}` : "";
+	const headersWithoutAuth = headers.length > 0 ? `,headers:{${headers.join(",")}}` : "";
+	const summaryPart = tc.summary ? ` - ${tc.summary}` : "";
+	const setupCode = [
+		...pathSetup,
+		...querySetup,
+		...headerSetup,
+		bodySetup
+	].filter(Boolean).join("\n");
+	const describeTitle = quoteSingle(`${tc.method} ${fullPath}`);
+	const methodLiteral = quoteSingle(tc.method);
+	return `${`describe(${describeTitle},()=>{it(${quoteSingle(`should return ${tc.successStatus}${summaryPart}`)},async()=>{${setupCode}\nconst res=await app.handle(new Request(\`http://localhost${testPath}${queryString}${authQueryString}\`,{method:${methodLiteral}${headersOption}${bodyOption}}))\nexpect(res.status).toBe(${tc.successStatus})})`}${tc.security.length > 0 ? `\nit('should return 401 without auth',async()=>{${setupCode}\nconst res=await app.handle(new Request(\`http://localhost${testPath}${queryString}\`,{method:${methodLiteral}${headersWithoutAuth}${bodyOption}}))\nexpect(res.status).toBe(401)})` : ""}${tc.pathParams.length > 0 && tc.errorStatuses.includes(404) ? (() => {
+		const probes = tc.pathParams.map((param) => ({
+			param,
+			probe: resolveNonExistent(param.schema, schemas)
+		}));
+		if (probes.some(({ probe }) => probe === void 0)) return "";
+		const probeSetup = probes.flatMap(({ param, probe }) => probe?.kind === "expr" ? [`const ${toSafeIdentifier(param.name)}=${probe.code}`] : []);
+		const notFoundPath = probes.reduce((path, { param, probe }) => {
+			const value = probe?.kind === "expr" ? `\${${toSafeIdentifier(param.name)}}` : probe?.value ?? "";
+			return path.replace(`{${param.name}}`, value);
+		}, escapedFullPath);
+		return `\nit('should return 404 for non-existent resource',async()=>{${[
+			...probeSetup,
+			...querySetup,
+			...headerSetup,
+			bodySetup
+		].filter(Boolean).join("\n")}\nconst res=await app.handle(new Request(\`http://localhost${notFoundPath}${queryString}\`,{method:${methodLiteral}${headersOption}${bodyOption}}))\nexpect(res.status).toBe(404)})`;
+	})() : ""}})\n`;
+}
+function makeTagDescribes(testCases, spec, prefix) {
+	return [...testCases.reduce((acc, tc) => {
+		const tag = tc.tag || "default";
+		return acc.set(tag, [...acc.get(tag) ?? [], tc]);
+	}, /* @__PURE__ */ new Map()).entries()].map(([tag, cases]) => {
+		const tagDescription = (spec.tags?.find((t) => t.name === tag))?.description || tag;
+		const testCasesCode = cases.map((tc) => makeTestCase(tc, prefix, spec.components?.schemas)).join("");
+		return `describe(${quoteSingle(tagDescription)},()=>{${testCasesCode}})\n`;
+	}).join("");
+}
+function makeAppTestFile(spec, appImport, prefix, resourceFilter) {
+	const testCases = resourceFilter ? extractTestCases(spec).filter((tc) => resourceFilter.has(resourceName(tc.path))) : extractTestCases(spec);
+	const apiTitle = spec.info?.title || "API";
+	const mockFunctions = makeMockFunctions(spec, new Set(testCases.flatMap((tc) => tc.usedSchemaRefs)));
+	const tagDescribes = makeTagDescribes(testCases, spec, prefix);
+	const body = `${mockFunctions ? `${mockFunctions}\n\n` : ""}describe(${quoteSingle(apiTitle)},()=>{${tagDescribes}})\n`;
+	return `${`import{describe,it,expect}from'bun:test'${body.includes("faker.") ? `\nimport{faker}from'@faker-js/faker'` : ""}\nimport{app}from'${appImport}'\n`}\n${body}`;
+}
+function makeTestFile(spec, appImport = "..", prefix) {
+	return makeAppTestFile(spec, appImport, prefix);
+}
+function makeColocatedTestEntries(spec, appImport = "../../index", prefix) {
+	const resources = [...operationsByResource(spec).keys()];
+	const resourcesWithCases = new Set(extractTestCases(spec).map((tc) => resourceName(tc.path)));
+	return resources.filter((name) => resourcesWithCases.has(name)).map((name) => ({
+		name,
+		code: makeAppTestFile(spec, appImport, prefix, new Set([name]))
+	}));
+}
+//#endregion
+//#region src/core/test/index.ts
+/** Writes `code`, keeping whatever the user already wrote in `output`. */
+function writeMerged(code, output) {
+	return Effect.gen(function* () {
+		const existing = yield* readFile(output);
+		yield* emit(existing === null ? code : mergeSource(existing, code), path.dirname(output), output);
+	});
+}
+function test(openAPI, output, options = {}) {
+	return Effect.gen(function* () {
+		const { appOutput = "src/index.ts", split = false, pathAlias, prefix } = options;
+		const appOutputAbs = path.resolve(process.cwd(), appOutput);
+		const appBase = path.basename(appOutput).replace(/\.ts$/u, "");
+		const appImportFor = (fromFileAbs) => {
+			if (pathAlias) return `${pathAlias.replace(/\/$/u, "")}/${appBase}`;
+			const rel = path.relative(path.dirname(fromFileAbs), appOutputAbs).replaceAll("\\", "/").replace(/\.ts$/u, "");
+			return rel.startsWith(".") ? rel : `./${rel}`;
+		};
+		if (split) {
+			const modulesDir = path.join(path.dirname(appOutputAbs), "modules");
+			const entries = makeColocatedTestEntries(openAPI, appImportFor(path.join(modulesDir, "resource", "index.test.ts")), prefix);
+			yield* Effect.all(entries.map((entry) => writeMerged(entry.code, path.join(modulesDir, entry.name, "index.test.ts"))), { concurrency: "unbounded" });
+			return `Generated ${entries.length} co-located test file(s) under ${path.posix.dirname(appOutput)}/modules/`;
+		}
+		if (output === void 0) return yield* new GenerateError({ message: "test.output is required when split is false" });
+		yield* writeMerged(makeTestFile(openAPI, appImportFor(path.resolve(process.cwd(), output)), prefix), output);
+		return `Generated test file written to ${output}`;
+	});
+}
+//#endregion
+//#region src/core/type/index.ts
+function primitiveTypeToTs(t) {
+	if (t === "string") return "string";
+	if (t === "number" || t === "integer") return "number";
+	if (t === "boolean") return "boolean";
+	if (t === "null") return "null";
+	return "unknown";
+}
+function tsName(name) {
+	if (/^[A-Za-z_][A-Za-z0-9_]*$/u.test(name)) return name;
+	return pascalCase(name);
+}
+function literalToTs(v) {
+	if (v === null) return "null";
+	if (typeof v === "string") return JSON.stringify(v);
+	if (typeof v === "number" || typeof v === "boolean") return String(v);
+	return JSON.stringify(v);
+}
+function isNullable(s) {
+	if (s.nullable === true) return true;
+	if (Array.isArray(s.type)) return s.type.some((t) => t === "null");
+	return false;
+}
+function primaryType(s) {
+	if (typeof s.type === "string") return s.type;
+	if (Array.isArray(s.type)) return s.type.find((t) => t !== "null");
+}
+function schemaToTs(schema) {
+	if (!schema) return "unknown";
+	if (schema.$ref) {
+		const raw = schema.$ref.split("/").pop();
+		return raw ? tsName(decodeURIComponent(raw)) : "unknown";
+	}
+	const wrap = (inner) => isNullable(schema) ? `(${inner} | null)` : inner;
+	if ("const" in schema && schema.const !== void 0) return wrap(literalToTs(schema.const));
+	if (schema.enum && schema.enum.length > 0) return wrap(schema.enum.map(literalToTs).join(" | "));
+	if (schema.oneOf) return wrap(schema.oneOf.map(schemaToTs).join(" | ") || "unknown");
+	if (schema.anyOf) return wrap(schema.anyOf.map(schemaToTs).join(" | ") || "unknown");
+	if (schema.allOf) return wrap(schema.allOf.map(schemaToTs).join(" & ") || "unknown");
+	if (Array.isArray(schema.type)) {
+		const nonNull = schema.type.filter((type) => type !== "null");
+		const isObj = schema.properties !== void 0 || schema.additionalProperties !== void 0;
+		const isArr = nonNull.includes("array");
+		if (nonNull.length > 1 && !isObj && !isArr) return wrap(nonNull.map(primitiveTypeToTs).join(" | "));
+	}
+	const primary = primaryType(schema);
+	if (primary === "array") {
+		if (Array.isArray(schema.prefixItems) && schema.prefixItems.length > 0) return wrap(`[${schema.prefixItems.map(schemaToTs).join(", ")}]`);
+		return wrap(`${schemaToTs(isSchemaArray(schema.items) ? schema.items[0] : schema.items)}[]`);
+	}
+	if (primary === "object" || schema.properties || schema.additionalProperties !== void 0) {
+		const props = schema.properties ?? {};
+		const required = new Set(schema.required);
+		const entries = Object.entries(props).map(([key, value]) => {
+			const opt = required.has(key) ? "" : "?";
+			return `${JSON.stringify(key)}${opt}: ${schemaToTs(value)}`;
+		});
+		const additional = schema.additionalProperties;
+		const propsTs = entries.length === 0 ? "" : `{ ${entries.join("; ")} }`;
+		if (additional && typeof additional === "object") {
+			const recordTs = `Record<string, ${schemaToTs(additional)}>`;
+			return wrap(propsTs === "" ? recordTs : `${propsTs} & ${recordTs}`);
+		}
+		if (additional === true) {
+			const recordTs = "Record<string, unknown>";
+			return wrap(propsTs === "" ? recordTs : `${propsTs} & ${recordTs}`);
+		}
+		return wrap(propsTs === "" ? "{}" : propsTs);
+	}
+	if (primary === "null") return "null";
+	if (primary !== void 0) return wrap(primitiveTypeToTs(primary));
+	return wrap("unknown");
+}
+function pathToKeys(pathStr) {
+	return pathStr.split("/").filter((s) => s.length > 0).map((seg) => seg.startsWith("{") && seg.endsWith("}") ? `:${seg.slice(1, -1)}` : seg);
+}
+function responseContentTs(resp, components) {
+	if (isStringRef(resp) && resp.$ref) {
+		const name = resp.$ref.split("/").pop();
+		const resolved = name ? components?.responses?.[decodeURIComponent(name)] : void 0;
+		if (!resolved) return "unknown";
+		return responseContentTs(resolved, components);
+	}
+	const json = resp.content?.["application/json"];
+	if (!json) return "unknown";
+	return schemaToTs(json.schema);
+}
+function isMedia(entry) {
+	return entry !== void 0 && !isStringRef(entry);
+}
+function requestBodyTs(body, components) {
+	if (!body) return "unknown";
+	if (isStringRef(body) && body.$ref) {
+		const name = body.$ref.split("/").pop();
+		const resolved = name ? components?.requestBodies?.[decodeURIComponent(name)] : void 0;
+		if (!resolved) return "unknown";
+		return requestBodyTs(resolved, components);
+	}
+	const content = "content" in body ? body.content : void 0;
+	if (!content) return "unknown";
+	for (const mediaType of [
+		"application/json",
+		"multipart/form-data",
+		"application/x-www-form-urlencoded",
+		"application/octet-stream"
+	]) {
+		const entry = content[mediaType];
+		if (!isMedia(entry)) continue;
+		if (!entry.schema) continue;
+		if (mediaType === "application/octet-stream") {
+			const schema = entry.schema;
+			if (!schema.$ref && (schema.format === "binary" || schema.type === "string")) return "Blob | File | ArrayBuffer";
+			return schemaToTs(schema);
+		}
+		return schemaToTs(entry.schema);
+	}
+	for (const [, entry] of Object.entries(content)) {
+		if (!isMedia(entry) || !entry.schema) continue;
+		return schemaToTs(entry.schema);
+	}
+	return "unknown";
+}
+function resolveParameter(p, components) {
+	if (isStringRef(p) && p.$ref) {
+		const name = p.$ref.split("/").pop();
+		if (!name) return void 0;
+		return components?.parameters?.[decodeURIComponent(name)];
+	}
+	return "name" in p && "in" in p ? p : void 0;
+}
+function paramsTs(params, where, components) {
+	const resolved = params.map((p) => resolveParameter(p, components)).filter((p) => p?.in === where);
+	if (resolved.length === 0) return "{}";
+	return `{ ${resolved.map((p) => {
+		const opt = p.required ? "" : "?";
+		return `${JSON.stringify(p.name)}${opt}: ${schemaToTs(p.schema)}`;
+	}).join("; ")} }`;
+}
+const VALIDATION_ERROR_TS = `{ type: "validation"; on: string; summary?: string; message?: string; found?: unknown; property?: string; expected?: string }`;
+function makeResponseTs(operation, components) {
+	const declared = Object.entries(operation.responses ?? {}).filter(([status]) => status !== "default");
+	const entries = declared.map(([status, resp]) => {
+		return `${status}: ${responseContentTs(resp, components)}`;
+	});
+	if (!declared.some(([status]) => status === "422")) entries.push(`422: ${VALIDATION_ERROR_TS}`);
+	return `{ ${entries.join("; ")} }`;
+}
+function makeOperationTs(operation, components) {
+	const params = operation.parameters ?? [];
+	const body = requestBodyTs(operation.requestBody, components);
+	const pathParams = paramsTs(params, "path", components);
+	const queryParams = paramsTs(params, "query", components);
+	const headerParams = paramsTs(params, "header", components);
+	const headers = headerParams === "{}" ? "unknown" : headerParams;
+	const response = makeResponseTs(operation, components);
+	return `{ body: ${body}; params: ${pathParams}; query: ${queryParams === "{}" ? "unknown" : queryParams}; headers: ${headers}; response: ${response} }`;
+}
+function nestRoute(keys, method, opTs) {
+	const leaf = `{ ${method}: ${opTs} }`;
+	return keys.reduceRight((acc, key) => `{ ${JSON.stringify(key)}: ${acc} }`, leaf);
+}
+function makeRoutes(openAPI, prefix) {
+	const out = [];
+	const prefixKeys = prefix && prefix !== "/" ? pathToKeys(prefix) : [];
+	for (const [pathStr, pathItem] of pathEntries(openAPI)) {
+		if (!pathItem) continue;
+		const keys = [...prefixKeys, ...pathToKeys(pathStr)];
+		for (const method of HTTP_METHODS) {
+			const operation = pathItem[method];
+			if (!operation) continue;
+			out.push(nestRoute(keys, method, makeOperationTs(operation, openAPI.components)));
+		}
+	}
+	return out;
+}
+function collectRefs(openAPI) {
+	const seen = /* @__PURE__ */ new Set();
+	const queue = [];
+	const components = openAPI.components;
+	const enqueue = (s) => {
+		if (!s) return;
+		for (const name of collectSchemaRefs$1(s)) if (!seen.has(name)) {
+			seen.add(name);
+			queue.push(name);
+		}
+	};
+	const walkContentMap = (content) => {
+		for (const media of Object.values(content)) if (isMediaWithSchema(media)) enqueue(media.schema);
+	};
+	const walkRequestBody = (rb) => {
+		if (!rb) return;
+		if (isStringRef(rb) && rb.$ref) {
+			const name = rb.$ref.split("/").pop();
+			const resolved = name ? components?.requestBodies?.[decodeURIComponent(name)] : void 0;
+			if (resolved?.content) walkContentMap(resolved.content);
+			return;
+		}
+		if ("content" in rb && rb.content) walkContentMap(rb.content);
+	};
+	const walkResponse = (resp) => {
+		if (isStringRef(resp) && resp.$ref) {
+			const name = resp.$ref.split("/").pop();
+			const resolved = name ? components?.responses?.[decodeURIComponent(name)] : void 0;
+			if (resolved?.content) walkContentMap(resolved.content);
+			return;
+		}
+		if (resp.content) walkContentMap(resp.content);
+	};
+	for (const [, pathItem] of pathEntries(openAPI)) {
+		if (!pathItem) continue;
+		for (const method of HTTP_METHODS) {
+			const op = pathItem[method];
+			if (!op) continue;
+			walkRequestBody(op.requestBody);
+			for (const p of op.parameters ?? []) if (isStringRef(p) && p.$ref) {
+				const pname = p.$ref.split("/").pop();
+				const resolved = pname ? components?.parameters?.[decodeURIComponent(pname)] : void 0;
+				if (resolved) enqueue(resolved.schema);
+			} else if ("schema" in p) enqueue(p.schema);
+			for (const resp of Object.values(op.responses ?? {})) if (resp) walkResponse(resp);
+		}
+	}
+	while (queue.length > 0) {
+		const name = queue.shift();
+		if (!name) continue;
+		enqueue(components?.schemas?.[name]);
+	}
+	return [...seen];
+}
+function makeAppType(openAPI, prefix) {
+	const refAliases = collectRefs(openAPI).map((name) => {
+		const schema = openAPI.components?.schemas?.[name];
+		return `type ${tsName(name)} = ${schemaToTs(schema)}`;
+	});
+	const routes = makeRoutes(openAPI, prefix);
+	const routesTs = routes.length === 0 ? "{}" : routes.join(" & ");
+	const SINGLETON = `{ decorator: {}; store: {}; derive: {}; resolve: {} }`;
+	const EPHEMERAL = `{ typebox: {}; error: {} }`;
+	const VOLATILE = `{ schema: {}; standaloneSchema: {}; macro: {}; macroFn: {}; parser: {}; response: {} }`;
+	const TAIL = `{ derive: {}; resolve: {}; schema: {}; standaloneSchema: {}; response: {} }`;
+	return {
+		refAliases,
+		appType: `export type App = Elysia<"", ${SINGLETON}, ${EPHEMERAL}, ${VOLATILE}, ${routesTs}, ${TAIL}, ${TAIL}>`,
+		routes
+	};
+}
+function types(openAPI, output, prefix) {
+	return Effect.gen(function* () {
+		const { refAliases, appType } = makeAppType(openAPI, prefix);
+		yield* emit(`${[
+			`import type { Elysia } from "elysia"`,
+			refAliases.join("\n"),
+			appType
+		].filter((s) => s.length > 0).join("\n\n")}\n`, path.dirname(output), output);
+		return `Generated app type written to ${output}`;
+	});
+}
+//#endregion
+//#region src/core/index.ts
+var core_exports = /* @__PURE__ */ __exportAll({
+	HOOK_CONFIGS: () => HOOK_CONFIGS,
+	callbacks: () => callbacks,
+	components: () => components,
+	eden: () => eden,
+	elysia: () => elysia,
+	examples: () => examples,
+	headers: () => headers,
+	hooks: () => hooks,
+	links: () => links,
+	makeAppType: () => makeAppType,
+	makeJsDocs: () => makeJsDocs,
+	mediaTypes: () => mediaTypes,
+	mock: () => mock,
+	parameters: () => parameters,
+	pathItems: () => pathItems,
+	requestBodies: () => requestBodies,
+	responses: () => responses,
+	schemaToTs: () => schemaToTs,
+	schemas: () => schemas,
+	securitySchemes: () => securitySchemes,
+	test: () => test,
+	types: () => types
+});
+//#endregion
+export { unlink as S, responses as _, hooks as a, fileSystemLayer as b, mediaTypes as c, links as d, securitySchemes as f, parameters as g, examples as h, mock as i, pathItems as l, requestBodies as m, types as n, elysia as o, headers as p, test as r, eden as s, core_exports as t, callbacks as u, schemas as v, readdir as x, components as y };