@lovrozagar/honey 0.1.0 → 0.2.0

package/src/plugin.ts

@@ -1,6 +1,6 @@
-import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, extname, resolve } from "node:path";
+import { createHash } from "node:crypto"
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
+import { dirname, extname, resolve } from "node:path"
 import {
 	generateManifest,
 	generateOpenApi,
@@ -10,28 +10,28 @@ import {
 	generateTypes,
 	prepareCodegen,
 	sanitizeOpenApiSpec,
-} from "./codegen.ts";
-import type { OpenApiRouteInfo, OpenApiSanitizeOptions, OpenApiSpecInput } from "./codegen.ts";
-import type { Honey } from "./index.ts";
-import type { ExtractedChainTypes } from "./type-extractor.ts";
-import { toYaml, yamlSiblingPath } from "./yaml.ts";
+} from "./codegen.ts"
+import type { OpenApiRouteInfo, OpenApiSanitizeOptions, OpenApiSpecInput } from "./codegen.ts"
+import type { Honey } from "./index.ts"
+import type { ExtractedChainTypes } from "./type-extractor.ts"
+import { toYaml, yamlSiblingPath } from "./yaml.ts"
 
 /* ---- generateFromApp (standalone utility) ---- */
 
 type HoneyPluginOptions = {
-	manifest?: { output: string };
+	manifest?: { output: string }
 	openApi?: {
-		info: { description?: string; title: string; version: string };
-		output: string;
-	};
-};
+		info: { description?: string; title: string; version: string }
+		output: string
+	}
+}
 
 type GeneratedArtifacts = {
-	manifest?: string;
-	openApi?: string;
-	openApiYaml?: string;
-	routeTree: string;
-};
+	manifest?: string
+	openApi?: string
+	openApiYaml?: string
+	routeTree: string
+}
 
 export async function generateFromApp<
 	TEnv,
@@ -48,20 +48,20 @@ export async function generateFromApp<
 	const host = app as unknown as Honey<TEnv, TCtx, unknown, unknown, unknown, string, string>
 	const artifacts: GeneratedArtifacts = {
 		routeTree: generateRouteTreeFromApp(host),
-	};
+	}
 
 	if (options?.manifest) {
-		const manifest = generateManifest(host);
-		artifacts.manifest = JSON.stringify(manifest, null, 2);
+		const manifest = generateManifest(host)
+		artifacts.manifest = JSON.stringify(manifest, null, 2)
 	}
 
 	if (options?.openApi) {
-		const spec = await generateOpenApi(host, { info: options.openApi.info });
-		artifacts.openApi = JSON.stringify(spec, null, 2);
-		artifacts.openApiYaml = toYaml(spec);
+		const spec = await generateOpenApi(host, { info: options.openApi.info })
+		artifacts.openApi = JSON.stringify(spec, null, 2)
+		artifacts.openApiYaml = toYaml(spec)
 	}
 
-	return artifacts;
+	return artifacts
 }
 
 /* ---- Config types ---- */
@@ -70,6 +70,8 @@ export interface HoneyOpenApiOutputConfig {
 	description?: string
 	filterRoutes?: (route: OpenApiRouteInfo) => boolean
 	path?: string
+	/** Named metaSpec profile selecting which emitted keys this document carries */
+	profile?: string
 	sanitize?: OpenApiSanitizeOptions
 	securitySchemes?: Record<string, unknown>
 	title: string
@@ -87,26 +89,26 @@ export interface HoneyGoCliConfig {
 }
 
 export interface HoneySdkPortsConfig {
-	go?: { modulePath?: string; outDir: string };
-	python?: { outDir: string };
-	rust?: { crateName?: string; outDir: string };
-	typescript?: boolean | { outDir?: string };
+	go?: { modulePath?: string; outDir: string }
+	python?: { outDir: string }
+	rust?: { crateName?: string; outDir: string }
+	typescript?: boolean | { outDir?: string }
 }
 
 export interface HoneyCodegenConfig {
-	cli?: boolean | HoneyGoCliConfig;
-	manifest?: boolean | string;
-	mergeTree?: string;
-	openApi?: HoneyOpenApiOutputConfig | HoneyOpenApiOutputConfig[];
-	sdk?: boolean | { name?: string; ports?: HoneySdkPortsConfig; specs?: string[] };
-	tree?: boolean | string;
-	types?: boolean | string | { baseCtxName?: string; path?: string };
+	cli?: boolean | HoneyGoCliConfig
+	manifest?: boolean | string
+	mergeTree?: string
+	openApi?: HoneyOpenApiOutputConfig | HoneyOpenApiOutputConfig[]
+	sdk?: boolean | { name?: string; ports?: HoneySdkPortsConfig; specs?: string[] }
+	tree?: boolean | string
+	types?: boolean | string | { baseCtxName?: string; path?: string }
 }
 
 export interface HoneyVitePluginConfig {
-	app?: string;
-	codegen?: HoneyCodegenConfig;
-	watch?: string[];
+	app?: string
+	codegen?: HoneyCodegenConfig
+	watch?: string[]
 }
 
 /* ---- Resolved config ---- */
@@ -115,6 +117,8 @@ export type ResolvedOpenApiOutput = {
 	description?: string
 	filterRoutes?: (route: OpenApiRouteInfo) => boolean
 	path: string
+	/** Named metaSpec profile selecting which emitted keys this document carries */
+	profile?: string
 	sanitize?: OpenApiSanitizeOptions
 	securitySchemes?: Record<string, unknown>
 	title: string
@@ -132,88 +136,85 @@ export type ResolvedGoCliConfig = {
 }
 
 export type ResolvedSdkPorts = {
-	go?: { modulePath: string | undefined; outDir: string };
-	python?: { outDir: string };
-	rust?: { crateName: string | undefined; outDir: string };
-	typescript?: { outDir: string };
-};
+	go?: { modulePath: string | undefined; outDir: string }
+	python?: { outDir: string }
+	rust?: { crateName: string | undefined; outDir: string }
+	typescript?: { outDir: string }
+}
 
 export interface ResolvedHoneyConfig {
-	app?: string;
+	app?: string
 	codegen: {
-		cli: false | ResolvedGoCliConfig;
-		manifest: false | string;
-		mergeTree: string | undefined;
-		openApi: false | ResolvedOpenApiOutput[];
-		sdk: false | { name: string; ports: ResolvedSdkPorts; specs?: string[] };
-		tree: false | string;
-		types: false | { baseCtxName: string | undefined; path: string };
-	};
-	watch: string[];
+		cli: false | ResolvedGoCliConfig
+		manifest: false | string
+		mergeTree: string | undefined
+		openApi: false | ResolvedOpenApiOutput[]
+		sdk: false | { name: string; ports: ResolvedSdkPorts; specs?: string[] }
+		tree: false | string
+		types: false | { baseCtxName: string | undefined; path: string }
+	}
+	watch: string[]
 }
 
-export function resolveHoneyConfig(
-	raw: HoneyVitePluginConfig,
-): ResolvedHoneyConfig {
-	const c = raw.codegen;
+export function resolveHoneyConfig(raw: HoneyVitePluginConfig): ResolvedHoneyConfig {
+	const c = raw.codegen
 
 	const resolvePathFlag = (
 		val: boolean | string | undefined,
 		defaultPath: string,
 		defaultEnabled: boolean,
 	): false | string => {
-		if (val === false) return false;
-		if (val === true || (val === undefined && defaultEnabled))
-			return defaultPath;
-		if (typeof val === "string") return val;
-		return false;
-	};
-
-	let types: false | { baseCtxName: string | undefined; path: string } = false;
+		if (val === false) return false
+		if (val === true || (val === undefined && defaultEnabled)) return defaultPath
+		if (typeof val === "string") return val
+		return false
+	}
+
+	let types: false | { baseCtxName: string | undefined; path: string } = false
 	if (c?.types !== undefined && c.types !== false) {
 		if (typeof c.types === "string") {
-			types = { baseCtxName: undefined, path: c.types };
+			types = { baseCtxName: undefined, path: c.types }
 		} else if (c.types === true) {
-			types = { baseCtxName: undefined, path: "src/_gen/types.gen.d.ts" };
+			types = { baseCtxName: undefined, path: "src/_gen/types.gen.d.ts" }
 		} else {
 			types = {
 				baseCtxName: c.types.baseCtxName,
 				path: c.types.path ?? "src/_gen/types.gen.d.ts",
-			};
+			}
 		}
 	}
 
-	let sdk: false | { name: string; ports: ResolvedSdkPorts; specs?: string[] } = false;
+	let sdk: false | { name: string; ports: ResolvedSdkPorts; specs?: string[] } = false
 	if (c?.sdk !== undefined && c.sdk !== false) {
 		if (typeof c.sdk === "string") {
 			throw new Error("codegen.sdk string form removed — pass object { name?, specs?, ports }")
 		}
 		if (c.sdk === true) {
-			sdk = { name: "SDK", ports: { typescript: { outDir: "src/_gen" } } };
+			sdk = { name: "SDK", ports: { typescript: { outDir: "src/_gen" } } }
 		} else {
-			const rawPorts = c.sdk.ports ?? { typescript: true };
-			const ports: ResolvedSdkPorts = {};
+			const rawPorts = c.sdk.ports ?? { typescript: true }
+			const ports: ResolvedSdkPorts = {}
 			if (rawPorts.typescript !== undefined && rawPorts.typescript !== false) {
 				if (rawPorts.typescript === true) {
-					ports.typescript = { outDir: "src/_gen" };
+					ports.typescript = { outDir: "src/_gen" }
 				} else {
-					ports.typescript = { outDir: rawPorts.typescript.outDir ?? "src/_gen" };
+					ports.typescript = { outDir: rawPorts.typescript.outDir ?? "src/_gen" }
 				}
 			}
 			if (rawPorts.python) {
-				ports.python = { outDir: rawPorts.python.outDir };
+				ports.python = { outDir: rawPorts.python.outDir }
 			}
 			if (rawPorts.go) {
-				ports.go = { modulePath: rawPorts.go.modulePath, outDir: rawPorts.go.outDir };
+				ports.go = { modulePath: rawPorts.go.modulePath, outDir: rawPorts.go.outDir }
 			}
 			if (rawPorts.rust) {
-				ports.rust = { crateName: rawPorts.rust.crateName, outDir: rawPorts.rust.outDir };
+				ports.rust = { crateName: rawPorts.rust.crateName, outDir: rawPorts.rust.outDir }
 			}
 			sdk = {
 				name: c.sdk.name ?? "SDK",
 				ports,
 				specs: c.sdk.specs,
-			};
+			}
 		}
 	}
 
@@ -224,6 +225,7 @@ export function resolveHoneyConfig(
 			description: entry.description,
 			filterRoutes: entry.filterRoutes,
 			path: entry.path ?? "src/_gen/openapi.gen.json",
+			profile: entry.profile,
 			sanitize: entry.sanitize,
 			securitySchemes: entry.securitySchemes,
 			title: entry.title,
@@ -234,9 +236,7 @@ export function resolveHoneyConfig(
 	let cli: false | ResolvedGoCliConfig = false
 	if (c?.cli !== undefined && c.cli !== false) {
 		if (c.cli === true) {
-			throw new Error(
-				"codegen.cli=true requires `out` and `binaryName` — pass an object { out, binaryName }",
-			)
+			throw new Error("codegen.cli=true requires `out` and `binaryName` — pass an object { out, binaryName }")
 		}
 		if (!c.cli.out || !c.cli.binaryName) {
 			throw new Error("codegen.cli requires `out` and `binaryName`")
@@ -256,11 +256,7 @@ export function resolveHoneyConfig(
 		app: raw.app,
 		codegen: {
 			cli,
-			manifest: resolvePathFlag(
-				c?.manifest,
-				"src/_gen/manifest.gen.json",
-				false,
-			),
+			manifest: resolvePathFlag(c?.manifest, "src/_gen/manifest.gen.json", false),
 			mergeTree: c?.mergeTree,
 			openApi,
 			sdk,
@@ -268,60 +264,61 @@ export function resolveHoneyConfig(
 			types,
 		},
 		watch: raw.watch ?? [],
-	};
+	}
 }
 
 /* ---- Config stash for CLI ---- */
 
-let _lastConfig: HoneyVitePluginConfig | undefined;
+let _lastConfig: HoneyVitePluginConfig | undefined
 
 export function getLastHoneyConfig(): HoneyVitePluginConfig | undefined {
-	return _lastConfig;
+	return _lastConfig
 }
 
 /* ---- writeGenFile / writeGenJsonFile ---- */
 
 function writeGenFile(filePath: string, body: string, generator: string): boolean {
-	const normalized = body.replace(/\n*$/, "\n");
-	const hash = createHash("sha256").update(normalized).digest("hex").slice(0, 12);
+	const normalized = body.replace(/\n*$/, "\n")
+	const hash = createHash("sha256").update(normalized).digest("hex").slice(0, 12)
 
-	const ext = filePath.endsWith(".d.ts") ? ".d.ts" : extname(filePath);
-	const header = ext === ".sql"
-		? `-- @generated by ${generator} — do not edit. checksum: ${hash}`
-		: `/* @generated by ${generator} — do not edit. checksum: ${hash} */`;
-	const fullContent = `${header}\n${normalized}`;
+	const ext = filePath.endsWith(".d.ts") ? ".d.ts" : extname(filePath)
+	const header =
+		ext === ".sql"
+			? `-- @generated by ${generator} — do not edit. checksum: ${hash}`
+			: `/* @generated by ${generator} — do not edit. checksum: ${hash} */`
+	const fullContent = `${header}\n${normalized}`
 
 	if (existsSync(filePath)) {
-		const existing = readFileSync(filePath, "utf-8");
-		const firstLine = existing.split("\n")[0] ?? "";
-		const match = firstLine.match(/checksum: ([0-9a-f]{12})/);
-		if (match?.[1] === hash) return false;
+		const existing = readFileSync(filePath, "utf-8")
+		const firstLine = existing.split("\n")[0] ?? ""
+		const match = firstLine.match(/checksum: ([0-9a-f]{12})/)
+		if (match?.[1] === hash) return false
 	}
 
-	mkdirSync(dirname(filePath), { recursive: true });
-	writeFileSync(filePath, fullContent, "utf-8");
-	return true;
+	mkdirSync(dirname(filePath), { recursive: true })
+	writeFileSync(filePath, fullContent, "utf-8")
+	return true
 }
 
 function writeGenJsonFile(filePath: string, data: unknown, generator: string): boolean {
-	const json = JSON.stringify(data, null, 2);
-	const hash = createHash("sha256").update(json).digest("hex").slice(0, 12);
-	const marker = `${generator} checksum:${hash}`;
+	const json = JSON.stringify(data, null, 2)
+	const hash = createHash("sha256").update(json).digest("hex").slice(0, 12)
+	const marker = `${generator} checksum:${hash}`
 
 	if (existsSync(filePath)) {
 		try {
-			const existing = readFileSync(filePath, "utf-8");
-			const parsed = JSON.parse(existing) as Record<string, unknown>;
-			if (parsed._generated === marker) return false;
+			const existing = readFileSync(filePath, "utf-8")
+			const parsed = JSON.parse(existing) as Record<string, unknown>
+			if (parsed._generated === marker) return false
 		} catch {
 			/* invalid JSON — proceed to write */
 		}
 	}
 
-	const output = { _generated: marker, ...(data as Record<string, unknown>) };
-	mkdirSync(dirname(filePath), { recursive: true });
-	writeFileSync(filePath, `${JSON.stringify(output, null, 2)}\n`, "utf-8");
-	return true;
+	const output = { _generated: marker, ...(data as Record<string, unknown>) }
+	mkdirSync(dirname(filePath), { recursive: true })
+	writeFileSync(filePath, `${JSON.stringify(output, null, 2)}\n`, "utf-8")
+	return true
 }
 
 function writeGenYamlFile(filePath: string, data: unknown, generator: string): boolean {
@@ -343,78 +340,65 @@ function writeGenYamlFile(filePath: string, data: unknown, generator: string): b
 
 /* ---- Loaders ---- */
 
-type HoneyApp = Honey<
-	unknown,
-	unknown,
-	unknown,
-	unknown,
-	unknown,
-	string,
-	string
->;
-type TreeResult = { root: import("./tree.ts").TreeNode };
+type HoneyApp = Honey<unknown, unknown, unknown, unknown, unknown, string, string>
+type TreeResult = { root: import("./tree.ts").TreeNode }
 
 async function loadDefaultWithJiti(entryPath: string): Promise<unknown> {
-	const { createJiti } = await import("jiti");
-	const jiti = createJiti(entryPath, { fsCache: false, interopDefault: true, moduleCache: false });
-	const mod = (await jiti.import(entryPath)) as Record<string, unknown>;
+	const { createJiti } = await import("jiti")
+	const jiti = createJiti(entryPath, { fsCache: false, interopDefault: true, moduleCache: false })
+	const mod = (await jiti.import(entryPath)) as Record<string, unknown>
 
 	/* prefer named exports, then unwrap interop default */
-	if (mod.app && isHoneyApp(mod.app)) return mod.app;
-	if (mod.tree && isRouteTree(mod.tree)) return mod.tree;
+	if (mod.app && isHoneyApp(mod.app)) return mod.app
+	if (mod.tree && isRouteTree(mod.tree)) return mod.tree
 	if (mod.default) {
-		const def = mod.default as Record<string, unknown>;
+		const def = mod.default as Record<string, unknown>
 		/* interopDefault may wrap: { default: { app: Honey } } */
-		if (isHoneyApp(def)) return def;
-		if (isRouteTree(def)) return def;
-		if (def.app && isHoneyApp(def.app)) return def.app;
-		if (def.tree && isRouteTree(def.tree)) return def.tree;
+		if (isHoneyApp(def)) return def
+		if (isRouteTree(def)) return def
+		if (def.app && isHoneyApp(def.app)) return def.app
+		if (def.tree && isRouteTree(def.tree)) return def.tree
 	}
-	return undefined;
+	return undefined
 }
 
 function isHoneyApp(val: unknown): val is HoneyApp {
-	if (val === null || typeof val !== "object") return false;
-	return typeof (val as Record<string, unknown>).fetch === "function";
+	if (val === null || typeof val !== "object") return false
+	return typeof (val as Record<string, unknown>).fetch === "function"
 }
 
 function isRouteTree(val: unknown): val is TreeResult {
-	if (val === null || typeof val !== "object") return false;
-	const obj = val as Record<string, unknown>;
-	return obj.root !== undefined && typeof obj.root === "object";
+	if (val === null || typeof val !== "object") return false
+	const obj = val as Record<string, unknown>
+	return obj.root !== undefined && typeof obj.root === "object"
 }
 
 /* ---- Generation ---- */
 
-export async function generateAndWrite(
-	config: ResolvedHoneyConfig,
-	root: string,
-): Promise<void> {
+export async function generateAndWrite(config: ResolvedHoneyConfig, root: string): Promise<void> {
 	await prepareCodegen()
-	const cg = config.codegen;
+	const cg = config.codegen
 
 	/* phase 1: route tree — from mergeTree source or app */
 	if (cg.tree && (cg.mergeTree || config.app)) {
-		const treeSrc = resolve(root, cg.mergeTree ?? config.app ?? "");
-		const exported = await loadDefaultWithJiti(treeSrc);
+		const treeSrc = resolve(root, cg.mergeTree ?? config.app ?? "")
+		const exported = await loadDefaultWithJiti(treeSrc)
 
-		let treeCode: string;
+		let treeCode: string
 		if (isHoneyApp(exported)) {
-			treeCode = generateRouteTreeFromApp(exported);
+			treeCode = generateRouteTreeFromApp(exported)
 		} else if (isRouteTree(exported)) {
-			treeCode = generateRouteTreeFromRouteTree(exported);
+			treeCode = generateRouteTreeFromRouteTree(exported)
 		} else {
-			throw new Error(
-				`Expected Honey app or RouteTree default export in ${treeSrc}`,
-			);
+			throw new Error(`Expected Honey app or RouteTree default export in ${treeSrc}`)
 		}
 
-		writeGenFile(resolve(root, cg.tree), treeCode, "honey");
+		writeGenFile(resolve(root, cg.tree), treeCode, "honey")
 	}
 
 	/* phase 2: types, manifest, openapi, sdk, cli — app needed unless sdk has specs */
 	const sdkHasSpecs = cg.sdk && cg.sdk.specs && cg.sdk.specs.length > 0
-	const needsApp = cg.types || cg.manifest || cg.openApi || (cg.sdk && !sdkHasSpecs) || cg.cli;
+	const needsApp = cg.types || cg.manifest || cg.openApi || (cg.sdk && !sdkHasSpecs) || cg.cli
 
 	let app: HoneyApp | undefined
 	let appPath: string | undefined
@@ -422,19 +406,19 @@ export async function generateAndWrite(
 		if (!config.app) {
 			throw new Error("No app configured — required for types/manifest/openapi/sdk without specs/cli")
 		}
-		appPath = resolve(root, config.app);
-		const appExported = await loadDefaultWithJiti(appPath);
+		appPath = resolve(root, config.app)
+		const appExported = await loadDefaultWithJiti(appPath)
 		if (!isHoneyApp(appExported)) {
-			throw new Error(`Expected Honey app default export in ${appPath}`);
+			throw new Error(`Expected Honey app default export in ${appPath}`)
 		}
-		app = appExported;
+		app = appExported
 	}
 
 	/* manifest */
 	if (cg.manifest) {
 		if (!app) throw new Error("Manifest generation requires a configured app")
-		const manifest = generateManifest(app);
-		writeGenJsonFile(resolve(root, cg.manifest), manifest, "honey");
+		const manifest = generateManifest(app)
+		writeGenJsonFile(resolve(root, cg.manifest), manifest, "honey")
 	}
 
 	/* openapi */
@@ -448,10 +432,11 @@ export async function generateAndWrite(
 					title: entry.title,
 					version: entry.version,
 				},
+				profile: entry.profile,
 				securitySchemes: entry.securitySchemes,
-			});
+			})
 			if (entry.sanitize) {
-				spec = sanitizeOpenApiSpec(spec, entry.sanitize);
+				spec = sanitizeOpenApiSpec(spec, entry.sanitize)
 			}
 			const jsonPath = resolve(root, entry.path)
 			writeGenJsonFile(jsonPath, spec, "honey")
@@ -461,34 +446,30 @@ export async function generateAndWrite(
 
 	/* types */
 	if (cg.types) {
-		const typesPath = resolve(root, cg.types.path);
-		const typesDir = dirname(typesPath);
+		const typesPath = resolve(root, cg.types.path)
+		const typesDir = dirname(typesPath)
 
 		if (!appPath) {
 			throw new Error("Type generation requires a configured app")
 		}
-		const { extractChainTypes } = await import("./type-extractor.ts").catch(
-			() => {
-				throw new Error(
-					'Type generation requires "ts-morph" — install it as a dev dependency',
-				);
-			},
-		);
+		const { extractChainTypes } = await import("./type-extractor.ts").catch(() => {
+			throw new Error('Type generation requires "ts-morph" — install it as a dev dependency')
+		})
 
 		/* prefer appBase (middleware-only, simpler type) over app (with routes) */
-		let extracted: ExtractedChainTypes;
+		let extracted: ExtractedChainTypes
 		try {
 			extracted = await extractChainTypes({
 				entryPath: appPath,
 				exportName: "appBase",
 				outputDir: typesDir,
-			});
+			})
 		} catch {
 			extracted = await extractChainTypes({
 				entryPath: appPath,
 				exportName: "app",
 				outputDir: typesDir,
-			});
+			})
 		}
 
 		if (!app) throw new Error("Type generation requires a configured app")
@@ -499,15 +480,13 @@ export async function generateAndWrite(
 			inlineTapsType: extracted.base.tapsType,
 			routeMiddleware: extracted.routeMiddleware,
 			routeMiddlewareProps: extracted.routeMiddlewareProps,
-		});
-		writeGenFile(typesPath, typesCode, "honey");
+		})
+		writeGenFile(typesPath, typesCode, "honey")
 	}
 
 	/* sdk */
 	if (cg.sdk) {
-		const { generateOpenApi: genOA, generateSDK: genSDK, mergeSpecs } = await import(
-			"./codegen.ts"
-		);
+		const { generateOpenApi: genOA, generateSDK: genSDK, mergeSpecs } = await import("./codegen.ts")
 
 		let spec: OpenApiSpecInput
 		if (cg.sdk.specs && cg.sdk.specs.length > 0) {
@@ -521,8 +500,8 @@ export async function generateAndWrite(
 			const primaryOA = cg.openApi && cg.openApi.length > 0 ? cg.openApi[0] : null
 			const info = primaryOA
 				? { title: primaryOA.title, version: primaryOA.version }
-				: { title: "API", version: "1.0.0" };
-			spec = await genOA(app, { info });
+				: { title: "API", version: "1.0.0" }
+			spec = await genOA(app, { info })
 		}
 
 		const ports = cg.sdk.ports
@@ -578,9 +557,7 @@ export async function generateAndWrite(
 		const { generateGoCLI } = await import("./codegen-go-cli.ts")
 
 		const primaryOA = cg.openApi && cg.openApi.length > 0 ? cg.openApi[0] : null
-		const info = primaryOA
-			? { title: primaryOA.title, version: primaryOA.version }
-			: { title: "API", version: "1.0.0" }
+		const info = primaryOA ? { title: primaryOA.title, version: primaryOA.version } : { title: "API", version: "1.0.0" }
 		if (!app) throw new Error("CLI generation requires a configured app")
 		const spec = await generateOpenApi(app, { info })
 
@@ -604,114 +581,112 @@ export async function generateAndWrite(
 
 /* ---- Vite plugin ---- */
 
-const VIRTUAL_ROUTES = "virtual:honey/routes";
-const VIRTUAL_MANIFEST = "virtual:honey/manifest";
-const VIRTUAL_OPENAPI = "virtual:honey/openapi";
-const RESOLVED_ROUTES = `\0${VIRTUAL_ROUTES}`;
-const RESOLVED_MANIFEST = `\0${VIRTUAL_MANIFEST}`;
-const RESOLVED_OPENAPI = `\0${VIRTUAL_OPENAPI}`;
+const VIRTUAL_ROUTES = "virtual:honey/routes"
+const VIRTUAL_MANIFEST = "virtual:honey/manifest"
+const VIRTUAL_OPENAPI = "virtual:honey/openapi"
+const RESOLVED_ROUTES = `\0${VIRTUAL_ROUTES}`
+const RESOLVED_MANIFEST = `\0${VIRTUAL_MANIFEST}`
+const RESOLVED_OPENAPI = `\0${VIRTUAL_OPENAPI}`
 
 function matchesGlob(filePath: string, patterns: string[]): boolean {
 	for (const pattern of patterns) {
 		const re = pattern
 			.replace(/[.+^${}()|[\]\\]/g, "\\$&")
 			.replace(/\*\*\//g, "(.+/)?")
-			.replace(/\*/g, "[^/]*");
-		if (new RegExp(`(^|/)${re}$`).test(filePath)) return true;
+			.replace(/\*/g, "[^/]*")
+		if (new RegExp(`(^|/)${re}$`).test(filePath)) return true
 	}
-	return false;
+	return false
 }
 
 export function honey(config: HoneyVitePluginConfig) {
-	_lastConfig = config;
+	_lastConfig = config
 
-	const resolved = resolveHoneyConfig(config);
+	const resolved = resolveHoneyConfig(config)
 
-	let root = "";
+	let root = ""
 
 	const plugin: {
-		buildStart(): Promise<void>;
-		configResolved(cfg: { root: string }): void;
+		buildStart(): Promise<void>
+		configResolved(cfg: { root: string }): void
 		hotUpdate(ctx: {
-			file: string;
-			modules: unknown[];
+			file: string
+			modules: unknown[]
 			server: {
-				moduleGraph: { getModuleById(id: string): unknown };
-				reloadModule(mod: unknown): void;
-			};
-		}): Promise<unknown[] | undefined>;
-		load(id: string): Promise<{ code: string; moduleType: string } | undefined>;
-		name: string;
-		resolveId(id: string): string | undefined;
-		transform(code: string, id: string): { code: string; map: null } | undefined;
+				moduleGraph: { getModuleById(id: string): unknown }
+				reloadModule(mod: unknown): void
+			}
+		}): Promise<unknown[] | undefined>
+		load(id: string): Promise<{ code: string; moduleType: string } | undefined>
+		name: string
+		resolveId(id: string): string | undefined
+		transform(code: string, id: string): { code: string; map: null } | undefined
 	} = {
 		async buildStart() {
-			await generateAndWrite(resolved, root);
+			await generateAndWrite(resolved, root)
 		},
 
 		configResolved(cfg: { root: string }) {
-			root = cfg.root;
+			root = cfg.root
 		},
 
 		async hotUpdate(ctx: {
-			file: string;
-			modules: unknown[];
+			file: string
+			modules: unknown[]
 			server: {
-				moduleGraph: { getModuleById(id: string): unknown };
-				reloadModule(mod: unknown): void;
-			};
+				moduleGraph: { getModuleById(id: string): unknown }
+				reloadModule(mod: unknown): void
+			}
 		}) {
-			const patterns = config.watch;
-			if (!patterns || patterns.length === 0) return;
-			if (!matchesGlob(ctx.file, patterns)) return;
+			const patterns = config.watch
+			if (!patterns || patterns.length === 0) return
+			if (!matchesGlob(ctx.file, patterns)) return
 
-			await generateAndWrite(resolved, root);
+			await generateAndWrite(resolved, root)
 
-			const mod = ctx.server.moduleGraph.getModuleById(RESOLVED_ROUTES);
+			const mod = ctx.server.moduleGraph.getModuleById(RESOLVED_ROUTES)
 			if (mod) {
-				ctx.server.reloadModule(mod);
+				ctx.server.reloadModule(mod)
 			}
-			return [];
+			return []
 		},
 
-		async load(
-			id: string,
-		): Promise<{ code: string; moduleType: string } | undefined> {
+		async load(id: string): Promise<{ code: string; moduleType: string } | undefined> {
 			if (id === RESOLVED_ROUTES) {
 				if (!resolved.codegen.mergeTree && !config.app) {
 					throw new Error("Route tree virtual module requires app or mergeTree")
 				}
 				const treeSrc = resolved.codegen.mergeTree
 					? resolve(root, resolved.codegen.mergeTree)
-					: resolve(root, config.app ?? "");
-				const exported = await loadDefaultWithJiti(treeSrc);
-				let code: string;
+					: resolve(root, config.app ?? "")
+				const exported = await loadDefaultWithJiti(treeSrc)
+				let code: string
 				if (isHoneyApp(exported)) {
-					code = generateRouteTreeFromApp(exported);
+					code = generateRouteTreeFromApp(exported)
 				} else if (isRouteTree(exported)) {
-					code = generateRouteTreeFromRouteTree(exported);
+					code = generateRouteTreeFromRouteTree(exported)
 				} else {
-					throw new Error(`Expected Honey app or RouteTree in ${treeSrc}`);
+					throw new Error(`Expected Honey app or RouteTree in ${treeSrc}`)
 				}
-				return { code, moduleType: "js" };
+				return { code, moduleType: "js" }
 			}
 			if (id === RESOLVED_MANIFEST && resolved.codegen.manifest) {
 				if (!config.app) throw new Error("Manifest virtual module requires app")
-				const appPath = resolve(root, config.app);
-				const exported = await loadDefaultWithJiti(appPath);
+				const appPath = resolve(root, config.app)
+				const exported = await loadDefaultWithJiti(appPath)
 				if (isHoneyApp(exported)) {
-					const manifest = generateManifest(exported);
+					const manifest = generateManifest(exported)
 					return {
 						code: `export default ${JSON.stringify(manifest, null, 2)};`,
 						moduleType: "js",
-					};
+					}
 				}
 			}
 			if (id === RESOLVED_OPENAPI && resolved.codegen.openApi) {
 				const primary = resolved.codegen.openApi[0]
 				if (!config.app) throw new Error("OpenAPI virtual module requires app")
-				const appPath = resolve(root, config.app);
-				const exported = await loadDefaultWithJiti(appPath);
+				const appPath = resolve(root, config.app)
+				const exported = await loadDefaultWithJiti(appPath)
 				if (isHoneyApp(exported)) {
 					let spec = await generateOpenApi(exported, {
 						filterRoutes: primary.filterRoutes,
@@ -721,17 +696,17 @@ export function honey(config: HoneyVitePluginConfig) {
 							version: primary.version,
 						},
 						securitySchemes: primary.securitySchemes,
-					});
+					})
 					if (primary.sanitize) {
-						spec = sanitizeOpenApiSpec(spec, primary.sanitize);
+						spec = sanitizeOpenApiSpec(spec, primary.sanitize)
 					}
 					return {
 						code: `export default ${JSON.stringify(spec, null, 2)};`,
 						moduleType: "js",
-					};
+					}
 				}
 			}
-			return undefined;
+			return undefined
 		},
 
 		name: "honey",
@@ -742,10 +717,7 @@ export function honey(config: HoneyVitePluginConfig) {
 			if (/\.openapi\s*\(|\.manifest\s*\(/.test(code) && !code.includes("@lovrozagar/honey/openapi")) {
 				inject.push('import { enableOpenApi } from "@lovrozagar/honey/openapi"', "enableOpenApi()")
 			}
-			if (
-				/(?<!Bun)(?<!Deno)\.serve\s*\(/.test(code) &&
-				!code.includes("@lovrozagar/honey/serve")
-			) {
+			if (/(?<!Bun)(?<!Deno)\.serve\s*\(/.test(code) && !code.includes("@lovrozagar/honey/serve")) {
 				inject.push('import { enableServe } from "@lovrozagar/honey/serve"', "enableServe()")
 			}
 			if (/\.errorI18n\s*\(/.test(code) && !code.includes("@lovrozagar/honey/i18n")) {
@@ -756,16 +728,14 @@ export function honey(config: HoneyVitePluginConfig) {
 		},
 
 		resolveId(id: string): string | undefined {
-			if (id === VIRTUAL_ROUTES) return RESOLVED_ROUTES;
-			if (id === VIRTUAL_MANIFEST && resolved.codegen.manifest)
-				return RESOLVED_MANIFEST;
-			if (id === VIRTUAL_OPENAPI && resolved.codegen.openApi)
-				return RESOLVED_OPENAPI;
-			return undefined;
+			if (id === VIRTUAL_ROUTES) return RESOLVED_ROUTES
+			if (id === VIRTUAL_MANIFEST && resolved.codegen.manifest) return RESOLVED_MANIFEST
+			if (id === VIRTUAL_OPENAPI && resolved.codegen.openApi) return RESOLVED_OPENAPI
+			return undefined
 		},
-	};
+	}
 
-	return [plugin];
+	return [plugin]
 }
 
-export { generateRouteTree };
+export { generateRouteTree }